duckdb 0.6.2-dev971.0 → 0.7.1-dev2.0

package/src/duckdb/src/function/scalar/list/list_lambdas.cpp

@@ -5,6 +5,8 @@
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/planner/expression/bound_lambda_expression.hpp"
+#include "duckdb/planner/expression/bound_cast_expression.hpp"
+#include "duckdb/function/cast/cast_function_set.hpp"
 
 namespace duckdb {
 
@@ -28,7 +30,7 @@ public:
 };
 
 ListLambdaBindData::ListLambdaBindData(const LogicalType &stype_p, unique_ptr<Expression> lambda_expr_p)
-    : stype(stype_p), lambda_expr(move(lambda_expr_p)) {
+    : stype(stype_p), lambda_expr(std::move(lambda_expr_p)) {
 }
 
 unique_ptr<FunctionData> ListLambdaBindData::Copy() const {
@@ -112,15 +114,19 @@ static void ExecuteExpression(vector<LogicalType> &types, vector<LogicalType> &r
 
 	// set the list child vector
 	Vector slice(child_vector, sel, elem_cnt);
+	Vector second_slice(child_vector, sel, elem_cnt);
 	slice.Flatten(elem_cnt);
+	second_slice.Flatten(elem_cnt);
+
 	input_chunk.data[0].Reference(slice);
+	input_chunk.data[1].Reference(second_slice);
 
 	// set the other vectors
 	vector<Vector> slices;
 	for (idx_t col_idx = 0; col_idx < args.ColumnCount() - 1; col_idx++) {
 		slices.emplace_back(Vector(args.data[col_idx + 1], sel_vectors[col_idx], elem_cnt));
 		slices[col_idx].Flatten(elem_cnt);
-		input_chunk.data[col_idx + 1].Reference(slices[col_idx]);
+		input_chunk.data[col_idx + 2].Reference(slices[col_idx]);
 	}
 
 	// execute the lambda expression
@@ -185,6 +191,7 @@ static void ListLambdaFunction(DataChunk &args, ExpressionState &state, Vector &
 
 	vector<LogicalType> types;
 	types.push_back(child_vector.GetType());
+	types.push_back(child_vector.GetType());
 
 	// skip the list column
 	for (idx_t i = 1; i < args.ColumnCount(); i++) {
@@ -331,8 +338,8 @@ static unique_ptr<FunctionData> ListLambdaBind(ClientContext &context, ScalarFun
 	D_ASSERT(arguments[0]->return_type.id() == LogicalTypeId::LIST);
 
 	// get the lambda expression and put it in the bind info
-	auto lambda_expr = move(bound_lambda_expr.lambda_expr);
-	return make_unique<ListLambdaBindData>(bound_function.return_type, move(lambda_expr));
+	auto lambda_expr = std::move(bound_lambda_expr.lambda_expr);
+	return make_unique<ListLambdaBindData>(bound_function.return_type, std::move(lambda_expr));
 }
 
 static unique_ptr<FunctionData> ListTransformBind(ClientContext &context, ScalarFunction &bound_function,
@@ -357,6 +364,15 @@ static unique_ptr<FunctionData> ListFilterBind(ClientContext &context, ScalarFun
 	if (arguments[1]->expression_class != ExpressionClass::BOUND_LAMBDA) {
 		throw BinderException("Invalid lambda expression!");
 	}
+
+	// try to cast to boolean, if the return type of the lambda filter expression is not already boolean
+	auto &bound_lambda_expr = (BoundLambdaExpression &)*arguments[1];
+	if (bound_lambda_expr.lambda_expr->return_type != LogicalType::BOOLEAN) {
+		auto cast_lambda_expr =
+		    BoundCastExpression::AddCastToType(context, std::move(bound_lambda_expr.lambda_expr), LogicalType::BOOLEAN);
+		bound_lambda_expr.lambda_expr = std::move(cast_lambda_expr);
+	}
+
 	bound_function.return_type = arguments[0]->return_type;
 	return ListLambdaBind<1>(context, bound_function, arguments);
 }

package/src/duckdb/src/function/scalar/list/list_sort.cpp

@@ -23,7 +23,6 @@ struct ListSortBindData : public FunctionData {
 	vector<LogicalType> payload_types;
 
 	ClientContext &context;
-	unique_ptr<GlobalSortState> global_sort_state;
 	RowLayout payload_layout;
 	vector<BoundOrderByNode> orders;
 
@@ -53,8 +52,8 @@ ListSortBindData::ListSortBindData(OrderType order_type_p, OrderByNullType null_
 	// get the BoundOrderByNode
 	auto idx_col_expr = make_unique_base<Expression, BoundReferenceExpression>(LogicalType::USMALLINT, 0);
 	auto lists_col_expr = make_unique_base<Expression, BoundReferenceExpression>(child_type, 1);
-	orders.emplace_back(OrderType::ASCENDING, OrderByNullType::ORDER_DEFAULT, move(idx_col_expr));
-	orders.emplace_back(order_type, null_order, move(lists_col_expr));
+	orders.emplace_back(OrderType::ASCENDING, OrderByNullType::ORDER_DEFAULT, std::move(idx_col_expr));
+	orders.emplace_back(order_type, null_order, std::move(lists_col_expr));
 }
 
 unique_ptr<FunctionData> ListSortBindData::Copy() const {
@@ -94,6 +93,7 @@ void SinkDataChunk(Vector *child_vector, SelectionVector &sel, idx_t offset_list
 	payload_chunk.Verify();
 
 	// sink
+	key_chunk.Flatten();
 	local_sort_state.SinkChunk(key_chunk, payload_chunk);
 	data_to_sort = true;
 }
@@ -116,8 +116,7 @@ static void ListSortFunction(DataChunk &args, ExpressionState &state, Vector &re
 
 	// initialize the global and local sorting state
 	auto &buffer_manager = BufferManager::GetBufferManager(info.context);
-	info.global_sort_state = make_unique<GlobalSortState>(buffer_manager, info.orders, info.payload_layout);
-	auto &global_sort_state = *info.global_sort_state;
+	GlobalSortState global_sort_state(buffer_manager, info.orders, info.payload_layout);
 	LocalSortState local_sort_state;
 	local_sort_state.Initialize(global_sort_state, buffer_manager);
 

package/src/duckdb/src/function/scalar/list/list_value.cpp

@@ -42,7 +42,7 @@ static unique_ptr<FunctionData> ListValueBind(ClientContext &context, ScalarFunc
 
 	// this is more for completeness reasons
 	bound_function.varargs = child_type;
-	bound_function.return_type = LogicalType::LIST(move(child_type));
+	bound_function.return_type = LogicalType::LIST(std::move(child_type));
 	return make_unique<VariableReturnBindData>(bound_function.return_type);
 }
 
@@ -55,10 +55,10 @@ unique_ptr<BaseStatistics> ListValueStats(ClientContext &context, FunctionStatis
 			list_stats->child_stats->Merge(*child_stats[i]);
 		} else {
 			list_stats->child_stats.reset();
-			return move(list_stats);
+			return std::move(list_stats);
 		}
 	}
-	return move(list_stats);
+	return std::move(list_stats);
 }
 
 void ListValueFun::RegisterFunction(BuiltinFunctions &set) {

package/src/duckdb/src/function/scalar/map/map_extract.cpp

@@ -40,18 +40,15 @@ static void MapExtractFunction(DataChunk &args, ExpressionState &state, Vector &
 	auto &key = args.data[1];
 
 	UnifiedVectorFormat map_data;
-	UnifiedVectorFormat key_data;
 
 	auto &map_keys = MapVector::GetKeys(map);
 	auto &map_values = MapVector::GetValues(map);
 
 	map.ToUnifiedFormat(args.size(), map_data);
-	key.ToUnifiedFormat(args.size(), key_data);
 
 	for (idx_t row = 0; row < args.size(); row++) {
 		idx_t row_index = map_data.sel->get_index(row);
-		idx_t key_index = key_data.sel->get_index(row);
-		auto key_value = key.GetValue(key_index);
+		auto key_value = key.GetValue(row);
 
 		list_entry_t entry = ListVector::GetData(map)[row_index];
 		auto offsets = MapVector::Search(map_keys, args.size(), key_value, entry);

package/src/duckdb/src/function/scalar/math/numeric.cpp

@@ -9,6 +9,7 @@
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/common/likely.hpp"
 #include "duckdb/storage/statistics/numeric_statistics.hpp"
+#include "duckdb/common/types/bit.hpp"
 #include <cmath>
 #include <errno.h>
 
@@ -123,17 +124,17 @@ static unique_ptr<BaseStatistics> PropagateAbsStats(ClientContext &context, Func
 			max_val = MaxValue(AbsValue(current_min), current_max);
 		} else {
 			// if both current_min and current_max are > 0, then the abs is a no-op and can be removed entirely
-			*input.expr_ptr = move(input.expr.children[0]);
-			return move(child_stats[0]);
+			*input.expr_ptr = std::move(input.expr.children[0]);
+			return std::move(child_stats[0]);
 		}
 		new_min = Value::Numeric(expr.return_type, min_val);
 		new_max = Value::Numeric(expr.return_type, max_val);
 		expr.function.function = ScalarFunction::GetScalarUnaryFunction<AbsOperator>(expr.return_type);
 	}
-	auto stats =
-	    make_unique<NumericStatistics>(expr.return_type, move(new_min), move(new_max), StatisticsType::LOCAL_STATS);
+	auto stats = make_unique<NumericStatistics>(expr.return_type, std::move(new_min), std::move(new_max),
+	                                            StatisticsType::LOCAL_STATS);
 	stats->validity_stats = lstats.validity_stats->Copy();
-	return move(stats);
+	return std::move(stats);
 }
 
 template <class OP>
@@ -222,6 +223,14 @@ struct HugeIntBitCntOperator {
 	}
 };
 
+struct BitStringBitCntOperator {
+	template <class TA, class TR>
+	static inline TR Operation(TA input) {
+		TR count = Bit::BitCount(input);
+		return count;
+	}
+};
+
 void BitCountFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet functions("bit_count");
 	functions.AddFunction(ScalarFunction({LogicalType::TINYINT}, LogicalType::TINYINT,
@@ -234,6 +243,8 @@ void BitCountFun::RegisterFunction(BuiltinFunctions &set) {
 	                                     ScalarFunction::UnaryFunction<int64_t, int8_t, BitCntOperator>));
 	functions.AddFunction(ScalarFunction({LogicalType::HUGEINT}, LogicalType::TINYINT,
 	                                     ScalarFunction::UnaryFunction<hugeint_t, int8_t, HugeIntBitCntOperator>));
+	functions.AddFunction(ScalarFunction({LogicalType::BIT}, LogicalType::BIGINT,
+	                                     ScalarFunction::UnaryFunction<string_t, idx_t, BitStringBitCntOperator>));
 	set.AddFunction(functions);
 }
 
@@ -846,6 +857,25 @@ void IsNanFun::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(funcs);
 }
 
+//===--------------------------------------------------------------------===//
+// signbit
+//===--------------------------------------------------------------------===//
+struct SignBitOperator {
+	template <class TA, class TR>
+	static inline TR Operation(TA input) {
+		return std::signbit(input);
+	}
+};
+
+void SignBitFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunctionSet funcs("signbit");
+	funcs.AddFunction(ScalarFunction({LogicalType::FLOAT}, LogicalType::BOOLEAN,
+	                                 ScalarFunction::UnaryFunction<float, bool, SignBitOperator>));
+	funcs.AddFunction(ScalarFunction({LogicalType::DOUBLE}, LogicalType::BOOLEAN,
+	                                 ScalarFunction::UnaryFunction<double, bool, SignBitOperator>));
+	set.AddFunction(funcs);
+}
+
 //===--------------------------------------------------------------------===//
 // isinf
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/function/scalar/math/setseed.cpp

@@ -36,7 +36,7 @@ static void SetSeedFunction(DataChunk &args, ExpressionState &state, Vector &res
 
 	auto &random_engine = RandomEngine::Get(info.context);
 	for (idx_t i = 0; i < args.size(); i++) {
-		if (input_seeds[i] < -1.0 || input_seeds[i] > 1.0) {
+		if (input_seeds[i] < -1.0 || input_seeds[i] > 1.0 || Value::IsNan(input_seeds[i])) {
 			throw Exception("SETSEED accepts seed values between -1.0 and 1.0, inclusive");
 		}
 		uint32_t norm_seed = (input_seeds[i] + 1.0) * half_max;

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

@@ -38,6 +38,7 @@ void BuiltinFunctions::RegisterMathFunctions() {
 	Register<EvenFun>();
 
 	Register<IsNanFun>();
+	Register<SignBitFun>();
 	Register<IsInfiniteFun>();
 	Register<IsFiniteFun>();
 }

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

@@ -119,7 +119,7 @@ struct DecimalArithmeticBindData : public FunctionData {
 	unique_ptr<FunctionData> Copy() const override {
 		auto res = make_unique<DecimalArithmeticBindData>();
 		res->check_overflow = check_overflow;
-		return move(res);
+		return std::move(res);
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
@@ -176,10 +176,10 @@ static unique_ptr<BaseStatistics> PropagateNumericStats(ClientContext &context,
 		}
 		expr.function.function = GetScalarIntegerFunction<BASEOP>(expr.return_type.InternalType());
 	}
-	auto stats =
-	    make_unique<NumericStatistics>(expr.return_type, move(new_min), move(new_max), StatisticsType::LOCAL_STATS);
+	auto stats = make_unique<NumericStatistics>(expr.return_type, std::move(new_min), std::move(new_max),
+	                                            StatisticsType::LOCAL_STATS);
 	stats->validity_stats = ValidityStatistics::Combine(lstats.validity_stats, rstats.validity_stats);
-	return move(stats);
+	return std::move(stats);
 }
 
 template <class OP, class OPOVERFLOWCHECK, bool IS_SUBTRACT = false>
@@ -246,7 +246,7 @@ unique_ptr<FunctionData> BindDecimalAddSubtract(ClientContext &context, ScalarFu
 			bound_function.statistics = PropagateNumericStats<TryDecimalAdd, AddPropagateStatistics, AddOperator>;
 		}
 	}
-	return move(bind_data);
+	return std::move(bind_data);
 }
 
 static void SerializeDecimalArithmetic(FieldWriter &writer, const FunctionData *bind_data_p,
@@ -278,7 +278,7 @@ unique_ptr<FunctionData> DeserializeDecimalArithmetic(ClientContext &context, Fi
 
 	auto bind_data = make_unique<DecimalArithmeticBindData>();
 	bind_data->check_overflow = check_overflow;
-	return move(bind_data);
+	return std::move(bind_data);
 }
 
 unique_ptr<FunctionData> NopDecimalBind(ClientContext &context, ScalarFunction &bound_function,
@@ -455,7 +455,7 @@ struct DecimalNegateBindData : public FunctionData {
 	unique_ptr<FunctionData> Copy() const override {
 		auto res = make_unique<DecimalNegateBindData>();
 		res->bound_type = bound_type;
-		return move(res);
+		return std::move(res);
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
@@ -542,12 +542,12 @@ static unique_ptr<BaseStatistics> NegateBindStatistics(ClientContext &context, F
 		new_min = Value(expr.return_type);
 		new_max = Value(expr.return_type);
 	}
-	auto stats =
-	    make_unique<NumericStatistics>(expr.return_type, move(new_min), move(new_max), StatisticsType::LOCAL_STATS);
+	auto stats = make_unique<NumericStatistics>(expr.return_type, std::move(new_min), std::move(new_max),
+	                                            StatisticsType::LOCAL_STATS);
 	if (istats.validity_stats) {
 		stats->validity_stats = istats.validity_stats->Copy();
 	}
-	return move(stats);
+	return std::move(stats);
 }
 
 ScalarFunction SubtractFun::GetFunction(const LogicalType &type) {
@@ -764,7 +764,7 @@ unique_ptr<FunctionData> BindDecimalMultiply(ClientContext &context, ScalarFunct
 		bound_function.statistics =
 		    PropagateNumericStats<TryDecimalMultiply, MultiplyPropagateStatistics, MultiplyOperator>;
 	}
-	return move(bind_data);
+	return std::move(bind_data);
 }
 
 void MultiplyFun::RegisterFunction(BuiltinFunctions &set) {

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

@@ -1,6 +1,8 @@
 #include "duckdb/function/scalar/operators.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 {
 
@@ -88,12 +90,24 @@ struct BitwiseANDOperator {
 	}
 };
 
+static void BitwiseANDOperation(DataChunk &args, ExpressionState &state, Vector &result) {
+	BinaryExecutor::Execute<string_t, string_t, string_t>(
+	    args.data[0], args.data[1], result, args.size(), [&](string_t rhs, string_t lhs) {
+		    string_t target = StringVector::EmptyString(result, rhs.GetSize());
+
+		    Bit::BitwiseAnd(rhs, lhs, target);
+		    return target;
+	    });
+}
+
 void BitwiseAndFun::RegisterFunction(BuiltinFunctions &set) {
 	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);
 }
 
@@ -107,12 +121,23 @@ struct BitwiseOROperator {
 	}
 };
 
+static void BitwiseOROperation(DataChunk &args, ExpressionState &state, Vector &result) {
+	BinaryExecutor::Execute<string_t, string_t, string_t>(
+	    args.data[0], args.data[1], result, args.size(), [&](string_t rhs, string_t lhs) {
+		    string_t target = StringVector::EmptyString(result, rhs.GetSize());
+
+		    Bit::BitwiseOr(rhs, lhs, target);
+		    return target;
+	    });
+}
+
 void BitwiseOrFun::RegisterFunction(BuiltinFunctions &set) {
 	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);
 }
 
@@ -126,12 +151,51 @@ struct BitwiseXOROperator {
 	}
 };
 
+static void BitwiseXOROperation(DataChunk &args, ExpressionState &state, Vector &result) {
+	BinaryExecutor::Execute<string_t, string_t, string_t>(
+	    args.data[0], args.data[1], result, args.size(), [&](string_t rhs, string_t lhs) {
+		    string_t target = StringVector::EmptyString(result, rhs.GetSize());
+
+		    Bit::BitwiseXor(rhs, lhs, target);
+		    return target;
+	    });
+}
+
 void BitwiseXorFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet functions("xor");
 	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);
+}
+
+//===--------------------------------------------------------------------===//
+// ~ [bitwise_not]
+//===--------------------------------------------------------------------===//
+struct BitwiseNotOperator {
+	template <class TA, class TR>
+	static inline TR Operation(TA input) {
+		return ~input;
+	}
+};
+
+static void BitwiseNOTOperation(DataChunk &args, ExpressionState &state, Vector &result) {
+	UnaryExecutor::Execute<string_t, string_t>(args.data[0], result, args.size(), [&](string_t input) {
+		string_t target = StringVector::EmptyString(result, input.GetSize());
+
+		Bit::BitwiseNot(input, target);
+		return target;
+	});
+}
+
+void BitwiseNotFun::RegisterFunction(BuiltinFunctions &set) {
+	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);
 }
 
@@ -167,12 +231,35 @@ struct BitwiseShiftLeftOperator {
 	}
 };
 
+static void BitwiseShiftLeftOperation(DataChunk &args, ExpressionState &state, Vector &result) {
+	BinaryExecutor::Execute<string_t, int32_t, string_t>(
+	    args.data[0], args.data[1], result, args.size(), [&](string_t input, int32_t shift) {
+		    int32_t max_shift = Bit::BitLength(input);
+		    if (shift == 0) {
+			    return input;
+		    }
+		    if (shift < 0) {
+			    throw OutOfRangeException("Cannot left-shift by negative number %s", NumericHelper::ToString(shift));
+		    }
+		    string_t target = StringVector::EmptyString(result, input.GetSize());
+
+		    if (shift >= max_shift) {
+			    Bit::SetEmptyBitString(target, input);
+			    return target;
+		    }
+		    Bit::LeftShift(input, shift, target);
+		    return target;
+	    });
+}
+
 void LeftShiftFun::RegisterFunction(BuiltinFunctions &set) {
 	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);
 }
 
