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

package/src/duckdb/src/function/cast/cast_function_set.cpp

@@ -16,7 +16,7 @@ BoundCastInfo BindCastInput::GetCastFunction(const LogicalType &source, const Lo
 }
 
 BindCastFunction::BindCastFunction(bind_cast_function_t function_p, unique_ptr<BindCastInfo> info_p)
-    : function(function_p), info(move(info_p)) {
+    : function(function_p), info(std::move(info_p)) {
 }
 
 CastFunctionSet::CastFunctionSet() : map_info(nullptr) {
@@ -53,7 +53,7 @@ BoundCastInfo CastFunctionSet::GetCastFunction(const LogicalType &source, const
 
 struct MapCastNode {
 	MapCastNode(BoundCastInfo info, int64_t implicit_cast_cost)
-	    : cast_info(move(info)), bind_function(nullptr), implicit_cast_cost(implicit_cast_cost) {
+	    : cast_info(std::move(info)), bind_function(nullptr), implicit_cast_cost(implicit_cast_cost) {
 	}
 	MapCastNode(bind_cast_function_t func, int64_t implicit_cast_cost)
 	    : cast_info(nullptr), bind_function(func), implicit_cast_cost(implicit_cast_cost) {
@@ -106,7 +106,7 @@ BoundCastInfo MapCastFunction(BindCastInput &input, const LogicalType &source, c
 
 void CastFunctionSet::RegisterCastFunction(const LogicalType &source, const LogicalType &target, BoundCastInfo function,
                                            int64_t implicit_cast_cost) {
-	RegisterCastFunction(source, target, MapCastNode(move(function), implicit_cast_cost));
+	RegisterCastFunction(source, target, MapCastNode(std::move(function), implicit_cast_cost));
 }
 
 void CastFunctionSet::RegisterCastFunction(const LogicalType &source, const LogicalType &target,
@@ -119,9 +119,9 @@ void CastFunctionSet::RegisterCastFunction(const LogicalType &source, const Logi
 		// create the cast map and the cast map function
 		auto info = make_unique<MapCastInfo>();
 		map_info = info.get();
-		bind_functions.emplace_back(MapCastFunction, move(info));
+		bind_functions.emplace_back(MapCastFunction, std::move(info));
 	}
-	map_info->casts[source].insert(make_pair(target, move(node)));
+	map_info->casts[source].insert(make_pair(target, std::move(node)));
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/cast/decimal_cast.cpp

@@ -66,7 +66,7 @@ struct DecimalScaleUpCheckOperator {
 			auto error = StringUtil::Format("Casting value \"%s\" to type %s failed: value is out of range!",
 			                                Decimal::ToString(input, data->source_width, data->source_scale),
 			                                data->result.GetType().ToString());
-			return HandleVectorCastError::Operation<RESULT_TYPE>(move(error), mask, idx, data->error_message,
+			return HandleVectorCastError::Operation<RESULT_TYPE>(std::move(error), mask, idx, data->error_message,
 			                                                     data->all_converted);
 		}
 		return Cast::Operation<INPUT_TYPE, RESULT_TYPE>(input) * data->factor;
@@ -115,7 +115,7 @@ struct DecimalScaleDownCheckOperator {
 			auto error = StringUtil::Format("Casting value \"%s\" to type %s failed: value is out of range!",
 			                                Decimal::ToString(input, data->source_width, data->source_scale),
 			                                data->result.GetType().ToString());
-			return HandleVectorCastError::Operation<RESULT_TYPE>(move(error), mask, idx, data->error_message,
+			return HandleVectorCastError::Operation<RESULT_TYPE>(std::move(error), mask, idx, data->error_message,
 			                                                     data->all_converted);
 		}
 		return Cast::Operation<INPUT_TYPE, RESULT_TYPE>(input / data->factor);

package/src/duckdb/src/function/cast/default_casts.cpp

@@ -1,13 +1,14 @@
 #include "duckdb/function/cast/default_casts.hpp"
+
+#include "duckdb/common/likely.hpp"
+#include "duckdb/common/limits.hpp"
 #include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/function/cast/vector_cast_helpers.hpp"
+#include "duckdb/common/string_util.hpp"
 #include "duckdb/common/types/cast_helpers.hpp"
 #include "duckdb/common/types/chunk_collection.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/common/types/null_value.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/likely.hpp"
-#include "duckdb/common/limits.hpp"
+#include "duckdb/common/vector_operations/vector_operations.hpp"
+#include "duckdb/function/cast/vector_cast_helpers.hpp"
 
 namespace duckdb {
 
@@ -17,12 +18,13 @@ BindCastInfo::~BindCastInfo() {
 BoundCastData::~BoundCastData() {
 }
 
-BoundCastInfo::BoundCastInfo(cast_function_t function_p, unique_ptr<BoundCastData> cast_data_p)
-    : function(function_p), cast_data(move(cast_data_p)) {
+BoundCastInfo::BoundCastInfo(cast_function_t function_p, unique_ptr<BoundCastData> cast_data_p,
+                             init_cast_local_state_t init_local_state_p)
+    : function(function_p), init_local_state(init_local_state_p), cast_data(std::move(cast_data_p)) {
 }
 
 BoundCastInfo BoundCastInfo::Copy() const {
-	return BoundCastInfo(function, cast_data ? cast_data->Copy() : nullptr);
+	return BoundCastInfo(function, cast_data ? cast_data->Copy() : nullptr, init_local_state);
 }
 
 bool DefaultCasts::NopCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
@@ -117,11 +119,12 @@ BoundCastInfo DefaultCasts::GetDefaultCastFunction(BindCastInput &input, const L
 		return TimestampSecCastSwitch(input, source, target);
 	case LogicalTypeId::INTERVAL:
 		return IntervalCastSwitch(input, source, target);
-	case LogicalTypeId::JSON:
 	case LogicalTypeId::VARCHAR:
 		return StringCastSwitch(input, source, target);
 	case LogicalTypeId::BLOB:
 		return BlobCastSwitch(input, source, target);
+	case LogicalTypeId::BIT:
+		return BitCastSwitch(input, source, target);
 	case LogicalTypeId::SQLNULL:
 		return NullTypeCast;
 	case LogicalTypeId::MAP:

package/src/duckdb/src/function/cast/enum_casts.cpp

@@ -91,7 +91,7 @@ static bool EnumToVarcharCast(Vector &source, Vector &result, idx_t count, CastP
 
 struct EnumBoundCastData : public BoundCastData {
 	EnumBoundCastData(BoundCastInfo to_varchar_cast, BoundCastInfo from_varchar_cast)
-	    : to_varchar_cast(move(to_varchar_cast)), from_varchar_cast(move(from_varchar_cast)) {
+	    : to_varchar_cast(std::move(to_varchar_cast)), from_varchar_cast(std::move(from_varchar_cast)) {
 	}
 
 	BoundCastInfo to_varchar_cast;
@@ -106,7 +106,7 @@ public:
 unique_ptr<BoundCastData> BindEnumCast(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
 	auto to_varchar_cast = input.GetCastFunction(source, LogicalType::VARCHAR);
 	auto from_varchar_cast = input.GetCastFunction(LogicalType::VARCHAR, target);
-	return make_unique<EnumBoundCastData>(move(to_varchar_cast), move(from_varchar_cast));
+	return make_unique<EnumBoundCastData>(std::move(to_varchar_cast), std::move(from_varchar_cast));
 }
 
 static bool EnumToAnyCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
@@ -140,7 +140,6 @@ BoundCastInfo DefaultCasts::EnumCastSwitch(BindCastInput &input, const LogicalTy
 			throw InternalException("ENUM can only have unsigned integers (except UINT64) as physical types");
 		}
 	}
-	case LogicalTypeId::JSON:
 	case LogicalTypeId::VARCHAR:
 		switch (enum_physical_type) {
 		case PhysicalType::UINT8:

package/src/duckdb/src/function/cast/list_casts.cpp

@@ -9,7 +9,7 @@ unique_ptr<BoundCastData> ListBoundCastData::BindListToListCast(BindCastInput &i
 	auto &source_child_type = ListType::GetChildType(source);
 	auto &result_child_type = ListType::GetChildType(target);
 	auto child_cast = input.GetCastFunction(source_child_type, result_child_type);
-	return make_unique<ListBoundCastData>(move(child_cast));
+	return make_unique<ListBoundCastData>(std::move(child_cast));
 }
 
 bool ListCast::ListToListCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
@@ -118,7 +118,6 @@ BoundCastInfo DefaultCasts::ListCastSwitch(BindCastInput &input, const LogicalTy
 	case LogicalTypeId::LIST:
 		return BoundCastInfo(ListCast::ListToListCast, ListBoundCastData::BindListToListCast(input, source, target));
 	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::JSON:
 		return BoundCastInfo(ListToVarcharCast, ListBoundCastData::BindListToListCast(
 		                                            input, source, LogicalType::LIST(LogicalType::VARCHAR)));
 	default:

package/src/duckdb/src/function/cast/map_cast.cpp

@@ -3,6 +3,18 @@
 
 namespace duckdb {
 
+unique_ptr<BoundCastData> MapBoundCastData::BindMapToMapCast(BindCastInput &input, const LogicalType &source,
+                                                             const LogicalType &target) {
+	vector<BoundCastInfo> child_cast_info;
+	auto source_key = MapType::KeyType(source);
+	auto target_key = MapType::KeyType(target);
+	auto source_val = MapType::ValueType(source);
+	auto target_val = MapType::ValueType(target);
+	auto key_cast = input.GetCastFunction(source_key, target_key);
+	auto value_cast = input.GetCastFunction(source_val, target_val);
+	return make_unique<MapBoundCastData>(std::move(key_cast), std::move(value_cast));
+}
+
 static bool MapToVarcharCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
 	auto constant = source.GetVectorType() == VectorType::CONSTANT_VECTOR;
 	auto varchar_type = LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR);
@@ -67,7 +79,6 @@ BoundCastInfo DefaultCasts::MapCastSwitch(BindCastInput &input, const LogicalTyp
 	switch (target.id()) {
 	case LogicalTypeId::MAP:
 		return BoundCastInfo(ListCast::ListToListCast, ListBoundCastData::BindListToListCast(input, source, target));
-	case LogicalTypeId::JSON:
 	case LogicalTypeId::VARCHAR: {
 		auto varchar_type = LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR);
 		return BoundCastInfo(MapToVarcharCast, ListBoundCastData::BindListToListCast(input, source, varchar_type));

package/src/duckdb/src/function/cast/numeric_casts.cpp

@@ -35,7 +35,6 @@ static BoundCastInfo InternalNumericCastSwitch(const LogicalType &source, const
 		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<SRC, double, duckdb::NumericTryCast>);
 	case LogicalTypeId::DECIMAL:
 		return BoundCastInfo(&VectorCastHelpers::ToDecimalCast<SRC>);
-	case LogicalTypeId::JSON:
 	case LogicalTypeId::VARCHAR:
 		return BoundCastInfo(&VectorCastHelpers::StringCast<SRC, duckdb::StringCast>);
 	default:

package/src/duckdb/src/function/cast/string_cast.cpp

@@ -2,6 +2,7 @@
 #include "duckdb/function/cast/vector_cast_helpers.hpp"
 #include "duckdb/common/pair.hpp"
 #include "duckdb/common/vector.hpp"
+#include "duckdb/function/scalar/nested_functions.hpp"
 
 namespace duckdb {
 
@@ -114,10 +115,10 @@ static BoundCastInfo VectorStringCastNumericSwitch(BindCastInput &input, const L
 	}
 }
 
+// string -> list casting
 bool VectorStringToList::StringToNestedTypeCastLoop(string_t *source_data, ValidityMask &source_mask, Vector &result,
                                                     ValidityMask &result_mask, idx_t count, CastParameters &parameters,
                                                     const SelectionVector *sel) {
-
 	idx_t total_list_size = 0;
 	for (idx_t i = 0; i < count; i++) {
 		idx_t idx = i;
@@ -127,7 +128,7 @@ bool VectorStringToList::StringToNestedTypeCastLoop(string_t *source_data, Valid
 		if (!source_mask.RowIsValid(idx)) {
 			continue;
 		}
-		total_list_size += VectorStringToList::CountParts(source_data[idx]);
+		total_list_size += VectorStringToList::CountPartsList(source_data[idx]);
 	}
 
 	Vector varchar_vector(LogicalType::VARCHAR, total_list_size);
@@ -151,7 +152,7 @@ bool VectorStringToList::StringToNestedTypeCastLoop(string_t *source_data, Valid
 		}
 
 		list_data[i].offset = total;
-		if (!VectorStringToList::SplitStringifiedList(source_data[idx], child_data, total, varchar_vector)) {
+		if (!VectorStringToList::SplitStringList(source_data[idx], child_data, total, varchar_vector)) {
 			string text = "Type VARCHAR with value '" + source_data[idx].GetString() +
 			              "' can't be cast to the destination type LIST";
 			HandleVectorCastError::Operation<string_t>(text, result_mask, idx, parameters.error_message, all_converted);
@@ -176,6 +177,7 @@ static LogicalType InitVarcharStructType(const LogicalType &target) {
 	return LogicalType::STRUCT(child_types);
 }
 
+// string -> struct casting
 bool VectorStringToStruct::StringToNestedTypeCastLoop(string_t *source_data, ValidityMask &source_mask, Vector &result,
                                                       ValidityMask &result_mask, idx_t count,
                                                       CastParameters &parameters, const SelectionVector *sel) {
@@ -220,8 +222,6 @@ bool VectorStringToStruct::StringToNestedTypeCastLoop(string_t *source_data, Val
 		auto &varchar_vector = *child_vectors[child_idx];
 		auto &result_child_vector = *result_children[child_idx];
 		auto &child_cast_info = cast_data.child_cast_info[child_idx];
-		// get the correct casting function (VARCHAR -> result_child_type) from cast_data
-		// casting functions are determined by BindStructtoStructCast
 		CastParameters child_parameters(parameters, child_cast_info.cast_data.get());
 		if (!child_cast_info.function(varchar_vector, result_child_vector, count, child_parameters)) {
 			all_converted = false;
@@ -230,6 +230,87 @@ bool VectorStringToStruct::StringToNestedTypeCastLoop(string_t *source_data, Val
 	return all_converted;
 }
 
+// string -> map casting
+bool VectorStringToMap::StringToNestedTypeCastLoop(string_t *source_data, ValidityMask &source_mask, Vector &result,
+                                                   ValidityMask &result_mask, idx_t count, CastParameters &parameters,
+                                                   const SelectionVector *sel) {
+	idx_t total_elements = 0;
+	for (idx_t i = 0; i < count; i++) {
+		idx_t idx = i;
+		if (sel) {
+			idx = sel->get_index(i);
+		}
+		if (!source_mask.RowIsValid(idx)) {
+			continue;
+		}
+		total_elements += (VectorStringToMap::CountPartsMap(source_data[idx]) + 1) / 2;
+	}
+
+	Vector varchar_key_vector(LogicalType::VARCHAR, total_elements);
+	Vector varchar_val_vector(LogicalType::VARCHAR, total_elements);
+	auto child_key_data = FlatVector::GetData<string_t>(varchar_key_vector);
+	auto child_val_data = FlatVector::GetData<string_t>(varchar_val_vector);
+
+	ListVector::Reserve(result, total_elements);
+	ListVector::SetListSize(result, total_elements);
+	auto list_data = ListVector::GetData(result);
+
+	bool all_converted = true;
+	idx_t total = 0;
+	for (idx_t i = 0; i < count; i++) {
+		idx_t idx = i;
+		if (sel) {
+			idx = sel->get_index(i);
+		}
+		if (!source_mask.RowIsValid(idx)) {
+			result_mask.SetInvalid(idx);
+			continue;
+		}
+
+		list_data[i].offset = total;
+		if (!VectorStringToMap::SplitStringMap(source_data[idx], child_key_data, child_val_data, total,
+		                                       varchar_key_vector, varchar_val_vector)) {
+			string text = "Type VARCHAR with value '" + source_data[idx].GetString() +
+			              "' can't be cast to the destination type MAP";
+			FlatVector::SetNull(result, idx, true);
+			HandleVectorCastError::Operation<string_t>(text, result_mask, idx, parameters.error_message, all_converted);
+		}
+		list_data[i].length = total - list_data[i].offset;
+	}
+	D_ASSERT(total_elements == total);
+
+	auto &result_key_child = MapVector::GetKeys(result);
+	auto &result_val_child = MapVector::GetValues(result);
+	auto &cast_data = (MapBoundCastData &)*parameters.cast_data;
+
+	CastParameters key_params(parameters, cast_data.key_cast.cast_data.get());
+	if (!cast_data.key_cast.function(varchar_key_vector, result_key_child, total_elements, key_params)) {
+		all_converted = false;
+	}
+	CastParameters val_params(parameters, cast_data.value_cast.cast_data.get());
+	if (!cast_data.value_cast.function(varchar_val_vector, result_val_child, total_elements, val_params)) {
+		all_converted = false;
+	}
+
+	auto &key_validity = FlatVector::Validity(result_key_child);
+	if (!all_converted) {
+		for (idx_t row_idx = 0; row_idx < count; row_idx++) {
+			if (!result_mask.RowIsValid(row_idx)) {
+				continue;
+			}
+			auto list = list_data[row_idx];
+			for (idx_t list_idx = 0; list_idx < list.length; list_idx++) {
+				auto idx = list.offset + list_idx;
+				if (!key_validity.RowIsValid(idx)) {
+					result_mask.SetInvalid(row_idx);
+				}
+			}
+		}
+	}
+	MapConversionVerify(result, count);
+	return all_converted;
+}
+
 template <class T>
 bool StringToNestedTypeCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
 	D_ASSERT(source.GetType().id() == LogicalTypeId::VARCHAR);
@@ -239,7 +320,6 @@ bool StringToNestedTypeCast(Vector &source, Vector &result, idx_t count, CastPar
 		auto source_data = ConstantVector::GetData<string_t>(source);
 		auto &source_mask = ConstantVector::Validity(source);
 		auto &result_mask = FlatVector::Validity(result);
-
 		auto ret = T::StringToNestedTypeCastLoop(source_data, source_mask, result, result_mask, 1, parameters, nullptr);
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
 		return ret;
@@ -281,12 +361,13 @@ BoundCastInfo DefaultCasts::StringCastSwitch(BindCastInput &input, const Logical
 		    &VectorCastHelpers::TryCastStrictLoop<string_t, timestamp_t, duckdb::TryCastToTimestampMS>);
 	case LogicalTypeId::BLOB:
 		return BoundCastInfo(&VectorCastHelpers::TryCastStringLoop<string_t, string_t, duckdb::TryCastToBlob>);
+	case LogicalTypeId::BIT:
+		return BoundCastInfo(&VectorCastHelpers::TryCastStringLoop<string_t, string_t, duckdb::TryCastToBit>);
 	case LogicalTypeId::UUID:
 		return BoundCastInfo(&VectorCastHelpers::TryCastStringLoop<string_t, hugeint_t, duckdb::TryCastToUUID>);
 	case LogicalTypeId::SQLNULL:
 		return &DefaultCasts::TryVectorNullCast;
 	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::JSON:
 		return &DefaultCasts::ReinterpretCast;
 	case LogicalTypeId::LIST:
 		// the second argument allows for a secondary casting function to be passed in the CastParameters
@@ -296,6 +377,10 @@ BoundCastInfo DefaultCasts::StringCastSwitch(BindCastInput &input, const Logical
 	case LogicalTypeId::STRUCT:
 		return BoundCastInfo(&StringToNestedTypeCast<VectorStringToStruct>,
 		                     StructBoundCastData::BindStructToStructCast(input, InitVarcharStructType(target), target));
+	case LogicalTypeId::MAP:
+		return BoundCastInfo(&StringToNestedTypeCast<VectorStringToMap>,
+		                     MapBoundCastData::BindMapToMapCast(
+		                         input, LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR), target));
 	default:
 		return VectorStringCastNumericSwitch(input, source, target);
 	}

package/src/duckdb/src/function/cast/struct_cast.cpp

@@ -13,9 +13,9 @@ unique_ptr<BoundCastData> StructBoundCastData::BindStructToStructCast(BindCastIn
 	}
 	for (idx_t i = 0; i < source_child_types.size(); i++) {
 		auto child_cast = input.GetCastFunction(source_child_types[i].second, result_child_types[i].second);
-		child_cast_info.push_back(move(child_cast));
+		child_cast_info.push_back(std::move(child_cast));
 	}
-	return make_unique<StructBoundCastData>(move(child_cast_info), target);
+	return make_unique<StructBoundCastData>(std::move(child_cast_info), target);
 }
 
 static bool StructToStructCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
@@ -122,7 +122,6 @@ BoundCastInfo DefaultCasts::StructCastSwitch(BindCastInput &input, const Logical
 	switch (target.id()) {
 	case LogicalTypeId::STRUCT:
 		return BoundCastInfo(StructToStructCast, StructBoundCastData::BindStructToStructCast(input, source, target));
-	case LogicalTypeId::JSON:
 	case LogicalTypeId::VARCHAR: {
 		// bind a cast in which we convert all child entries to VARCHAR entries
 		auto &struct_children = StructType::GetChildTypes(source);
@@ -130,7 +129,7 @@ BoundCastInfo DefaultCasts::StructCastSwitch(BindCastInput &input, const Logical
 		for (auto &child_entry : struct_children) {
 			varchar_children.push_back(make_pair(child_entry.first, LogicalType::VARCHAR));
 		}
-		auto varchar_type = LogicalType::STRUCT(move(varchar_children));
+		auto varchar_type = LogicalType::STRUCT(std::move(varchar_children));
 		return BoundCastInfo(StructToVarcharCast,
 		                     StructBoundCastData::BindStructToStructCast(input, source, varchar_type));
 	}

package/src/duckdb/src/function/cast/time_casts.cpp

@@ -7,7 +7,6 @@ BoundCastInfo DefaultCasts::DateCastSwitch(BindCastInput &input, const LogicalTy
 	// now switch on the result type
 	switch (target.id()) {
 	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::JSON:
 		// date to varchar
 		return BoundCastInfo(&VectorCastHelpers::StringCast<date_t, duckdb::StringCast>);
 	case LogicalTypeId::TIMESTAMP:
@@ -29,7 +28,6 @@ BoundCastInfo DefaultCasts::TimeCastSwitch(BindCastInput &input, const LogicalTy
 	// now switch on the result type
 	switch (target.id()) {
 	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::JSON:
 		// time to varchar
 		return BoundCastInfo(&VectorCastHelpers::StringCast<dtime_t, duckdb::StringCast>);
 	case LogicalTypeId::TIME_TZ:
@@ -45,7 +43,6 @@ BoundCastInfo DefaultCasts::TimeTzCastSwitch(BindCastInput &input, const Logical
 	// now switch on the result type
 	switch (target.id()) {
 	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::JSON:
 		// time with time zone to varchar
 		return BoundCastInfo(&VectorCastHelpers::StringCast<dtime_t, duckdb::StringCastTZ>);
 	case LogicalTypeId::TIME:
@@ -61,7 +58,6 @@ BoundCastInfo DefaultCasts::TimestampCastSwitch(BindCastInput &input, const Logi
 	// now switch on the result type
 	switch (target.id()) {
 	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::JSON:
 		// timestamp to varchar
 		return BoundCastInfo(&VectorCastHelpers::StringCast<timestamp_t, duckdb::StringCast>);
 	case LogicalTypeId::DATE:
@@ -96,7 +92,6 @@ BoundCastInfo DefaultCasts::TimestampTzCastSwitch(BindCastInput &input, const Lo
 	// now switch on the result type
 	switch (target.id()) {
 	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::JSON:
 		// timestamp with time zone to varchar
 		return BoundCastInfo(&VectorCastHelpers::StringCast<timestamp_t, duckdb::StringCastTZ>);
 	case LogicalTypeId::TIME_TZ:
@@ -116,7 +111,6 @@ BoundCastInfo DefaultCasts::TimestampNsCastSwitch(BindCastInput &input, const Lo
 	// now switch on the result type
 	switch (target.id()) {
 	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::JSON:
 		// timestamp (ns) to varchar
 		return BoundCastInfo(&VectorCastHelpers::StringCast<timestamp_t, duckdb::CastFromTimestampNS>);
 	case LogicalTypeId::TIMESTAMP:
@@ -133,7 +127,6 @@ BoundCastInfo DefaultCasts::TimestampMsCastSwitch(BindCastInput &input, const Lo
 	// now switch on the result type
 	switch (target.id()) {
 	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::JSON:
 		// timestamp (ms) to varchar
 		return BoundCastInfo(&VectorCastHelpers::StringCast<timestamp_t, duckdb::CastFromTimestampMS>);
 	case LogicalTypeId::TIMESTAMP:
@@ -150,7 +143,6 @@ BoundCastInfo DefaultCasts::TimestampSecCastSwitch(BindCastInput &input, const L
 	// now switch on the result type
 	switch (target.id()) {
 	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::JSON:
 		// timestamp (sec) to varchar
 		return BoundCastInfo(&VectorCastHelpers::StringCast<timestamp_t, duckdb::CastFromTimestampSec>);
 	case LogicalTypeId::TIMESTAMP:
@@ -166,7 +158,6 @@ BoundCastInfo DefaultCasts::IntervalCastSwitch(BindCastInput &input, const Logic
 	// now switch on the result type
 	switch (target.id()) {
 	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::JSON:
 		// time to varchar
 		return BoundCastInfo(&VectorCastHelpers::StringCast<interval_t, duckdb::StringCast>);
 	default:

package/src/duckdb/src/function/cast/union_casts.cpp

@@ -1,6 +1,7 @@
-#include "duckdb/function/cast/default_casts.hpp"
 #include "duckdb/function/cast/cast_function_set.hpp"
+#include "duckdb/function/cast/default_casts.hpp"
 #include "duckdb/function/cast/vector_cast_helpers.hpp"
+
 #include <algorithm> // for std::sort
 
 namespace duckdb {
@@ -13,7 +14,8 @@ namespace duckdb {
 struct ToUnionBoundCastData : public BoundCastData {
 	ToUnionBoundCastData(union_tag_t member_idx, string name, LogicalType type, int64_t cost,
 	                     BoundCastInfo member_cast_info)
-	    : tag(member_idx), name(move(name)), type(move(type)), cost(cost), member_cast_info(move(member_cast_info)) {
+	    : tag(member_idx), name(std::move(name)), type(std::move(type)), cost(cost),
+	      member_cast_info(std::move(member_cast_info)) {
 	}
 
 	union_tag_t tag;
@@ -43,7 +45,8 @@ unique_ptr<BoundCastData> BindToUnionCast(BindCastInput &input, const LogicalTyp
 		auto member_cast_cost = input.function_set.ImplicitCastCost(source, member_type);
 		if (member_cast_cost != -1) {
 			auto member_cast_info = input.GetCastFunction(source, member_type);
-			candidates.emplace_back(member_idx, member_name, member_type, member_cast_cost, move(member_cast_info));
+			candidates.emplace_back(member_idx, member_name, member_type, member_cast_cost,
+			                        std::move(member_cast_info));
 		}
 	};
 
@@ -92,7 +95,7 @@ unique_ptr<BoundCastData> BindToUnionCast(BindCastInput &input, const LogicalTyp
 	}
 
 	// otherwise, return the selected cast
-	return make_unique<ToUnionBoundCastData>(move(selected_cast));
+	return make_unique<ToUnionBoundCastData>(std::move(selected_cast));
 }
 
 static bool ToUnionCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
@@ -142,7 +145,7 @@ struct UnionToUnionBoundCastData : public BoundCastData {
 	LogicalType target_type;
 
 	UnionToUnionBoundCastData(vector<idx_t> tag_map, vector<BoundCastInfo> member_casts, LogicalType target_type)
-	    : tag_map(move(tag_map)), member_casts(move(member_casts)), target_type(move(target_type)) {
+	    : tag_map(std::move(tag_map)), member_casts(std::move(member_casts)), target_type(std::move(target_type)) {
 	}
 
 public:
@@ -151,7 +154,7 @@ public:
 		for (auto &member_cast : member_casts) {
 			member_casts_copy.push_back(member_cast.Copy());
 		}
-		return make_unique<UnionToUnionBoundCastData>(tag_map, move(member_casts_copy), target_type);
+		return make_unique<UnionToUnionBoundCastData>(tag_map, std::move(member_casts_copy), target_type);
 	}
 };
 
@@ -191,7 +194,7 @@ unique_ptr<BoundCastData> BindUnionToUnionCast(BindCastInput &input, const Logic
 		}
 	}
 
-	return make_unique<UnionToUnionBoundCastData>(tag_map, move(member_casts), target);
+	return make_unique<UnionToUnionBoundCastData>(tag_map, std::move(member_casts), target);
 }
 
 static bool UnionToUnionCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
@@ -329,14 +332,13 @@ static bool UnionToVarcharCast(Vector &source, Vector &result, idx_t count, Cast
 BoundCastInfo DefaultCasts::UnionCastSwitch(BindCastInput &input, const LogicalType &source,
                                             const LogicalType &target) {
 	switch (target.id()) {
-	case LogicalTypeId::JSON:
 	case LogicalTypeId::VARCHAR: {
 		// bind a cast in which we convert all members to VARCHAR first
 		child_list_t<LogicalType> varchar_members;
 		for (idx_t member_idx = 0; member_idx < UnionType::GetMemberCount(source); member_idx++) {
 			varchar_members.push_back(make_pair(UnionType::GetMemberName(source, member_idx), LogicalType::VARCHAR));
 		}
-		auto varchar_type = LogicalType::UNION(move(varchar_members));
+		auto varchar_type = LogicalType::UNION(std::move(varchar_members));
 		return BoundCastInfo(UnionToVarcharCast, BindUnionToUnionCast(input, source, varchar_type));
 	} break;
 	case LogicalTypeId::UNION:

package/src/duckdb/src/function/cast/uuid_casts.cpp

@@ -8,7 +8,6 @@ BoundCastInfo DefaultCasts::UUIDCastSwitch(BindCastInput &input, const LogicalTy
 	// now switch on the result type
 	switch (target.id()) {
 	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::JSON:
 		// uuid to varchar
 		return BoundCastInfo(&VectorCastHelpers::StringCast<hugeint_t, duckdb::CastFromUUID>);
 	default: