duckdb 0.7.2-dev314.0 → 0.7.2-dev3154.0

package/src/duckdb/src/{function → core_functions}/scalar/operators/bitwise.cpp

@@ -1,7 +1,6 @@
-#include "duckdb/function/scalar/operators.hpp"
+#include "duckdb/core_functions/scalar/operators_functions.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/common/types/cast_helpers.hpp"
-#include "duckdb/function/scalar/bit_functions.hpp"
 #include "duckdb/common/types/bit.hpp"
 
 namespace duckdb {
@@ -100,14 +99,14 @@ static void BitwiseANDOperation(DataChunk &args, ExpressionState &state, Vector
 	    });
 }
 
-void BitwiseAndFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("&");
+ScalarFunctionSet BitwiseAndFun::GetFunctions() {
+	ScalarFunctionSet functions;
 	for (auto &type : LogicalType::Integral()) {
 		functions.AddFunction(
 		    ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction<BitwiseANDOperator>(type)));
 	}
 	functions.AddFunction(ScalarFunction({LogicalType::BIT, LogicalType::BIT}, LogicalType::BIT, BitwiseANDOperation));
-	set.AddFunction(functions);
+	return functions;
 }
 
 //===--------------------------------------------------------------------===//
@@ -130,14 +129,14 @@ static void BitwiseOROperation(DataChunk &args, ExpressionState &state, Vector &
 	    });
 }
 
-void BitwiseOrFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("|");
+ScalarFunctionSet BitwiseOrFun::GetFunctions() {
+	ScalarFunctionSet functions;
 	for (auto &type : LogicalType::Integral()) {
 		functions.AddFunction(
 		    ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction<BitwiseOROperator>(type)));
 	}
 	functions.AddFunction(ScalarFunction({LogicalType::BIT, LogicalType::BIT}, LogicalType::BIT, BitwiseOROperation));
-	set.AddFunction(functions);
+	return functions;
 }
 
 //===--------------------------------------------------------------------===//
@@ -160,14 +159,14 @@ static void BitwiseXOROperation(DataChunk &args, ExpressionState &state, Vector
 	    });
 }
 
-void BitwiseXorFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("xor");
+ScalarFunctionSet BitwiseXorFun::GetFunctions() {
+	ScalarFunctionSet functions;
 	for (auto &type : LogicalType::Integral()) {
 		functions.AddFunction(
 		    ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction<BitwiseXOROperator>(type)));
 	}
 	functions.AddFunction(ScalarFunction({LogicalType::BIT, LogicalType::BIT}, LogicalType::BIT, BitwiseXOROperation));
-	set.AddFunction(functions);
+	return functions;
 }
 
 //===--------------------------------------------------------------------===//
@@ -189,13 +188,13 @@ static void BitwiseNOTOperation(DataChunk &args, ExpressionState &state, Vector
 	});
 }
 
-void BitwiseNotFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("~");
+ScalarFunctionSet BitwiseNotFun::GetFunctions() {
+	ScalarFunctionSet functions;
 	for (auto &type : LogicalType::Integral()) {
 		functions.AddFunction(ScalarFunction({type}, type, GetScalarIntegerUnaryFunction<BitwiseNotOperator>(type)));
 	}
 	functions.AddFunction(ScalarFunction({LogicalType::BIT}, LogicalType::BIT, BitwiseNOTOperation));
-	set.AddFunction(functions);
+	return functions;
 }
 
 //===--------------------------------------------------------------------===//
@@ -251,15 +250,15 @@ static void BitwiseShiftLeftOperation(DataChunk &args, ExpressionState &state, V
 	    });
 }
 
-void LeftShiftFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("<<");
+ScalarFunctionSet LeftShiftFun::GetFunctions() {
+	ScalarFunctionSet functions;
 	for (auto &type : LogicalType::Integral()) {
 		functions.AddFunction(
 		    ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction<BitwiseShiftLeftOperator>(type)));
 	}
 	functions.AddFunction(
 	    ScalarFunction({LogicalType::BIT, LogicalType::INTEGER}, LogicalType::BIT, BitwiseShiftLeftOperation));
-	set.AddFunction(functions);
+	return functions;
 }
 
 //===--------------------------------------------------------------------===//
