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

package/src/duckdb/src/function/scalar/string/bar.cpp

@@ -0,0 +1,93 @@
+#include "duckdb/common/exception.hpp"
+#include "duckdb/common/operator/cast_operators.hpp"
+#include "duckdb/common/types/string_type.hpp"
+#include "duckdb/common/types/value.hpp"
+#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 {
+
+static string_t BarScalarFunction(double x, double min, double max, double max_width, string &result) {
+	static const char *FULL_BLOCK = UnicodeBar::FullBlock();
+	static const char *const *PARTIAL_BLOCKS = UnicodeBar::PartialBlocks();
+	static const idx_t PARTIAL_BLOCKS_COUNT = UnicodeBar::PartialBlocksCount();
+
+	if (!Value::IsFinite(max_width)) {
+		throw ValueOutOfRangeException("Max bar width must not be NaN or infinity");
+	}
+	if (max_width < 1) {
+		throw ValueOutOfRangeException("Max bar width must be >= 1");
+	}
+	if (max_width > 1000) {
+		throw ValueOutOfRangeException("Max bar width must be <= 1000");
+	}
+
+	double width;
+
+	if (Value::IsNan(x) || Value::IsNan(min) || Value::IsNan(max) || x <= min) {
+		width = 0;
+	} else if (x >= max) {
+		width = max_width;
+	} else {
+		width = max_width * (x - min) / (max - min);
+	}
+
+	if (!Value::IsFinite(width)) {
+		throw ValueOutOfRangeException("Bar width must not be NaN or infinity");
+	}
+
+	result.clear();
+
+	int32_t width_as_int = static_cast<int32_t>(width * PARTIAL_BLOCKS_COUNT);
+	idx_t full_blocks_count = (width_as_int / PARTIAL_BLOCKS_COUNT);
+	for (idx_t i = 0; i < full_blocks_count; i++) {
+		result += FULL_BLOCK;
+	}
+
+	idx_t remaining = width_as_int % PARTIAL_BLOCKS_COUNT;
+
+	if (remaining) {
+		result += PARTIAL_BLOCKS[remaining];
+	}
+
+	return string_t(result);
+}
+
+static void BarFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	D_ASSERT(args.ColumnCount() == 3 || args.ColumnCount() == 4);
+	auto &x_arg = args.data[0];
+	auto &min_arg = args.data[1];
+	auto &max_arg = args.data[2];
+	string buffer;
+
+	if (args.ColumnCount() == 3) {
+		GenericExecutor::ExecuteTernary<PrimitiveType<double>, PrimitiveType<double>, PrimitiveType<double>,
+		                                PrimitiveType<string_t>>(
+		    x_arg, min_arg, max_arg, result, args.size(),
+		    [&](PrimitiveType<double> x, PrimitiveType<double> min, PrimitiveType<double> max) {
+			    return StringVector::AddString(result, BarScalarFunction(x.val, min.val, max.val, 80, buffer));
+		    });
+	} else {
+		auto &width_arg = args.data[3];
+		GenericExecutor::ExecuteQuaternary<PrimitiveType<double>, PrimitiveType<double>, PrimitiveType<double>,
+		                                   PrimitiveType<double>, PrimitiveType<string_t>>(
+		    x_arg, min_arg, max_arg, width_arg, result, args.size(),
+		    [&](PrimitiveType<double> x, PrimitiveType<double> min, PrimitiveType<double> max,
+		        PrimitiveType<double> width) {
+			    return StringVector::AddString(result, BarScalarFunction(x.val, min.val, max.val, width.val, buffer));
+		    });
+	}
+}
+
+void BarFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunctionSet bar("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);
+}
+
+} // namespace duckdb

package/src/duckdb/src/function/scalar/string/left_right.cpp

@@ -1,5 +1,6 @@
 #include "duckdb/function/scalar/string_functions.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
+#include "duckdb/common/limits.hpp"
 
 #include <ctype.h>
 #include <algorithm>
