duckdb 0.7.2-dev2740.0 → 0.7.2-dev2820.0

package/src/duckdb/src/function/scalar/operators.cpp

@@ -9,12 +9,6 @@ void BuiltinFunctions::RegisterOperators() {
 	Register<MultiplyFun>();
 	Register<DivideFun>();
 	Register<ModFun>();
-	Register<LeftShiftFun>();
-	Register<RightShiftFun>();
-	Register<BitwiseAndFun>();
-	Register<BitwiseOrFun>();
-	Register<BitwiseXorFun>();
-	Register<BitwiseNotFun>();
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/scalar/{date/strftime.cpp → strftime_format.cpp}

@@ -1,19 +1,10 @@
-#include "duckdb/function/scalar/strftime.hpp"
-
+#include "duckdb/function/scalar/strftime_format.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/to_string.hpp"
 #include "duckdb/common/types/cast_helpers.hpp"
 #include "duckdb/common/types/date.hpp"
 #include "duckdb/common/types/time.hpp"
 #include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/common/vector_operations/unary_executor.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/function/scalar/date_functions.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression/bound_parameter_expression.hpp"
-
-#include <cctype>
-#include <utility>
 
 namespace duckdb {
 
@@ -594,49 +585,6 @@ string StrTimeFormat::ParseFormatSpecifier(const string &format_string, StrTimeF
 	return string();
 }
 
-struct StrfTimeBindData : public FunctionData {
-	explicit StrfTimeBindData(StrfTimeFormat format_p, string format_string_p, bool is_null)
-	    : format(std::move(format_p)), format_string(std::move(format_string_p)), is_null(is_null) {
-	}
-
-	StrfTimeFormat format;
-	string format_string;
-	bool is_null;
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<StrfTimeBindData>(format, format_string, is_null);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const StrfTimeBindData &)other_p;
-		return format_string == other.format_string;
-	}
-};
-
-template <bool REVERSED>
-static unique_ptr<FunctionData> StrfTimeBindFunction(ClientContext &context, ScalarFunction &bound_function,
-                                                     vector<unique_ptr<Expression>> &arguments) {
-	auto format_idx = REVERSED ? 0 : 1;
-	auto &format_arg = arguments[format_idx];
-	if (format_arg->HasParameter()) {
-		throw ParameterNotResolvedException();
-	}
-	if (!format_arg->IsFoldable()) {
-		throw InvalidInputException("strftime format must be a constant");
-	}
-	Value options_str = ExpressionExecutor::EvaluateScalar(context, *format_arg);
-	auto format_string = options_str.GetValue<string>();
-	StrfTimeFormat format;
-	bool is_null = options_str.IsNull();
-	if (!is_null) {
-		string error = StrTimeFormat::ParseFormatSpecifier(format_string, format);
-		if (!error.empty()) {
-			throw InvalidInputException("Failed to parse format specifier %s: %s", format_string, error);
-		}
-	}
-	return make_uniq<StrfTimeBindData>(format, format_string, is_null);
-}
-
 void StrfTimeFormat::ConvertDateVector(Vector &input, Vector &result, idx_t count) {
 	D_ASSERT(input.GetType().id() == LogicalTypeId::DATE);
 	D_ASSERT(result.GetType().id() == LogicalTypeId::VARCHAR);
@@ -656,19 +604,6 @@ void StrfTimeFormat::ConvertDateVector(Vector &input, Vector &result, idx_t coun
 	                                                  });
 }
 
-template <bool REVERSED>
-static void StrfTimeFunctionDate(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	auto &info = func_expr.bind_info->Cast<StrfTimeBindData>();
-
-	if (info.is_null) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::SetNull(result, true);
-		return;
-	}
-	info.format.ConvertDateVector(args.data[REVERSED ? 1 : 0], result, args.size());
-}
-
 void StrfTimeFormat::ConvertTimestampVector(Vector &input, Vector &result, idx_t count) {
 	D_ASSERT(input.GetType().id() == LogicalTypeId::TIMESTAMP || input.GetType().id() == LogicalTypeId::TIMESTAMP_TZ);
 	D_ASSERT(result.GetType().id() == LogicalTypeId::VARCHAR);
@@ -690,37 +625,6 @@ void StrfTimeFormat::ConvertTimestampVector(Vector &input, Vector &result, idx_t
 	    });
 }
 