@@ -191,31 +278,94 @@ struct BitwiseShiftRightOperator {
 	}
 };
 
+static void BitwiseShiftRightOperation(DataChunk &args, ExpressionState &state, Vector &result) {
+	BinaryExecutor::Execute<string_t, int32_t, string_t>(
+	    args.data[0], args.data[1], result, args.size(), [&](string_t input, int32_t shift) {
+		    int32_t max_shift = Bit::BitLength(input);
+		    if (shift == 0) {
+			    return input;
+		    }
+		    string_t target = StringVector::EmptyString(result, input.GetSize());
+		    if (shift < 0 || shift >= max_shift) {
+			    Bit::SetEmptyBitString(target, input);
+			    return target;
+		    }
+		    Bit::RightShift(input, shift, target);
+		    return target;
+	    });
+}
+
 void RightShiftFun::RegisterFunction(BuiltinFunctions &set) {
 	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);
 }
 
 //===--------------------------------------------------------------------===//
-// ~ [bitwise_not]
+// get_bit
 //===--------------------------------------------------------------------===//
-struct BitwiseNotOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return ~input;
+struct GetBitOperator {
+	template <class TA, class TB, class TR>
+	static inline TR Operation(TA input, TB n) {
+		if (n < 0 || (idx_t)n > Bit::BitLength(input) - 1) {
+			throw OutOfRangeException("bit index %s out of valid range (0..%s)", NumericHelper::ToString(n),
+			                          NumericHelper::ToString(Bit::BitLength(input) - 1));
+		}
+		return Bit::GetBit(input, n);
 	}
 };
 