@@ -294,15 +293,15 @@ static void BitwiseShiftRightOperation(DataChunk &args, ExpressionState &state,
 	    });
 }
 
-void RightShiftFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions(">>");
+ScalarFunctionSet RightShiftFun::GetFunctions() {
+	ScalarFunctionSet functions;
 	for (auto &type : LogicalType::Integral()) {
 		functions.AddFunction(
 		    ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction<BitwiseShiftRightOperator>(type)));
 	}
 	functions.AddFunction(
 	    ScalarFunction({LogicalType::BIT, LogicalType::INTEGER}, LogicalType::BIT, BitwiseShiftRightOperation));
-	set.AddFunction(functions);
+	return functions;
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function/scalar/math → core_functions/scalar/random}/random.cpp

@@ -1,10 +1,9 @@
-#include "duckdb/function/scalar/math_functions.hpp"
+#include "duckdb/core_functions/scalar/random_functions.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/common/random_engine.hpp"
-#include "duckdb/function/scalar/uuid_functions.hpp"
 #include "duckdb/common/types/uuid.hpp"
 
 namespace duckdb {
@@ -18,7 +17,7 @@ struct RandomLocalState : public FunctionLocalState {
 
 static void RandomFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 0);
-	auto &lstate = (RandomLocalState &)*ExecuteFunctionState::GetFunctionState(state);
+	auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RandomLocalState>();
 
 	result.SetVectorType(VectorType::FLAT_VECTOR);
 	auto result_data = FlatVector::GetData<double>(result);
@@ -31,19 +30,19 @@ static unique_ptr<FunctionLocalState> RandomInitLocalState(ExpressionState &stat
                                                            FunctionData *bind_data) {
 	auto &random_engine = RandomEngine::Get(state.GetContext());
 	lock_guard<mutex> guard(random_engine.lock);
-	return make_unique<RandomLocalState>(random_engine.NextRandomInteger());
+	return make_uniq<RandomLocalState>(random_engine.NextRandomInteger());
 }
 
-void RandomFun::RegisterFunction(BuiltinFunctions &set) {
+ScalarFunction RandomFun::GetFunction() {
 	ScalarFunction random("random", {}, LogicalType::DOUBLE, RandomFunction, nullptr, nullptr, nullptr,
 	                      RandomInitLocalState);
 	random.side_effects = FunctionSideEffects::HAS_SIDE_EFFECTS;
-	set.AddFunction(random);
+	return random;
 }
 
 static void GenerateUUIDFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 0);
-	auto &lstate = (RandomLocalState &)*ExecuteFunctionState::GetFunctionState(state);
+	auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RandomLocalState>();
 
 	result.SetVectorType(VectorType::FLAT_VECTOR);
 	auto result_data = FlatVector::GetData<hugeint_t>(result);
@@ -53,12 +52,12 @@ static void GenerateUUIDFunction(DataChunk &args, ExpressionState &state, Vector
 	}
 }
 