@@ -65,7 +66,10 @@ static string_t RightScalarFunction(Vector &result, const string_t str, int64_t
 		return OP::Substring(result, str, start, len);
 	}
 
-	int64_t len = num_characters - MinValue<int64_t>(num_characters, -pos);
+	int64_t len = 0;
+	if (pos != std::numeric_limits<int64_t>::min()) {
+		len = num_characters - MinValue<int64_t>(num_characters, -pos);
+	}
 	int64_t start = num_characters - len + 1;
 	return OP::Substring(result, str, start, len);
 }

package/src/duckdb/src/function/scalar/string/length.cpp

@@ -1,4 +1,5 @@
 #include "duckdb/function/scalar/string_functions.hpp"
+#include "duckdb/common/types/bit.hpp"
 
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
@@ -49,6 +50,13 @@ struct StrLenOperator {
 	}
 };
 
+struct OctetLenOperator {
+	template <class TA, class TR>
+	static inline TR Operation(TA input) {
+		return Bit::OctetLength(input);
+	}
+};
+
 // bitlen returns the size in bits
 struct BitLenOperator {
 	template <class TA, class TR>
@@ -57,6 +65,14 @@ struct BitLenOperator {
 	}
 };
 
+// bitstringlen returns the amount of bits in a bitstring
+struct BitStringLenOperator {
+	template <class TA, class TR>
+	static inline TR Operation(TA input) {
+		return Bit::BitLength(input);
+	}
+};
+
 static unique_ptr<BaseStatistics> LengthPropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
 	auto &child_stats = input.child_stats;
 	auto &expr = input.expr;
@@ -89,6 +105,8 @@ void LengthFun::RegisterFunction(BuiltinFunctions &set) {
 	length.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::BIGINT,
 	                                  ScalarFunction::UnaryFunction<string_t, int64_t, StringLengthOperator>, nullptr,
 	                                  nullptr, LengthPropagateStats));
+	length.AddFunction(ScalarFunction({LogicalType::BIT}, LogicalType::BIGINT,
+	                                  ScalarFunction::UnaryFunction<string_t, int64_t, BitStringLenOperator>));
 	length.AddFunction(array_length_unary);
 	set.AddFunction(length);
 	length.name = "len";
@@ -109,11 +127,19 @@ void LengthFun::RegisterFunction(BuiltinFunctions &set) {
 
 	set.AddFunction(ScalarFunction("strlen", {LogicalType::VARCHAR}, LogicalType::BIGINT,
 	                               ScalarFunction::UnaryFunction<string_t, int64_t, StrLenOperator>));
-	set.AddFunction(ScalarFunction("bit_length", {LogicalType::VARCHAR}, LogicalType::BIGINT,
-	                               ScalarFunction::UnaryFunction<string_t, int64_t, BitLenOperator>));
+	ScalarFunctionSet bit_length("bit_length");
+	bit_length.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::BIGINT,
+	                                      ScalarFunction::UnaryFunction<string_t, int64_t, BitLenOperator>));
+	bit_length.AddFunction(ScalarFunction({LogicalType::BIT}, LogicalType::BIGINT,
+	                                      ScalarFunction::UnaryFunction<string_t, int64_t, BitStringLenOperator>));
+	set.AddFunction(bit_length);
 	// length for BLOB type