-template <bool REVERSED>
-static void StrfTimeFunctionTimestamp(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	auto &info = func_expr.bind_info->Cast<StrfTimeBindData>();
-
-	if (info.is_null) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::SetNull(result, true);
-		return;
-	}
-	info.format.ConvertTimestampVector(args.data[REVERSED ? 1 : 0], result, args.size());
-}
-
-void StrfTimeFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet strftime("strftime");
-
-	strftime.AddFunction(ScalarFunction({LogicalType::DATE, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                                    StrfTimeFunctionDate<false>, StrfTimeBindFunction<false>));
-
-	strftime.AddFunction(ScalarFunction({LogicalType::TIMESTAMP, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                                    StrfTimeFunctionTimestamp<false>, StrfTimeBindFunction<false>));
-
-	strftime.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::DATE}, LogicalType::VARCHAR,
-	                                    StrfTimeFunctionDate<true>, StrfTimeBindFunction<true>));
-
-	strftime.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP}, LogicalType::VARCHAR,
-	                                    StrfTimeFunctionTimestamp<true>, StrfTimeBindFunction<true>));
-
-	set.AddFunction(strftime);
-}
-
 void StrpTimeFormat::AddFormatSpecifier(string preceding_literal, StrTimeSpecifier specifier) {
 	numeric_width.push_back(NumericSpecifierWidth(specifier));
 	StrTimeFormat::AddFormatSpecifier(std::move(preceding_literal), specifier);
@@ -1187,79 +1091,6 @@ bool StrpTimeFormat::Parse(string_t str, ParseResult &result) {
 	return true;
 }
 
-struct StrpTimeBindData : public FunctionData {
-	StrpTimeBindData(const StrpTimeFormat &format, const string &format_string)
-	    : formats(1, format), format_strings(1, format_string) {
-	}
-
-	StrpTimeBindData(vector<StrpTimeFormat> formats_p, vector<string> format_strings_p)
-	    : formats(std::move(formats_p)), format_strings(std::move(format_strings_p)) {
-	}
-
-	vector<StrpTimeFormat> formats;
-	vector<string> format_strings;
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<StrpTimeBindData>(formats, format_strings);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const StrpTimeBindData &)other_p;
-		return format_strings == other.format_strings;
-	}
-};
-
-static unique_ptr<FunctionData> StrpTimeBindFunction(ClientContext &context, ScalarFunction &bound_function,
-                                                     vector<unique_ptr<Expression>> &arguments) {
-	if (arguments[1]->HasParameter()) {
-		throw ParameterNotResolvedException();
-	}
-	if (!arguments[1]->IsFoldable()) {
-		throw InvalidInputException("strptime format must be a constant");
-	}
-	Value format_value = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
-	string format_string;
-	StrpTimeFormat format;
-	if (format_value.IsNull()) {
-		return make_uniq<StrpTimeBindData>(format, format_string);
-	} else if (format_value.type().id() == LogicalTypeId::VARCHAR) {
-		format_string = format_value.ToString();
-		format.format_specifier = format_string;
-		string error = StrTimeFormat::ParseFormatSpecifier(format_string, format);
-		if (!error.empty()) {
-			throw InvalidInputException("Failed to parse format specifier %s: %s", format_string, error);
-		}
-		if (format.HasFormatSpecifier(StrTimeSpecifier::UTC_OFFSET)) {
-			bound_function.return_type = LogicalType::TIMESTAMP_TZ;
-		}
-		return make_uniq<StrpTimeBindData>(format, format_string);
-	} else if (format_value.type() == LogicalType::LIST(LogicalType::VARCHAR)) {
-		const auto &children = ListValue::GetChildren(format_value);
-		if (children.empty()) {
-			throw InvalidInputException("strptime format list must not be empty");
-		}
-		vector<string> format_strings;
-		vector<StrpTimeFormat> formats;
-		for (const auto &child : children) {
-			format_string = child.ToString();
-			format.format_specifier = format_string;
-			string error = StrTimeFormat::ParseFormatSpecifier(format_string, format);
-			if (!error.empty()) {
-				throw InvalidInputException("Failed to parse format specifier %s: %s", format_string, error);
-			}
-			// If any format has UTC offsets, then we have to produce TSTZ
-			if (format.HasFormatSpecifier(StrTimeSpecifier::UTC_OFFSET)) {
-				bound_function.return_type = LogicalType::TIMESTAMP_TZ;
-			}
-			format_strings.emplace_back(format_string);
-			formats.emplace_back(format);
-		}
-		return make_uniq<StrpTimeBindData>(formats, format_strings);
-	} else {
-		throw InvalidInputException("strptime format must be a string");
-	}
-}
-
 StrpTimeFormat::ParseResult StrpTimeFormat::Parse(const string &format_string, const string &text) {
 	StrpTimeFormat format;
 	format.format_specifier = format_string;
@@ -1348,83 +1179,4 @@ timestamp_t StrpTimeFormat::ParseTimestamp(string_t input) {
 	return result.ToTimestamp();
 }
 
-struct StrpTimeFunction {
-
-	static void Parse(DataChunk &args, ExpressionState &state, Vector &result) {
-		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-		auto &info = func_expr.bind_info->Cast<StrpTimeBindData>();
-
-		if (ConstantVector::IsNull(args.data[1])) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(result, true);
-			return;
-		}
-		UnaryExecutor::Execute<string_t, timestamp_t>(args.data[0], result, args.size(), [&](string_t input) {
-			StrpTimeFormat::ParseResult result;
-			for (auto &format : info.formats) {
-				if (format.Parse(input, result)) {
-					return result.ToTimestamp();
-				}
-			}
-			throw InvalidInputException(result.FormatError(input, info.formats[0].format_specifier));
-		});
-	}
-
-	static void TryParse(DataChunk &args, ExpressionState &state, Vector &result) {
-		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-		auto &info = func_expr.bind_info->Cast<StrpTimeBindData>();
-
-		if (ConstantVector::IsNull(args.data[1])) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(result, true);
-			return;
-		}
-
-		UnaryExecutor::ExecuteWithNulls<string_t, timestamp_t>(
-		    args.data[0], result, args.size(), [&](string_t input, ValidityMask &mask, idx_t idx) {
-			    timestamp_t result;
-			    string error;
-			    for (auto &format : info.formats) {
-				    if (format.TryParseTimestamp(input, result, error)) {
-					    return result;
-				    }
-			    }
-
-			    mask.SetInvalid(idx);
-			    return timestamp_t();
-		    });
-	}
-};
-
-void StrpTimeFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet strptime("strptime");
-
-	const auto list_type = LogicalType::LIST(LogicalType::VARCHAR);
-	auto fun = ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::TIMESTAMP,
-	                          StrpTimeFunction::Parse, StrpTimeBindFunction);
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	strptime.AddFunction(fun);
-
-	fun = ScalarFunction({LogicalType::VARCHAR, list_type}, LogicalType::TIMESTAMP, StrpTimeFunction::Parse,
-	                     StrpTimeBindFunction);
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	strptime.AddFunction(fun);
-
-	set.AddFunction(strptime);
-
-	ScalarFunctionSet try_strptime("try_strptime");
-
-	fun = ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::TIMESTAMP,
-	                     StrpTimeFunction::TryParse, StrpTimeBindFunction);
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	try_strptime.AddFunction(fun);
-
-	fun = ScalarFunction({LogicalType::VARCHAR, list_type}, LogicalType::TIMESTAMP, StrpTimeFunction::TryParse,
-	                     StrpTimeBindFunction);
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	try_strptime.AddFunction(fun);
-
-	set.AddFunction(try_strptime);
-}
-
 } // namespace duckdb

package/src/duckdb/src/function/scalar/string/length.cpp

@@ -138,23 +138,4 @@ void LengthFun::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(octet_length);
 }
 
-struct UnicodeOperator {
-	template <class TA, class TR>
-	static inline TR Operation(const TA &input) {
-		auto str = reinterpret_cast<const utf8proc_uint8_t *>(input.GetData());
-		auto len = input.GetSize();
-		utf8proc_int32_t codepoint;
-		(void)utf8proc_iterate(str, len, &codepoint);
-		return codepoint;
-	}
-};
-
-void UnicodeFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunction unicode("unicode", {LogicalType::VARCHAR}, LogicalType::INTEGER,
-	                       ScalarFunction::UnaryFunction<string_t, int32_t, UnicodeOperator>);
-	set.AddFunction(unicode);
-	unicode.name = "ord";
-	set.AddFunction(unicode);
-}
-
 } // namespace duckdb

package/src/duckdb/src/function/scalar/string_functions.cpp

@@ -1,61 +1,21 @@
 #include "duckdb/function/scalar/string_functions.hpp"
-#include "duckdb/function/scalar/blob_functions.hpp"
-#include "duckdb/function/scalar/uuid_functions.hpp"
-#include "duckdb/function/scalar/bit_functions.hpp"
 
 namespace duckdb {
 
 void BuiltinFunctions::RegisterStringFunctions() {
-	Register<ReverseFun>();
 	Register<LowerFun>();
 	Register<UpperFun>();
 	Register<StripAccentsFun>();
 	Register<ConcatFun>();
-	Register<StartsWithFun>();
 	Register<ContainsFun>();
 	Register<LengthFun>();
 	Register<LikeFun>();
 	Register<LikeEscapeFun>();
-	Register<LpadFun>();
-	Register<LeftFun>();
-	Register<MD5Fun>();
-	Register<RightFun>();
-	Register<PrintfFun>();
 	Register<RegexpFun>();
 	Register<SubstringFun>();
-	Register<InstrFun>();
 	Register<PrefixFun>();
-	Register<RepeatFun>();
-	Register<ReplaceFun>();
-	Register<RpadFun>();
-	Register<TranslateFun>();
 	Register<SuffixFun>();
-	Register<TrimFun>();
-	Register<UnicodeFun>();
 	Register<NFCNormalizeFun>();
-	Register<StringSplitFun>();
-	Register<BarFun>();
-	Register<ASCII>();
-	Register<CHR>();
-	Register<MismatchesFun>();
-	Register<LevenshteinFun>();
-	Register<DamerauLevenshteinFun>();
-	Register<JaccardFun>();
-	Register<JaroWinklerFun>();
-
-	// blob functions
-	Register<Base64Fun>();
-	Register<EncodeFun>();
-	Register<HexFun>();
-
-	// bit functions
-	Register<GetBitFun>();
-	Register<SetBitFun>();
-	Register<BitPositionFun>();
-	Register<BitStringFun>();
-
-	// uuid functions
-	Register<UUIDFun>();
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/scalar/system/aggregate_export.cpp

@@ -347,4 +347,9 @@ ScalarFunction ExportAggregateFunction::GetCombine() {
 	return result;
 }
 
+void ExportAggregateFunction::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction(ExportAggregateFunction::GetCombine());
+	set.AddFunction(ExportAggregateFunction::GetFinalize());
+}
+
 } // namespace duckdb

