diff --git a/src/common/vector_operations/CMakeLists.txt b/src/common/vector_operations/CMakeLists.txt
index a71e51a17b9..627000f5b08 100644
--- a/src/common/vector_operations/CMakeLists.txt
+++ b/src/common/vector_operations/CMakeLists.txt
@@ -10,7 +10,6 @@ add_library_unity(duckdb_vector_operations
                   gather.cpp
                   hash.cpp
                   null_operations.cpp
-                  numeric_bitwise_operators.cpp
                   numeric_inplace_operators.cpp
                   numeric_inplace_bitwise_operators.cpp
                   numeric_binary_operators.cpp
diff --git a/src/common/vector_operations/numeric_bitwise_operators.cpp b/src/common/vector_operations/numeric_bitwise_operators.cpp
deleted file mode 100644
index 0a0c428ab5c..00000000000
--- a/src/common/vector_operations/numeric_bitwise_operators.cpp
+++ /dev/null
@@ -1,71 +0,0 @@
-//===--------------------------------------------------------------------===//
-// numeric_bitwise_operators.cpp
-// Description: This file contains the implementation of the numeric bitwise
-// operations (^ | & >> << ~)
-//===--------------------------------------------------------------------===//
-
-#include "duckdb/common/operator/numeric_bitwise_operators.hpp"
-
-#include "duckdb/common/vector_operations/binary_loops.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-
-using namespace duckdb;
-using namespace std;
-
-template <class OP> static void templated_binary_bitwise_operation(Vector &left, Vector &right, Vector &result) {
-	BINARY_TYPE_CHECK(left, right, result);
-	switch (left.type) {
-	case TypeId::TINYINT:
-		templated_binary_loop<int8_t, int8_t, int8_t, OP>(left, right, result);
-		break;
-	case TypeId::SMALLINT:
-		templated_binary_loop<int16_t, int16_t, int16_t, OP>(left, right, result);
-		break;
-	case TypeId::INTEGER:
-		templated_binary_loop<int32_t, int32_t, int32_t, OP>(left, right, result);
-		break;
-	case TypeId::BIGINT:
-		templated_binary_loop<int64_t, int64_t, int64_t, OP>(left, right, result);
-		break;
-	case TypeId::POINTER:
-		templated_binary_loop<uint64_t, uint64_t, uint64_t, OP>(left, right, result);
-		break;
-	default:
-		throw InvalidTypeException(left.type, "Invalid type for bitwise operation");
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Bitwise XOR
-//===--------------------------------------------------------------------===//
-void VectorOperations::BitwiseXOR(Vector &left, Vector &right, Vector &result) {
-	templated_binary_bitwise_operation<duckdb::BitwiseXOR>(left, right, result);
-}
-
-//===--------------------------------------------------------------------===//
-// Bitwise AND
-//===--------------------------------------------------------------------===//
-void VectorOperations::BitwiseAND(Vector &left, Vector &right, Vector &result) {
-	templated_binary_bitwise_operation<duckdb::BitwiseAND>(left, right, result);
-}
-
-//===--------------------------------------------------------------------===//
-// Bitwise OR
-//===--------------------------------------------------------------------===//
-void VectorOperations::BitwiseOR(Vector &left, Vector &right, Vector &result) {
-	templated_binary_bitwise_operation<duckdb::BitwiseOR>(left, right, result);
-}
-
-//===--------------------------------------------------------------------===//
-// Bitwise Shift Left
-//===--------------------------------------------------------------------===//
-void VectorOperations::BitwiseShiftLeft(Vector &left, Vector &right, Vector &result) {
-	templated_binary_bitwise_operation<duckdb::BitwiseShiftLeft>(left, right, result);
-}
-
-//===--------------------------------------------------------------------===//
-// Bitwise Shift Right
-//===--------------------------------------------------------------------===//
-void VectorOperations::BitwiseShiftRight(Vector &left, Vector &right, Vector &result) {
-	templated_binary_bitwise_operation<duckdb::BitwiseShiftRight>(left, right, result);
-}
diff --git a/src/function/scalar/operators/CMakeLists.txt b/src/function/scalar/operators/CMakeLists.txt
index ad24ac439e7..50b6be27098 100644
--- a/src/function/scalar/operators/CMakeLists.txt
+++ b/src/function/scalar/operators/CMakeLists.txt
@@ -1,15 +1,7 @@
 add_library_unity(duckdb_func_ops
                   OBJECT
-                  add.cpp
-                  subtract.cpp
-                  multiply.cpp
-                  divide.cpp
-                  mod.cpp
-                  left_shift.cpp
-                  right_shift.cpp
-                  bitwise_and.cpp
-                  bitwise_or.cpp
-                  bitwise_xor.cpp)
+                  arithmetic.cpp
+                  bitwise.cpp)
 set(ALL_OBJECT_FILES
     ${ALL_OBJECT_FILES} $<TARGET_OBJECTS:duckdb_func_ops>
     PARENT_SCOPE)
diff --git a/src/function/scalar/operators/add.cpp b/src/function/scalar/operators/add.cpp
deleted file mode 100644
index 669457bd36d..00000000000
--- a/src/function/scalar/operators/add.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#include "duckdb/function/scalar/operators.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-
-using namespace duckdb;
-using namespace std;
-
-static void add_function(ExpressionExecutor &exec, Vector inputs[], index_t input_count, BoundFunctionExpression &expr,
-                         Vector &result) {
-	result.Initialize(inputs[0].type);
-	VectorOperations::Add(inputs[0], inputs[1], result);
-}
-
-static void unary_add_function(ExpressionExecutor &exec, Vector inputs[], index_t input_count,
-                               BoundFunctionExpression &expr, Vector &result) {
-	inputs[0].Move(result);
-}
-
-void AddFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("+");
-	// binary add function adds two numbers together
-	for (auto &type : SQLType::NUMERIC) {
-		functions.AddFunction(ScalarFunction({type, type}, type, add_function));
-	}
-	// we can add integers to dates
-	functions.AddFunction(ScalarFunction({SQLType::DATE, SQLType::INTEGER}, SQLType::DATE, add_function));
-	functions.AddFunction(ScalarFunction({SQLType::INTEGER, SQLType::DATE}, SQLType::DATE, add_function));
-	// unary add function is a nop, but only exists for numeric types
-	for (auto &type : SQLType::NUMERIC) {
-		functions.AddFunction(ScalarFunction({type}, type, unary_add_function));
-	}
-	set.AddFunction(functions);
-}
diff --git a/src/function/scalar/operators/arithmetic.cpp b/src/function/scalar/operators/arithmetic.cpp
new file mode 100644
index 00000000000..25b5410c89b
--- /dev/null
+++ b/src/function/scalar/operators/arithmetic.cpp
@@ -0,0 +1,120 @@
+#include "duckdb/function/scalar/operators.hpp"
+#include "duckdb/common/vector_operations/vector_operations.hpp"
+
+using namespace std;
+
+namespace duckdb {
+
+//===--------------------------------------------------------------------===//
+// + [add]
+//===--------------------------------------------------------------------===//
+static void add_function(ExpressionExecutor &exec, Vector inputs[], index_t input_count, BoundFunctionExpression &expr,
+                         Vector &result) {
+	result.Initialize(inputs[0].type);
+	VectorOperations::Add(inputs[0], inputs[1], result);
+}
+
+void AddFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunctionSet functions("+");
+	// binary add function adds two numbers together
+	for (auto &type : SQLType::NUMERIC) {
+		functions.AddFunction(ScalarFunction({type, type}, type, add_function));
+	}
+	// we can add integers to dates
+	functions.AddFunction(ScalarFunction({SQLType::DATE, SQLType::INTEGER}, SQLType::DATE, add_function));
+	functions.AddFunction(ScalarFunction({SQLType::INTEGER, SQLType::DATE}, SQLType::DATE, add_function));
+	// unary add function is a nop, but only exists for numeric types
+	for (auto &type : SQLType::NUMERIC) {
+		functions.AddFunction(ScalarFunction({type}, type, ScalarFunction::NopFunction));
+	}
+	set.AddFunction(functions);
+}
+
+//===--------------------------------------------------------------------===//
+// - [subtract]
+//===--------------------------------------------------------------------===//
+static void subtract_function(ExpressionExecutor &exec, Vector inputs[], index_t input_count,
+                              BoundFunctionExpression &expr, Vector &result) {
+	result.Initialize(inputs[0].type);
+	VectorOperations::Subtract(inputs[0], inputs[1], result);
+}
+
+static void unary_subtract_function(ExpressionExecutor &exec, Vector inputs[], index_t input_count,
+                                    BoundFunctionExpression &expr, Vector &result) {
+	Value minus_one = Value::Numeric(inputs[0].type, -1);
+	Vector right;
+	right.Reference(minus_one);
+
+	result.Initialize(inputs[0].type);
+	VectorOperations::Multiply(inputs[0], right, result);
+}
+
+void SubtractFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunctionSet functions("-");
+	// binary subtract function "a - b", subtracts b from a
+	for (auto &type : SQLType::NUMERIC) {
+		functions.AddFunction(ScalarFunction({type, type}, type, subtract_function));
+	}
+	functions.AddFunction(ScalarFunction({SQLType::DATE, SQLType::DATE}, SQLType::INTEGER, subtract_function));
+	functions.AddFunction(ScalarFunction({SQLType::DATE, SQLType::INTEGER}, SQLType::DATE, subtract_function));
+	// unary subtract function, negates the input (i.e. multiplies by -1)
+	for (auto &type : SQLType::NUMERIC) {
+		functions.AddFunction(ScalarFunction({type}, type, unary_subtract_function));
+	}
+	set.AddFunction(functions);
+}
+
+//===--------------------------------------------------------------------===//
+// * [multiply]
+//===--------------------------------------------------------------------===//
+static void multiply_function(ExpressionExecutor &exec, Vector inputs[], index_t input_count,
+                              BoundFunctionExpression &expr, Vector &result) {
+	result.Initialize(inputs[0].type);
+	VectorOperations::Multiply(inputs[0], inputs[1], result);
+}
+
+void MultiplyFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunctionSet functions("*");
+	for (auto &type : SQLType::NUMERIC) {
+		functions.AddFunction(ScalarFunction({type, type}, type, multiply_function));
+	}
+	set.AddFunction(functions);
+}
+
+//===--------------------------------------------------------------------===//
+// / [divide]
+//===--------------------------------------------------------------------===//
+static void divide_function(ExpressionExecutor &exec, Vector inputs[], index_t input_count,
+                            BoundFunctionExpression &expr, Vector &result) {
+	result.Initialize(inputs[0].type);
+	VectorOperations::Divide(inputs[0], inputs[1], result);
+}
+
+void DivideFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunctionSet functions("/");
+	for (auto &type : SQLType::NUMERIC) {
+		functions.AddFunction(ScalarFunction({type, type}, type, divide_function));
+	}
+	set.AddFunction(functions);
+}
+
+//===--------------------------------------------------------------------===//
+// % [modulo]
+//===--------------------------------------------------------------------===//
+static void mod_function(ExpressionExecutor &exec, Vector inputs[], index_t input_count, BoundFunctionExpression &expr,
+                         Vector &result) {
+	result.Initialize(inputs[0].type);
+	VectorOperations::Modulo(inputs[0], inputs[1], result);
+}
+
+void ModFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunctionSet functions("%");
+	for (auto &type : SQLType::NUMERIC) {
+		functions.AddFunction(ScalarFunction({type, type}, type, mod_function));
+	}
+	set.AddFunction(functions);
+	functions.name = "mod";
+	set.AddFunction(functions);
+}
+
+}
diff --git a/src/function/scalar/operators/bitwise.cpp b/src/function/scalar/operators/bitwise.cpp
new file mode 100644
index 00000000000..6d61d24473f
--- /dev/null
+++ b/src/function/scalar/operators/bitwise.cpp
@@ -0,0 +1,109 @@
+#include "duckdb/function/scalar/operators.hpp"
+#include "duckdb/common/vector_operations/vector_operations.hpp"
+
+using namespace duckdb;
+using namespace std;
+
+namespace duckdb {
+
+template <class OP> static scalar_function_t GetScalarIntegerBinaryFunction(SQLType type) {
+	switch (type.id) {
+	case SQLTypeId::TINYINT:
+		return ScalarFunction::BinaryFunction<int8_t, int8_t, int8_t, OP>;
+	case SQLTypeId::SMALLINT:
+		return ScalarFunction::BinaryFunction<int16_t, int16_t, int16_t, OP>;
+	case SQLTypeId::INTEGER:
+		return ScalarFunction::BinaryFunction<int32_t, int32_t, int32_t, OP>;
+	case SQLTypeId::BIGINT:
+		return ScalarFunction::BinaryFunction<int64_t, int64_t, int64_t, OP>;
+	default:
+		throw NotImplementedException("Unimplemented type for GetScalarIntegerBinaryFunction");
+	}
+}
+
+//===--------------------------------------------------------------------===//
+// & [bitwise_and]
+//===--------------------------------------------------------------------===//
+struct BitwiseANDOperator {
+	template <class T> static inline T Operation(T left, T right) {
+		return left & right;
+	}
+};
+
+void BitwiseAndFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunctionSet functions("&");
+	for (auto &type : SQLType::INTEGRAL) {
+		functions.AddFunction(ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction<BitwiseANDOperator>(type)));
+	}
+	set.AddFunction(functions);
+}
+
+//===--------------------------------------------------------------------===//
+// | [bitwise_or]
+//===--------------------------------------------------------------------===//
+struct BitwiseOROperator {
+	template <class T> static inline T Operation(T left, T right) {
+		return left | right;
+	}
+};
+
+void BitwiseOrFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunctionSet functions("|");
+	for (auto &type : SQLType::INTEGRAL) {
+		functions.AddFunction(ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction<BitwiseOROperator>(type)));
+	}
+	set.AddFunction(functions);
+}
+
+//===--------------------------------------------------------------------===//
+// # [bitwise_xor]
+//===--------------------------------------------------------------------===//
+struct BitwiseXOROperator {
+	template <class T> static inline T Operation(T left, T right) {
+		return left ^ right;
+	}
+};
+
+void BitwiseXorFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunctionSet functions("#");
+	for (auto &type : SQLType::INTEGRAL) {
+		functions.AddFunction(ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction<BitwiseXOROperator>(type)));
+	}
+	set.AddFunction(functions);
+}
+
+//===--------------------------------------------------------------------===//
+// << [bitwise_left_shift]
+//===--------------------------------------------------------------------===//
+struct BitwiseShiftLeftOperator {
+	template <class T> static inline T Operation(T left, T right) {
+		return left << right;
+	}
+};
+
+void LeftShiftFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunctionSet functions("<<");
+	for (auto &type : SQLType::INTEGRAL) {
+		functions.AddFunction(ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction<BitwiseShiftLeftOperator>(type)));
+	}
+	set.AddFunction(functions);
+}
+
+//===--------------------------------------------------------------------===//
+// >> [bitwise_right_shift]
+//===--------------------------------------------------------------------===//
+struct BitwiseShiftRightOperator {
+	template <class T> static inline T Operation(T left, T right) {
+		return left >> right;
+	}
+};
+
+void RightShiftFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunctionSet functions(">>");
+	for (auto &type : SQLType::INTEGRAL) {
+		functions.AddFunction(ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction<BitwiseShiftRightOperator>(type)));
+	}
+	set.AddFunction(functions);
+}
+
+}
diff --git a/src/function/scalar/operators/bitwise_and.cpp b/src/function/scalar/operators/bitwise_and.cpp
deleted file mode 100644
index ba618c0baf5..00000000000
--- a/src/function/scalar/operators/bitwise_and.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "duckdb/function/scalar/operators.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-
-using namespace duckdb;
-using namespace std;
-
-static void bitwise_and_function(ExpressionExecutor &exec, Vector inputs[], index_t input_count,
-                                 BoundFunctionExpression &expr, Vector &result) {
-	result.Initialize(inputs[0].type);
-	VectorOperations::BitwiseAND(inputs[0], inputs[1], result);
-}
-
-void BitwiseAndFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("&");
-	for (auto &type : SQLType::INTEGRAL) {
-		functions.AddFunction(ScalarFunction({type, type}, type, bitwise_and_function));
-	}
-	set.AddFunction(functions);
-}
diff --git a/src/function/scalar/operators/bitwise_or.cpp b/src/function/scalar/operators/bitwise_or.cpp
deleted file mode 100644
index 56c99796c3b..00000000000
--- a/src/function/scalar/operators/bitwise_or.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "duckdb/function/scalar/operators.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-
-using namespace duckdb;
-using namespace std;
-
-static void bitwise_or_function(ExpressionExecutor &exec, Vector inputs[], index_t input_count,
-                                BoundFunctionExpression &expr, Vector &result) {
-	result.Initialize(inputs[0].type);
-	VectorOperations::BitwiseOR(inputs[0], inputs[1], result);
-}
-
-void BitwiseOrFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("|");
-	for (auto &type : SQLType::INTEGRAL) {
-		functions.AddFunction(ScalarFunction({type, type}, type, bitwise_or_function));
-	}
-	set.AddFunction(functions);
-}
diff --git a/src/function/scalar/operators/bitwise_xor.cpp b/src/function/scalar/operators/bitwise_xor.cpp
deleted file mode 100644
index ca89855d391..00000000000
--- a/src/function/scalar/operators/bitwise_xor.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "duckdb/function/scalar/operators.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-
-using namespace duckdb;
-using namespace std;
-
-static void bitwise_xor_function(ExpressionExecutor &exec, Vector inputs[], index_t input_count,
-                                 BoundFunctionExpression &expr, Vector &result) {
-	result.Initialize(inputs[0].type);
-	VectorOperations::BitwiseXOR(inputs[0], inputs[1], result);
-}
-
-void BitwiseXorFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("#");
-	for (auto &type : SQLType::INTEGRAL) {
-		functions.AddFunction(ScalarFunction({type, type}, type, bitwise_xor_function));
-	}
-	set.AddFunction(functions);
-}
diff --git a/src/function/scalar/operators/divide.cpp b/src/function/scalar/operators/divide.cpp
deleted file mode 100644
index 280d8273292..00000000000
--- a/src/function/scalar/operators/divide.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "duckdb/function/scalar/operators.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-
-using namespace duckdb;
-using namespace std;
-
-static void divide_function(ExpressionExecutor &exec, Vector inputs[], index_t input_count,
-                            BoundFunctionExpression &expr, Vector &result) {
-	result.Initialize(inputs[0].type);
-	VectorOperations::Divide(inputs[0], inputs[1], result);
-}
-
-void DivideFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("/");
-	for (auto &type : SQLType::NUMERIC) {
-		functions.AddFunction(ScalarFunction({type, type}, type, divide_function));
-	}
-	set.AddFunction(functions);
-}
diff --git a/src/function/scalar/operators/left_shift.cpp b/src/function/scalar/operators/left_shift.cpp
deleted file mode 100644
index 2584b5fc780..00000000000
--- a/src/function/scalar/operators/left_shift.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "duckdb/function/scalar/operators.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-
-using namespace duckdb;
-using namespace std;
-
-static void bitwise_lshift_function(ExpressionExecutor &exec, Vector inputs[], index_t input_count,
-                                    BoundFunctionExpression &expr, Vector &result) {
-	result.Initialize(inputs[0].type);
-	VectorOperations::BitwiseShiftLeft(inputs[0], inputs[1], result);
-}
-
-void LeftShiftFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("<<");
-	for (auto &type : SQLType::INTEGRAL) {
-		functions.AddFunction(ScalarFunction({type, type}, type, bitwise_lshift_function));
-	}
-	set.AddFunction(functions);
-}
diff --git a/src/function/scalar/operators/mod.cpp b/src/function/scalar/operators/mod.cpp
deleted file mode 100644
index f06cf7a11f6..00000000000
--- a/src/function/scalar/operators/mod.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#include "duckdb/function/scalar/operators.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-
-using namespace duckdb;
-using namespace std;
-
-static void mod_function(ExpressionExecutor &exec, Vector inputs[], index_t input_count, BoundFunctionExpression &expr,
-                         Vector &result) {
-	result.Initialize(inputs[0].type);
-	VectorOperations::Modulo(inputs[0], inputs[1], result);
-}
-
-void ModFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("%");
-	for (auto &type : SQLType::NUMERIC) {
-		functions.AddFunction(ScalarFunction({type, type}, type, mod_function));
-	}
-	set.AddFunction(functions);
-	functions.name = "mod";
-	set.AddFunction(functions);
-}
diff --git a/src/function/scalar/operators/multiply.cpp b/src/function/scalar/operators/multiply.cpp
deleted file mode 100644
index efc39fc592c..00000000000
--- a/src/function/scalar/operators/multiply.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "duckdb/function/scalar/operators.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-
-using namespace duckdb;
-using namespace std;
-
-static void multiply_function(ExpressionExecutor &exec, Vector inputs[], index_t input_count,
-                              BoundFunctionExpression &expr, Vector &result) {
-	result.Initialize(inputs[0].type);
-	VectorOperations::Multiply(inputs[0], inputs[1], result);
-}
-
-void MultiplyFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("*");
-	for (auto &type : SQLType::NUMERIC) {
-		functions.AddFunction(ScalarFunction({type, type}, type, multiply_function));
-	}
-	set.AddFunction(functions);
-}
diff --git a/src/function/scalar/operators/right_shift.cpp b/src/function/scalar/operators/right_shift.cpp
deleted file mode 100644
index 2bab433701d..00000000000
--- a/src/function/scalar/operators/right_shift.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "duckdb/function/scalar/operators.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-
-using namespace duckdb;
-using namespace std;
-
-static void bitwise_rshift_function(ExpressionExecutor &exec, Vector inputs[], index_t input_count,
-                                    BoundFunctionExpression &expr, Vector &result) {
-	result.Initialize(inputs[0].type);
-	VectorOperations::BitwiseShiftRight(inputs[0], inputs[1], result);
-}
-
-void RightShiftFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions(">>");
-	for (auto &type : SQLType::INTEGRAL) {
-		functions.AddFunction(ScalarFunction({type, type}, type, bitwise_rshift_function));
-	}
-	set.AddFunction(functions);
-}
diff --git a/src/function/scalar/operators/subtract.cpp b/src/function/scalar/operators/subtract.cpp
deleted file mode 100644
index e8498262ed9..00000000000
--- a/src/function/scalar/operators/subtract.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-#include "duckdb/function/scalar/operators.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-
-using namespace duckdb;
-using namespace std;
-
-static void subtract_function(ExpressionExecutor &exec, Vector inputs[], index_t input_count,
-                              BoundFunctionExpression &expr, Vector &result) {
-	result.Initialize(inputs[0].type);
-	VectorOperations::Subtract(inputs[0], inputs[1], result);
-}
-
-static void unary_subtract_function(ExpressionExecutor &exec, Vector inputs[], index_t input_count,
-                                    BoundFunctionExpression &expr, Vector &result) {
-	Value minus_one = Value::Numeric(inputs[0].type, -1);
-	Vector right;
-	right.Reference(minus_one);
-
-	result.Initialize(inputs[0].type);
-	VectorOperations::Multiply(inputs[0], right, result);
-}
-
-void SubtractFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("-");
-	// binary subtract function "a - b", subtracts b from a
-	for (auto &type : SQLType::NUMERIC) {
-		functions.AddFunction(ScalarFunction({type, type}, type, subtract_function));
-	}
-	functions.AddFunction(ScalarFunction({SQLType::DATE, SQLType::DATE}, SQLType::INTEGER, subtract_function));
-	functions.AddFunction(ScalarFunction({SQLType::DATE, SQLType::INTEGER}, SQLType::DATE, subtract_function));
-	// unary subtract function, negates the input (i.e. multiplies by -1)
-	for (auto &type : SQLType::NUMERIC) {
-		functions.AddFunction(ScalarFunction({type}, type, unary_subtract_function));
-	}
-	set.AddFunction(functions);
-}
diff --git a/src/include/duckdb/common/operator/numeric_bitwise_operators.hpp b/src/include/duckdb/common/operator/numeric_bitwise_operators.hpp
deleted file mode 100644
index 9d8d50b85a6..00000000000
--- a/src/include/duckdb/common/operator/numeric_bitwise_operators.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/numeric_bitwise_operators.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-namespace duckdb {
-
-struct BitwiseXOR {
-	template <class T> static inline T Operation(T left, T right) {
-		return left ^ right;
-	}
-};
-
-struct BitwiseAND {
-	template <class T> static inline T Operation(T left, T right) {
-		return left & right;
-	}
-};
-
-struct BitwiseOR {
-	template <class T> static inline T Operation(T left, T right) {
-		return left | right;
-	}
-};
-
-struct BitwiseShiftLeft {
-	template <class T> static inline T Operation(T left, T right) {
-		return left << right;
-	}
-};
-
-struct BitwiseShiftRight {
-	template <class T> static inline T Operation(T left, T right) {
-		return left >> right;
-	}
-};
-
-struct BitwiseNOT {
-	template <class T> static inline T Operation(T input) {
-		return ~input;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/include/duckdb/common/vector_operations/vector_operations.hpp b/src/include/duckdb/common/vector_operations/vector_operations.hpp
index c399ade5f3a..1be755c5e6c 100644
--- a/src/include/duckdb/common/vector_operations/vector_operations.hpp
+++ b/src/include/duckdb/common/vector_operations/vector_operations.hpp
@@ -49,20 +49,6 @@ struct VectorOperations {
 	//! A %= B
 	static void ModuloInPlace(Vector &A, int64_t B);
 
-	//===--------------------------------------------------------------------===//
-	// Bitwise Operators
-	//===--------------------------------------------------------------------===//
-	//! result = A ^ B
-	static void BitwiseXOR(Vector &A, Vector &B, Vector &result);
-	//! result = A & B
-	static void BitwiseAND(Vector &A, Vector &B, Vector &result);
-	//! result = A | B
-	static void BitwiseOR(Vector &A, Vector &B, Vector &result);
-	//! result = A << B
-	static void BitwiseShiftLeft(Vector &A, Vector &B, Vector &result);
-	//! result = A >> B
-	static void BitwiseShiftRight(Vector &A, Vector &B, Vector &result);
-
 	//===--------------------------------------------------------------------===//
 	// In-Place Bitwise Operators
 	//===--------------------------------------------------------------------===//