-void BitwiseNotFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("~");
-	for (auto &type : LogicalType::Integral()) {
-		functions.AddFunction(ScalarFunction({type}, type, GetScalarIntegerUnaryFunction<BitwiseNotOperator>(type)));
+void GetBitFun::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction(ScalarFunction("get_bit", {LogicalType::BIT, LogicalType::INTEGER}, LogicalType::INTEGER,
+	                               ScalarFunction::BinaryFunction<string_t, int32_t, int32_t, GetBitOperator>));
+}
+
+//===--------------------------------------------------------------------===//
+// set_bit
+//===--------------------------------------------------------------------===//
+static void SetBitOperation(DataChunk &args, ExpressionState &state, Vector &result) {
+	TernaryExecutor::Execute<string_t, int32_t, int32_t, string_t>(
+	    args.data[0], args.data[1], args.data[2], result, args.size(),
+	    [&](string_t input, int32_t n, int32_t new_value) {
+		    if (new_value != 0 && new_value != 1) {
+			    throw InvalidInputException("The new bit must be 1 or 0");
+		    }
+		    if (n < 0 || (idx_t)n > Bit::BitLength(input) - 1) {
+			    throw OutOfRangeException("bit index %s out of valid range (0..%s)", NumericHelper::ToString(n),
+			                              NumericHelper::ToString(Bit::BitLength(input) - 1));
+		    }
+		    string_t target = StringVector::EmptyString(result, input.GetSize());
+		    Bit::SetBit(input, n, new_value, target);
+		    return target;
+	    });
+}
+
+void SetBitFun::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction(ScalarFunction("set_bit", {LogicalType::BIT, LogicalType::INTEGER, LogicalType::INTEGER},
+	                               LogicalType::BIT, SetBitOperation));
+}
+
+//===--------------------------------------------------------------------===//
+// bit_position
+//===--------------------------------------------------------------------===//
+struct BitPositionOperator {
+	template <class TA, class TB, class TR>
+	static inline TR Operation(TA substring, TB input) {
+		if (substring.GetSize() > input.GetSize()) {
+			return 0;
+		}
+		return Bit::BitPosition(substring, input);
 	}
-	set.AddFunction(functions);
+};
+
+void BitPositionFun::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction(ScalarFunction("bit_position", {LogicalType::BIT, LogicalType::BIT}, LogicalType::INTEGER,
+	                               ScalarFunction::BinaryFunction<string_t, string_t, int32_t, BitPositionOperator>));
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/scalar/sequence/nextval.cpp