-void UUIDFun::RegisterFunction(BuiltinFunctions &set) {
+ScalarFunction UUIDFun::GetFunction() {
 	ScalarFunction uuid_function({}, LogicalType::UUID, GenerateUUIDFunction, nullptr, nullptr, nullptr,
 	                             RandomInitLocalState);
 	// generate a random uuid
 	uuid_function.side_effects = FunctionSideEffects::HAS_SIDE_EFFECTS;
-	set.AddFunction({"uuid", "gen_random_uuid"}, uuid_function);
+	return uuid_function;
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function/scalar/math → core_functions/scalar/random}/setseed.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/math_functions.hpp"
+#include "duckdb/core_functions/scalar/random_functions.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/execution/expression_executor.hpp"
@@ -17,7 +17,7 @@ struct SetseedBindData : public FunctionData {
 	}
 
 	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<SetseedBindData>(context);
+		return make_uniq<SetseedBindData>(context);
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
@@ -26,8 +26,8 @@ struct SetseedBindData : public FunctionData {
 };
 
 static void SetSeedFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (SetseedBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<SetseedBindData>();
 	auto &input = args.data[0];
 	input.Flatten(args.size());
 
@@ -49,13 +49,13 @@ static void SetSeedFunction(DataChunk &args, ExpressionState &state, Vector &res
 
 unique_ptr<FunctionData> SetSeedBind(ClientContext &context, ScalarFunction &bound_function,
                                      vector<unique_ptr<Expression>> &arguments) {
-	return make_unique<SetseedBindData>(context);
+	return make_uniq<SetseedBindData>(context);
 }
 
-void SetseedFun::RegisterFunction(BuiltinFunctions &set) {
+ScalarFunction SetseedFun::GetFunction() {
 	ScalarFunction setseed("setseed", {LogicalType::DOUBLE}, LogicalType::SQLNULL, SetSeedFunction, SetSeedBind);
 	setseed.side_effects = FunctionSideEffects::HAS_SIDE_EFFECTS;
-	set.AddFunction(setseed);
+	return setseed;
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/scalar/string/ascii.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/string_functions.hpp"
+#include "duckdb/core_functions/scalar/string_functions.hpp"
 #include "utf8proc.hpp"
 #include "utf8proc_wrapper.hpp"
 
@@ -7,7 +7,7 @@ namespace duckdb {
 struct AsciiOperator {
 	template <class TA, class TR>
 	static inline TR Operation(const TA &input) {
-		auto str = input.GetDataUnsafe();
+		auto str = input.GetData();
 		if (Utf8Proc::Analyze(str, input.GetSize()) == UnicodeType::ASCII) {
 			return str[0];
 		}
@@ -16,10 +16,9 @@ struct AsciiOperator {
 	}
 };
 
-void ASCII::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunction ascii("ascii", {LogicalType::VARCHAR}, LogicalType::INTEGER,
-	                     ScalarFunction::UnaryFunction<string_t, int32_t, AsciiOperator>);
-	set.AddFunction(ascii);
+ScalarFunction ASCIIFun::GetFunction() {
+	return ScalarFunction({LogicalType::VARCHAR}, LogicalType::INTEGER,
+	                      ScalarFunction::UnaryFunction<string_t, int32_t, AsciiOperator>);
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/scalar/string/bar.cpp

@@ -1,3 +1,4 @@
+#include "duckdb/core_functions/scalar/string_functions.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/operator/cast_operators.hpp"
 #include "duckdb/common/types/string_type.hpp"
@@ -5,7 +6,6 @@
 #include "duckdb/common/types/vector.hpp"
 #include "duckdb/common/unicode_bar.hpp"
 #include "duckdb/common/vector_operations/generic_executor.hpp"
-#include "duckdb/function/scalar/string_functions.hpp"
 
 namespace duckdb {
 
@@ -81,13 +81,13 @@ static void BarFunction(DataChunk &args, ExpressionState &state, Vector &result)
 	}
 }
 
-void BarFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet bar("bar");
+ScalarFunctionSet BarFun::GetFunctions() {
+	ScalarFunctionSet bar;
 	bar.AddFunction(ScalarFunction({LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE},
 	                               LogicalType::VARCHAR, BarFunction));
 	bar.AddFunction(ScalarFunction({LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE},
 	                               LogicalType::VARCHAR, BarFunction));
-	set.AddFunction(bar);
+	return bar;
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/scalar/string/chr.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/string_functions.hpp"
+#include "duckdb/core_functions/scalar/string_functions.hpp"
 #include "utf8proc.hpp"
 #include "utf8proc_wrapper.hpp"
 
@@ -35,15 +35,14 @@ static void ChrFunction(DataChunk &args, ExpressionState &state, Vector &result)
 }
 #endif
 
-void CHR::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunction chr("chr", {LogicalType::INTEGER}, LogicalType::VARCHAR,
+ScalarFunction ChrFun::GetFunction() {
+	return ScalarFunction("chr", {LogicalType::INTEGER}, LogicalType::VARCHAR,
 #ifdef DUCKDB_DEBUG_NO_INLINE
-	                   ChrFunction
+	                      ChrFunction
 #else
-	                   ScalarFunction::UnaryFunction<int32_t, string_t, ChrOperator>
+	                      ScalarFunction::UnaryFunction<int32_t, string_t, ChrOperator>
 #endif
 	);
-	set.AddFunction(chr);
 }
 
 } // namespace duckdb

package/src/duckdb/src/core_functions/scalar/string/damerau_levenshtein.cpp

@@ -0,0 +1,104 @@
+#include "duckdb/core_functions/scalar/string_functions.hpp"
+#include "duckdb/common/map.hpp"
+#include "duckdb/common/vector.hpp"
+
+namespace duckdb {
+
+// Using Lowrance-Wagner (LW) algorithm: https://doi.org/10.1145%2F321879.321880
+// Can't calculate as trivial modification to levenshtein algorithm
+// as we need to potentially know about earlier in the string
+static idx_t DamerauLevenshteinDistance(const string_t &source, const string_t &target) {
+	// costs associated with each type of edit, to aid readability
+	constexpr uint8_t COST_SUBSTITUTION = 1;
+	constexpr uint8_t COST_INSERTION = 1;
+	constexpr uint8_t COST_DELETION = 1;
+	constexpr uint8_t COST_TRANSPOSITION = 1;
+	const auto source_len = source.GetSize();
+	const auto target_len = target.GetSize();
+
+	// If one string is empty, the distance equals the length of the other string
+	// either through target_len insertions
+	// or source_len deletions
+	if (source_len == 0) {
+		return target_len * COST_INSERTION;
+	} else if (target_len == 0) {
+		return source_len * COST_DELETION;
+	}
+
+	const auto source_str = source.GetData();
+	const auto target_str = target.GetData();
+
+	// larger than the largest possible value:
+	const auto inf = source_len * COST_DELETION + target_len * COST_INSERTION + 1;
+	// minimum edit distance from prefix of source string to prefix of target string
+	// same object as H in LW paper (with indices offset by 1)
+	vector<vector<idx_t>> distance(source_len + 2, vector<idx_t>(target_len + 2, inf));
+	// keeps track of the largest string indices of source string matching each character
+	// same as DA in LW paper
+	map<char, idx_t> largest_source_chr_matching;
+
+	// initialise row/column corresponding to zero-length strings
+	// partial string -> empty requires a deletion for each character
+	for (idx_t source_idx = 0; source_idx <= source_len; source_idx++) {
+		distance[source_idx + 1][1] = source_idx * COST_DELETION;
+	}
+	// and empty -> partial string means simply inserting characters
+	for (idx_t target_idx = 1; target_idx <= target_len; target_idx++) {
+		distance[1][target_idx + 1] = target_idx * COST_INSERTION;
+	}
+	// loop through string indices - these are offset by 2 from distance indices
+	for (idx_t source_idx = 0; source_idx < source_len; source_idx++) {
+		// keeps track of the largest string indices of target string matching current source character
+		// same as DB in LW paper
+		idx_t largest_target_chr_matching;
+		largest_target_chr_matching = 0;
+		for (idx_t target_idx = 0; target_idx < target_len; target_idx++) {
+			// correspond to i1 and j1 in LW paper respectively
+			idx_t largest_source_chr_matching_target;
+			idx_t largest_target_chr_matching_source;
+			// cost associated to diagnanl shift in distance matrix
+			// corresponds to d in LW paper
+			uint8_t cost_diagonal_shift;
+			largest_source_chr_matching_target = largest_source_chr_matching[target_str[target_idx]];
+			largest_target_chr_matching_source = largest_target_chr_matching;
+			// if characters match, diagonal move costs nothing and we update our largest target index
+			// otherwise move is substitution and costs as such
+			if (source_str[source_idx] == target_str[target_idx]) {
+				cost_diagonal_shift = 0;
+				largest_target_chr_matching = target_idx + 1;
+			} else {
+				cost_diagonal_shift = COST_SUBSTITUTION;
+			}
+			distance[source_idx + 2][target_idx + 2] = MinValue(
+			    distance[source_idx + 1][target_idx + 1] + cost_diagonal_shift,
+			    MinValue(distance[source_idx + 2][target_idx + 1] + COST_INSERTION,
+			             MinValue(distance[source_idx + 1][target_idx + 2] + COST_DELETION,
+			                      distance[largest_source_chr_matching_target][largest_target_chr_matching_source] +
+			                          (source_idx - largest_source_chr_matching_target) * COST_DELETION +
+			                          COST_TRANSPOSITION +
+			                          (target_idx - largest_target_chr_matching_source) * COST_INSERTION)));
+		}
+		largest_source_chr_matching[source_str[source_idx]] = source_idx + 1;
+	}
+	return distance[source_len + 1][target_len + 1];
+}
+
+static int64_t DamerauLevenshteinScalarFunction(Vector &result, const string_t source, const string_t target) {
+	return (int64_t)DamerauLevenshteinDistance(source, target);
+}
+
+static void DamerauLevenshteinFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &source_vec = args.data[0];
+	auto &target_vec = args.data[1];
+
+	BinaryExecutor::Execute<string_t, string_t, int64_t>(
+	    source_vec, target_vec, result, args.size(),
+	    [&](string_t source, string_t target) { return DamerauLevenshteinScalarFunction(result, source, target); });
+}
+
+ScalarFunction DamerauLevenshteinFun::GetFunction() {
+	return ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BIGINT,
+	                      DamerauLevenshteinFunction);
+}
+
+} // namespace duckdb

package/src/duckdb/src/core_functions/scalar/string/format_bytes.cpp

@@ -0,0 +1,29 @@
+#include "duckdb/core_functions/scalar/string_functions.hpp"
+#include "duckdb/common/types/data_chunk.hpp"
+#include "duckdb/common/string_util.hpp"
+
+namespace duckdb {
+
+static void FormatBytesFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	UnaryExecutor::Execute<int64_t, string_t>(args.data[0], result, args.size(), [&](int64_t bytes) {
+		bool is_negative = bytes < 0;
+		idx_t unsigned_bytes;
+		if (bytes < 0) {
+			if (bytes == NumericLimits<int64_t>::Minimum()) {
+				unsigned_bytes = idx_t(NumericLimits<int64_t>::Maximum()) + 1;
+			} else {
+				unsigned_bytes = idx_t(-bytes);
+			}
+		} else {
+			unsigned_bytes = idx_t(bytes);
+		}
+		return StringVector::AddString(result, (is_negative ? "-" : "") +
+		                                           StringUtil::BytesToHumanReadableString(unsigned_bytes));
+	});
+}
+
+ScalarFunction FormatBytesFun::GetFunction() {
+	return ScalarFunction({LogicalType::BIGINT}, LogicalType::VARCHAR, FormatBytesFunction);
+}
+
+} // namespace duckdb

package/src/duckdb/src/{function/scalar/string/mismatches.cpp → core_functions/scalar/string/hamming.cpp}

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/string_functions.hpp"
+#include "duckdb/core_functions/scalar/string_functions.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 
 #include <ctype.h>
@@ -18,8 +18,8 @@ static int64_t MismatchesScalarFunction(Vector &result, const string_t str, stri
 	}
 
 	idx_t mismatches = 0;
-	auto str_str = str.GetDataUnsafe();
-	auto tgt_str = tgt.GetDataUnsafe();
+	auto str_str = str.GetData();
+	auto tgt_str = tgt.GetData();
 
 	for (idx_t idx = 0; idx < str_len; ++idx) {
 		if (str_str[idx] != tgt_str[idx]) {
@@ -38,17 +38,8 @@ static void MismatchesFunction(DataChunk &args, ExpressionState &state, Vector &
 	    [&](string_t str, string_t tgt) { return MismatchesScalarFunction(result, str, tgt); });
 }
 
-void MismatchesFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet mismatches("mismatches");
-	mismatches.AddFunction(ScalarFunction("mismatches", {LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                                      LogicalType::BIGINT,
-	                                      MismatchesFunction)); // Pointer to function implementation
-	set.AddFunction(mismatches);
-
-	ScalarFunctionSet hamming("hamming");
-	hamming.AddFunction(ScalarFunction("mismatches", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BIGINT,
-	                                   MismatchesFunction)); // Pointer to function implementation
-	set.AddFunction(hamming);
+ScalarFunction HammingFun::GetFunction() {
+	return ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BIGINT, MismatchesFunction);
 }
 
 } // namespace duckdb