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

package/src/duckdb/src/common/types/value.cpp

@@ -20,6 +20,7 @@
 #include "duckdb/common/types/null_value.hpp"
 #include "duckdb/common/types/time.hpp"
 #include "duckdb/common/types/timestamp.hpp"
+#include "duckdb/common/types/bit.hpp"
 #include "duckdb/common/types/vector.hpp"
 #include "duckdb/common/value_operations/value_operations.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
@@ -34,7 +35,7 @@
 
 namespace duckdb {
 
-Value::Value(LogicalType type) : type_(move(type)), is_null(true) {
+Value::Value(LogicalType type) : type_(std::move(type)), is_null(true) {
 }
 
 Value::Value(int32_t val) : type_(LogicalType::INTEGER), is_null(false) {
@@ -62,7 +63,7 @@ Value::Value(std::nullptr_t val) : Value(LogicalType::VARCHAR) {
 Value::Value(string_t val) : Value(string(val.GetDataUnsafe(), val.GetSize())) {
 }
 
-Value::Value(string val) : type_(LogicalType::VARCHAR), is_null(false), str_value(move(val)) {
+Value::Value(string val) : type_(LogicalType::VARCHAR), is_null(false), str_value(std::move(val)) {
 	if (!Value::StringIsValid(str_value.c_str(), str_value.size())) {
 		throw Exception(ErrorManager::InvalidUnicodeError(str_value, "value construction"));
 	}
@@ -77,8 +78,9 @@ Value::Value(const Value &other)
 }
 
 Value::Value(Value &&other) noexcept
-    : type_(move(other.type_)), is_null(other.is_null), value_(other.value_), str_value(move(other.str_value)),
-      struct_value(move(other.struct_value)), list_value(move(other.list_value)) {
+    : type_(std::move(other.type_)), is_null(other.is_null), value_(other.value_),
+      str_value(std::move(other.str_value)), struct_value(std::move(other.struct_value)),
+      list_value(std::move(other.list_value)) {
 }
 
 Value &Value::operator=(const Value &other) {
@@ -92,12 +94,12 @@ Value &Value::operator=(const Value &other) {
 }
 
 Value &Value::operator=(Value &&other) noexcept {
-	type_ = move(other.type_);
+	type_ = std::move(other.type_);
 	is_null = other.is_null;
 	value_ = other.value_;
-	str_value = move(other.str_value);
-	struct_value = move(other.struct_value);
-	list_value = move(other.list_value);
+	str_value = std::move(other.str_value);
+	struct_value = std::move(other.struct_value);
+	list_value = std::move(other.list_value);
 	return *this;
 }
 
@@ -367,19 +369,11 @@ bool Value::StringIsValid(const char *str, idx_t length) {
 }
 
 Value Value::DECIMAL(int16_t value, uint8_t width, uint8_t scale) {
-	D_ASSERT(width <= Decimal::MAX_WIDTH_INT16);
-	Value result(LogicalType::DECIMAL(width, scale));
-	result.value_.smallint = value;
-	result.is_null = false;
-	return result;
+	return Value::DECIMAL(int64_t(value), width, scale);
 }
 
 Value Value::DECIMAL(int32_t value, uint8_t width, uint8_t scale) {
-	D_ASSERT(width >= Decimal::MAX_WIDTH_INT16 && width <= Decimal::MAX_WIDTH_INT32);
-	Value result(LogicalType::DECIMAL(width, scale));
-	result.value_.integer = value;
-	result.is_null = false;
-	return result;
+	return Value::DECIMAL(int64_t(value), width, scale);
 }
 
 Value Value::DECIMAL(int64_t value, uint8_t width, uint8_t scale) {
@@ -519,10 +513,10 @@ Value Value::STRUCT(child_list_t<Value> values) {
 	Value result;
 	child_list_t<LogicalType> child_types;
 	for (auto &child : values) {
-		child_types.push_back(make_pair(move(child.first), child.second.type()));
-		result.struct_value.push_back(move(child.second));
+		child_types.push_back(make_pair(std::move(child.first), child.second.type()));
+		result.struct_value.push_back(std::move(child.second));
 	}
-	result.type_ = LogicalType::STRUCT(move(child_types));
+	result.type_ = LogicalType::STRUCT(std::move(child_types));
 
 	result.is_null = false;
 	return result;
@@ -531,12 +525,12 @@ Value Value::STRUCT(child_list_t<Value> values) {
 Value Value::MAP(LogicalType child_type, vector<Value> values) {
 	Value result;
 
-	result.type_ = LogicalType::MAP(move(child_type));
+	result.type_ = LogicalType::MAP(std::move(child_type));
 	result.is_null = false;
 	if (values.empty()) {
 		return result;
 	}
-	result.list_value = move(values);
+	result.list_value = std::move(values);
 	return result;
 }
 
@@ -558,9 +552,9 @@ Value Value::UNION(child_list_t<LogicalType> members, uint8_t tag, Value value)
 			result.struct_value.emplace_back(nullptr);
 		}
 	}
-	result.struct_value[tag + 1] = move(value);
+	result.struct_value[tag + 1] = std::move(value);
 
-	result.type_ = LogicalType::UNION(move(members));
+	result.type_ = LogicalType::UNION(std::move(members));
 	return result;
 }
 
@@ -576,24 +570,24 @@ Value Value::LIST(vector<Value> values) {
 #endif
 	Value result;
 	result.type_ = LogicalType::LIST(values[0].type());
-	result.list_value = move(values);
+	result.list_value = std::move(values);
 	result.is_null = false;
 	return result;
 }
 
 Value Value::LIST(LogicalType child_type, vector<Value> values) {
 	if (values.empty()) {
-		return Value::EMPTYLIST(move(child_type));
+		return Value::EMPTYLIST(std::move(child_type));
 	}
 	for (auto &val : values) {
 		val = val.DefaultCastAs(child_type);
 	}
-	return Value::LIST(move(values));
+	return Value::LIST(std::move(values));
 }
 
 Value Value::EMPTYLIST(LogicalType child_type) {
 	Value result;
-	result.type_ = LogicalType::LIST(move(child_type));
+	result.type_ = LogicalType::LIST(std::move(child_type));
 	result.is_null = false;
 	return result;
 }
@@ -612,21 +606,17 @@ Value Value::BLOB(const string &data) {
 	return result;
 }
 
-Value Value::JSON(const char *val) {
-	auto result = Value(val);
-	result.type_ = LogicalTypeId::JSON;
-	return result;
-}
-
-Value Value::JSON(string_t val) {
-	auto result = Value(val);
-	result.type_ = LogicalTypeId::JSON;
+Value Value::BIT(const_data_ptr_t data, idx_t len) {
+	Value result(LogicalType::BIT);
+	result.is_null = false;
+	result.str_value = string((const char *)data, len);
 	return result;
 }
 
-Value Value::JSON(string val) {
-	auto result = Value(move(val));
-	result.type_ = LogicalTypeId::JSON;
+Value Value::BIT(const string &data) {
+	Value result(LogicalType::BIT);
+	result.is_null = false;
+	result.str_value = Bit::ToBit(string_t(data));
 	return result;
 }
 
@@ -1586,6 +1576,10 @@ bool Value::DefaultTryCastAs(const LogicalType &target_type, bool strict) {
 	return TryCastAs(set, get_input, target_type, strict);
 }
 
+void Value::Reinterpret(LogicalType new_type) {
+	this->type_ = std::move(new_type);
+}
+
 void Value::Serialize(Serializer &main_serializer) const {
 	FieldWriter writer(main_serializer);
 	writer.WriteSerializable(type_);

package/src/duckdb/src/common/types/vector.cpp

@@ -23,17 +23,17 @@
 namespace duckdb {
 
 Vector::Vector(LogicalType type_p, bool create_data, bool zero_data, idx_t capacity)
-    : vector_type(VectorType::FLAT_VECTOR), type(move(type_p)), data(nullptr) {
+    : vector_type(VectorType::FLAT_VECTOR), type(std::move(type_p)), data(nullptr) {
 	if (create_data) {
 		Initialize(zero_data, capacity);
 	}
 }
 
-Vector::Vector(LogicalType type_p, idx_t capacity) : Vector(move(type_p), true, false, capacity) {
+Vector::Vector(LogicalType type_p, idx_t capacity) : Vector(std::move(type_p), true, false, capacity) {
 }
 
 Vector::Vector(LogicalType type_p, data_ptr_t dataptr)
-    : vector_type(VectorType::FLAT_VECTOR), type(move(type_p)), data(dataptr) {
+    : vector_type(VectorType::FLAT_VECTOR), type(std::move(type_p)), data(dataptr) {
 	if (dataptr && !type.IsValid()) {
 		throw InternalException("Cannot create a vector of type INVALID!");
 	}
@@ -60,8 +60,8 @@ Vector::Vector(const Value &value) : type(value.type()) {
 }
 
 Vector::Vector(Vector &&other) noexcept
-    : vector_type(other.vector_type), type(move(other.type)), data(other.data), validity(move(other.validity)),
-      buffer(move(other.buffer)), auxiliary(move(other.auxiliary)) {
+    : vector_type(other.vector_type), type(std::move(other.type)), data(other.data),
+      validity(std::move(other.validity)), buffer(std::move(other.buffer)), auxiliary(std::move(other.auxiliary)) {
 }
 
 void Vector::Reference(const Value &value) {
@@ -76,15 +76,15 @@ void Vector::Reference(const Value &value) {
 		auto &value_children = StructValue::GetChildren(value);
 		for (idx_t i = 0; i < child_types.size(); i++) {
 			auto vector = make_unique<Vector>(value.IsNull() ? Value(child_types[i].second) : value_children[i]);
-			child_vectors.push_back(move(vector));
+			child_vectors.push_back(std::move(vector));
 		}
-		auxiliary = move(struct_buffer);
+		auxiliary = std::move(struct_buffer);
 		if (value.IsNull()) {
 			SetValue(0, value);
 		}
 	} else if (internal_type == PhysicalType::LIST) {
 		auto list_buffer = make_unique<VectorListBuffer>(value.type());
-		auxiliary = move(list_buffer);
+		auxiliary = std::move(list_buffer);
 		data = buffer->GetData();
 		SetValue(0, value);
 	} else {
@@ -161,13 +161,13 @@ void Vector::Slice(const SelectionVector &sel, idx_t count) {
 		// already a dictionary, slice the current dictionary
 		auto &current_sel = DictionaryVector::SelVector(*this);
 		auto sliced_dictionary = current_sel.Slice(sel, count);
-		buffer = make_buffer<DictionaryBuffer>(move(sliced_dictionary));
+		buffer = make_buffer<DictionaryBuffer>(std::move(sliced_dictionary));
 		if (GetType().InternalType() == PhysicalType::STRUCT) {
 			auto &child_vector = DictionaryVector::Child(*this);
 
 			Vector new_child(child_vector);
 			new_child.auxiliary = make_buffer<VectorStructBuffer>(new_child, sel, count);
-			auxiliary = make_buffer<VectorChildBuffer>(move(new_child));
+			auxiliary = make_buffer<VectorChildBuffer>(std::move(new_child));
 		}
 		return;
 	}
@@ -182,11 +182,11 @@ void Vector::Slice(const SelectionVector &sel, idx_t count) {
 	if (internal_type == PhysicalType::STRUCT) {
 		child_vector.auxiliary = make_buffer<VectorStructBuffer>(*this, sel, count);
 	}
-	auto child_ref = make_buffer<VectorChildBuffer>(move(child_vector));
+	auto child_ref = make_buffer<VectorChildBuffer>(std::move(child_vector));
 	auto dict_buffer = make_buffer<DictionaryBuffer>(sel);
 	vector_type = VectorType::DICTIONARY_VECTOR;
-	buffer = move(dict_buffer);
-	auxiliary = move(child_ref);
+	buffer = std::move(dict_buffer);
+	auxiliary = std::move(child_ref);
 }
 
 void Vector::Slice(const SelectionVector &sel, idx_t count, SelCache &cache) {
@@ -216,10 +216,10 @@ void Vector::Initialize(bool zero_data, idx_t capacity) {
 	auto internal_type = type.InternalType();
 	if (internal_type == PhysicalType::STRUCT) {
 		auto struct_buffer = make_unique<VectorStructBuffer>(type, capacity);
-		auxiliary = move(struct_buffer);
+		auxiliary = std::move(struct_buffer);
 	} else if (internal_type == PhysicalType::LIST) {
 		auto list_buffer = make_unique<VectorListBuffer>(type, capacity);
-		auxiliary = move(list_buffer);
+		auxiliary = std::move(list_buffer);
 	}
 	auto type_size = GetTypeIdSize(internal_type);
 	if (type_size > 0) {
@@ -297,7 +297,7 @@ void Vector::Resize(idx_t cur_size, idx_t new_size) {
 		if (!data_to_resize.is_nested) {
 			auto new_data = unique_ptr<data_t[]>(new data_t[new_size * data_to_resize.type_size]);
 			memcpy(new_data.get(), data_to_resize.data, cur_size * data_to_resize.type_size * sizeof(data_t));
-			data_to_resize.buffer->SetData(move(new_data));
+			data_to_resize.buffer->SetData(std::move(new_data));
 			data_to_resize.vec.data = data_to_resize.buffer->GetData();
 		}
 		data_to_resize.vec.validity.Resize(cur_size, new_size);
@@ -536,15 +536,15 @@ Value Vector::GetValueInternal(const Vector &v_p, idx_t index_p) {
 		auto str = ((string_t *)data)[index];
 		return Value(str.GetString());
 	}
-	case LogicalTypeId::JSON: {
-		auto str = ((string_t *)data)[index];
-		return Value::JSON(str.GetString());
-	}
 	case LogicalTypeId::AGGREGATE_STATE:
 	case LogicalTypeId::BLOB: {
 		auto str = ((string_t *)data)[index];
 		return Value::BLOB((const_data_ptr_t)str.GetDataUnsafe(), str.GetSize());
 	}
+	case LogicalTypeId::BIT: {
+		auto str = ((string_t *)data)[index];
+		return Value::BIT((const_data_ptr_t)str.GetDataUnsafe(), str.GetSize());
+	}
 	case LogicalTypeId::MAP: {
 		auto offlen = ((list_entry_t *)data)[index];
 		auto &child_vec = ListVector::GetEntry(*vector);
@@ -552,13 +552,13 @@ Value Vector::GetValueInternal(const Vector &v_p, idx_t index_p) {
 		for (idx_t i = offlen.offset; i < offlen.offset + offlen.length; i++) {
 			children.push_back(child_vec.GetValue(i));
 		}
-		return Value::MAP(ListType::GetChildType(type), move(children));
+		return Value::MAP(ListType::GetChildType(type), std::move(children));
 	}
 	case LogicalTypeId::UNION: {
 		auto tag = UnionVector::GetTag(*vector, index);
 		auto value = UnionVector::GetMember(*vector, tag).GetValue(index);
 		auto members = UnionType::CopyMemberTypes(type);
-		return Value::UNION(members, tag, move(value));
+		return Value::UNION(members, tag, std::move(value));
 	}
 	case LogicalTypeId::STRUCT: {
 		// we can derive the value schema from the vector schema
@@ -568,7 +568,7 @@ Value Vector::GetValueInternal(const Vector &v_p, idx_t index_p) {
 			auto &struct_child = child_entries[child_idx];
 			children.push_back(make_pair(StructType::GetChildName(type, child_idx), struct_child->GetValue(index_p)));
 		}
-		return Value::STRUCT(move(children));
+		return Value::STRUCT(std::move(children));
 	}
 	case LogicalTypeId::LIST: {
 		auto offlen = ((list_entry_t *)data)[index];
@@ -577,7 +577,7 @@ Value Vector::GetValueInternal(const Vector &v_p, idx_t index_p) {
 		for (idx_t i = offlen.offset; i < offlen.offset + offlen.length; i++) {
 			children.push_back(child_vec.GetValue(i));
 		}
-		return Value::LIST(ListType::GetChildType(type), move(children));
+		return Value::LIST(ListType::GetChildType(type), std::move(children));
 	}
 	default:
 		throw InternalException("Unimplemented type for value access");
@@ -588,9 +588,10 @@ Value Vector::GetValue(const Vector &v_p, idx_t index_p) {
 	auto value = GetValueInternal(v_p, index_p);
 	// set the alias of the type to the correct value, if there is a type alias
 	if (v_p.GetType().HasAlias()) {
-		value.type().CopyAuxInfo(v_p.GetType());
+		value.GetTypeMutable().CopyAuxInfo(v_p.GetType());
 	}
 	if (v_p.GetType().id() != LogicalTypeId::AGGREGATE_STATE && value.type().id() != LogicalTypeId::AGGREGATE_STATE) {
+
 		D_ASSERT(v_p.GetType() == value.type());
 	}
 	return value;
@@ -656,7 +657,7 @@ string Vector::ToString(idx_t count) const {
 	return retval;
 }
 
-void Vector::Print(idx_t count) {
+void Vector::Print(idx_t count) const {
 	Printer::Print(ToString(count));
 }
 
@@ -680,7 +681,7 @@ string Vector::ToString() const {
 	return retval;
 }
 
-void Vector::Print() {
+void Vector::Print() const {
 	Printer::Print(ToString());
 }
 // LCOV_EXCL_STOP
@@ -723,7 +724,7 @@ void Vector::Flatten(idx_t count) {
 	case VectorType::CONSTANT_VECTOR: {
 		bool is_null = ConstantVector::IsNull(*this);
 		// allocate a new buffer for the vector
-		auto old_buffer = move(buffer);
+		auto old_buffer = std::move(buffer);
 		auto old_data = data;
 		buffer = VectorBuffer::CreateStandardVector(type, MaxValue<idx_t>(STANDARD_VECTOR_SIZE, count));
 		data = buffer->GetData();
@@ -792,9 +793,9 @@ void Vector::Flatten(idx_t count) {
 				D_ASSERT(child->GetVectorType() == VectorType::CONSTANT_VECTOR);
 				auto vector = make_unique<Vector>(*child);
 				vector->Flatten(count);
-				new_children.push_back(move(vector));
+				new_children.push_back(std::move(vector));
 			}
-			auxiliary = move(normalified_buffer);
+			auxiliary = std::move(normalified_buffer);
 		} break;
 		default:
 			throw InternalException("Unimplemented type for VectorOperations::Flatten");
@@ -856,12 +857,12 @@ void Vector::ToUnifiedFormat(idx_t count, UnifiedVectorFormat &data) {
 			// dictionary with non-flat child: create a new reference to the child and normalify it
 			Vector child_vector(child);
 			child_vector.Flatten(sel, count);
-			auto new_aux = make_buffer<VectorChildBuffer>(move(child_vector));
+			auto new_aux = make_buffer<VectorChildBuffer>(std::move(child_vector));
 
 			data.sel = &sel;
 			data.data = FlatVector::GetData(new_aux->data);
 			data.validity = FlatVector::Validity(new_aux->data);
-			this->auxiliary = move(new_aux);
+			this->auxiliary = std::move(new_aux);
 		}
 		break;
 	}
@@ -1114,7 +1115,7 @@ void Vector::Verify(Vector &vector_p, const SelectionVector &sel_p, idx_t count)
 	    (vtype == VectorType::CONSTANT_VECTOR || vtype == VectorType::FLAT_VECTOR)) {
 		D_ASSERT(!vector->auxiliary);
 	}
-	if (type.id() == LogicalTypeId::VARCHAR || type.id() == LogicalTypeId::JSON) {
+	if (type.id() == LogicalTypeId::VARCHAR) {
 		// verify that the string is correct unicode
 		switch (vtype) {
 		case VectorType::FLAT_VECTOR: {
@@ -1133,6 +1134,25 @@ void Vector::Verify(Vector &vector_p, const SelectionVector &sel_p, idx_t count)
 		}
 	}
 
+	if (type.id() == LogicalTypeId::BIT) {
+		switch (vtype) {
+		case VectorType::FLAT_VECTOR: {
+			auto &validity = FlatVector::Validity(*vector);
+			auto strings = FlatVector::GetData<string_t>(*vector);
+			for (idx_t i = 0; i < count; i++) {
+				auto oidx = sel->get_index(i);
+				if (validity.RowIsValid(oidx)) {
+					auto buf = strings[oidx].GetDataUnsafe();
+					D_ASSERT(*buf >= 0 && *buf < 8);
+				}
+			}
+			break;
+		}
+		default:
+			break;
+		}
+	}
+
 	if (type.InternalType() == PhysicalType::STRUCT) {
 		auto &child_types = StructType::GetChildTypes(type);
 		D_ASSERT(!child_types.empty());
@@ -1326,6 +1346,7 @@ void ConstantVector::Reference(Vector &vector, Vector &source, idx_t position, i
 			ConstantVector::Reference(*target_entries[i], *source_entries[i], position, count);
 		}
 		vector.SetVectorType(VectorType::CONSTANT_VECTOR);
+		vector.validity.Set(0, true);
 		break;
 	}
 	default:
@@ -1355,7 +1376,7 @@ string_t StringVector::AddString(Vector &vector, const string &data) {
 }
 
 string_t StringVector::AddString(Vector &vector, string_t data) {
-	D_ASSERT(vector.GetType().id() == LogicalTypeId::VARCHAR || vector.GetType().id() == LogicalTypeId::JSON);
+	D_ASSERT(vector.GetType().id() == LogicalTypeId::VARCHAR);
 	if (data.IsInlined()) {
 		// string will be inlined: no need to store in string heap
 		return data;
@@ -1401,7 +1422,7 @@ void StringVector::AddHandle(Vector &vector, BufferHandle handle) {
 		vector.auxiliary = make_buffer<VectorStringBuffer>();
 	}
 	auto &string_buffer = (VectorStringBuffer &)*vector.auxiliary;
-	string_buffer.AddHeapReference(make_buffer<ManagedVectorBuffer>(move(handle)));
+	string_buffer.AddHeapReference(make_buffer<ManagedVectorBuffer>(std::move(handle)));
 }
 
 void StringVector::AddBuffer(Vector &vector, buffer_ptr<VectorBuffer> buffer) {
@@ -1411,7 +1432,7 @@ void StringVector::AddBuffer(Vector &vector, buffer_ptr<VectorBuffer> buffer) {
 		vector.auxiliary = make_buffer<VectorStringBuffer>();
 	}
 	auto &string_buffer = (VectorStringBuffer &)*vector.auxiliary;
-	string_buffer.AddHeapReference(move(buffer));
+	string_buffer.AddHeapReference(std::move(buffer));
 }
 
 void StringVector::AddHeapReference(Vector &vector, Vector &other) {
@@ -1690,7 +1711,7 @@ Value FlatVector::GetValuesFromOffsets(Vector &values, vector<idx_t> &offsets) {
 	for (auto &offset : offsets) {
 		list_values.push_back(values.GetValue(offset));
 	}
-	return Value::LIST(values.GetType(), move(list_values));
+	return Value::LIST(values.GetType(), std::move(list_values));
 }
 
 idx_t ListVector::GetListSize(const Vector &vec) {
@@ -1752,6 +1773,97 @@ void ListVector::PushBack(Vector &target, const Value &insert) {
 	target_buffer.PushBack(insert);
 }
 
+idx_t ListVector::GetConsecutiveChildList(Vector &list, Vector &result, idx_t offset, idx_t count) {
+
+	auto info = ListVector::GetConsecutiveChildListInfo(list, offset, count);
+	if (info.needs_slicing) {
+		SelectionVector sel(info.child_list_info.length);
+		ListVector::GetConsecutiveChildSelVector(list, sel, offset, count);
+
+		result.Slice(sel, info.child_list_info.length);
+		result.Flatten(info.child_list_info.length);
+	}
+	return info.child_list_info.length;
+}
+
+ConsecutiveChildListInfo ListVector::GetConsecutiveChildListInfo(Vector &list, idx_t offset, idx_t count) {
+
+	ConsecutiveChildListInfo info;
+	UnifiedVectorFormat unified_list_data;
+	list.ToUnifiedFormat(offset + count, unified_list_data);
+	auto list_data = (list_entry_t *)unified_list_data.data;
+
+	// find the first non-NULL entry
+	idx_t first_length = 0;
+	for (idx_t i = offset; i < offset + count; i++) {
+		auto idx = unified_list_data.sel->get_index(i);
+		if (!unified_list_data.validity.RowIsValid(idx)) {
+			continue;
+		}
+		info.child_list_info.offset = list_data[idx].offset;
+		first_length = list_data[idx].length;
+		break;
+	}
+
+	// small performance improvement for constant vectors
+	// avoids iterating over all their (constant) elements
+	if (list.GetVectorType() == VectorType::CONSTANT_VECTOR) {
+		info.child_list_info.length = first_length;
+		return info;
+	}
+
+	// now get the child count and determine whether the children are stored consecutively
+	// also determine if a flat vector has pseudo constant values (all offsets + length the same)
+	// this can happen e.g. for UNNESTs
+	bool is_consecutive = true;
+	for (idx_t i = offset; i < offset + count; i++) {
+		auto idx = unified_list_data.sel->get_index(i);
+		if (!unified_list_data.validity.RowIsValid(idx)) {
+			continue;
+		}
+		if (list_data[idx].offset != info.child_list_info.offset || list_data[idx].length != first_length) {
+			info.is_constant = false;
+		}
+		if (list_data[idx].offset != info.child_list_info.offset + info.child_list_info.length) {
+			is_consecutive = false;
+		}
+		info.child_list_info.length += list_data[idx].length;
+	}
+
+	if (info.is_constant) {
+		info.child_list_info.length = first_length;
+	}
+	if (!info.is_constant && !is_consecutive) {
+		info.needs_slicing = true;
+	}
+
+	return info;
+}
+
+void ListVector::GetConsecutiveChildSelVector(Vector &list, SelectionVector &sel, idx_t offset, idx_t count) {
+
+	UnifiedVectorFormat unified_list_data;
+	list.ToUnifiedFormat(offset + count, unified_list_data);
+	auto list_data = (list_entry_t *)unified_list_data.data;
+
+	//	SelectionVector child_sel(info.second.length);
+	idx_t entry = 0;
+	for (idx_t i = offset; i < offset + count; i++) {
+		auto idx = unified_list_data.sel->get_index(i);
+		if (!unified_list_data.validity.RowIsValid(idx)) {
+			continue;
+		}
+		for (idx_t k = 0; k < list_data[idx].length; k++) {
+			//			child_sel.set_index(entry++, list_data[idx].offset + k);
+			sel.set_index(entry++, list_data[idx].offset + k);
+		}
+	}
+	//
+	//	result.Slice(child_sel, info.second.length);
+	//	result.Flatten(info.second.length);
+	//	info.second.offset = 0;
+}
+
 // Union vector
 const Vector &UnionVector::GetMember(const Vector &vector, idx_t member_index) {
 	D_ASSERT(member_index < UnionType::GetMemberCount(vector.GetType()));

package/src/duckdb/src/common/types/vector_buffer.cpp

@@ -41,7 +41,7 @@ VectorStructBuffer::VectorStructBuffer(const LogicalType &type, idx_t capacity)
 	auto &child_types = StructType::GetChildTypes(type);
 	for (auto &child_type : child_types) {
 		auto vector = make_unique<Vector>(child_type.second, capacity);
-		children.push_back(move(vector));
+		children.push_back(std::move(vector));
 	}
 }
 
@@ -50,7 +50,7 @@ VectorStructBuffer::VectorStructBuffer(Vector &other, const SelectionVector &sel
 	auto &other_vector = StructVector::GetEntries(other);
 	for (auto &child_vector : other_vector) {
 		auto vector = make_unique<Vector>(*child_vector, sel, count);
-		children.push_back(move(vector));
+		children.push_back(std::move(vector));
 	}
 }
 
@@ -58,7 +58,7 @@ VectorStructBuffer::~VectorStructBuffer() {
 }
 
 VectorListBuffer::VectorListBuffer(unique_ptr<Vector> vector, idx_t initial_capacity)
-    : VectorBuffer(VectorBufferType::LIST_BUFFER), capacity(initial_capacity), child(move(vector)) {
+    : VectorBuffer(VectorBufferType::LIST_BUFFER), capacity(initial_capacity), child(std::move(vector)) {
 }
 
 VectorListBuffer::VectorListBuffer(const LogicalType &list_type, idx_t initial_capacity)
@@ -100,7 +100,7 @@ VectorListBuffer::~VectorListBuffer() {
 }
 
 ManagedVectorBuffer::ManagedVectorBuffer(BufferHandle handle)
-    : VectorBuffer(VectorBufferType::MANAGED_BUFFER), handle(move(handle)) {
+    : VectorBuffer(VectorBufferType::MANAGED_BUFFER), handle(std::move(handle)) {
 }
 
 ManagedVectorBuffer::~ManagedVectorBuffer() {

package/src/duckdb/src/common/types/vector_cache.cpp

@@ -18,7 +18,7 @@ public:
 			auto &child_type = ListType::GetChildType(type);
 			child_caches.push_back(make_buffer<VectorCacheBuffer>(allocator, child_type));
 			auto child_vector = make_unique<Vector>(child_type, false, false);
-			auxiliary = make_unique<VectorListBuffer>(move(child_vector));
+			auxiliary = make_unique<VectorListBuffer>(std::move(child_vector));
 			break;
 		}
 		case PhysicalType::STRUCT: {
@@ -27,7 +27,7 @@ public:
 				child_caches.push_back(make_buffer<VectorCacheBuffer>(allocator, child_type.second));
 			}
 			auto struct_buffer = make_unique<VectorStructBuffer>(type);
-			auxiliary = move(struct_buffer);
+			auxiliary = std::move(struct_buffer);
 			break;
 		}
 		default: