duckdb 0.7.2-dev2706.0 → 0.7.2-dev2820.0

package/src/duckdb/src/function/function.cpp

@@ -92,21 +92,13 @@ void BuiltinFunctions::Initialize() {
 	RegisterTableFunctions();
 	RegisterArrowFunctions();
 
-	RegisterAlgebraicAggregates();
 	RegisterDistributiveAggregates();
-	RegisterNestedAggregates();
-	RegisterHolisticAggregates();
-	RegisterRegressiveAggregates();
 
-	RegisterDateFunctions();
-	RegisterEnumFunctions();
 	RegisterGenericFunctions();
-	RegisterMathFunctions();
 	RegisterOperators();
 	RegisterSequenceFunctions();
 	RegisterStringFunctions();
 	RegisterNestedFunctions();
-	RegisterTrigonometricsFunctions();
 
 	RegisterPragmaFunctions();
 

package/src/duckdb/src/function/function_set.cpp

@@ -3,9 +3,16 @@
 
 namespace duckdb {
 
+ScalarFunctionSet::ScalarFunctionSet() : FunctionSet("") {
+}
+
 ScalarFunctionSet::ScalarFunctionSet(string name) : FunctionSet(std::move(name)) {
 }
 
+ScalarFunctionSet::ScalarFunctionSet(ScalarFunction fun) : FunctionSet(std::move(fun.name)) {
+	functions.push_back(std::move(fun));
+}
+
 ScalarFunction ScalarFunctionSet::GetFunctionByArguments(ClientContext &context, const vector<LogicalType> &arguments) {
 	string error;
 	FunctionBinder binder(context);
@@ -17,9 +24,16 @@ ScalarFunction ScalarFunctionSet::GetFunctionByArguments(ClientContext &context,
 	return GetFunctionByOffset(index);
 }
 
+AggregateFunctionSet::AggregateFunctionSet() : FunctionSet("") {
+}
+
 AggregateFunctionSet::AggregateFunctionSet(string name) : FunctionSet(std::move(name)) {
 }
 
+AggregateFunctionSet::AggregateFunctionSet(AggregateFunction fun) : FunctionSet(std::move(fun.name)) {
+	functions.push_back(std::move(fun));
+}
+
 AggregateFunction AggregateFunctionSet::GetFunctionByArguments(ClientContext &context,
                                                                const vector<LogicalType> &arguments) {
 	string error;
@@ -53,6 +67,10 @@ AggregateFunction AggregateFunctionSet::GetFunctionByArguments(ClientContext &co
 TableFunctionSet::TableFunctionSet(string name) : FunctionSet(std::move(name)) {
 }
 
+TableFunctionSet::TableFunctionSet(TableFunction fun) : FunctionSet(std::move(fun.name)) {
+	functions.push_back(std::move(fun));
+}
+
 TableFunction TableFunctionSet::GetFunctionByArguments(ClientContext &context, const vector<LogicalType> &arguments) {
 	string error;
 	FunctionBinder binder(context);
@@ -64,4 +82,11 @@ TableFunction TableFunctionSet::GetFunctionByArguments(ClientContext &context, c
 	return GetFunctionByOffset(index);
 }
 
+PragmaFunctionSet::PragmaFunctionSet(string name) : FunctionSet(std::move(name)) {
+}
+
+PragmaFunctionSet::PragmaFunctionSet(PragmaFunction fun) : FunctionSet(std::move(fun.name)) {
+	functions.push_back(std::move(fun));
+}
+
 } // namespace duckdb

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

@@ -3,16 +3,8 @@
 namespace duckdb {
 
 void BuiltinFunctions::RegisterGenericFunctions() {
-	Register<AliasFun>();
-	Register<HashFun>();
-	Register<LeastFun>();
-	Register<GreatestFun>();
-	Register<StatsFun>();
-	Register<TypeOfFun>();
 	Register<ConstantOrNull>();
-	Register<CurrentSettingFun>();
-	Register<SystemFun>();
-	Register<ErrorFun>();
+	Register<ExportAggregateFunction>();
 }
 
 } // namespace duckdb

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

@@ -3,33 +3,11 @@
 namespace duckdb {
 
 void BuiltinFunctions::RegisterNestedFunctions() {
-	Register<ArraySliceFun>();
-	Register<StructPackFun>();
 	Register<StructExtractFun>();
-	Register<StructInsertFun>();
-	Register<ListTransformFun>();
-	Register<ListFilterFun>();
 	Register<ListConcatFun>();
 	Register<ListContainsFun>();
 	Register<ListPositionFun>();
-	Register<ListAggregateFun>();
-	Register<ListDistinctFun>();
-	Register<ListUniqueFun>();
-	Register<ListValueFun>();
 	Register<ListExtractFun>();
-	Register<ListSortFun>();
-	Register<ListRangeFun>();
-	Register<ListFlattenFun>();
-	Register<MapFun>();
-	Register<MapFromEntriesFun>();
-	Register<MapEntriesFun>();
-	Register<MapValuesFun>();
-	Register<MapKeysFun>();
-	Register<MapExtractFun>();
-	Register<UnionValueFun>();
-	Register<UnionExtractFun>();
-	Register<UnionTagFun>();
-	Register<CardinalityFun>();
 }
 
 } // namespace duckdb

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/range.cpp

@@ -273,6 +273,7 @@ void BuiltinFunctions::RegisterTableFunctions() {
 	RepeatTableFunction::RegisterFunction(*this);
 	SummaryTableFunction::RegisterFunction(*this);
 	UnnestTableFunction::RegisterFunction(*this);
+	RepeatRowTableFunction::RegisterFunction(*this);
 }
 
 } // namespace duckdb

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

@@ -0,0 +1,60 @@
+#include "duckdb/function/table/range.hpp"
+#include "duckdb/common/algorithm.hpp"
+
+namespace duckdb {
+
+struct RepeatRowFunctionData : public TableFunctionData {
+	RepeatRowFunctionData(vector<Value> values, idx_t target_count)
+	    : values(std::move(values)), target_count(target_count) {
+	}
+
+	const vector<Value> values;
+	idx_t target_count;
+};
+
+struct RepeatRowOperatorData : public GlobalTableFunctionState {
+	RepeatRowOperatorData() : current_count(0) {
+	}
+	idx_t current_count;
+};
+
+static unique_ptr<FunctionData> RepeatRowBind(ClientContext &context, TableFunctionBindInput &input,
+                                              vector<LogicalType> &return_types, vector<string> &names) {
+	auto &inputs = input.inputs;
+	for (idx_t input_idx = 0; input_idx < inputs.size(); input_idx++) {
+		return_types.push_back(inputs[input_idx].type());
+		names.push_back("column" + std::to_string(input_idx));
+	}
+	return make_uniq<RepeatRowFunctionData>(inputs, input.named_parameters["num_rows"].GetValue<int64_t>());
+}
+
+static unique_ptr<GlobalTableFunctionState> RepeatRowInit(ClientContext &context, TableFunctionInitInput &input) {
+	return make_uniq<RepeatRowOperatorData>();
+}
+
+static void RepeatRowFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &bind_data = (const RepeatRowFunctionData &)*data_p.bind_data;
+	auto &state = data_p.global_state->Cast<RepeatRowOperatorData>();
+
+	idx_t remaining = MinValue<idx_t>(bind_data.target_count - state.current_count, STANDARD_VECTOR_SIZE);
+	for (idx_t val_idx = 0; val_idx < bind_data.values.size(); val_idx++) {
+		output.data[val_idx].Reference(bind_data.values[val_idx]);
+	}
+	output.SetCardinality(remaining);
+	state.current_count += remaining;
+}
+
+static unique_ptr<NodeStatistics> RepeatRowCardinality(ClientContext &context, const FunctionData *bind_data_p) {
+	auto &bind_data = (const RepeatRowFunctionData &)*bind_data_p;
+	return make_uniq<NodeStatistics>(bind_data.target_count, bind_data.target_count);
+}
+
+void RepeatRowTableFunction::RegisterFunction(BuiltinFunctions &set) {
+	TableFunction repeat_row("repeat_row", {}, RepeatRowFunction, RepeatRowBind, RepeatRowInit);
+	repeat_row.varargs = LogicalType::ANY;
+	repeat_row.named_parameters["num_rows"] = LogicalType::BIGINT;
+	repeat_row.cardinality = RepeatRowCardinality;
+	set.AddFunction(repeat_row);
+}
+
+} // namespace duckdb