package/src/duckdb/src/function/table/arrow_conversion.cpp

@@ -225,7 +225,7 @@ static void ArrowToDuckDBBlob(Vector &vector, ArrowArray &array, ArrowScanLocalS
 }
 
 static void ArrowToDuckDBMapVerify(Vector &vector, idx_t count) {
-	auto valid_check = CheckMapValidity(vector, count);
+	auto valid_check = MapVector::CheckMapValidity(vector, count);
 	switch (valid_check) {
 	case MapInvalidReason::VALID:
 		break;

package/src/duckdb/src/function/table/system/duckdb_functions.cpp

@@ -67,6 +67,9 @@ static unique_ptr<FunctionData> DuckDBFunctionsBind(ClientContext &context, Tabl
 	names.emplace_back("function_oid");
 	return_types.emplace_back(LogicalType::BIGINT);
 
+	names.emplace_back("example");
+	return_types.emplace_back(LogicalType::VARCHAR);
+
 	return nullptr;
 }
 
@@ -105,20 +108,16 @@ struct ScalarFunctionExtractor {
 		return Value("scalar");
 	}
 
-	static Value GetFunctionDescription(ScalarFunctionCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
 	static Value GetReturnType(ScalarFunctionCatalogEntry &entry, idx_t offset) {
 		return Value(entry.functions.GetFunctionByOffset(offset).return_type.ToString());
 	}
 
-	static Value GetParameters(ScalarFunctionCatalogEntry &entry, idx_t offset) {
+	static vector<Value> GetParameters(ScalarFunctionCatalogEntry &entry, idx_t offset) {
 		vector<Value> results;
 		for (idx_t i = 0; i < entry.functions.GetFunctionByOffset(offset).arguments.size(); i++) {
 			results.emplace_back("col" + to_string(i));
 		}
-		return Value::LIST(LogicalType::VARCHAR, std::move(results));
+		return results;
 	}
 
 	static Value GetParameterTypes(ScalarFunctionCatalogEntry &entry, idx_t offset) {
@@ -154,20 +153,16 @@ struct AggregateFunctionExtractor {
 		return Value("aggregate");
 	}
 
-	static Value GetFunctionDescription(AggregateFunctionCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
 	static Value GetReturnType(AggregateFunctionCatalogEntry &entry, idx_t offset) {
 		return Value(entry.functions.GetFunctionByOffset(offset).return_type.ToString());
 	}
 
-	static Value GetParameters(AggregateFunctionCatalogEntry &entry, idx_t offset) {
+	static vector<Value> GetParameters(AggregateFunctionCatalogEntry &entry, idx_t offset) {
 		vector<Value> results;
 		for (idx_t i = 0; i < entry.functions.GetFunctionByOffset(offset).arguments.size(); i++) {
 			results.emplace_back("col" + to_string(i));
 		}
-		return Value::LIST(LogicalType::VARCHAR, std::move(results));
+		return results;
 	}
 
 	static Value GetParameterTypes(AggregateFunctionCatalogEntry &entry, idx_t offset) {
@@ -203,15 +198,11 @@ struct MacroExtractor {
 		return Value("macro");
 	}
 
-	static Value GetFunctionDescription(ScalarMacroCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
 	static Value GetReturnType(ScalarMacroCatalogEntry &entry, idx_t offset) {
 		return Value();
 	}
 
-	static Value GetParameters(ScalarMacroCatalogEntry &entry, idx_t offset) {
+	static vector<Value> GetParameters(ScalarMacroCatalogEntry &entry, idx_t offset) {
 		vector<Value> results;
 		for (auto &param : entry.function->parameters) {
 			D_ASSERT(param->type == ExpressionType::COLUMN_REF);
@@ -221,7 +212,7 @@ struct MacroExtractor {
 		for (auto &param_entry : entry.function->default_parameters) {
 			results.emplace_back(param_entry.first);
 		}
-		return Value::LIST(LogicalType::VARCHAR, std::move(results));
+		return results;
 	}
 
 	static Value GetParameterTypes(ScalarMacroCatalogEntry &entry, idx_t offset) {
@@ -259,15 +250,11 @@ struct TableMacroExtractor {
 		return Value("table_macro");
 	}
 
-	static Value GetFunctionDescription(TableMacroCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
 	static Value GetReturnType(TableMacroCatalogEntry &entry, idx_t offset) {
 		return Value();
 	}
 
-	static Value GetParameters(TableMacroCatalogEntry &entry, idx_t offset) {
+	static vector<Value> GetParameters(TableMacroCatalogEntry &entry, idx_t offset) {
 		vector<Value> results;
 		for (auto &param : entry.function->parameters) {
 			D_ASSERT(param->type == ExpressionType::COLUMN_REF);
@@ -277,7 +264,7 @@ struct TableMacroExtractor {
 		for (auto &param_entry : entry.function->default_parameters) {
 			results.emplace_back(param_entry.first);
 		}
-		return Value::LIST(LogicalType::VARCHAR, std::move(results));
+		return results;
 	}
 
 	static Value GetParameterTypes(TableMacroCatalogEntry &entry, idx_t offset) {
@@ -317,15 +304,11 @@ struct TableFunctionExtractor {
 		return Value("table");
 	}
 
-	static Value GetFunctionDescription(TableFunctionCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
 	static Value GetReturnType(TableFunctionCatalogEntry &entry, idx_t offset) {
 		return Value();
 	}
 
-	static Value GetParameters(TableFunctionCatalogEntry &entry, idx_t offset) {
+	static vector<Value> GetParameters(TableFunctionCatalogEntry &entry, idx_t offset) {
 		vector<Value> results;
 		auto fun = entry.functions.GetFunctionByOffset(offset);
 		for (idx_t i = 0; i < fun.arguments.size(); i++) {
@@ -334,7 +317,7 @@ struct TableFunctionExtractor {
 		for (auto &param : fun.named_parameters) {
 			results.emplace_back(param.first);
 		}
-		return Value::LIST(LogicalType::VARCHAR, std::move(results));
+		return results;
 	}
 
 	static Value GetParameterTypes(TableFunctionCatalogEntry &entry, idx_t offset) {
@@ -373,15 +356,11 @@ struct PragmaFunctionExtractor {
 		return Value("pragma");
 	}
 
-	static Value GetFunctionDescription(PragmaFunctionCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
 	static Value GetReturnType(PragmaFunctionCatalogEntry &entry, idx_t offset) {
 		return Value();
 	}
 
-	static Value GetParameters(PragmaFunctionCatalogEntry &entry, idx_t offset) {
+	static vector<Value> GetParameters(PragmaFunctionCatalogEntry &entry, idx_t offset) {
 		vector<Value> results;
 		auto fun = entry.functions.GetFunctionByOffset(offset);
 
@@ -391,7 +370,7 @@ struct PragmaFunctionExtractor {
 		for (auto &param : fun.named_parameters) {
 			results.emplace_back(param.first);
 		}
-		return Value::LIST(LogicalType::VARCHAR, std::move(results));
+		return results;
 	}
 
 	static Value GetParameterTypes(PragmaFunctionCatalogEntry &entry, idx_t offset) {
@@ -422,7 +401,7 @@ struct PragmaFunctionExtractor {
 };
 
 template <class T, class OP>
-bool ExtractFunctionData(CatalogEntry &entry, idx_t function_idx, DataChunk &output, idx_t output_offset) {
+bool ExtractFunctionData(FunctionEntry &entry, idx_t function_idx, DataChunk &output, idx_t output_offset) {
 	auto &function = entry.Cast<T>();
 	idx_t col = 0;
 
@@ -439,13 +418,18 @@ bool ExtractFunctionData(CatalogEntry &entry, idx_t function_idx, DataChunk &out
 	output.SetValue(col++, output_offset, Value(OP::GetFunctionType()));
 
 	// function_description, LogicalType::VARCHAR
-	output.SetValue(col++, output_offset, OP::GetFunctionDescription(function, function_idx));
+	output.SetValue(col++, output_offset, entry.description.empty() ? Value() : entry.description);
 
 	// return_type, LogicalType::VARCHAR
 	output.SetValue(col++, output_offset, OP::GetReturnType(function, function_idx));
 
 	// parameters, LogicalType::LIST(LogicalType::VARCHAR)
-	output.SetValue(col++, output_offset, OP::GetParameters(function, function_idx));
+	auto parameters = OP::GetParameters(function, function_idx);
+	for (idx_t param_idx = 0; param_idx < function.parameter_names.size() && param_idx < parameters.size();
+	     param_idx++) {
+		parameters[param_idx] = Value(function.parameter_names[param_idx]);
+	}
+	output.SetValue(col++, output_offset, Value::LIST(LogicalType::VARCHAR, std::move(parameters)));
 
 	// parameter_types, LogicalType::LIST(LogicalType::VARCHAR)
 	output.SetValue(col++, output_offset, OP::GetParameterTypes(function, function_idx));
@@ -465,6 +449,9 @@ bool ExtractFunctionData(CatalogEntry &entry, idx_t function_idx, DataChunk &out
 	// function_oid, LogicalType::BIGINT
 	output.SetValue(col++, output_offset, Value::BIGINT(function.oid));
 
+	// example, LogicalType::VARCHAR
+	output.SetValue(col++, output_offset, entry.example.empty() ? Value() : entry.example);
+
 	return function_idx + 1 == OP::FunctionCount(function);
 }
 
@@ -478,7 +465,7 @@ void DuckDBFunctionsFunction(ClientContext &context, TableFunctionInput &data_p,
 	// either fill up the chunk or return all the remaining columns
 	idx_t count = 0;
 	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.entries[data.offset].get();
+		auto &entry = data.entries[data.offset].get().Cast<FunctionEntry>();
 		bool finished;
 
 		switch (entry.type) {

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.2-dev2740"
+#define DUCKDB_VERSION "0.7.2-dev2820"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "bb37f3fd06"
+#define DUCKDB_SOURCE_ID "fc797c18cf"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include "duckdb/catalog/standard_entry.hpp"
+#include "duckdb/catalog/catalog_entry/function_entry.hpp"
 #include "duckdb/catalog/catalog_set.hpp"
 #include "duckdb/function/function.hpp"
 #include "duckdb/parser/parsed_data/create_aggregate_function_info.hpp"
@@ -16,14 +16,14 @@
 namespace duckdb {
 
 //! An aggregate function in the catalog
-class AggregateFunctionCatalogEntry : public StandardEntry {
+class AggregateFunctionCatalogEntry : public FunctionEntry {
 public:
 	static constexpr const CatalogType Type = CatalogType::AGGREGATE_FUNCTION_ENTRY;
 	static constexpr const char *Name = "aggregate function";
 
 public:
 	AggregateFunctionCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateAggregateFunctionInfo &info)
-	    : StandardEntry(CatalogType::AGGREGATE_FUNCTION_ENTRY, schema, catalog, info.name), functions(info.functions) {
+	    : FunctionEntry(CatalogType::AGGREGATE_FUNCTION_ENTRY, catalog, schema, info), functions(info.functions) {
 	}
 
 	//! The aggregate functions