@@ -7,7 +7,7 @@
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/transaction/transaction.hpp"
+#include "duckdb/transaction/duck_transaction.hpp"
 #include "duckdb/common/vector_operations/unary_executor.hpp"
 #include "duckdb/common/operator/add.hpp"
 #include "duckdb/planner/binder.hpp"
@@ -32,7 +32,7 @@ struct NextvalBindData : public FunctionData {
 };
 
 struct CurrentSequenceValueOperator {
-	static int64_t Operation(Transaction &transaction, SequenceCatalogEntry *seq) {
+	static int64_t Operation(DuckTransaction &transaction, SequenceCatalogEntry *seq) {
 		lock_guard<mutex> seqlock(seq->lock);
 		int64_t result;
 		if (seq->usage_count == 0u) {
@@ -44,7 +44,7 @@ struct CurrentSequenceValueOperator {
 };
 
 struct NextSequenceValueOperator {
-	static int64_t Operation(Transaction &transaction, SequenceCatalogEntry *seq) {
+	static int64_t Operation(DuckTransaction &transaction, SequenceCatalogEntry *seq) {
 		lock_guard<mutex> seqlock(seq->lock);
 		int64_t result;
 		result = seq->counter;
@@ -91,7 +91,7 @@ static void NextValFunction(DataChunk &args, ExpressionState &state, Vector &res
 
 	auto &context = state.GetContext();
 	if (info.sequence) {
-		auto &transaction = Transaction::Get(context, *info.sequence->catalog);
+		auto &transaction = DuckTransaction::Get(context, *info.sequence->catalog);
 		// sequence to use is hard coded
 		// increment the sequence
 		result.SetVectorType(VectorType::FLAT_VECTOR);
@@ -106,7 +106,7 @@ static void NextValFunction(DataChunk &args, ExpressionState &state, Vector &res
 			// fetch the sequence from the catalog
 			auto sequence = BindSequence(context, value.GetString());
 			// finally get the next value from the sequence
-			auto &transaction = Transaction::Get(context, *sequence->catalog);
+			auto &transaction = DuckTransaction::Get(context, *sequence->catalog);
 			return OP::Operation(transaction, sequence);
 		});
 	}