duckdb 0.3.5-dev1285.0 → 0.3.5-dev1297.0

package/src/duckdb.cpp

@@ -31721,32 +31721,16 @@ static void ComputeStructEntrySizes(Vector &v, idx_t entry_sizes[], idx_t vcount
                                     const SelectionVector &sel, idx_t offset) {
 	// obtain child vectors
 	idx_t num_children;
-	vector<Vector> struct_vectors;
-	if (v.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		auto &child = DictionaryVector::Child(v);
-		auto &dict_sel = DictionaryVector::SelVector(v);
-		auto &children = StructVector::GetEntries(child);
-		num_children = children.size();
-		for (auto &struct_child : children) {
-			Vector struct_vector(*struct_child, dict_sel, vcount);
-			struct_vectors.push_back(move(struct_vector));
-		}
-	} else {
-		auto &children = StructVector::GetEntries(v);
-		num_children = children.size();
-		for (auto &struct_child : children) {
-			Vector struct_vector(*struct_child);
-			struct_vectors.push_back(move(struct_vector));
-		}
-	}
+	auto &children = StructVector::GetEntries(v);
+	num_children = children.size();
 	// add struct validitymask size
 	const idx_t struct_validitymask_size = (num_children + 7) / 8;
 	for (idx_t i = 0; i < ser_count; i++) {
 		entry_sizes[i] += struct_validitymask_size;
 	}
 	// compute size of child vectors
-	for (auto &struct_vector : struct_vectors) {
-		RowOperations::ComputeEntrySizes(struct_vector, entry_sizes, vcount, ser_count, sel, offset);
+	for (auto &struct_vector : children) {
+		RowOperations::ComputeEntrySizes(*struct_vector, entry_sizes, vcount, ser_count, sel, offset);
 	}
 }
 
@@ -31911,25 +31895,8 @@ static void HeapScatterStructVector(Vector &v, idx_t vcount, const SelectionVect
 	VectorData vdata;
 	v.Orrify(vcount, vdata);
 
-	idx_t num_children;
-	vector<Vector> struct_vectors;
-	if (v.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		auto &child = DictionaryVector::Child(v);
-		auto &dict_sel = DictionaryVector::SelVector(v);
-		auto &children = StructVector::GetEntries(child);
-		num_children = children.size();
-		for (auto &struct_child : children) {
-			Vector struct_vector(*struct_child, dict_sel, vcount);
-			struct_vectors.push_back(move(struct_vector));
-		}
-	} else {
-		auto &children = StructVector::GetEntries(v);
-		num_children = children.size();
-		for (auto &struct_child : children) {
-			Vector struct_vector(*struct_child);
-			struct_vectors.push_back(move(struct_vector));
-		}
-	}
+	auto &children = StructVector::GetEntries(v);
+	idx_t num_children = children.size();
 
 	// the whole struct itself can be NULL
 	idx_t entry_idx;
@@ -31955,8 +31922,8 @@ static void HeapScatterStructVector(Vector &v, idx_t vcount, const SelectionVect
 	}
 
 	// now serialize the struct vectors
-	for (idx_t i = 0; i < struct_vectors.size(); i++) {
-		auto &struct_vector = struct_vectors[i];
+	for (idx_t i = 0; i < children.size(); i++) {
+		auto &struct_vector = *children[i];
 		RowOperations::HeapScatter(struct_vector, vcount, sel, ser_count, i, key_locations,
 		                           struct_validitymask_locations, offset);
 	}
@@ -42828,6 +42795,15 @@ void RowLayout::Initialize(Aggregates aggregates_p, bool align) {
 
 namespace duckdb {
 
+SelectionData::SelectionData(idx_t count) {
+	owned_data = unique_ptr<sel_t[]>(new sel_t[count]);
+#ifdef DEBUG
+	for (idx_t i = 0; i < count; i++) {
+		owned_data[i] = std::numeric_limits<sel_t>::max();
+	}
+#endif
+}
+
 // LCOV_EXCL_START
 string SelectionVector::ToString(idx_t count) const {
 	string result = "Selection Vector (" + to_string(count) + ") [";
@@ -45717,9 +45693,20 @@ void Vector::Slice(const SelectionVector &sel, idx_t count) {
 		auto &current_sel = DictionaryVector::SelVector(*this);
 		auto sliced_dictionary = current_sel.Slice(sel, count);
 		buffer = make_buffer<DictionaryBuffer>(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));
+		}
 		return;
 	}
 	Vector child_vector(*this);
+	auto internal_type = GetType().InternalType();
+	if (internal_type == PhysicalType::STRUCT) {
+		child_vector.auxiliary = make_buffer<VectorStructBuffer>(*this, sel, count);
+	}
 	auto child_ref = make_buffer<VectorChildBuffer>(move(child_vector));
 	auto dict_buffer = make_buffer<DictionaryBuffer>(sel);
 	vector_type = VectorType::DICTIONARY_VECTOR;
@@ -45728,7 +45715,7 @@ void Vector::Slice(const SelectionVector &sel, idx_t count) {
 }
 
 void Vector::Slice(const SelectionVector &sel, idx_t count, SelCache &cache) {
-	if (GetVectorType() == VectorType::DICTIONARY_VECTOR) {
+	if (GetVectorType() == VectorType::DICTIONARY_VECTOR && GetType().InternalType() != PhysicalType::STRUCT) {
 		// dictionary vector: need to merge dictionaries
 		// check if we have a cached entry
 		auto &current_sel = DictionaryVector::SelVector(*this);
@@ -45938,32 +45925,44 @@ void Vector::SetValue(idx_t index, const Value &val) {
 	}
 }
 
-Value Vector::GetValue(idx_t index) const {
-	switch (GetVectorType()) {
-	case VectorType::CONSTANT_VECTOR:
-		index = 0;
-		break;
-	case VectorType::FLAT_VECTOR:
-		break;
-		// dictionary: apply dictionary and forward to child
-	case VectorType::DICTIONARY_VECTOR: {
-		auto &sel_vector = DictionaryVector::SelVector(*this);
-		auto &child = DictionaryVector::Child(*this);
-		return child.GetValue(sel_vector.get_index(index));
-	}
-	case VectorType::SEQUENCE_VECTOR: {
-		int64_t start, increment;
-		SequenceVector::GetSequence(*this, start, increment);
-		return Value::Numeric(GetType(), start + increment * index);
-	}
-	default:
-		throw InternalException("Unimplemented vector type for Vector::GetValue");
+Value Vector::GetValue(const Vector &v_p, idx_t index_p) {
+	const Vector *vector = &v_p;
+	idx_t index = index_p;
+	bool finished = false;
+	while (!finished) {
+		switch (vector->GetVectorType()) {
+		case VectorType::CONSTANT_VECTOR:
+			index = 0;
+			finished = true;
+			break;
+		case VectorType::FLAT_VECTOR:
+			finished = true;
+			break;
+			// dictionary: apply dictionary and forward to child
+		case VectorType::DICTIONARY_VECTOR: {
+			auto &sel_vector = DictionaryVector::SelVector(*vector);
+			auto &child = DictionaryVector::Child(*vector);
+			vector = &child;
+			index = sel_vector.get_index(index);
+			break;
+		}
+		case VectorType::SEQUENCE_VECTOR: {
+			int64_t start, increment;
+			SequenceVector::GetSequence(*vector, start, increment);
+			return Value::Numeric(vector->GetType(), start + increment * index);
+		}
+		default:
+			throw InternalException("Unimplemented vector type for Vector::GetValue");
+		}
 	}
+	auto data = vector->data;
+	auto &validity = vector->validity;
+	auto &type = vector->GetType();
 
 	if (!validity.RowIsValid(index)) {
-		return Value(GetType());
+		return Value(vector->GetType());
 	}
-	switch (GetType().id()) {
+	switch (vector->GetType().id()) {
 	case LogicalTypeId::BOOLEAN:
 		return Value::BOOLEAN(((bool *)data)[index]);
 	case LogicalTypeId::TINYINT:
@@ -46003,9 +46002,9 @@ Value Vector::GetValue(idx_t index) const {
 	case LogicalTypeId::UUID:
 		return Value::UUID(((hugeint_t *)data)[index]);
 	case LogicalTypeId::DECIMAL: {
-		auto width = DecimalType::GetWidth(GetType());
-		auto scale = DecimalType::GetScale(GetType());
-		switch (GetType().InternalType()) {
+		auto width = DecimalType::GetWidth(type);
+		auto scale = DecimalType::GetScale(type);
+		switch (type.InternalType()) {
 		case PhysicalType::INT16:
 			return Value::DECIMAL(((int16_t *)data)[index], width, scale);
 		case PhysicalType::INT32:
@@ -46021,13 +46020,13 @@ Value Vector::GetValue(idx_t index) const {
 	case LogicalTypeId::ENUM: {
 		switch (type.InternalType()) {
 		case PhysicalType::UINT8:
-			return Value::ENUM(((uint8_t *)data)[index], GetType());
+			return Value::ENUM(((uint8_t *)data)[index], type);
 		case PhysicalType::UINT16:
-			return Value::ENUM(((uint16_t *)data)[index], GetType());
+			return Value::ENUM(((uint16_t *)data)[index], type);
 		case PhysicalType::UINT32:
-			return Value::ENUM(((uint32_t *)data)[index], GetType());
+			return Value::ENUM(((uint32_t *)data)[index], type);
 		case PhysicalType::UINT64: //  DEDUP_POINTER_ENUM
-			return Value::ENUM(((uint64_t *)data)[index], GetType());
+			return Value::ENUM(((uint64_t *)data)[index], type);
 		default:
 			throw InternalException("ENUM can only have unsigned integers as physical types");
 		}
@@ -46056,36 +46055,39 @@ Value Vector::GetValue(idx_t index) const {
 		return Value::BLOB((const_data_ptr_t)str.GetDataUnsafe(), str.GetSize());
 	}
 	case LogicalTypeId::MAP: {
-		auto &child_entries = StructVector::GetEntries(*this);
+		auto &child_entries = StructVector::GetEntries(*vector);
 		Value key = child_entries[0]->GetValue(index);
 		Value value = child_entries[1]->GetValue(index);
 		return Value::MAP(move(key), move(value));
 	}
 	case LogicalTypeId::STRUCT: {
 		// we can derive the value schema from the vector schema
-		auto &child_entries = StructVector::GetEntries(*this);
+		auto &child_entries = StructVector::GetEntries(*vector);
 		child_list_t<Value> children;
 		for (idx_t child_idx = 0; child_idx < child_entries.size(); child_idx++) {
 			auto &struct_child = child_entries[child_idx];
-			children.push_back(
-			    make_pair(StructType::GetChildName(GetType(), child_idx), struct_child->GetValue(index)));
+			children.push_back(make_pair(StructType::GetChildName(type, child_idx), struct_child->GetValue(index_p)));
 		}
 		return Value::STRUCT(move(children));
 	}
 	case LogicalTypeId::LIST: {
 		auto offlen = ((list_entry_t *)data)[index];
-		auto &child_vec = ListVector::GetEntry(*this);
-		vector<Value> children;
+		auto &child_vec = ListVector::GetEntry(*vector);
+		std::vector<Value> children;
 		for (idx_t i = offlen.offset; i < offlen.offset + offlen.length; i++) {
 			children.push_back(child_vec.GetValue(i));
 		}
-		return Value::LIST(ListType::GetChildType(GetType()), move(children));
+		return Value::LIST(ListType::GetChildType(type), move(children));
 	}
 	default:
 		throw InternalException("Unimplemented type for value access");
 	}
 }
 
+Value Vector::GetValue(idx_t index) const {
+	return GetValue(*this, index);
+}
+
 // LCOV_EXCL_START
 string VectorTypeToString(VectorType type) {
 	switch (type) {
@@ -46526,32 +46528,39 @@ void Vector::UTFVerify(idx_t count) {
 	UTFVerify(*flat_sel, count);
 }
 
-void Vector::Verify(const SelectionVector &sel, idx_t count) {
+void Vector::Verify(Vector &vector_p, const SelectionVector &sel_p, idx_t count) {
 #ifdef DEBUG
 	if (count == 0) {
 		return;
 	}
-	if (GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		auto &child = DictionaryVector::Child(*this);
+	Vector *vector = &vector_p;
+	const SelectionVector *sel = &sel_p;
+	SelectionVector owned_sel;
+	auto &type = vector->GetType();
+	auto vtype = vector->GetVectorType();
+	if (vector->GetVectorType() == VectorType::DICTIONARY_VECTOR) {
+		auto &child = DictionaryVector::Child(*vector);
 		D_ASSERT(child.GetVectorType() != VectorType::DICTIONARY_VECTOR);
-		auto &dict_sel = DictionaryVector::SelVector(*this);
+		auto &dict_sel = DictionaryVector::SelVector(*vector);
 		// merge the selection vectors and verify the child
-		auto new_buffer = dict_sel.Slice(sel, count);
-		SelectionVector new_sel(new_buffer);
-		child.Verify(new_sel, count);
-		return;
+		auto new_buffer = dict_sel.Slice(*sel, count);
+		owned_sel.Initialize(new_buffer);
+		sel = &owned_sel;
+		vector = &child;
+		vtype = vector->GetVectorType();
 	}
-	if (TypeIsConstantSize(GetType().InternalType()) &&
-	    (GetVectorType() == VectorType::CONSTANT_VECTOR || GetVectorType() == VectorType::FLAT_VECTOR)) {
-		D_ASSERT(!auxiliary);
+	if (TypeIsConstantSize(type.InternalType()) &&
+	    (vtype == VectorType::CONSTANT_VECTOR || vtype == VectorType::FLAT_VECTOR)) {
+		D_ASSERT(!vector->auxiliary);
 	}
-	if (GetType().id() == LogicalTypeId::VARCHAR || GetType().id() == LogicalTypeId::JSON) {
+	if (type.id() == LogicalTypeId::VARCHAR || type.id() == LogicalTypeId::JSON) {
 		// verify that there are no '\0' bytes in string values
-		switch (GetVectorType()) {
+		switch (vtype) {
 		case VectorType::FLAT_VECTOR: {
-			auto strings = FlatVector::GetData<string_t>(*this);
+			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);
+				auto oidx = sel->get_index(i);
 				if (validity.RowIsValid(oidx)) {
 					strings[oidx].VerifyNull();
 				}
@@ -46563,57 +46572,76 @@ void Vector::Verify(const SelectionVector &sel, idx_t count) {
 		}
 	}
 
-	if (GetType().InternalType() == PhysicalType::STRUCT) {
-		auto &child_types = StructType::GetChildTypes(GetType());
+	if (type.InternalType() == PhysicalType::STRUCT) {
+		auto &child_types = StructType::GetChildTypes(type);
 		D_ASSERT(!child_types.empty());
-		if (GetVectorType() == VectorType::FLAT_VECTOR || GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			// create a selection vector of the non-null entries of the struct vector
-			auto &children = StructVector::GetEntries(*this);
-			D_ASSERT(child_types.size() == children.size());
-			for (idx_t child_idx = 0; child_idx < children.size(); child_idx++) {
-				if (GetVectorType() == VectorType::CONSTANT_VECTOR) {
-					D_ASSERT(children[child_idx]->GetVectorType() == VectorType::CONSTANT_VECTOR);
-					if (ConstantVector::IsNull(*this)) {
-						D_ASSERT(ConstantVector::IsNull(*children[child_idx]));
-					}
-				} else if (GetVectorType() == VectorType::FLAT_VECTOR &&
-				           children[child_idx]->GetVectorType() == VectorType::FLAT_VECTOR) {
-					// for any NULL entry in the struct, the child should be NULL as well
-					auto &validity = FlatVector::Validity(*this);
-					auto &child_validity = FlatVector::Validity(*children[child_idx]);
-					for (idx_t i = 0; i < count; i++) {
-						auto index = sel.get_index(i);
-						if (!validity.RowIsValid(index)) {
-							D_ASSERT(!child_validity.RowIsValid(index));
-						}
-					}
+		// create a selection vector of the non-null entries of the struct vector
+		auto &children = StructVector::GetEntries(*vector);
+		D_ASSERT(child_types.size() == children.size());
+		for (idx_t child_idx = 0; child_idx < children.size(); child_idx++) {
+			D_ASSERT(children[child_idx]->GetType() == child_types[child_idx].second);
+			children[child_idx]->Verify(count);
+			if (vtype == VectorType::CONSTANT_VECTOR) {
+				D_ASSERT(children[child_idx]->GetVectorType() == VectorType::CONSTANT_VECTOR);
+				if (ConstantVector::IsNull(*vector)) {
+					D_ASSERT(ConstantVector::IsNull(*children[child_idx]));
+				}
+			}
+			if (vtype != VectorType::FLAT_VECTOR) {
+				continue;
+			}
+			ValidityMask *child_validity;
+			SelectionVector owned_child_sel;
+			const SelectionVector *child_sel = &owned_child_sel;
+			if (children[child_idx]->GetVectorType() == VectorType::FLAT_VECTOR) {
+				child_sel = FlatVector::IncrementalSelectionVector();
+				child_validity = &FlatVector::Validity(*children[child_idx]);
+			} else if (children[child_idx]->GetVectorType() == VectorType::DICTIONARY_VECTOR) {
+				auto &child = DictionaryVector::Child(*children[child_idx]);
+				if (child.GetVectorType() != VectorType::FLAT_VECTOR) {
+					continue;
+				}
+				child_validity = &FlatVector::Validity(child);
+				child_sel = &DictionaryVector::SelVector(*children[child_idx]);
+			} else if (children[child_idx]->GetVectorType() == VectorType::CONSTANT_VECTOR) {
+				child_sel = ConstantVector::ZeroSelectionVector(count, owned_child_sel);
+				child_validity = &ConstantVector::Validity(*children[child_idx]);
+			} else {
+				continue;
+			}
+			// for any NULL entry in the struct, the child should be NULL as well
+			auto &validity = FlatVector::Validity(*vector);
+			for (idx_t i = 0; i < count; i++) {
+				auto index = sel->get_index(i);
+				if (!validity.RowIsValid(index)) {
+					auto child_index = child_sel->get_index(sel_p.get_index(i));
+					D_ASSERT(!child_validity->RowIsValid(child_index));
 				}
-				D_ASSERT(children[child_idx]->GetType() == child_types[child_idx].second);
-				children[child_idx]->Verify(sel, count);
 			}
 		}
 	}
 
-	if (GetType().InternalType() == PhysicalType::LIST) {
-		if (GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			if (!ConstantVector::IsNull(*this)) {
-				auto &child = ListVector::GetEntry(*this);
-				SelectionVector child_sel(ListVector::GetListSize(*this));
+	if (type.InternalType() == PhysicalType::LIST) {
+		if (vtype == VectorType::CONSTANT_VECTOR) {
+			if (!ConstantVector::IsNull(*vector)) {
+				auto &child = ListVector::GetEntry(*vector);
+				SelectionVector child_sel(ListVector::GetListSize(*vector));
 				idx_t child_count = 0;
-				auto le = ConstantVector::GetData<list_entry_t>(*this);
-				D_ASSERT(le->offset + le->length <= ListVector::GetListSize(*this));
+				auto le = ConstantVector::GetData<list_entry_t>(*vector);
+				D_ASSERT(le->offset + le->length <= ListVector::GetListSize(*vector));
 				for (idx_t k = 0; k < le->length; k++) {
 					child_sel.set_index(child_count++, le->offset + k);
 				}
-				child.Verify(child_sel, child_count);
+				Vector::Verify(child, child_sel, child_count);
 			}
-		} else if (GetVectorType() == VectorType::FLAT_VECTOR) {
-			auto &child = ListVector::GetEntry(*this);
-			auto child_size = ListVector::GetListSize(*this);
-			auto list_data = FlatVector::GetData<list_entry_t>(*this);
+		} else if (vtype == VectorType::FLAT_VECTOR) {
+			auto &validity = FlatVector::Validity(*vector);
+			auto &child = ListVector::GetEntry(*vector);
+			auto child_size = ListVector::GetListSize(*vector);
+			auto list_data = FlatVector::GetData<list_entry_t>(*vector);
 			idx_t total_size = 0;
 			for (idx_t i = 0; i < count; i++) {
-				auto idx = sel.get_index(i);
+				auto idx = sel->get_index(i);
 				auto &le = list_data[idx];
 				if (validity.RowIsValid(idx)) {
 					D_ASSERT(le.offset + le.length <= child_size);
@@ -46623,7 +46651,7 @@ void Vector::Verify(const SelectionVector &sel, idx_t count) {
 			SelectionVector child_sel(total_size);
 			idx_t child_count = 0;
 			for (idx_t i = 0; i < count; i++) {
-				auto idx = sel.get_index(i);
+				auto idx = sel->get_index(i);
 				auto &le = list_data[idx];
 				if (validity.RowIsValid(idx)) {
 					D_ASSERT(le.offset + le.length <= child_size);
@@ -46632,7 +46660,7 @@ void Vector::Verify(const SelectionVector &sel, idx_t count) {
 					}
 				}
 			}
-			child.Verify(child_sel, child_count);
+			Vector::Verify(child, child_sel, child_count);
 		}
 	}
 #endif
@@ -46640,7 +46668,7 @@ void Vector::Verify(const SelectionVector &sel, idx_t count) {
 
 void Vector::Verify(idx_t count) {
 	auto flat_sel = FlatVector::IncrementalSelectionVector();
-	Verify(*flat_sel, count);
+	Verify(*this, *flat_sel, count);
 }
 
 void FlatVector::SetNull(Vector &vector, idx_t idx, bool is_null) {
@@ -46727,7 +46755,7 @@ void ConstantVector::Reference(Vector &vector, Vector &source, idx_t position, i
 		auto &source_entries = StructVector::GetEntries(source);
 		auto &target_entries = StructVector::GetEntries(vector);
 		for (idx_t i = 0; i < source_entries.size(); i++) {
-			ConstantVector::Reference(*target_entries[i], *source_entries[i], struct_index, count);
+			ConstantVector::Reference(*target_entries[i], *source_entries[i], position, count);
 		}
 		vector.SetVectorType(VectorType::CONSTANT_VECTOR);
 		break;
@@ -47087,6 +47115,15 @@ VectorStructBuffer::VectorStructBuffer(const LogicalType &type, idx_t capacity)
 	}
 }
 
+VectorStructBuffer::VectorStructBuffer(Vector &other, const SelectionVector &sel, idx_t count)
+    : VectorBuffer(VectorBufferType::STRUCT_BUFFER) {
+	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));
+	}
+}
+
 VectorStructBuffer::~VectorStructBuffer() {
 }
 
@@ -49990,22 +50027,6 @@ idx_t PositionComparator::Final<duckdb::DistinctGreaterThan>(Vector &left, Vecto
 
 using StructEntries = vector<unique_ptr<Vector>>;
 
-static StructEntries &StructVectorGetSlicedEntries(Vector &parent, StructEntries &sliced, const idx_t count) {
-	// We have to manually slice STRUCT dictionaries.
-	auto &children = StructVector::GetEntries(parent);
-	if (parent.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		auto &dict_sel = DictionaryVector::SelVector(parent);
-		for (auto &child : children) {
-			auto v = make_unique<Vector>(*child, dict_sel, count);
-			sliced.push_back(move(v));
-		}
-
-		return sliced;
-	}
-
-	return children;
-}
-
 static void ExtractNestedSelection(const SelectionVector &slice_sel, const idx_t count, const SelectionVector &sel,
                                    OptionalSelection &opt) {
 
@@ -50032,8 +50053,8 @@ static idx_t DistinctSelectStruct(Vector &left, Vector &right, idx_t count, cons
 
 	// Avoid allocating in the 99% of the cases where we don't need to.
 	StructEntries lsliced, rsliced;
-	auto &lchildren = StructVectorGetSlicedEntries(left, lsliced, count);
-	auto &rchildren = StructVectorGetSlicedEntries(right, rsliced, count);
+	auto &lchildren = StructVector::GetEntries(left);
+	auto &rchildren = StructVector::GetEntries(right);
 	D_ASSERT(lchildren.size() == rchildren.size());
 
 	// In order to reuse the comparators, we have to track what passed and failed internally.
@@ -50100,7 +50121,6 @@ static idx_t DistinctSelectStruct(Vector &left, Vector &right, idx_t count, cons
 			match_count += true_count;
 		}
 	}
-
 	return match_count;
 }
 
@@ -50127,6 +50147,8 @@ static idx_t DistinctSelectList(Vector &left, Vector &right, idx_t count, const
 	SelectionVector lcursor(count);
 	SelectionVector rcursor(count);
 
+	ListVector::GetEntry(left).Normalify(count);
+	ListVector::GetEntry(right).Normalify(count);
 	Vector lchild(ListVector::GetEntry(left), lcursor, count);
 	Vector rchild(ListVector::GetEntry(right), rcursor, count);
 
@@ -51939,40 +51961,48 @@ static void TemplatedCopy(const Vector &source, const SelectionVector &sel, Vect
 	}
 }
 
-void VectorOperations::Copy(const Vector &source, Vector &target, const SelectionVector &sel_p, idx_t source_count,
+void VectorOperations::Copy(const Vector &source_p, Vector &target, const SelectionVector &sel_p, idx_t source_count,
                             idx_t source_offset, idx_t target_offset) {
 	D_ASSERT(source_offset <= source_count);
-	D_ASSERT(source.GetType() == target.GetType());
+	D_ASSERT(source_p.GetType() == target.GetType());
 	idx_t copy_count = source_count - source_offset;
 
 	SelectionVector owned_sel;
 	const SelectionVector *sel = &sel_p;
-	switch (source.GetVectorType()) {
-	case VectorType::DICTIONARY_VECTOR: {
-		// dictionary vector: merge selection vectors
-		auto &child = DictionaryVector::Child(source);
-		auto &dict_sel = DictionaryVector::SelVector(source);
-		// merge the selection vectors and verify the child
-		auto new_buffer = dict_sel.Slice(*sel, source_count);
-		SelectionVector merged_sel(new_buffer);
-		VectorOperations::Copy(child, target, merged_sel, source_count, source_offset, target_offset);
-		return;
-	}
-	case VectorType::SEQUENCE_VECTOR: {
-		int64_t start, increment;
-		Vector seq(source.GetType());
-		SequenceVector::GetSequence(source, start, increment);
-		VectorOperations::GenerateSequence(seq, source_count, *sel, start, increment);
-		VectorOperations::Copy(seq, target, *sel, source_count, source_offset, target_offset);
-		return;
-	}
-	case VectorType::CONSTANT_VECTOR:
-		sel = ConstantVector::ZeroSelectionVector(copy_count, owned_sel);
-		break; // carry on with below code
-	case VectorType::FLAT_VECTOR:
-		break;
-	default:
-		throw NotImplementedException("FIXME unimplemented vector type for VectorOperations::Copy");
+
+	const Vector *source = &source_p;
+	bool finished = false;
+	while (!finished) {
+		switch (source->GetVectorType()) {
+		case VectorType::DICTIONARY_VECTOR: {
+			// dictionary vector: merge selection vectors
+			auto &child = DictionaryVector::Child(*source);
+			auto &dict_sel = DictionaryVector::SelVector(*source);
+			// merge the selection vectors and verify the child
+			auto new_buffer = dict_sel.Slice(*sel, source_count);
+			owned_sel.Initialize(new_buffer);
+			sel = &owned_sel;
+			source = &child;
+			break;
+		}
+		case VectorType::SEQUENCE_VECTOR: {
+			int64_t start, increment;
+			Vector seq(source->GetType());
+			SequenceVector::GetSequence(*source, start, increment);
+			VectorOperations::GenerateSequence(seq, source_count, *sel, start, increment);
+			VectorOperations::Copy(seq, target, *sel, source_count, source_offset, target_offset);
+			return;
+		}
+		case VectorType::CONSTANT_VECTOR:
+			sel = ConstantVector::ZeroSelectionVector(copy_count, owned_sel);
+			finished = true;
+			break;
+		case VectorType::FLAT_VECTOR:
+			finished = true;
+			break;
+		default:
+			throw NotImplementedException("FIXME unimplemented vector type for VectorOperations::Copy");
+		}
 	}
 
 	if (copy_count == 0) {
@@ -51989,13 +52019,13 @@ void VectorOperations::Copy(const Vector &source, Vector &target, const Selectio
 
 	// first copy the nullmask
 	auto &tmask = FlatVector::Validity(target);
-	if (source.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		const bool valid = !ConstantVector::IsNull(source);
+	if (source->GetVectorType() == VectorType::CONSTANT_VECTOR) {
+		const bool valid = !ConstantVector::IsNull(*source);
 		for (idx_t i = 0; i < copy_count; i++) {
 			tmask.Set(target_offset + i, valid);
 		}
 	} else {
-		auto &smask = FlatVector::Validity(source);
+		auto &smask = FlatVector::Validity(*source);
 		if (smask.IsMaskSet()) {
 			for (idx_t i = 0; i < copy_count; i++) {
 				auto idx = sel->get_index(source_offset + i);
@@ -52020,46 +52050,46 @@ void VectorOperations::Copy(const Vector &source, Vector &target, const Selectio
 	D_ASSERT(sel);
 
 	// now copy over the data
-	switch (source.GetType().InternalType()) {
+	switch (source->GetType().InternalType()) {
 	case PhysicalType::BOOL:
 	case PhysicalType::INT8:
-		TemplatedCopy<int8_t>(source, *sel, target, source_offset, target_offset, copy_count);
+		TemplatedCopy<int8_t>(*source, *sel, target, source_offset, target_offset, copy_count);
 		break;
 	case PhysicalType::INT16:
-		TemplatedCopy<int16_t>(source, *sel, target, source_offset, target_offset, copy_count);
+		TemplatedCopy<int16_t>(*source, *sel, target, source_offset, target_offset, copy_count);
 		break;
 	case PhysicalType::INT32:
-		TemplatedCopy<int32_t>(source, *sel, target, source_offset, target_offset, copy_count);
+		TemplatedCopy<int32_t>(*source, *sel, target, source_offset, target_offset, copy_count);
 		break;
 	case PhysicalType::INT64:
-		TemplatedCopy<int64_t>(source, *sel, target, source_offset, target_offset, copy_count);
+		TemplatedCopy<int64_t>(*source, *sel, target, source_offset, target_offset, copy_count);
 		break;
 	case PhysicalType::UINT8:
-		TemplatedCopy<uint8_t>(source, *sel, target, source_offset, target_offset, copy_count);
+		TemplatedCopy<uint8_t>(*source, *sel, target, source_offset, target_offset, copy_count);
 		break;
 	case PhysicalType::UINT16:
-		TemplatedCopy<uint16_t>(source, *sel, target, source_offset, target_offset, copy_count);
+		TemplatedCopy<uint16_t>(*source, *sel, target, source_offset, target_offset, copy_count);
 		break;
 	case PhysicalType::UINT32:
-		TemplatedCopy<uint32_t>(source, *sel, target, source_offset, target_offset, copy_count);
+		TemplatedCopy<uint32_t>(*source, *sel, target, source_offset, target_offset, copy_count);
 		break;
 	case PhysicalType::UINT64:
-		TemplatedCopy<uint64_t>(source, *sel, target, source_offset, target_offset, copy_count);
+		TemplatedCopy<uint64_t>(*source, *sel, target, source_offset, target_offset, copy_count);
 		break;
 	case PhysicalType::INT128:
-		TemplatedCopy<hugeint_t>(source, *sel, target, source_offset, target_offset, copy_count);
+		TemplatedCopy<hugeint_t>(*source, *sel, target, source_offset, target_offset, copy_count);
 		break;
 	case PhysicalType::FLOAT:
-		TemplatedCopy<float>(source, *sel, target, source_offset, target_offset, copy_count);
+		TemplatedCopy<float>(*source, *sel, target, source_offset, target_offset, copy_count);
 		break;
 	case PhysicalType::DOUBLE:
-		TemplatedCopy<double>(source, *sel, target, source_offset, target_offset, copy_count);
+		TemplatedCopy<double>(*source, *sel, target, source_offset, target_offset, copy_count);
 		break;
 	case PhysicalType::INTERVAL:
-		TemplatedCopy<interval_t>(source, *sel, target, source_offset, target_offset, copy_count);
+		TemplatedCopy<interval_t>(*source, *sel, target, source_offset, target_offset, copy_count);
 		break;
 	case PhysicalType::VARCHAR: {
-		auto ldata = FlatVector::GetData<string_t>(source);
+		auto ldata = FlatVector::GetData<string_t>(*source);
 		auto tdata = FlatVector::GetData<string_t>(target);
 		for (idx_t i = 0; i < copy_count; i++) {
 			auto source_idx = sel->get_index(source_offset + i);
@@ -52071,11 +52101,11 @@ void VectorOperations::Copy(const Vector &source, Vector &target, const Selectio
 		break;
 	}
 	case PhysicalType::STRUCT: {
-		auto &source_children = StructVector::GetEntries(source);
+		auto &source_children = StructVector::GetEntries(*source);
 		auto &target_children = StructVector::GetEntries(target);
 		D_ASSERT(source_children.size() == target_children.size());
 		for (idx_t i = 0; i < source_children.size(); i++) {
-			VectorOperations::Copy(*source_children[i], *target_children[i], *sel, source_count, source_offset,
+			VectorOperations::Copy(*source_children[i], *target_children[i], sel_p, source_count, source_offset,
 			                       target_offset);
 		}
 		break;
@@ -52083,8 +52113,8 @@ void VectorOperations::Copy(const Vector &source, Vector &target, const Selectio
 	case PhysicalType::LIST: {
 		D_ASSERT(target.GetType().InternalType() == PhysicalType::LIST);
 
-		auto &source_child = ListVector::GetEntry(source);
-		auto sdata = FlatVector::GetData<list_entry_t>(source);
+		auto &source_child = ListVector::GetEntry(*source);
+		auto sdata = FlatVector::GetData<list_entry_t>(*source);
 		auto tdata = FlatVector::GetData<list_entry_t>(target);
 
 		if (target_vector_type == VectorType::CONSTANT_VECTOR) {
@@ -52142,7 +52172,7 @@ void VectorOperations::Copy(const Vector &source, Vector &target, const Selectio
 	}
 	default:
 		throw NotImplementedException("Unimplemented type '%s' for copy!",
-		                              TypeIdToString(source.GetType().InternalType()));
+		                              TypeIdToString(source->GetType().InternalType()));
 	}
 
 	if (target_vector_type != VectorType::FLAT_VECTOR) {
@@ -52152,38 +52182,8 @@ void VectorOperations::Copy(const Vector &source, Vector &target, const Selectio
 
 void VectorOperations::Copy(const Vector &source, Vector &target, idx_t source_count, idx_t source_offset,
                             idx_t target_offset) {
-	switch (source.GetVectorType()) {
-	case VectorType::DICTIONARY_VECTOR: {
-		// dictionary: continue into child with selection vector
-		auto &child = DictionaryVector::Child(source);
-		auto &dict_sel = DictionaryVector::SelVector(source);
-		VectorOperations::Copy(child, target, dict_sel, source_count, source_offset, target_offset);
-		break;
-	}
-	case VectorType::CONSTANT_VECTOR: {
-		SelectionVector owned_sel;
-		auto sel = ConstantVector::ZeroSelectionVector(source_count, owned_sel);
-		VectorOperations::Copy(source, target, *sel, source_count, source_offset, target_offset);
-		break;
-	}
-	case VectorType::FLAT_VECTOR: {
-		auto sel = FlatVector::IncrementalSelectionVector();
-		VectorOperations::Copy(source, target, *sel, source_count, source_offset, target_offset);
-		break;
-	}
-	case VectorType::SEQUENCE_VECTOR: {
-		int64_t start, increment;
-		SequenceVector::GetSequence(source, start, increment);
-		Vector flattened(source.GetType());
-		VectorOperations::GenerateSequence(flattened, source_count, start, increment);
-
-		auto sel = FlatVector::IncrementalSelectionVector();
-		VectorOperations::Copy(flattened, target, *sel, source_count, source_offset, target_offset);
-		break;
-	}
-	default:
-		throw NotImplementedException("FIXME: unimplemented vector type for VectorOperations::Copy");
-	}
+	VectorOperations::Copy(source, target, *FlatVector::IncrementalSelectionVector(), source_count, source_offset,
+	                       target_offset);
 }
 
 } // namespace duckdb
@@ -54339,11 +54339,14 @@ void ValidityFillLoop(Vector &vector, Vector &result, const SelectionVector &sel
 	} else {
 		VectorData vdata;
 		vector.Orrify(count, vdata);
+		if (vdata.validity.AllValid()) {
+			return;
+		}
 		for (idx_t i = 0; i < count; i++) {
 			auto source_idx = vdata.sel->get_index(i);
-			auto res_idx = sel.get_index(i);
-
-			result_mask.Set(res_idx, vdata.validity.RowIsValid(source_idx));
+			if (!vdata.validity.RowIsValid(source_idx)) {
+				result_mask.SetInvalid(sel.get_index(i));
+			}
 		}
 	}
 }
@@ -54418,7 +54421,7 @@ void ExpressionExecutor::FillSwitch(Vector &vector, Vector &result, const Select
 			result_data[result_idx].offset += offset;
 		}
 
-		result.Verify(sel, count);
+		Vector::Verify(result, sel, count);
 		break;
 	}
 	default:
@@ -67734,6 +67737,7 @@ OperatorResultType PhysicalPiecewiseMergeJoin::Execute(ExecutionContext &context
 		}
 	}
 
+	input.Verify();
 	switch (join_type) {
 	case JoinType::SEMI:
 	case JoinType::ANTI:
@@ -68332,6 +68336,8 @@ SinkResultType PhysicalOrder::Sink(ExecutionContext &context, GlobalSinkState &g
 	lstate.executor.Execute(input, sort);
 
 	// Sink the data into the local sort state
+	sort.Verify();
+	input.Verify();
 	local_sort_state.SinkChunk(sort, input);
 
 	// When sorting data reaches a certain size, we sort it
@@ -82027,15 +82033,16 @@ static bool TemplatedOptimumValue(Vector &left, idx_t lidx, idx_t lcount, Vector
 }
 
 template <class OP>
-static bool TemplatedOptimumStruct(Vector &left, idx_t lidx, idx_t lcount, Vector &right, idx_t ridx, idx_t rcount) {
+static bool TemplatedOptimumStruct(Vector &left, idx_t lidx_p, idx_t lcount, Vector &right, idx_t ridx_p,
+                                   idx_t rcount) {
 	// STRUCT dictionaries apply to all the children
 	// so map the indexes first
 	VectorData lvdata, rvdata;
 	left.Orrify(lcount, lvdata);
 	right.Orrify(rcount, rvdata);
 
-	lidx = lvdata.sel->get_index(lidx);
-	ridx = rvdata.sel->get_index(ridx);
+	idx_t lidx = lvdata.sel->get_index(lidx_p);
+	idx_t ridx = rvdata.sel->get_index(ridx_p);
 
 	// DISTINCT semantics are in effect for nested types
 	auto lnull = !lvdata.validity.RowIsValid(lidx);
@@ -82053,7 +82060,7 @@ static bool TemplatedOptimumStruct(Vector &left, idx_t lidx, idx_t lcount, Vecto
 		auto &rchild = *rchildren[col_no];
 
 		// Strict comparisons use the OP for definite
-		if (TemplatedOptimumValue<OP>(lchild, lidx, lcount, rchild, ridx, rcount)) {
+		if (TemplatedOptimumValue<OP>(lchild, lidx_p, lcount, rchild, ridx_p, rcount)) {
 			return true;
 		}
 
@@ -82062,7 +82069,7 @@ static bool TemplatedOptimumStruct(Vector &left, idx_t lidx, idx_t lcount, Vecto
 		}
 
 		// Strict comparisons use IS NOT DISTINCT for possible
-		if (!TemplatedOptimumValue<NotDistinctFrom>(lchild, lidx, lcount, rchild, ridx, rcount)) {
+		if (!TemplatedOptimumValue<NotDistinctFrom>(lchild, lidx_p, lcount, rchild, ridx_p, rcount)) {
 			return false;
 		}
 	}
@@ -96522,23 +96529,11 @@ static void CardinalityFunction(DataChunk &args, ExpressionState &state, Vector
 	result.SetVectorType(VectorType::FLAT_VECTOR);
 	auto result_data = FlatVector::GetData<uint64_t>(result);
 
-	if (map.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		auto &child = DictionaryVector::Child(map);
-		auto &dict_sel = DictionaryVector::SelVector(map);
-
-		auto &children = StructVector::GetEntries(child);
-		children[0]->Orrify(args.size(), list_data);
-		for (idx_t row = 0; row < args.size(); row++) {
-			auto list_entry = ((list_entry_t *)list_data.data)[list_data.sel->get_index(dict_sel.get_index(row))];
-			result_data[row] = list_entry.length;
-		}
-	} else {
-		auto &children = StructVector::GetEntries(map);
-		children[0]->Orrify(args.size(), list_data);
-		for (idx_t row = 0; row < args.size(); row++) {
-			auto list_entry = ((list_entry_t *)list_data.data)[list_data.sel->get_index(row)];
-			result_data[row] = list_entry.length;
-		}
+	auto &children = StructVector::GetEntries(map);
+	children[0]->Orrify(args.size(), list_data);
+	for (idx_t row = 0; row < args.size(); row++) {
+		auto list_entry = ((list_entry_t *)list_data.data)[list_data.sel->get_index(row)];
+		result_data[row] = list_entry.length;
 	}
 
 	if (args.size() == 1) {
@@ -96686,33 +96681,16 @@ static void MapExtractFunction(DataChunk &args, ExpressionState &state, Vector &
 	auto key_value = key.GetValue(0);
 	VectorData offset_data;
 
-	if (map.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		auto &child = DictionaryVector::Child(map);
-		auto &children = StructVector::GetEntries(child);
-		auto &dict_sel = DictionaryVector::SelVector(map);
-		children[0]->Orrify(args.size(), offset_data);
-		auto &key_type = ListType::GetChildType(children[0]->GetType());
-		if (key_type != LogicalTypeId::SQLNULL) {
-			key_value = key_value.CastAs(key_type);
-		}
-		for (idx_t row = 0; row < args.size(); row++) {
-			auto offsets =
-			    ListVector::Search(*children[0], key_value, offset_data.sel->get_index(dict_sel.get_index(row)));
-			auto values = ListVector::GetValuesFromOffsets(*children[1], offsets);
-			FillResult(values, result, row);
-		}
-	} else {
-		auto &children = StructVector::GetEntries(map);
-		children[0]->Orrify(args.size(), offset_data);
-		auto &key_type = ListType::GetChildType(children[0]->GetType());
-		if (key_type != LogicalTypeId::SQLNULL) {
-			key_value = key_value.CastAs(key_type);
-		}
-		for (idx_t row = 0; row < args.size(); row++) {
-			auto offsets = ListVector::Search(*children[0], key_value, offset_data.sel->get_index(row));
-			auto values = ListVector::GetValuesFromOffsets(*children[1], offsets);
-			FillResult(values, result, row);
-		}
+	auto &children = StructVector::GetEntries(map);
+	children[0]->Orrify(args.size(), offset_data);
+	auto &key_type = ListType::GetChildType(children[0]->GetType());
+	if (key_type != LogicalTypeId::SQLNULL) {
+		key_value = key_value.CastAs(key_type);
+	}
+	for (idx_t row = 0; row < args.size(); row++) {
+		auto offsets = ListVector::Search(*children[0], key_value, offset_data.sel->get_index(row));
+		auto values = ListVector::GetValuesFromOffsets(*children[1], offsets);
+		FillResult(values, result, row);
 	}
 
 	if (args.size() == 1) {
@@ -103967,19 +103945,10 @@ static void StructExtractFunction(DataChunk &args, ExpressionState &state, Vecto
 	auto &vec = args.data[0];
 
 	vec.Verify(args.size());
-	if (vec.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		auto &child = DictionaryVector::Child(vec);
-		auto &dict_sel = DictionaryVector::SelVector(vec);
-		auto &children = StructVector::GetEntries(child);
-		D_ASSERT(info.index < children.size());
-		auto &struct_child = children[info.index];
-		result.Slice(*struct_child, dict_sel, args.size());
-	} else {
-		auto &children = StructVector::GetEntries(vec);
-		D_ASSERT(info.index < children.size());
-		auto &struct_child = children[info.index];
-		result.Reference(*struct_child);
-	}
+	auto &children = StructVector::GetEntries(vec);
+	D_ASSERT(info.index < children.size());
+	auto &struct_child = children[info.index];
+	result.Reference(*struct_child);
 	result.Verify(args.size());
 }
 
@@ -106648,8 +106617,28 @@ struct DuckDBViewsFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct TestType {
+	TestType(LogicalType type_p, string name_p)
+	    : type(move(type_p)), name(move(name_p)), min_value(Value::MinimumValue(type)),
+	      max_value(Value::MaximumValue(type)) {
+	}
+	TestType(LogicalType type_p, string name_p, Value min, Value max)
+	    : type(move(type_p)), name(move(name_p)), min_value(move(min)), max_value(move(max)) {
+	}
+
+	LogicalType type;
+	string name;
+	Value min_value;
+	Value max_value;
+};
+
 struct TestAllTypesFun {
 	static void RegisterFunction(BuiltinFunctions &set);
+	static vector<TestType> GetTestTypes();
+};
+
+struct TestVectorTypesFun {
+	static void RegisterFunction(BuiltinFunctions &set);
 };
 
 } // namespace duckdb
@@ -110259,22 +110248,7 @@ struct TestAllTypesData : public GlobalTableFunctionState {
 	idx_t offset;
 };
 
-struct TestType {
-	TestType(LogicalType type_p, string name_p)
-	    : type(move(type_p)), name(move(name_p)), min_value(Value::MinimumValue(type)),
-	      max_value(Value::MaximumValue(type)) {
-	}
-	TestType(LogicalType type_p, string name_p, Value min, Value max)
-	    : type(move(type_p)), name(move(name_p)), min_value(move(min)), max_value(move(max)) {
-	}
-
-	LogicalType type;
-	string name;
-	Value min_value;
-	Value max_value;
-};
-
-static vector<TestType> GetTestTypes() {
+vector<TestType> TestAllTypesFun::GetTestTypes() {
 	vector<TestType> result;
 	// scalar types/numerics
 	result.emplace_back(LogicalType::BOOLEAN, "bool");
@@ -110445,7 +110419,7 @@ static vector<TestType> GetTestTypes() {
 
 static unique_ptr<FunctionData> TestAllTypesBind(ClientContext &context, TableFunctionBindInput &input,
                                                  vector<LogicalType> &return_types, vector<string> &names) {
-	auto test_types = GetTestTypes();
+	auto test_types = TestAllTypesFun::GetTestTypes();
 	for (auto &test_type : test_types) {
 		return_types.push_back(move(test_type.type));
 		names.push_back(move(test_type.name));
@@ -110455,7 +110429,7 @@ static unique_ptr<FunctionData> TestAllTypesBind(ClientContext &context, TableFu
 
 unique_ptr<GlobalTableFunctionState> TestAllTypesInit(ClientContext &context, TableFunctionInitInput &input) {
 	auto result = make_unique<TestAllTypesData>();
-	auto test_types = GetTestTypes();
+	auto test_types = TestAllTypesFun::GetTestTypes();
 	// 3 rows: min, max and NULL
 	result->entries.resize(3);
 	// initialize the values
@@ -110493,6 +110467,256 @@ void TestAllTypesFun::RegisterFunction(BuiltinFunctions &set) {
 } // namespace duckdb
 
 
+
+
+namespace duckdb {
+
+// FLAT, CONSTANT, DICTIONARY, SEQUENCE
+struct TestVectorBindData : public TableFunctionData {
+	LogicalType type;
+	bool all_flat;
+};
+
+struct TestVectorTypesData : public GlobalTableFunctionState {
+	TestVectorTypesData() : offset(0) {
+	}
+
+	vector<unique_ptr<DataChunk>> entries;
+	idx_t offset;
+};
+
+struct TestVectorInfo {
+	TestVectorInfo(const LogicalType &type, const map<LogicalTypeId, TestType> &test_type_map,
+	               vector<unique_ptr<DataChunk>> &entries)
+	    : type(type), test_type_map(test_type_map), entries(entries) {
+	}
+
+	const LogicalType &type;
+	const map<LogicalTypeId, TestType> &test_type_map;
+	vector<unique_ptr<DataChunk>> &entries;
+};
+
+struct TestVectorFlat {
+	static constexpr const idx_t TEST_VECTOR_CARDINALITY = 3;
+
+	static vector<Value> GenerateValues(TestVectorInfo &info, const LogicalType &type) {
+		vector<Value> result;
+		switch (type.InternalType()) {
+		case PhysicalType::STRUCT: {
+			vector<child_list_t<Value>> struct_children;
+			auto &child_types = StructType::GetChildTypes(type);
+
+			struct_children.resize(TEST_VECTOR_CARDINALITY);
+			for (auto &child_type : child_types) {
+				auto child_values = GenerateValues(info, child_type.second);
+
+				for (idx_t i = 0; i < child_values.size(); i++) {
+					struct_children[i].push_back(make_pair(child_type.first, move(child_values[i])));
+				}
+			}
+			for (auto &struct_child : struct_children) {
+				result.push_back(Value::STRUCT(move(struct_child)));
+			}
+			break;
+		}
+		case PhysicalType::LIST: {
+			auto &child_type = ListType::GetChildType(type);
+			auto child_values = GenerateValues(info, child_type);
+
+			result.push_back(Value::LIST(child_type, {child_values[0], child_values[1]}));
+			result.push_back(Value::LIST(child_type, {}));
+			result.push_back(Value::LIST(child_type, {child_values[2]}));
+			break;
+		}
+		default: {
+			auto entry = info.test_type_map.find(type.id());
+			if (entry == info.test_type_map.end()) {
+				throw NotImplementedException("Unimplemented type for test_vector_types %s", type.ToString());
+			}
+			result.push_back(entry->second.min_value);
+			result.push_back(entry->second.max_value);
+			result.emplace_back(type);
+			break;
+		}
+		}
+		return result;
+	}
+
+	static void Generate(TestVectorInfo &info) {
+		vector<Value> result_values = GenerateValues(info, info.type);
+		for (idx_t cur_row = 0; cur_row < result_values.size(); cur_row += STANDARD_VECTOR_SIZE) {
+			auto result = make_unique<DataChunk>();
+			result->Initialize({info.type});
+			auto cardinality = MinValue<idx_t>(STANDARD_VECTOR_SIZE, result_values.size() - cur_row);
+			for (idx_t i = 0; i < cardinality; i++) {
+				result->data[0].SetValue(i, result_values[cur_row + i]);
+			}
+			result->SetCardinality(cardinality);
+			info.entries.push_back(move(result));
+		}
+	}
+};
+
+struct TestVectorConstant {
+	static void Generate(TestVectorInfo &info) {
+		auto values = TestVectorFlat::GenerateValues(info, info.type);
+		for (idx_t cur_row = 0; cur_row < TestVectorFlat::TEST_VECTOR_CARDINALITY; cur_row += STANDARD_VECTOR_SIZE) {
+			auto result = make_unique<DataChunk>();
+			result->Initialize({info.type});
+			auto cardinality = MinValue<idx_t>(STANDARD_VECTOR_SIZE, TestVectorFlat::TEST_VECTOR_CARDINALITY - cur_row);
+			result->data[0].SetValue(0, values[0]);
+			result->data[0].SetVectorType(VectorType::CONSTANT_VECTOR);
+			result->SetCardinality(cardinality);
+
+			info.entries.push_back(move(result));
+		}
+	}
+};
+
+struct TestVectorSequence {
+	static void GenerateVector(TestVectorInfo &info, const LogicalType &type, Vector &result) {
+		D_ASSERT(type == result.GetType());
+		switch (type.id()) {
+		case LogicalTypeId::TINYINT:
+		case LogicalTypeId::SMALLINT:
+		case LogicalTypeId::INTEGER:
+		case LogicalTypeId::BIGINT:
+		case LogicalTypeId::UTINYINT:
+		case LogicalTypeId::USMALLINT:
+		case LogicalTypeId::UINTEGER:
+		case LogicalTypeId::UBIGINT:
+			result.Sequence(3, 2);
+			return;
+		default:
+			break;
+		}
+		switch (type.InternalType()) {
+		case PhysicalType::STRUCT: {
+			auto &child_entries = StructVector::GetEntries(result);
+			for (auto &child_entry : child_entries) {
+				GenerateVector(info, child_entry->GetType(), *child_entry);
+			}
+			break;
+		}
+		case PhysicalType::LIST: {
+			auto data = FlatVector::GetData<list_entry_t>(result);
+			data[0].offset = 0;
+			data[0].length = 2;
+			data[1].offset = 2;
+			data[1].length = 0;
+			data[2].offset = 2;
+			data[2].length = 1;
+
+			GenerateVector(info, ListType::GetChildType(type), ListVector::GetEntry(result));
+			ListVector::SetListSize(result, 3);
+			break;
+		}
+		default: {
+			auto entry = info.test_type_map.find(type.id());
+			if (entry == info.test_type_map.end()) {
+				throw NotImplementedException("Unimplemented type for test_vector_types %s", type.ToString());
+			}
+			result.SetValue(0, entry->second.min_value);
+			result.SetValue(1, entry->second.max_value);
+			result.SetValue(2, Value(type));
+			break;
+		}
+		}
+	}
+
+	static void Generate(TestVectorInfo &info) {
+#if STANDARD_VECTOR_SIZE > 2
+		auto result = make_unique<DataChunk>();
+		result->Initialize({info.type});
+
+		GenerateVector(info, info.type, result->data[0]);
+		result->SetCardinality(3);
+		info.entries.push_back(move(result));
+#endif
+	}
+};
+
+struct TestVectorDictionary {
+	static void Generate(TestVectorInfo &info) {
+		idx_t current_chunk = info.entries.size();
+
+		unordered_set<idx_t> slice_entries {1, 2};
+
+		TestVectorFlat::Generate(info);
+		idx_t current_idx = 0;
+		for (idx_t i = current_chunk; i < info.entries.size(); i++) {
+			auto &chunk = *info.entries[i];
+			SelectionVector sel(STANDARD_VECTOR_SIZE);
+			idx_t sel_idx = 0;
+			for (idx_t k = 0; k < chunk.size(); k++) {
+				if (slice_entries.count(current_idx + k) > 0) {
+					sel.set_index(sel_idx++, k);
+				}
+			}
+			chunk.Slice(sel, sel_idx);
+			current_idx += chunk.size();
+		}
+	}
+};
+
+static unique_ptr<FunctionData> TestVectorTypesBind(ClientContext &context, TableFunctionBindInput &input,
+                                                    vector<LogicalType> &return_types, vector<string> &names) {
+	auto result = make_unique<TestVectorBindData>();
+	result->type = input.inputs[0].type();
+	result->all_flat = BooleanValue::Get(input.inputs[1]);
+
+	return_types.push_back(result->type);
+	names.emplace_back("test_vector");
+	return move(result);
+}
+
+unique_ptr<GlobalTableFunctionState> TestVectorTypesInit(ClientContext &context, TableFunctionInitInput &input) {
+	auto &bind_data = (TestVectorBindData &)*input.bind_data;
+
+	auto result = make_unique<TestVectorTypesData>();
+
+	auto test_types = TestAllTypesFun::GetTestTypes();
+
+	map<LogicalTypeId, TestType> test_type_map;
+	for (auto &test_type : test_types) {
+		test_type_map.insert(make_pair(test_type.type.id(), move(test_type)));
+	}
+
+	TestVectorInfo info(bind_data.type, test_type_map, result->entries);
+	TestVectorFlat::Generate(info);
+	TestVectorConstant::Generate(info);
+	TestVectorDictionary::Generate(info);
+	TestVectorSequence::Generate(info);
+	for (auto &entry : result->entries) {
+		entry->Verify();
+	}
+	if (bind_data.all_flat) {
+		for (auto &entry : result->entries) {
+			entry->Normalify();
+			entry->Verify();
+		}
+	}
+	return move(result);
+}
+
+void TestVectorTypesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &data = (TestVectorTypesData &)*data_p.global_state;
+	if (data.offset >= data.entries.size()) {
+		// finished returning values
+		return;
+	}
+	output.Reference(*data.entries[data.offset]);
+	data.offset++;
+}
+
+void TestVectorTypesFun::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction(TableFunction("test_vector_types", {LogicalType::ANY, LogicalType::BOOLEAN},
+	                              TestVectorTypesFunction, TestVectorTypesBind, TestVectorTypesInit));
+}
+
+} // namespace duckdb
+
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -110608,6 +110832,7 @@ void BuiltinFunctions::RegisterSQLiteFunctions() {
 	DuckDBTypesFun::RegisterFunction(*this);
 	DuckDBViewsFun::RegisterFunction(*this);
 	TestAllTypesFun::RegisterFunction(*this);
+	TestVectorTypesFun::RegisterFunction(*this);
 }
 
 } // namespace duckdb