duckdb 1.0.1-dev21.0 → 1.0.1-dev27.0

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

@@ -19,6 +19,16 @@ namespace duckdb {
 
 enum class MacroType : uint8_t { VOID_MACRO = 0, TABLE_MACRO = 1, SCALAR_MACRO = 2 };
 
+struct MacroBindResult {
+	explicit MacroBindResult(string error_p) : error(std::move(error_p)) {
+	}
+	explicit MacroBindResult(idx_t function_idx) : function_idx(function_idx) {
+	}
+
+	optional_idx function_idx;
+	string error;
+};
+
 class MacroFunction {
 public:
 	explicit MacroFunction(MacroType type);
@@ -38,12 +48,12 @@ public:
 
 	virtual unique_ptr<MacroFunction> Copy() const = 0;
 
-	static string ValidateArguments(MacroFunction &macro_function, const string &name,
-	                                FunctionExpression &function_expr,
-	                                vector<unique_ptr<ParsedExpression>> &positionals,
-	                                unordered_map<string, unique_ptr<ParsedExpression>> &defaults);
+	static MacroBindResult BindMacroFunction(const vector<unique_ptr<MacroFunction>> &macro_functions,
+	                                         const string &name, FunctionExpression &function_expr,
+	                                         vector<unique_ptr<ParsedExpression>> &positionals,
+	                                         unordered_map<string, unique_ptr<ParsedExpression>> &defaults);
 
-	virtual string ToSQL(const string &schema, const string &name) const;
+	virtual string ToSQL() const;
 
 	virtual void Serialize(Serializer &serializer) const;
 	static unique_ptr<MacroFunction> Deserialize(Deserializer &deserializer);

package/src/duckdb/src/include/duckdb/function/pragma/pragma_functions.hpp

@@ -24,6 +24,7 @@ struct PragmaFunctions {
 string PragmaShowTables();
 string PragmaShowTablesExpanded();
 string PragmaShowDatabases();
+string PragmaShowVariables();
 string PragmaShow(const string &table_name);
 
 } // namespace duckdb

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

@@ -10,6 +10,7 @@
 
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/string_util.hpp"
+#include "duckdb/common/enums/file_compression_type.hpp"
 
 namespace duckdb {
 
@@ -36,11 +37,13 @@ public:
 
 struct ReplacementScanInput {
 public:
-	ReplacementScanInput(TableRef &ref, const string &table_name) : ref(ref), table_name(table_name) {
+	explicit ReplacementScanInput(const string &catalog_name, const string &schema_name, const string &table_name)
+	    : catalog_name(catalog_name), schema_name(schema_name), table_name(table_name) {
 	}
 
 public:
-	TableRef &ref;
+	const string &catalog_name;
+	const string &schema_name;
 	const string &table_name;
 };
 
@@ -57,9 +60,9 @@ struct ReplacementScan {
 	static bool CanReplace(const string &table_name, const vector<string> &extensions) {
 		auto lower_name = StringUtil::Lower(table_name);
 
-		if (StringUtil::EndsWith(lower_name, ".gz")) {
+		if (StringUtil::EndsWith(lower_name, CompressionExtensionFromType(FileCompressionType::GZIP))) {
 			lower_name = lower_name.substr(0, lower_name.size() - 3);
-		} else if (StringUtil::EndsWith(lower_name, ".zst")) {
+		} else if (StringUtil::EndsWith(lower_name, CompressionExtensionFromType(FileCompressionType::ZSTD))) {
 			lower_name = lower_name.substr(0, lower_name.size() - 4);
 		}
 
@@ -73,6 +76,19 @@ struct ReplacementScan {
 		return false;
 	}
 
+	static string GetFullPath(const string &catalog, const string &schema, const string &table) {
+		string table_name = catalog;
+		if (!schema.empty()) {
+			table_name += (!table_name.empty() ? "." : "") + schema;
+		}
+		table_name += (!table_name.empty() ? "." : "") + table;
+		return table_name;
+	}
+
+	static string GetFullPath(ReplacementScanInput &input) {
+		return GetFullPath(input.catalog_name, input.schema_name, input.table_name);
+	}
+
 	replacement_scan_t function;
 	unique_ptr<ReplacementScanData> data;
 };

package/src/duckdb/src/include/duckdb/function/scalar/generic_functions.hpp

@@ -11,6 +11,8 @@
 #include "duckdb/function/scalar_function.hpp"
 #include "duckdb/function/function_set.hpp"
 #include "duckdb/function/built_in_functions.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 class BoundFunctionExpression;
@@ -36,4 +38,8 @@ struct ExportAggregateFunction {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct GetVariableFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/function/scalar/list/contains_or_position.hpp

@@ -1,141 +1,109 @@
 #pragma once
+#include "duckdb/core_functions/create_sort_key.hpp"
+#include "duckdb/common/operator/comparison_operators.hpp"
 
 namespace duckdb {
 
-template <class CHILD_TYPE, class RETURN_TYPE, class OP, class LIST_ACCESSOR>
-static void TemplatedContainsOrPosition(DataChunk &args, Vector &result, bool is_nested = false) {
-	D_ASSERT(args.ColumnCount() == 2);
-	auto count = args.size();
-	Vector &list = LIST_ACCESSOR::GetList(args.data[0]);
-	Vector &value_vector = args.data[1];
-
-	// Create a result vector of type RETURN_TYPE
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	auto result_entries = FlatVector::GetData<RETURN_TYPE>(result);
-	auto &result_validity = FlatVector::Validity(result);
-
-	if (list.GetType().id() == LogicalTypeId::SQLNULL) {
-		result_validity.SetInvalid(0);
-		return;
-	}
-
-	auto list_size = LIST_ACCESSOR::GetListSize(list);
-	auto &child_vector = LIST_ACCESSOR::GetEntry(list);
-
-	UnifiedVectorFormat child_data;
-	child_vector.ToUnifiedFormat(list_size, child_data);
-
-	UnifiedVectorFormat list_data;
-	list.ToUnifiedFormat(count, list_data);
-	auto list_entries = UnifiedVectorFormat::GetData<list_entry_t>(list_data);
-
-	UnifiedVectorFormat value_data;
-	value_vector.ToUnifiedFormat(count, value_data);
-
-	// not required for a comparison of nested types
-	auto child_value = UnifiedVectorFormat::GetData<CHILD_TYPE>(child_data);
-	auto values = UnifiedVectorFormat::GetData<CHILD_TYPE>(value_data);
-
-	for (idx_t i = 0; i < count; i++) {
-		auto list_index = list_data.sel->get_index(i);
-		auto value_index = value_data.sel->get_index(i);
-
-		if (!list_data.validity.RowIsValid(list_index) || !value_data.validity.RowIsValid(value_index)) {
-			result_validity.SetInvalid(i);
-			continue;
-		}
-
-		const auto &list_entry = list_entries[list_index];
-
-		result_entries[i] = OP::Initialize();
-		for (idx_t child_idx = 0; child_idx < list_entry.length; child_idx++) {
-
-			auto child_value_idx = child_data.sel->get_index(list_entry.offset + child_idx);
-			if (!child_data.validity.RowIsValid(child_value_idx)) {
-				continue;
-			}
+template <class T, bool RETURN_POSITION>
+idx_t ListSearchSimpleOp(Vector &list_vec, Vector &source_vec, Vector &target_vec, Vector &result, idx_t count) {
+
+	UnifiedVectorFormat source_format;
+	const auto source_count = ListVector::GetListSize(list_vec);
+	source_vec.ToUnifiedFormat(source_count, source_format);
+	const auto source_data = UnifiedVectorFormat::GetData<T>(source_format);
+
+	using RETURN_TYPE = typename std::conditional<RETURN_POSITION, int32_t, int8_t>::type;
+
+	idx_t total_matches = 0;
+
+	BinaryExecutor::ExecuteWithNulls<list_entry_t, T, RETURN_TYPE>(
+	    list_vec, target_vec, result, count,
+	    [&](const list_entry_t &list, const T &target, ValidityMask &validity, idx_t out_idx) -> RETURN_TYPE {
+		    if (list.length == 0) {
+			    if (RETURN_POSITION) {
+				    validity.SetInvalid(out_idx);
+			    }
+			    return 0;
+		    }
+
+		    for (auto i = list.offset; i < list.offset + list.length; i++) {
+			    const auto entry_idx = source_format.sel->get_index(i);
+			    if (source_format.validity.RowIsValid(entry_idx) &&
+			        Equals::Operation<T>(source_data[entry_idx], target)) {
+				    total_matches++;
+				    return RETURN_POSITION ? UnsafeNumericCast<RETURN_TYPE>(1 + i - list.offset) : 1;
+			    }
+		    }
+
+		    if (RETURN_POSITION) {
+			    validity.SetInvalid(out_idx);
+		    }
+		    return 0;
+	    });
+
+	return total_matches;
+}
 
-			if (!is_nested) {
-				if (Equals::Operation(child_value[child_value_idx], values[value_index])) {
-					result_entries[i] = OP::UpdateResultEntries(child_idx);
-					break; // Found value in list, no need to look further
-				}
-			} else {
-				// FIXME: using Value is less efficient than modifying the vector comparison code
-				// to more efficiently compare nested types
+template <bool RETURN_POSITION>
+idx_t ListSearchNestedOp(Vector &list_vec, Vector &source_vec, Vector &target_vec, Vector &result_vec,
+                         const idx_t target_count) {
+	// Set up sort keys for nested types.
+	auto source_count = ListVector::GetListSize(list_vec);
+	Vector source_sort_key_vec(LogicalType::BLOB, source_count);
+	Vector target_sort_key_vec(LogicalType::BLOB, target_count);
 
-				// Note: When using GetValue we don't first apply the selection vector
-				// because it is already done inside GetValue
-				auto lvalue = child_vector.GetValue(list_entry.offset + child_idx);
-				auto rvalue = value_vector.GetValue(i);
-				if (Value::NotDistinctFrom(lvalue, rvalue)) {
-					result_entries[i] = OP::UpdateResultEntries(child_idx);
-					break; // Found value in list, no need to look further
-				}
-			}
-		}
-	}
+	const OrderModifiers order_modifiers(OrderType::ASCENDING, OrderByNullType::NULLS_LAST);
+	CreateSortKeyHelpers::CreateSortKeyWithValidity(source_vec, source_sort_key_vec, order_modifiers, source_count);
+	CreateSortKeyHelpers::CreateSortKeyWithValidity(target_vec, target_sort_key_vec, order_modifiers, target_count);
 
-	if (args.AllConstant()) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
+	return ListSearchSimpleOp<string_t, RETURN_POSITION>(list_vec, source_sort_key_vec, target_sort_key_vec, result_vec,
+	                                                     target_count);
 }
 
-template <class T, class OP, class LIST_ACCESSOR>
-void ListContainsOrPosition(DataChunk &args, Vector &result) {
-	const auto physical_type = args.data[1].GetType().InternalType();
-	switch (physical_type) {
+//! "Search" each list in the list vector for the corresponding value in the target vector, returning either
+//! true/false or the position of the value in the list. The result vector is populated with the result of the search.
+//! usually the "source" vector is the list child vector, but it is passed separately to enable searching nested
+//! children, for example when searching the keys of a MAP vectors.
+template <bool RETURN_POSITION>
+idx_t ListSearchOp(Vector &list_v, Vector &source_v, Vector &target_v, Vector &result_v, idx_t target_count) {
+	const auto type = target_v.GetType().InternalType();
+	switch (type) {
 	case PhysicalType::BOOL:
 	case PhysicalType::INT8:
-		TemplatedContainsOrPosition<int8_t, T, OP, LIST_ACCESSOR>(args, result);
-		break;
+		return ListSearchSimpleOp<int8_t, RETURN_POSITION>(list_v, source_v, target_v, result_v, target_count);
 	case PhysicalType::INT16:
-		TemplatedContainsOrPosition<int16_t, T, OP, LIST_ACCESSOR>(args, result);
-		break;
+		return ListSearchSimpleOp<int16_t, RETURN_POSITION>(list_v, source_v, target_v, result_v, target_count);
 	case PhysicalType::INT32:
-		TemplatedContainsOrPosition<int32_t, T, OP, LIST_ACCESSOR>(args, result);
-		break;
+		return ListSearchSimpleOp<int32_t, RETURN_POSITION>(list_v, source_v, target_v, result_v, target_count);
 	case PhysicalType::INT64:
-		TemplatedContainsOrPosition<int64_t, T, OP, LIST_ACCESSOR>(args, result);
-		break;
+		return ListSearchSimpleOp<int64_t, RETURN_POSITION>(list_v, source_v, target_v, result_v, target_count);
 	case PhysicalType::INT128:
-		TemplatedContainsOrPosition<hugeint_t, T, OP, LIST_ACCESSOR>(args, result);
-		break;
+		return ListSearchSimpleOp<hugeint_t, RETURN_POSITION>(list_v, source_v, target_v, result_v, target_count);
 	case PhysicalType::UINT8:
-		TemplatedContainsOrPosition<uint8_t, T, OP, LIST_ACCESSOR>(args, result);
-		break;
+		return ListSearchSimpleOp<uint8_t, RETURN_POSITION>(list_v, source_v, target_v, result_v, target_count);
 	case PhysicalType::UINT16:
-		TemplatedContainsOrPosition<uint16_t, T, OP, LIST_ACCESSOR>(args, result);
-		break;
+		return ListSearchSimpleOp<uint16_t, RETURN_POSITION>(list_v, source_v, target_v, result_v, target_count);
 	case PhysicalType::UINT32:
-		TemplatedContainsOrPosition<uint32_t, T, OP, LIST_ACCESSOR>(args, result);
-		break;
+		return ListSearchSimpleOp<uint32_t, RETURN_POSITION>(list_v, source_v, target_v, result_v, target_count);
 	case PhysicalType::UINT64:
-		TemplatedContainsOrPosition<uint64_t, T, OP, LIST_ACCESSOR>(args, result);
-		break;
+		return ListSearchSimpleOp<uint64_t, RETURN_POSITION>(list_v, source_v, target_v, result_v, target_count);
 	case PhysicalType::UINT128:
-		TemplatedContainsOrPosition<uhugeint_t, T, OP, LIST_ACCESSOR>(args, result);
-		break;
+		return ListSearchSimpleOp<uhugeint_t, RETURN_POSITION>(list_v, source_v, target_v, result_v, target_count);
 	case PhysicalType::FLOAT:
-		TemplatedContainsOrPosition<float, T, OP, LIST_ACCESSOR>(args, result);
-		break;
+		return ListSearchSimpleOp<float, RETURN_POSITION>(list_v, source_v, target_v, result_v, target_count);
 	case PhysicalType::DOUBLE:
-		TemplatedContainsOrPosition<double, T, OP, LIST_ACCESSOR>(args, result);
-		break;
+		return ListSearchSimpleOp<double, RETURN_POSITION>(list_v, source_v, target_v, result_v, target_count);
 	case PhysicalType::VARCHAR:
-		TemplatedContainsOrPosition<string_t, T, OP, LIST_ACCESSOR>(args, result);
-		break;
+		return ListSearchSimpleOp<string_t, RETURN_POSITION>(list_v, source_v, target_v, result_v, target_count);
 	case PhysicalType::INTERVAL:
-		TemplatedContainsOrPosition<interval_t, T, OP, LIST_ACCESSOR>(args, result);
-		break;
+		return ListSearchSimpleOp<interval_t, RETURN_POSITION>(list_v, source_v, target_v, result_v, target_count);
 	case PhysicalType::STRUCT:
 	case PhysicalType::LIST:
 	case PhysicalType::ARRAY:
-		TemplatedContainsOrPosition<int8_t, T, OP, LIST_ACCESSOR>(args, result, true);
-		break;
+		return ListSearchNestedOp<RETURN_POSITION>(list_v, source_v, target_v, result_v, target_count);
 	default:
 		throw NotImplementedException("This function has not been implemented for logical type %s",
-		                              TypeIdToString(physical_type));
+		                              TypeIdToString(type));
 	}
 }
 

package/src/duckdb/src/include/duckdb/function/scalar/nested_functions.hpp

@@ -13,7 +13,6 @@
 #include "duckdb/common/map.hpp"
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/function/built_in_functions.hpp"
-#include "duckdb/function/scalar/list/contains_or_position.hpp"
 #include "duckdb/common/serializer/serializer.hpp"
 #include "duckdb/common/serializer/deserializer.hpp"
 
@@ -125,6 +124,7 @@ struct StructExtractFun {
 	static ScalarFunction KeyExtractFunction();
 	static ScalarFunction IndexExtractFunction();
 	static ScalarFunctionSet GetFunctions();
+	static unique_ptr<FunctionData> GetBindData(idx_t index);
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 

package/src/duckdb/src/include/duckdb/function/scalar/regexp.hpp

@@ -106,9 +106,12 @@ struct RegexStringPieceArgs {
 	}
 
 	RegexStringPieceArgs &operator=(RegexStringPieceArgs &&other) noexcept {
-		std::swap(this->size, other.size);
-		std::swap(this->capacity, other.capacity);
-		std::swap(this->group_buffer, other.group_buffer);
+		this->size = other.size;
+		this->capacity = other.capacity;
+		this->group_buffer = other.group_buffer;
+		other.size = 0;
+		other.capacity = 0;
+		other.group_buffer = nullptr;
 		return *this;
 	}
 

package/src/duckdb/src/include/duckdb/function/scalar/strftime_format.hpp

@@ -98,6 +98,7 @@ protected:
 struct StrfTimeFormat : public StrTimeFormat { // NOLINT: work-around bug in clang-tidy
 	DUCKDB_API idx_t GetLength(date_t date, dtime_t time, int32_t utc_offset, const char *tz_name);
 
+	DUCKDB_API void FormatStringNS(date_t date, int32_t data[8], const char *tz_name, char *target) const;
 	DUCKDB_API void FormatString(date_t date, int32_t data[8], const char *tz_name, char *target);
 	void FormatString(date_t date, dtime_t time, char *target);
 
@@ -105,6 +106,7 @@ struct StrfTimeFormat : public StrTimeFormat { // NOLINT: work-around bug in cla
 
 	DUCKDB_API void ConvertDateVector(Vector &input, Vector &result, idx_t count);
 	DUCKDB_API void ConvertTimestampVector(Vector &input, Vector &result, idx_t count);
+	DUCKDB_API void ConvertTimestampNSVector(Vector &input, Vector &result, idx_t count);
 
 protected:
 	//! The variable-length specifiers. To determine total string size, these need to be checked.
@@ -115,17 +117,21 @@ protected:
 
 protected:
 	DUCKDB_API void AddFormatSpecifier(string preceding_literal, StrTimeSpecifier specifier) override;
-	static idx_t GetSpecifierLength(StrTimeSpecifier specifier, date_t date, dtime_t time, int32_t utc_offset,
-	                                const char *tz_name);
-	char *WriteString(char *target, const string_t &str);
-	char *Write2(char *target, uint8_t value);
-	char *WritePadded2(char *target, uint32_t value);
-	char *WritePadded3(char *target, uint32_t value);
-	char *WritePadded(char *target, uint32_t value, size_t padding);
+	static idx_t GetSpecifierLength(StrTimeSpecifier specifier, date_t date, int32_t data[8], const char *tz_name);
+	idx_t GetLength(date_t date, int32_t data[8], const char *tz_name) const;
+
+	string_t ConvertTimestampValue(const timestamp_t &input, Vector &result) const;
+	string_t ConvertTimestampValue(const timestamp_ns_t &input, Vector &result) const;
+
+	char *WriteString(char *target, const string_t &str) const;
+	char *Write2(char *target, uint8_t value) const;
+	char *WritePadded2(char *target, uint32_t value) const;
+	char *WritePadded3(char *target, uint32_t value) const;
+	char *WritePadded(char *target, uint32_t value, size_t padding) const;
 	bool IsDateSpecifier(StrTimeSpecifier specifier);
-	char *WriteDateSpecifier(StrTimeSpecifier specifier, date_t date, char *target);
+	char *WriteDateSpecifier(StrTimeSpecifier specifier, date_t date, char *target) const;
 	char *WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t data[], const char *tz_name, size_t tz_len,
-	                             char *target);
+	                             char *target) const;
 };
 
 struct StrpTimeFormat : public StrTimeFormat { // NOLINT: work-around bug in clang-tidy
@@ -134,7 +140,7 @@ public:
 
 	//! Type-safe parsing argument
 	struct ParseResult {
-		int32_t data[8]; // year, month, day, hour, min, sec, µs, offset
+		int32_t data[8]; // year, month, day, hour, min, sec, ns, offset
 		string tz;
 		string error_message;
 		optional_idx error_position;
@@ -142,13 +148,18 @@ public:
 		bool is_special;
 		date_t special;
 
+		int32_t GetMicros() const;
+
 		date_t ToDate();
 		dtime_t ToTime();
+		int64_t ToTimeNS();
 		timestamp_t ToTimestamp();
+		timestamp_ns_t ToTimestampNS();
 
 		bool TryToDate(date_t &result);
 		bool TryToTime(dtime_t &result);
 		bool TryToTimestamp(timestamp_t &result);
+		bool TryToTimestampNS(timestamp_ns_t &result);
 
 		DUCKDB_API string FormatError(string_t input, const string &format_specifier);
 	};
@@ -159,16 +170,18 @@ public:
 	}
 	DUCKDB_API static ParseResult Parse(const string &format, const string &text);
 
-	DUCKDB_API bool Parse(string_t str, ParseResult &result) const;
+	DUCKDB_API bool Parse(string_t str, ParseResult &result, bool strict = false) const;
 
-	DUCKDB_API bool Parse(const char *data, size_t size, ParseResult &result) const;
+	DUCKDB_API bool Parse(const char *data, size_t size, ParseResult &result, bool strict = false) const;
 
 	DUCKDB_API bool TryParseDate(const char *data, size_t size, date_t &result) const;
 	DUCKDB_API bool TryParseTimestamp(const char *data, size_t size, timestamp_t &result) const;
+	DUCKDB_API bool TryParseTimestampNS(const char *data, size_t size, timestamp_ns_t &result) const;
 
 	DUCKDB_API bool TryParseDate(string_t str, date_t &result, string &error_message) const;
 	DUCKDB_API bool TryParseTime(string_t str, dtime_t &result, string &error_message) const;
 	DUCKDB_API bool TryParseTimestamp(string_t str, timestamp_t &result, string &error_message) const;
+	DUCKDB_API bool TryParseTimestampNS(string_t str, timestamp_ns_t &result, string &error_message) const;
 
 	void Serialize(Serializer &serializer) const;
 	static StrpTimeFormat Deserialize(Deserializer &deserializer);

package/src/duckdb/src/include/duckdb/function/scalar/string_functions.hpp

@@ -9,7 +9,7 @@
 #pragma once
 
 #include "duckdb/function/function_set.hpp"
-#include "utf8proc.hpp"
+#include "utf8proc_wrapper.hpp"
 #include "duckdb/function/built_in_functions.hpp"
 
 namespace duckdb_re2 {
@@ -44,6 +44,11 @@ struct StripAccentsFun {
 
 struct ConcatFun {
 	static void RegisterFunction(BuiltinFunctions &set);
+	static ScalarFunction GetFunction();
+};
+
+struct ConcatWSFun {
+	static void RegisterFunction(BuiltinFunctions &set);
 };
 
 struct LengthFun {
@@ -69,13 +74,8 @@ struct LengthFun {
 		auto input_length = input.GetSize();
 		for (idx_t i = 0; i < input_length; i++) {
 			if (input_data[i] & 0x80) {
-				int64_t length = 0;
 				// non-ascii character: use grapheme iterator on remainder of string
-				utf8proc_grapheme_callback(input_data, input_length, [&](size_t start, size_t end) {
-					length++;
-					return true;
-				});
-				return length;
+				return UnsafeNumericCast<TR>(Utf8Proc::GraphemeCount(input_data, input_length));
 			}
 		}
 		return UnsafeNumericCast<TR>(input_length);
@@ -116,7 +116,8 @@ struct SuffixFun {
 };
 
 struct ContainsFun {
-	static ScalarFunction GetFunction();
+	static ScalarFunctionSet GetFunctions();
+	static ScalarFunction GetStringContains();
 	static void RegisterFunction(BuiltinFunctions &set);
 	static idx_t Find(const string_t &haystack, const string_t &needle);
 	static idx_t Find(const unsigned char *haystack, idx_t haystack_size, const unsigned char *needle,

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

@@ -34,10 +34,26 @@ struct FunctionLocalState {
 	}
 };
 
+struct ScalarFunctionInfo {
+	DUCKDB_API virtual ~ScalarFunctionInfo();
+
+	template <class TARGET>
+	TARGET &Cast() {
+		DynamicCastCheck<TARGET>(this);
+		return reinterpret_cast<TARGET &>(*this);
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		DynamicCastCheck<TARGET>(this);
+		return reinterpret_cast<const TARGET &>(*this);
+	}
+};
+
 class Binder;
 class BoundFunctionExpression;
 class LogicalDependencyList;
 class ScalarFunctionCatalogEntry;
+struct StatementProperties;
 
 struct FunctionStatisticsInput {
 	FunctionStatisticsInput(BoundFunctionExpression &expr_p, optional_ptr<FunctionData> bind_data_p,
@@ -52,12 +68,23 @@ struct FunctionStatisticsInput {
 };
 
 struct FunctionModifiedDatabasesInput {
-	FunctionModifiedDatabasesInput(optional_ptr<FunctionData> bind_data_p, unordered_set<string> &modified_databases_p)
-	    : bind_data(bind_data_p), modified_databases(modified_databases_p) {
+	FunctionModifiedDatabasesInput(optional_ptr<FunctionData> bind_data_p, StatementProperties &properties)
+	    : bind_data(bind_data_p), properties(properties) {
+	}
+
+	optional_ptr<FunctionData> bind_data;
+	StatementProperties &properties;
+};
+
+struct FunctionBindExpressionInput {
+	FunctionBindExpressionInput(ClientContext &context_p, optional_ptr<FunctionData> bind_data_p,
+	                            BoundFunctionExpression &function_p)
+	    : context(context_p), bind_data(bind_data_p), function(function_p) {
 	}
 
+	ClientContext &context;
 	optional_ptr<FunctionData> bind_data;
-	unordered_set<string> &modified_databases;
+	BoundFunctionExpression &function;
 };
 
 //! The scalar function type
@@ -76,12 +103,15 @@ typedef unique_ptr<BaseStatistics> (*function_statistics_t)(ClientContext &conte
 //! The type to bind lambda-specific parameter types
 typedef LogicalType (*bind_lambda_function_t)(const idx_t parameter_idx, const LogicalType &list_child_type);
 //! The type to bind lambda-specific parameter types
-typedef void (*get_modified_databases_t)(FunctionModifiedDatabasesInput &input);
+typedef void (*get_modified_databases_t)(ClientContext &context, FunctionModifiedDatabasesInput &input);
 
 typedef void (*function_serialize_t)(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
                                      const ScalarFunction &function);
 typedef unique_ptr<FunctionData> (*function_deserialize_t)(Deserializer &deserializer, ScalarFunction &function);
 
+//! The type to bind lambda-specific parameter types
+typedef unique_ptr<Expression> (*function_bind_expression_t)(FunctionBindExpressionInput &input);
+
 class ScalarFunction : public BaseScalarFunction { // NOLINT: work-around bug in clang-tidy
 public:
 	DUCKDB_API ScalarFunction(string name, vector<LogicalType> arguments, LogicalType return_type,
@@ -113,11 +143,15 @@ public:
 	function_statistics_t statistics;
 	//! The lambda bind function (if any)
 	bind_lambda_function_t bind_lambda;
+	//! Function to bind the result function expression directly (if any)
+	function_bind_expression_t bind_expression;
 	//! Gets the modified databases (if any)
 	get_modified_databases_t get_modified_databases;
 
 	function_serialize_t serialize;
 	function_deserialize_t deserialize;
+	//! Additional function info, passed to the bind
+	shared_ptr<ScalarFunctionInfo> function_info;
 
 	DUCKDB_API bool operator==(const ScalarFunction &rhs) const;
 	DUCKDB_API bool operator!=(const ScalarFunction &rhs) const;

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

@@ -32,7 +32,7 @@ public:
 public:
 	unique_ptr<MacroFunction> Copy() const override;
 
-	string ToSQL(const string &schema, const string &name) const override;
+	string ToSQL() const override;
 
 	void Serialize(Serializer &serializer) const override;
 	static unique_ptr<MacroFunction> Deserialize(Deserializer &deserializer);