-	set.AddFunction(ScalarFunction("octet_length", {LogicalType::BLOB}, LogicalType::BIGINT,
-	                               ScalarFunction::UnaryFunction<string_t, int64_t, StrLenOperator>));
+	ScalarFunctionSet octet_length("octet_length");
+	octet_length.AddFunction(ScalarFunction({LogicalType::BLOB}, LogicalType::BIGINT,
+	                                        ScalarFunction::UnaryFunction<string_t, int64_t, StrLenOperator>));
+	octet_length.AddFunction(ScalarFunction({LogicalType::BIT}, LogicalType::BIGINT,
+	                                        ScalarFunction::UnaryFunction<string_t, int64_t, OctetLenOperator>));
+	set.AddFunction(octet_length);
 }
 
 struct UnicodeOperator {

package/src/duckdb/src/function/scalar/string/like.cpp

@@ -65,7 +65,7 @@ bool TemplatedLikeOperator(const char *sdata, idx_t slen, const char *pdata, idx
 }
 
 struct LikeSegment {
-	explicit LikeSegment(string pattern) : pattern(move(pattern)) {
+	explicit LikeSegment(string pattern) : pattern(std::move(pattern)) {
 	}
 
 	string pattern;
@@ -73,8 +73,8 @@ struct LikeSegment {
 
 struct LikeMatcher : public FunctionData {
 	LikeMatcher(string like_pattern_p, vector<LikeSegment> segments, bool has_start_percentage, bool has_end_percentage)
-	    : like_pattern(move(like_pattern_p)), segments(move(segments)), has_start_percentage(has_start_percentage),
-	      has_end_percentage(has_end_percentage) {
+	    : like_pattern(std::move(like_pattern_p)), segments(std::move(segments)),
+	      has_start_percentage(has_start_percentage), has_end_percentage(has_end_percentage) {
 	}
 
 	bool Match(string_t &str) {
@@ -170,7 +170,8 @@ struct LikeMatcher : public FunctionData {
 		if (segments.empty()) {
 			return nullptr;
 		}
-		return make_unique<LikeMatcher>(move(like_pattern), move(segments), has_start_percentage, has_end_percentage);
+		return make_unique<LikeMatcher>(std::move(like_pattern), std::move(segments), has_start_percentage,
+		                                has_end_percentage);
 	}
 
 	unique_ptr<FunctionData> Copy() const override {

package/src/duckdb/src/function/scalar/string/regexp.cpp

@@ -20,7 +20,7 @@ RegexpBaseBindData::RegexpBaseBindData() : constant_pattern(false) {
 }
 RegexpBaseBindData::RegexpBaseBindData(duckdb_re2::RE2::Options options, string constant_string_p,
                                        bool constant_pattern)
-    : options(options), constant_string(move(constant_string_p)), constant_pattern(constant_pattern) {
+    : options(options), constant_string(std::move(constant_string_p)), constant_pattern(constant_pattern) {
 }
 
 RegexpBaseBindData::~RegexpBaseBindData() {
@@ -119,7 +119,7 @@ static bool TryParseConstantPattern(ClientContext &context, Expression &expr, st
 //===--------------------------------------------------------------------===//
 RegexpMatchesBindData::RegexpMatchesBindData(duckdb_re2::RE2::Options options, string constant_string_p,
                                              bool constant_pattern)
-    : RegexpBaseBindData(options, move(constant_string_p), constant_pattern) {
+    : RegexpBaseBindData(options, std::move(constant_string_p), constant_pattern) {
 	if (constant_pattern) {
 		auto pattern = make_unique<RE2>(constant_string, options);
 		if (!pattern->ok()) {
@@ -135,8 +135,8 @@ RegexpMatchesBindData::RegexpMatchesBindData(duckdb_re2::RE2::Options options, s
 RegexpMatchesBindData::RegexpMatchesBindData(duckdb_re2::RE2::Options options, string constant_string_p,
                                              bool constant_pattern, string range_min_p, string range_max_p,
                                              bool range_success)
-    : RegexpBaseBindData(options, move(constant_string_p), constant_pattern), range_min(move(range_min_p)),
-      range_max(move(range_max_p)), range_success(range_success) {
+    : RegexpBaseBindData(options, std::move(constant_string_p), constant_pattern), range_min(std::move(range_min_p)),
+      range_max(std::move(range_max_p)), range_success(range_success) {
 }
 
 unique_ptr<FunctionData> RegexpMatchesBindData::Copy() const {
@@ -157,7 +157,7 @@ unique_ptr<FunctionData> RegexpMatchesBind(ClientContext &context, ScalarFunctio
 	string constant_string;
 	bool constant_pattern;
 	constant_pattern = TryParseConstantPattern(context, *arguments[1], constant_string);
-	return make_unique<RegexpMatchesBindData>(options, move(constant_string), constant_pattern);
+	return make_unique<RegexpMatchesBindData>(options, std::move(constant_string), constant_pattern);
 }
 
 struct RegexPartialMatch {
@@ -205,12 +205,12 @@ RegexpReplaceBindData::RegexpReplaceBindData() : global_replace(false) {
 
 RegexpReplaceBindData::RegexpReplaceBindData(duckdb_re2::RE2::Options options, string constant_string_p,
                                              bool constant_pattern, bool global_replace)
-    : RegexpBaseBindData(options, move(constant_string_p), constant_pattern), global_replace(global_replace) {
+    : RegexpBaseBindData(options, std::move(constant_string_p), constant_pattern), global_replace(global_replace) {
 }
 
 unique_ptr<FunctionData> RegexpReplaceBindData::Copy() const {
 	auto copy = make_unique<RegexpReplaceBindData>(options, constant_string, constant_pattern, global_replace);
-	return move(copy);
+	return std::move(copy);
 }
 
 bool RegexpReplaceBindData::Equals(const FunctionData &other_p) const {
@@ -227,7 +227,7 @@ static unique_ptr<FunctionData> RegexReplaceBind(ClientContext &context, ScalarF
 		ParseRegexOptions(context, *arguments[3], data->options, &data->global_replace);
 	}
 	data->options.set_log_errors(false);
-	return move(data);
+	return std::move(data);
 }
 
 static void RegexReplaceFunction(DataChunk &args, ExpressionState &state, Vector &result) {
@@ -273,8 +273,8 @@ RegexpExtractBindData::RegexpExtractBindData() {
 
 RegexpExtractBindData::RegexpExtractBindData(duckdb_re2::RE2::Options options, string constant_string_p,
                                              bool constant_pattern, string group_string_p)
-    : RegexpBaseBindData(options, move(constant_string_p), constant_pattern), group_string(move(group_string_p)),
-      rewrite(group_string) {
+    : RegexpBaseBindData(options, std::move(constant_string_p), constant_pattern),
+      group_string(std::move(group_string_p)), rewrite(group_string) {
 }
 
 unique_ptr<FunctionData> RegexpExtractBindData::Copy() const {
@@ -317,7 +317,8 @@ static unique_ptr<FunctionData> RegexExtractBind(ClientContext &context, ScalarF
 	if (arguments.size() >= 4) {
 		ParseRegexOptions(context, *arguments[3], options);
 	}
-	return make_unique<RegexpExtractBindData>(options, move(constant_string), constant_pattern, move(group_string));
+	return make_unique<RegexpExtractBindData>(options, std::move(constant_string), constant_pattern,
+	                                          std::move(group_string));
 }
 
 inline static string_t Extract(const string_t &input, Vector &result, const RE2 &re,

package/src/duckdb/src/function/scalar/string/string_split.cpp

@@ -74,7 +74,7 @@ struct StringSplitter {
 		auto delim_size = delim.GetSize();
 		idx_t list_idx = 0;
 		while (input_size > 0) {
-			idx_t match_size;
+			idx_t match_size = 0;
 			auto pos = OP::Find(input_data, input_size, delim_data, delim_size, match_size, data);
 			if (pos > input_size) {
 				break;

package/src/duckdb/src/function/scalar/string/substring.cpp

@@ -7,6 +7,7 @@
 #include "duckdb/storage/statistics/string_statistics.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "utf8proc.hpp"
+#include "duckdb/common/types/blob.hpp"
 
 namespace duckdb {
 
@@ -138,6 +139,13 @@ string_t SubstringFun::SubstringUnicode(Vector &result, string_t input, int64_t
 				}
 			}
 		}
+		while (!LengthFun::IsCharacter(input_data[start_pos])) {
+			start_pos++;
+		}
+		while (end_pos < input_size && !LengthFun::IsCharacter(input_data[end_pos])) {
+			end_pos++;
+		}
+
 		if (end_pos == DConstants::INVALID_INDEX) {
 			return SubstringEmptyString(result);
 		}

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

@@ -1,6 +1,7 @@
 #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 {
 
@@ -33,6 +34,7 @@ void BuiltinFunctions::RegisterStringFunctions() {
 	Register<UnicodeFun>();
 	Register<NFCNormalizeFun>();
 	Register<StringSplitFun>();
+	Register<BarFun>();
 	Register<ASCII>();
 	Register<CHR>();
 	Register<MismatchesFun>();
@@ -44,6 +46,11 @@ void BuiltinFunctions::RegisterStringFunctions() {
 	Register<Base64Fun>();
 	Register<EncodeFun>();
 
+	// bit functions
+	Register<GetBitFun>();
+	Register<SetBitFun>();
+	Register<BitPositionFun>();
+
 	// uuid functions
 	Register<UUIDFun>();
 }

package/src/duckdb/src/function/scalar/struct/struct_extract.cpp

@@ -8,7 +8,8 @@
 namespace duckdb {
 
 struct StructExtractBindData : public FunctionData {
-	StructExtractBindData(string key, idx_t index, LogicalType type) : key(move(key)), index(index), type(move(type)) {
+	StructExtractBindData(string key, idx_t index, LogicalType type)
+	    : key(std::move(key)), index(index), type(std::move(type)) {
 	}
 
 	string key;

package/src/duckdb/src/function/scalar/struct/struct_insert.cpp

@@ -74,7 +74,7 @@ static unique_ptr<FunctionData> StructInsertBind(ClientContext &context, ScalarF
 	}
 
 	// this is more for completeness reasons
-	bound_function.return_type = LogicalType::STRUCT(move(new_struct_children));
+	bound_function.return_type = LogicalType::STRUCT(std::move(new_struct_children));
 	return make_unique<VariableReturnBindData>(bound_function.return_type);
 }
 
@@ -96,7 +96,7 @@ unique_ptr<BaseStatistics> StructInsertStats(ClientContext &context, FunctionSta
 	for (idx_t i = 1; i < child_stats.size(); i++) {
 		new_struct_stats->child_stats[offset + i] = child_stats[i] ? child_stats[i]->Copy() : nullptr;
 	}
-	return move(new_struct_stats);
+	return std::move(new_struct_stats);
 }
 
 void StructInsertFun::RegisterFunction(BuiltinFunctions &set) {

package/src/duckdb/src/function/scalar/struct/struct_pack.cpp

@@ -54,7 +54,7 @@ static unique_ptr<FunctionData> StructPackBind(ClientContext &context, ScalarFun
 	}
 
 	// this is more for completeness reasons
-	bound_function.return_type = LogicalType::STRUCT(move(struct_children));
+	bound_function.return_type = LogicalType::STRUCT(std::move(struct_children));
 	return make_unique<VariableReturnBindData>(bound_function.return_type);
 }
 
@@ -66,7 +66,7 @@ unique_ptr<BaseStatistics> StructPackStats(ClientContext &context, FunctionStati
 	for (idx_t i = 0; i < struct_stats->child_stats.size(); i++) {
 		struct_stats->child_stats[i] = child_stats[i] ? child_stats[i]->Copy() : nullptr;
 	}
-	return move(struct_stats);
+	return std::move(struct_stats);
 }
 
 void StructPackFun::RegisterFunction(BuiltinFunctions &set) {

package/src/duckdb/src/function/scalar/system/aggregate_export.cpp

@@ -15,7 +15,7 @@ struct ExportAggregateBindData : public FunctionData {
 	idx_t state_size;
 
 	explicit ExportAggregateBindData(AggregateFunction aggr_p, idx_t state_size_p)
-	    : aggr(move(aggr_p)), state_size(state_size_p) {
+	    : aggr(std::move(aggr_p)), state_size(state_size_p) {
 	}
 
 	unique_ptr<FunctionData> Copy() const override {
@@ -313,7 +313,7 @@ ExportAggregateFunction::Bind(unique_ptr<BoundAggregateExpression> child_aggrega
 	auto export_bind_data = make_unique<ExportAggregateFunctionBindData>(child_aggregate->Copy());
 	aggregate_state_t state_type(child_aggregate->function.name, child_aggregate->function.return_type,
 	                             child_aggregate->function.arguments);
-	auto return_type = LogicalType::AGGREGATE_STATE(move(state_type));
+	auto return_type = LogicalType::AGGREGATE_STATE(std::move(state_type));
 
 	auto export_function =
 	    AggregateFunction("aggregate_state_export_" + bound_function.name, bound_function.arguments, return_type,
@@ -325,8 +325,8 @@ ExportAggregateFunction::Bind(unique_ptr<BoundAggregateExpression> child_aggrega
 	export_function.serialize = ExportStateAggregateSerialize;
 	export_function.deserialize = ExportStateAggregateDeserialize;
 
-	return make_unique<BoundAggregateExpression>(export_function, move(child_aggregate->children),
-	                                             move(child_aggregate->filter), move(export_bind_data),
+	return make_unique<BoundAggregateExpression>(export_function, std::move(child_aggregate->children),
+	                                             std::move(child_aggregate->filter), std::move(export_bind_data),
 	                                             child_aggregate->aggr_type);
 }
 

package/src/duckdb/src/function/scalar/system/system_functions.cpp

@@ -5,7 +5,7 @@
 #include "duckdb/main/client_data.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
-#include "duckdb/transaction/transaction.hpp"
+#include "duckdb/transaction/duck_transaction.hpp"
 #include "duckdb/main/database_manager.hpp"
 
 namespace duckdb {
@@ -22,6 +22,12 @@ static void CurrentSchemaFunction(DataChunk &input, ExpressionState &state, Vect
 	result.Reference(val);
 }
 
+// current_database
+static void CurrentDatabaseFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+	Value val(DatabaseManager::GetDefaultDatabase(state.GetContext()));
+	result.Reference(val);
+}
+
 // current_schemas
 static void CurrentSchemasFunction(DataChunk &input, ExpressionState &state, Vector &result) {
 	if (!input.AllConstant()) {
@@ -47,7 +53,7 @@ static void CurrentSchemasFunction(DataChunk &input, ExpressionState &state, Vec
 static void TransactionIdCurrent(DataChunk &input, ExpressionState &state, Vector &result) {
 	auto &context = state.GetContext();
 	auto &catalog = Catalog::GetCatalog(context, DatabaseManager::GetDefaultDatabase(context));
-	auto &transaction = Transaction::Get(context, catalog);
+	auto &transaction = DuckTransaction::Get(context, catalog);
 	auto val = Value::BIGINT(transaction.start_time);
 	result.Reference(val);
 }
@@ -65,6 +71,7 @@ void SystemFun::RegisterFunction(BuiltinFunctions &set) {
 	current_query.side_effects = FunctionSideEffects::HAS_SIDE_EFFECTS;
 	set.AddFunction(current_query);
 	set.AddFunction(ScalarFunction("current_schema", {}, LogicalType::VARCHAR, CurrentSchemaFunction));
+	set.AddFunction(ScalarFunction("current_database", {}, LogicalType::VARCHAR, CurrentDatabaseFunction));
 	set.AddFunction(
 	    ScalarFunction("current_schemas", {LogicalType::BOOLEAN}, varchar_list_type, CurrentSchemasFunction));
 	set.AddFunction(ScalarFunction("txid_current", {}, LogicalType::BIGINT, TransactionIdCurrent));

package/src/duckdb/src/function/scalar/union/union_extract.cpp

@@ -7,7 +7,8 @@
 namespace duckdb {
 
 struct UnionExtractBindData : public FunctionData {
-	UnionExtractBindData(string key, idx_t index, LogicalType type) : key(move(key)), index(index), type(move(type)) {
+	UnionExtractBindData(string key, idx_t index, LogicalType type)
+	    : key(std::move(key)), index(index), type(std::move(type)) {
 	}
 
 	string key;

package/src/duckdb/src/function/scalar/union/union_value.cpp

@@ -102,7 +102,7 @@ static unique_ptr<FunctionData> UnionValueBind(ClientContext &context, ScalarFun
 
 	union_members.push_back(make_pair(child->alias, child->return_type));
 
-	bound_function.return_type = LogicalType::UNION(move(union_members));
+	bound_function.return_type = LogicalType::UNION(std::move(union_members));
 	return make_unique<VariableReturnBindData>(bound_function.return_type);
 }
 

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

@@ -10,8 +10,9 @@ ScalarFunction::ScalarFunction(string name, vector<LogicalType> arguments, Logic
                                dependency_function_t dependency, function_statistics_t statistics,
                                init_local_state_t init_local_state, LogicalType varargs,
                                FunctionSideEffects side_effects, FunctionNullHandling null_handling)
-    : BaseScalarFunction(move(name), move(arguments), move(return_type), side_effects, move(varargs), null_handling),
-      function(move(function)), bind(bind), init_local_state(init_local_state), dependency(dependency),
+    : BaseScalarFunction(std::move(name), std::move(arguments), std::move(return_type), side_effects,
+                         std::move(varargs), null_handling),
+      function(std::move(function)), bind(bind), init_local_state(init_local_state), dependency(dependency),
       statistics(statistics), serialize(nullptr), deserialize(nullptr) {
 }
 
@@ -20,8 +21,8 @@ ScalarFunction::ScalarFunction(vector<LogicalType> arguments, LogicalType return
                                function_statistics_t statistics, init_local_state_t init_local_state,
                                LogicalType varargs, FunctionSideEffects side_effects,
                                FunctionNullHandling null_handling)
-    : ScalarFunction(string(), move(arguments), move(return_type), move(function), bind, dependency, statistics,
-                     init_local_state, move(varargs), side_effects, null_handling) {
+    : ScalarFunction(string(), std::move(arguments), std::move(return_type), std::move(function), bind, dependency,
+                     statistics, init_local_state, std::move(varargs), side_effects, null_handling) {
 }
 
 bool ScalarFunction::operator==(const ScalarFunction &rhs) const {

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

@@ -15,7 +15,7 @@
 namespace duckdb {
 
 ScalarMacroFunction::ScalarMacroFunction(unique_ptr<ParsedExpression> expression)
-    : MacroFunction(MacroType::SCALAR_MACRO), expression(move(expression)) {
+    : MacroFunction(MacroType::SCALAR_MACRO), expression(std::move(expression)) {
 }
 
 ScalarMacroFunction::ScalarMacroFunction(void) : MacroFunction(MacroType::SCALAR_MACRO) {
@@ -26,7 +26,7 @@ unique_ptr<MacroFunction> ScalarMacroFunction::Copy() {
 	result->expression = expression->Copy();
 	CopyProperties(*result);
 
-	return move(result);
+	return std::move(result);
 }
 
 void RemoveQualificationRecursive(unique_ptr<ParsedExpression> &expr) {

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

@@ -114,14 +114,14 @@ LogicalType ArrowTableFunction::GetArrowLogicalType(
 		idx_t fixed_size = std::stoi(parameters);
 		arrow_convert_data[col_idx]->variable_sz_type.emplace_back(ArrowVariableSizeType::FIXED_SIZE, fixed_size);
 		auto child_type = GetArrowLogicalType(*schema.children[0], arrow_convert_data, col_idx);
-		return LogicalType::LIST(move(child_type));
+		return LogicalType::LIST(std::move(child_type));
 	} else if (format == "+s") {
 		child_list_t<LogicalType> child_types;
 		for (idx_t type_idx = 0; type_idx < (idx_t)schema.n_children; type_idx++) {
 			auto child_type = GetArrowLogicalType(*schema.children[type_idx], arrow_convert_data, col_idx);
 			child_types.push_back({schema.children[type_idx]->name, child_type});
 		}
-		return LogicalType::STRUCT(move(child_types));
+		return LogicalType::STRUCT(std::move(child_types));
 
 	} else if (format == "+m") {
 		arrow_convert_data[col_idx]->variable_sz_type.emplace_back(ArrowVariableSizeType::NORMAL, 0);
@@ -217,7 +217,7 @@ unique_ptr<FunctionData> ArrowTableFunction::ArrowScanBind(ClientContext &contex
 	}
 	RenameArrowColumns(names);
 	res->all_types = return_types;
-	return move(res);
+	return std::move(res);
 }
 
 unique_ptr<ArrowArrayStreamWrapper> ProduceArrowScan(const ArrowScanFunctionData &function,
@@ -254,7 +254,7 @@ bool ArrowTableFunction::ArrowScanParallelStateNext(ClientContext &context, cons
 	while (current_chunk->arrow_array.length == 0 && current_chunk->arrow_array.release) {
 		current_chunk = parallel_state.stream->GetNextChunk();
 	}
-	state.chunk = move(current_chunk);
+	state.chunk = std::move(current_chunk);
 	//! have we run out of chunks? we are done
 	if (!state.chunk->arrow_array.release) {
 		parallel_state.done = true;
@@ -279,7 +279,7 @@ unique_ptr<GlobalTableFunctionState> ArrowTableFunction::ArrowScanInitGlobal(Cli
 			}
 		}
 	}
-	return move(result);
+	return std::move(result);
 }
 
 unique_ptr<LocalTableFunctionState> ArrowTableFunction::ArrowScanInitLocal(ExecutionContext &context,
@@ -287,7 +287,7 @@ unique_ptr<LocalTableFunctionState> ArrowTableFunction::ArrowScanInitLocal(Execu
                                                                            GlobalTableFunctionState *global_state_p) {
 	auto &global_state = (ArrowScanGlobalState &)*global_state_p;
 	auto current_chunk = make_unique<ArrowArrayWrapper>();
-	auto result = make_unique<ArrowScanLocalState>(move(current_chunk));
+	auto result = make_unique<ArrowScanLocalState>(std::move(current_chunk));
 	result->column_ids = input.column_ids;
 	result->filters = input.filters;
 	if (input.CanRemoveFilterColumns()) {
@@ -297,7 +297,7 @@ unique_ptr<LocalTableFunctionState> ArrowTableFunction::ArrowScanInitLocal(Execu
 	if (!ArrowScanParallelStateNext(context.client, input.bind_data, *result, global_state)) {
 		return nullptr;
 	}
-	return move(result);
+	return std::move(result);
 }
 
 void ArrowTableFunction::ArrowScanFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {

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

@@ -369,7 +369,6 @@ void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanLocalState
 		DirectConversion(vector, array, scan_state, nested_offset);
 		break;
 	}
-	case LogicalTypeId::JSON:
 	case LogicalTypeId::VARCHAR: {
 		auto original_type = arrow_convert_data[col_idx]->variable_sz_type[arrow_convert_idx.first++];
 		auto cdata = (char *)array.buffers[2];
@@ -741,7 +740,7 @@ void ColumnArrowToDuckDBDictionary(Vector &vector, ArrowArray &array, ArrowScanL
 		SetValidityMask(*base_vector, *array.dictionary, scan_state, array.dictionary->length, 0, array.null_count > 0);
 		ColumnArrowToDuckDB(*base_vector, *array.dictionary, scan_state, array.dictionary->length, arrow_convert_data,
 		                    col_idx, arrow_convert_idx);
-		dict_vectors[col_idx] = move(base_vector);
+		dict_vectors[col_idx] = std::move(base_vector);
 	}
 	auto dictionary_type = arrow_convert_data[col_idx]->dictionary_type;
 	//! Get Pointer to Indices of Dictionary

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

@@ -3,6 +3,7 @@
 #include "duckdb/storage/storage_manager.hpp"
 #include "duckdb/transaction/transaction_manager.hpp"
 #include "duckdb/main/database_manager.hpp"
+#include "duckdb/function/function_set.hpp"
 
 namespace duckdb {