duckdb 0.7.2-dev2740.0 → 0.7.2-dev2867.0

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

@@ -497,7 +497,8 @@ bool ParallelCSVGlobalState::Next(ClientContext &context, const ReadCSVData &bin
 		}
 		reader->options.file_path = current_file_path;
 		MultiFileReader::InitializeReader(*reader, bind_data.options.file_options, bind_data.reader_bind,
-		                                  bind_data.return_types, bind_data.return_names, column_ids, nullptr);
+		                                  bind_data.return_types, bind_data.return_names, column_ids, nullptr,
+		                                  bind_data.files.front());
 	} else {
 		// update the current reader
 		reader->SetBufferRead(std::move(result));
@@ -660,7 +661,8 @@ struct SingleThreadedCSVState : public GlobalTableFunctionState {
 				result->names = csv_names;
 			}
 			MultiFileReader::InitializeReader(*result, bind_data.options.file_options, bind_data.reader_bind,
-			                                  bind_data.return_types, bind_data.return_names, column_ids, nullptr);
+			                                  bind_data.return_types, bind_data.return_names, column_ids, nullptr,
+			                                  bind_data.files.front());
 		}
 		total_size = result->file_handle->FileSize();
 		return result;
@@ -707,14 +709,15 @@ static unique_ptr<GlobalTableFunctionState> SingleThreadedCSVInit(ClientContext
 		}
 	}
 	MultiFileReader::InitializeReader(*result->initial_reader, bind_data.options.file_options, bind_data.reader_bind,
-	                                  bind_data.return_types, bind_data.return_names, input.column_ids, input.filters);
+	                                  bind_data.return_types, bind_data.return_names, input.column_ids, input.filters,
+	                                  bind_data.files.front());
 	for (auto &reader : bind_data.union_readers) {
 		if (!reader) {
 			continue;
 		}
 		MultiFileReader::InitializeReader(*reader, bind_data.options.file_options, bind_data.reader_bind,
 		                                  bind_data.return_types, bind_data.return_names, input.column_ids,
-		                                  input.filters);
+		                                  input.filters, bind_data.files.front());
 	}
 	result->column_ids = input.column_ids;