duckdb 0.10.1 → 0.10.2-dev3.0

package/src/duckdb/src/common/tree_renderer.cpp

@@ -42,12 +42,12 @@ void RenderTree::SetNode(idx_t x, idx_t y, unique_ptr<RenderTreeNode> node) {
 
 void TreeRenderer::RenderTopLayer(RenderTree &root, std::ostream &ss, idx_t y) {
 	for (idx_t x = 0; x < root.width; x++) {
-		if (x * config.NODE_RENDER_WIDTH >= config.MAXIMUM_RENDER_WIDTH) {
+		if (x * config.node_render_width >= config.maximum_render_width) {
 			break;
 		}
 		if (root.HasNode(x, y)) {
 			ss << config.LTCORNER;
-			ss << StringUtil::Repeat(config.HORIZONTAL, config.NODE_RENDER_WIDTH / 2 - 1);
+			ss << StringUtil::Repeat(config.HORIZONTAL, config.node_render_width / 2 - 1);
 			if (y == 0) {
 				// top level node: no node above this one
 				ss << config.HORIZONTAL;
@@ -55,23 +55,23 @@ void TreeRenderer::RenderTopLayer(RenderTree &root, std::ostream &ss, idx_t y) {
 				// render connection to node above this one
 				ss << config.DMIDDLE;
 			}
-			ss << StringUtil::Repeat(config.HORIZONTAL, config.NODE_RENDER_WIDTH / 2 - 1);
+			ss << StringUtil::Repeat(config.HORIZONTAL, config.node_render_width / 2 - 1);
 			ss << config.RTCORNER;
 		} else {
-			ss << StringUtil::Repeat(" ", config.NODE_RENDER_WIDTH);
+			ss << StringUtil::Repeat(" ", config.node_render_width);
 		}
 	}
-	ss << std::endl;
+	ss << '\n';
 }
 
 void TreeRenderer::RenderBottomLayer(RenderTree &root, std::ostream &ss, idx_t y) {
 	for (idx_t x = 0; x <= root.width; x++) {
-		if (x * config.NODE_RENDER_WIDTH >= config.MAXIMUM_RENDER_WIDTH) {
+		if (x * config.node_render_width >= config.maximum_render_width) {
 			break;
 		}
 		if (root.HasNode(x, y)) {
 			ss << config.LDCORNER;
-			ss << StringUtil::Repeat(config.HORIZONTAL, config.NODE_RENDER_WIDTH / 2 - 1);
+			ss << StringUtil::Repeat(config.HORIZONTAL, config.node_render_width / 2 - 1);
 			if (root.HasNode(x, y + 1)) {
 				// node below this one: connect to that one
 				ss << config.TMIDDLE;
@@ -79,17 +79,17 @@ void TreeRenderer::RenderBottomLayer(RenderTree &root, std::ostream &ss, idx_t y
 				// no node below this one: end the box
 				ss << config.HORIZONTAL;
 			}
-			ss << StringUtil::Repeat(config.HORIZONTAL, config.NODE_RENDER_WIDTH / 2 - 1);
+			ss << StringUtil::Repeat(config.HORIZONTAL, config.node_render_width / 2 - 1);
 			ss << config.RDCORNER;
 		} else if (root.HasNode(x, y + 1)) {
-			ss << StringUtil::Repeat(" ", config.NODE_RENDER_WIDTH / 2);
+			ss << StringUtil::Repeat(" ", config.node_render_width / 2);
 			ss << config.VERTICAL;
-			ss << StringUtil::Repeat(" ", config.NODE_RENDER_WIDTH / 2);
+			ss << StringUtil::Repeat(" ", config.node_render_width / 2);
 		} else {
-			ss << StringUtil::Repeat(" ", config.NODE_RENDER_WIDTH);
+			ss << StringUtil::Repeat(" ", config.node_render_width);
 		}
 	}
-	ss << std::endl;
+	ss << '\n';
 }
 
 string AdjustTextForRendering(string source, idx_t max_render_width) {
@@ -145,12 +145,12 @@ void TreeRenderer::RenderBoxContent(RenderTree &root, std::ostream &ss, idx_t y)
 			}
 		}
 	}
-	extra_height = MinValue<idx_t>(extra_height, config.MAX_EXTRA_LINES);
+	extra_height = MinValue<idx_t>(extra_height, config.max_extra_lines);
 	idx_t halfway_point = (extra_height + 1) / 2;
 	// now we render the actual node
 	for (idx_t render_y = 0; render_y <= extra_height; render_y++) {
 		for (idx_t x = 0; x < root.width; x++) {
-			if (x * config.NODE_RENDER_WIDTH >= config.MAXIMUM_RENDER_WIDTH) {
+			if (x * config.node_render_width >= config.maximum_render_width) {
 				break;
 			}
 			auto node = root.GetNode(x, y);
@@ -159,35 +159,35 @@ void TreeRenderer::RenderBoxContent(RenderTree &root, std::ostream &ss, idx_t y)
 					bool has_child_to_the_right = NodeHasMultipleChildren(root, x, y);
 					if (root.HasNode(x, y + 1)) {
 						// node right below this one
-						ss << StringUtil::Repeat(config.HORIZONTAL, config.NODE_RENDER_WIDTH / 2);
+						ss << StringUtil::Repeat(config.HORIZONTAL, config.node_render_width / 2);
 						ss << config.RTCORNER;
 						if (has_child_to_the_right) {
 							// but we have another child to the right! keep rendering the line
-							ss << StringUtil::Repeat(config.HORIZONTAL, config.NODE_RENDER_WIDTH / 2);
+							ss << StringUtil::Repeat(config.HORIZONTAL, config.node_render_width / 2);
 						} else {
 							// only a child below this one: fill the rest with spaces
-							ss << StringUtil::Repeat(" ", config.NODE_RENDER_WIDTH / 2);
+							ss << StringUtil::Repeat(" ", config.node_render_width / 2);
 						}
 					} else if (has_child_to_the_right) {
 						// child to the right, but no child right below this one: render a full line
-						ss << StringUtil::Repeat(config.HORIZONTAL, config.NODE_RENDER_WIDTH);
+						ss << StringUtil::Repeat(config.HORIZONTAL, config.node_render_width);
 					} else {
 						// empty spot: render spaces
-						ss << StringUtil::Repeat(" ", config.NODE_RENDER_WIDTH);
+						ss << StringUtil::Repeat(" ", config.node_render_width);
 					}
 				} else if (render_y >= halfway_point) {
 					if (root.HasNode(x, y + 1)) {
 						// we have a node below this empty spot: render a vertical line
-						ss << StringUtil::Repeat(" ", config.NODE_RENDER_WIDTH / 2);
+						ss << StringUtil::Repeat(" ", config.node_render_width / 2);
 						ss << config.VERTICAL;
-						ss << StringUtil::Repeat(" ", config.NODE_RENDER_WIDTH / 2);
+						ss << StringUtil::Repeat(" ", config.node_render_width / 2);
 					} else {
 						// empty spot: render spaces
-						ss << StringUtil::Repeat(" ", config.NODE_RENDER_WIDTH);
+						ss << StringUtil::Repeat(" ", config.node_render_width);
 					}
 				} else {
 					// empty spot: render spaces
-					ss << StringUtil::Repeat(" ", config.NODE_RENDER_WIDTH);
+					ss << StringUtil::Repeat(" ", config.node_render_width);
 				}
 			} else {
 				ss << config.VERTICAL;
@@ -200,7 +200,7 @@ void TreeRenderer::RenderBoxContent(RenderTree &root, std::ostream &ss, idx_t y)
 						render_text = extra_info[x][render_y - 1];
 					}
 				}
-				render_text = AdjustTextForRendering(render_text, config.NODE_RENDER_WIDTH - 2);
+				render_text = AdjustTextForRendering(render_text, config.node_render_width - 2);
 				ss << render_text;
 
 				if (render_y == halfway_point && NodeHasMultipleChildren(root, x, y)) {
@@ -210,7 +210,7 @@ void TreeRenderer::RenderBoxContent(RenderTree &root, std::ostream &ss, idx_t y)
 				}
 			}
 		}
-		ss << std::endl;
+		ss << '\n';
 	}
 }
 
@@ -259,11 +259,11 @@ void TreeRenderer::Render(const Pipeline &op, std::ostream &ss) {
 }
 
 void TreeRenderer::ToStream(RenderTree &root, std::ostream &ss) {
-	while (root.width * config.NODE_RENDER_WIDTH > config.MAXIMUM_RENDER_WIDTH) {
-		if (config.NODE_RENDER_WIDTH - 2 < config.MINIMUM_RENDER_WIDTH) {
+	while (root.width * config.node_render_width > config.maximum_render_width) {
+		if (config.node_render_width - 2 < config.minimum_render_width) {
 			break;
 		}
-		config.NODE_RENDER_WIDTH -= 2;
+		config.node_render_width -= 2;
 	}
 
 	for (idx_t y = 0; y < root.height; y++) {
@@ -297,7 +297,7 @@ string TreeRenderer::RemovePadding(string l) {
 
 void TreeRenderer::SplitStringBuffer(const string &source, vector<string> &result) {
 	D_ASSERT(Utf8Proc::IsValid(source.c_str(), source.size()));
-	idx_t max_line_render_size = config.NODE_RENDER_WIDTH - 2;
+	idx_t max_line_render_size = config.node_render_width - 2;
 	// utf8 in prompt, get render width
 	idx_t cpos = 0;
 	idx_t start_pos = 0;
@@ -352,7 +352,7 @@ void TreeRenderer::SplitUpExtraInfo(const string &extra_info, vector<string> &re
 }
 
 string TreeRenderer::ExtraInfoSeparator() {
-	return StringUtil::Repeat(string(config.HORIZONTAL) + " ", (config.NODE_RENDER_WIDTH - 7) / 2);
+	return StringUtil::Repeat(string(config.HORIZONTAL) + " ", (config.node_render_width - 7) / 2);
 }
 
 unique_ptr<RenderTreeNode> TreeRenderer::CreateRenderNode(string name, string extra_info) {
@@ -483,47 +483,12 @@ unique_ptr<RenderTreeNode> TreeRenderer::CreateNode(const PipelineRenderNode &op
 	return CreateNode(op.op);
 }
 
-string TreeRenderer::ExtractExpressionsRecursive(ExpressionInfo &state) {
-	string result = "\n[INFOSEPARATOR]";
-	result += "\n" + state.function_name;
-	result += "\n" + StringUtil::Format("%.9f", double(state.function_time));
-	if (state.children.empty()) {
-		return result;
-	}
-	// render the children of this node
-	for (auto &child : state.children) {
-		result += ExtractExpressionsRecursive(*child);
-	}
-	return result;
-}
-
 unique_ptr<RenderTreeNode> TreeRenderer::CreateNode(const QueryProfiler::TreeNode &op) {
 	auto result = TreeRenderer::CreateRenderNode(op.name, op.extra_info);
 	result->extra_text += "\n[INFOSEPARATOR]";
 	result->extra_text += "\n" + to_string(op.info.elements);
 	string timing = StringUtil::Format("%.2f", op.info.time);
 	result->extra_text += "\n(" + timing + "s)";
-	if (config.detailed) {
-		for (auto &info : op.info.executors_info) {
-			if (!info) {
-				continue;
-			}
-			for (auto &executor_info : info->roots) {
-				string sample_count = to_string(executor_info->sample_count);
-				result->extra_text += "\n[INFOSEPARATOR]";
-				result->extra_text += "\nsample_count: " + sample_count;
-				string sample_tuples_count = to_string(executor_info->sample_tuples_count);
-				result->extra_text += "\n[INFOSEPARATOR]";
-				result->extra_text += "\nsample_tuples_count: " + sample_tuples_count;
-				string total_count = to_string(executor_info->total_count);
-				result->extra_text += "\n[INFOSEPARATOR]";
-				result->extra_text += "\ntotal_count: " + total_count;
-				for (auto &state : executor_info->root->children) {
-					result->extra_text += ExtractExpressionsRecursive(*state);
-				}
-			}
-		}
-	}
 	return result;
 }
 
@@ -539,8 +504,8 @@ unique_ptr<RenderTree> TreeRenderer::CreateTree(const QueryProfiler::TreeNode &o
 	return CreateRenderTree<QueryProfiler::TreeNode>(op);
 }
 
-unique_ptr<RenderTree> TreeRenderer::CreateTree(const Pipeline &op) {
-	auto operators = op.GetOperators();
+unique_ptr<RenderTree> TreeRenderer::CreateTree(const Pipeline &pipeline) {
+	auto operators = pipeline.GetOperators();
 	D_ASSERT(!operators.empty());
 	unique_ptr<PipelineRenderNode> node;
 	for (auto &op : operators) {

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

@@ -51,6 +51,7 @@ void Bit::Finalize(string_t &str) {
 	for (idx_t i = 0; i < idx_t(padding); i++) {
 		Bit::SetBitInternal(str, i, 1);
 	}
+	str.Finalize();
 	Bit::Verify(str);
 }
 
@@ -145,7 +146,6 @@ void Bit::ToBit(string_t str, string_t &output_str) {
 		*(output++) = byte;
 	}
 	Bit::Finalize(output_str);
-	Bit::Verify(output_str);
 }
 
 string Bit::ToBit(string_t str) {
@@ -287,6 +287,7 @@ idx_t Bit::GetBitInternal(string_t bit_string, idx_t n) {
 
 void Bit::SetBit(string_t &bit_string, idx_t n, idx_t new_value) {
 	SetBitInternal(bit_string, n + GetBitPadding(bit_string), new_value);
+	Bit::Finalize(bit_string);
 }
 
 void Bit::SetBitInternal(string_t &bit_string, idx_t n, idx_t new_value) {
@@ -332,7 +333,6 @@ void Bit::LeftShift(const string_t &bit_string, const idx_t &shift, string_t &re
 		}
 	}
 	Bit::Finalize(result);
-	Bit::Verify(result);
 }
 
 void Bit::BitwiseAnd(const string_t &rhs, const string_t &lhs, string_t &result) {
@@ -348,8 +348,7 @@ void Bit::BitwiseAnd(const string_t &rhs, const string_t &lhs, string_t &result)
 	for (idx_t i = 1; i < lhs.GetSize(); i++) {
 		buf[i] = l_buf[i] & r_buf[i];
 	}
-	// and should preserve padding bits
-	Bit::Verify(result);
+	Bit::Finalize(result);
 }
 
 void Bit::BitwiseOr(const string_t &rhs, const string_t &lhs, string_t &result) {
@@ -365,8 +364,7 @@ void Bit::BitwiseOr(const string_t &rhs, const string_t &lhs, string_t &result)
 	for (idx_t i = 1; i < lhs.GetSize(); i++) {
 		buf[i] = l_buf[i] | r_buf[i];
 	}
-	// or should preserve padding bits
-	Bit::Verify(result);
+	Bit::Finalize(result);
 }
 
 void Bit::BitwiseXor(const string_t &rhs, const string_t &lhs, string_t &result) {
@@ -403,6 +401,8 @@ void Bit::Verify(const string_t &input) {
 	for (idx_t i = 0; i < padding; i++) {
 		D_ASSERT(Bit::GetBitInternal(input, i));
 	}
+	// verify bit respects the "normal" string_t rules (i.e. null padding for inlined strings, prefix matches)
+	input.VerifyCharacters();
 #endif
 }
 

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

@@ -218,7 +218,7 @@ void DataChunk::Flatten() {
 	}
 }
 
-vector<LogicalType> DataChunk::GetTypes() {
+vector<LogicalType> DataChunk::GetTypes() const {
 	vector<LogicalType> types;
 	for (idx_t i = 0; i < ColumnCount(); i++) {
 		types.push_back(data[i].GetType());
@@ -290,7 +290,7 @@ void DataChunk::Slice(const SelectionVector &sel_vector, idx_t count_p) {
 	}
 }
 
-void DataChunk::Slice(DataChunk &other, const SelectionVector &sel, idx_t count_p, idx_t col_offset) {
+void DataChunk::Slice(const DataChunk &other, const SelectionVector &sel, idx_t count_p, idx_t col_offset) {
 	D_ASSERT(other.ColumnCount() <= col_offset + ColumnCount());
 	this->count = count_p;
 	SelCache merge_cache;

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

@@ -12,22 +12,22 @@ namespace duckdb {
 
 template <>
 hash_t Hash(uint64_t val) {
-	return murmurhash64(val);
+	return MurmurHash64(val);
 }
 
 template <>
 hash_t Hash(int64_t val) {
-	return murmurhash64((uint64_t)val);
+	return MurmurHash64((uint64_t)val);
 }
 
 template <>
 hash_t Hash(hugeint_t val) {
-	return murmurhash64(val.lower) ^ murmurhash64(val.upper);
+	return MurmurHash64(val.lower) ^ MurmurHash64(val.upper);
 }
 
 template <>
 hash_t Hash(uhugeint_t val) {
-	return murmurhash64(val.lower) ^ murmurhash64(val.upper);
+	return MurmurHash64(val.lower) ^ MurmurHash64(val.upper);
 }
 
 template <class T>
@@ -47,7 +47,7 @@ hash_t Hash(float val) {
 	static_assert(sizeof(float) == sizeof(uint32_t), "");
 	FloatingPointEqualityTransform<float>::OP(val);
 	uint32_t uval = Load<uint32_t>(const_data_ptr_cast(&val));
-	return murmurhash64(uval);
+	return MurmurHash64(uval);
 }
 
 template <>
@@ -55,7 +55,7 @@ hash_t Hash(double val) {
 	static_assert(sizeof(double) == sizeof(uint64_t), "");
 	FloatingPointEqualityTransform<double>::OP(val);
 	uint64_t uval = Load<uint64_t>(const_data_ptr_cast(&val));
-	return murmurhash64(uval);
+	return MurmurHash64(uval);
 }
 
 template <>

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

@@ -171,6 +171,8 @@ inline uint64_t HashOtherSize(const_data_ptr_t &data, const idx_t &len) {
 		CreateIntegerRecursive<1>(data, x);
 		break;
 	case 0:
+	default:
+		D_ASSERT((len & 7) == 0);
 		break;
 	}
 	return TemplatedHash<uint64_t>(x);

package/src/duckdb/src/common/types/row/tuple_data_allocator.cpp

@@ -3,6 +3,7 @@
 #include "duckdb/common/types/row/tuple_data_segment.hpp"
 #include "duckdb/common/types/row/tuple_data_states.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/common/fast_mem.hpp"
 
 namespace duckdb {
 
@@ -82,6 +83,18 @@ void TupleDataAllocator::Build(TupleDataSegment &segment, TupleDataPinState &pin
 			segment.data_size += chunk_part.total_heap_size;
 		}
 
+		if (layout.HasDestructor()) {
+			const auto base_row_ptr = GetRowPointer(pin_state, chunk_part);
+			for (auto &aggr_idx : layout.GetAggregateDestructorIndices()) {
+				const auto aggr_offset = layout.GetOffsets()[layout.ColumnCount() + aggr_idx];
+				auto &aggr_fun = layout.GetAggregates()[aggr_idx];
+				for (idx_t i = 0; i < next; i++) {
+					duckdb::FastMemset(base_row_ptr + i * layout.GetRowWidth() + aggr_offset, '\0',
+					                   aggr_fun.payload_size);
+				}
+			}
+		}
+
 		offset += next;
 		chunk_part_indices.emplace_back(chunks.size() - 1, chunk.parts.size() - 1);
 	}

package/src/duckdb/src/common/types/row/tuple_data_layout.cpp

@@ -5,8 +5,7 @@
 namespace duckdb {
 
 TupleDataLayout::TupleDataLayout()
-    : flag_width(0), data_width(0), aggr_width(0), row_width(0), all_constant(true), heap_size_offset(0),
-      has_destructor(false) {
+    : flag_width(0), data_width(0), aggr_width(0), row_width(0), all_constant(true), heap_size_offset(0) {
 }
 
 TupleDataLayout TupleDataLayout::Copy() const {
@@ -26,7 +25,7 @@ TupleDataLayout TupleDataLayout::Copy() const {
 	result.offsets = this->offsets;
 	result.all_constant = this->all_constant;
 	result.heap_size_offset = this->heap_size_offset;
-	result.has_destructor = this->has_destructor;
+	result.aggr_destructor_idxs = this->aggr_destructor_idxs;
 	return result;
 }
 
@@ -109,11 +108,10 @@ void TupleDataLayout::Initialize(vector<LogicalType> types_p, Aggregates aggrega
 	}
 #endif
 
-	has_destructor = false;
-	for (auto &aggr : GetAggregates()) {
+	for (idx_t aggr_idx = 0; aggr_idx < aggregates.size(); aggr_idx++) {
+		const auto &aggr = aggregates[aggr_idx];
 		if (aggr.function.destructor) {
-			has_destructor = true;
-			break;
+			aggr_destructor_idxs.push_back(aggr_idx);
 		}
 	}
 }

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

@@ -3,7 +3,7 @@
 
 namespace duckdb {
 
-bool UUID::FromString(string str, hugeint_t &result) {
+bool UUID::FromString(const string &str, hugeint_t &result) {
 	auto hex2char = [](char ch) -> unsigned char {
 		if (ch >= '0' && ch <= '9') {
 			return ch - '0';

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

@@ -78,11 +78,11 @@ Vector::Vector(Vector &other) : type(other.type) {
 	Reference(other);
 }
 
-Vector::Vector(Vector &other, const SelectionVector &sel, idx_t count) : type(other.type) {
+Vector::Vector(const Vector &other, const SelectionVector &sel, idx_t count) : type(other.type) {
 	Slice(other, sel, count);
 }
 
-Vector::Vector(Vector &other, idx_t offset, idx_t end) : type(other.type) {
+Vector::Vector(const Vector &other, idx_t offset, idx_t end) : type(other.type) {
 	Slice(other, offset, end);
 }
 
@@ -574,8 +574,8 @@ Value Vector::GetValueInternal(const Vector &v_p, idx_t index_p) {
 			throw InternalException("FSST Vector with non-string datatype found!");
 		}
 		auto str_compressed = reinterpret_cast<string_t *>(data)[index];
-		Value result = FSSTPrimitives::DecompressValue(FSSTVector::GetDecoder(const_cast<Vector &>(*vector)),
-		                                               str_compressed.GetData(), str_compressed.GetSize());
+		Value result = FSSTPrimitives::DecompressValue(FSSTVector::GetDecoder(*vector), str_compressed.GetData(),
+		                                               str_compressed.GetSize());
 		return result;
 	}
 
@@ -776,8 +776,8 @@ string Vector::ToString(idx_t count) const {
 	case VectorType::FSST_VECTOR: {
 		for (idx_t i = 0; i < count; i++) {
 			string_t compressed_string = reinterpret_cast<string_t *>(data)[i];
-			Value val = FSSTPrimitives::DecompressValue(FSSTVector::GetDecoder(const_cast<Vector &>(*this)),
-			                                            compressed_string.GetData(), compressed_string.GetSize());
+			Value val = FSSTPrimitives::DecompressValue(FSSTVector::GetDecoder(*this), compressed_string.GetData(),
+			                                            compressed_string.GetSize());
 			retval += GetValue(i).ToString() + (i == count - 1 ? "" : ", ");
 		}
 	} break;
@@ -2127,7 +2127,8 @@ const vector<unique_ptr<Vector>> &StructVector::GetEntries(const Vector &vector)
 //===--------------------------------------------------------------------===//
 // ListVector
 //===--------------------------------------------------------------------===//
-const Vector &ListVector::GetEntry(const Vector &vector) {
+template <class T>
+T &ListVector::GetEntryInternal(T &vector) {
 	D_ASSERT(vector.GetType().id() == LogicalTypeId::LIST || vector.GetType().id() == LogicalTypeId::MAP);
 	if (vector.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
 		auto &child = DictionaryVector::Child(vector);
@@ -2137,12 +2138,15 @@ const Vector &ListVector::GetEntry(const Vector &vector) {
 	         vector.GetVectorType() == VectorType::CONSTANT_VECTOR);
 	D_ASSERT(vector.auxiliary);
 	D_ASSERT(vector.auxiliary->GetBufferType() == VectorBufferType::LIST_BUFFER);
-	return vector.auxiliary->Cast<VectorListBuffer>().GetChild();
+	return vector.auxiliary->template Cast<VectorListBuffer>().GetChild();
+}
+
+const Vector &ListVector::GetEntry(const Vector &vector) {
+	return GetEntryInternal<const Vector>(vector);
 }
 
 Vector &ListVector::GetEntry(Vector &vector) {
-	const Vector &cvector = vector;
-	return const_cast<Vector &>(ListVector::GetEntry(cvector));
+	return GetEntryInternal<Vector>(vector);
 }
 
 void ListVector::Reserve(Vector &vector, idx_t required_capacity) {
@@ -2496,7 +2500,8 @@ UnionInvalidReason UnionVector::CheckUnionValidity(Vector &vector_p, idx_t count
 //===--------------------------------------------------------------------===//
 // ArrayVector
 //===--------------------------------------------------------------------===//
-const Vector &ArrayVector::GetEntry(const Vector &vector) {
+template <class T>
+T &ArrayVector::GetEntryInternal(T &vector) {
 	D_ASSERT(vector.GetType().id() == LogicalTypeId::ARRAY);
 	if (vector.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
 		auto &child = DictionaryVector::Child(vector);
@@ -2506,12 +2511,15 @@ const Vector &ArrayVector::GetEntry(const Vector &vector) {
 	         vector.GetVectorType() == VectorType::CONSTANT_VECTOR);
 	D_ASSERT(vector.auxiliary);
 	D_ASSERT(vector.auxiliary->GetBufferType() == VectorBufferType::ARRAY_BUFFER);
-	return vector.auxiliary->Cast<VectorArrayBuffer>().GetChild();
+	return vector.auxiliary->template Cast<VectorArrayBuffer>().GetChild();
+}
+
+const Vector &ArrayVector::GetEntry(const Vector &vector) {
+	return GetEntryInternal<const Vector>(vector);
 }
 
 Vector &ArrayVector::GetEntry(Vector &vector) {
-	const Vector &cvector = vector;
-	return const_cast<Vector &>(ArrayVector::GetEntry(cvector));
+	return GetEntryInternal<Vector>(vector);
 }
 
 idx_t ArrayVector::GetTotalSize(const Vector &vector) {

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

@@ -868,6 +868,8 @@ static bool CombineEqualTypes(const LogicalType &left, const LogicalType &right,
 		// struct: perform recursively on each child
 		auto &left_child_types = StructType::GetChildTypes(left);
 		auto &right_child_types = StructType::GetChildTypes(right);
+		bool left_unnamed = StructType::IsUnnamed(left);
+		auto any_unnamed = left_unnamed || StructType::IsUnnamed(right);
 		if (left_child_types.size() != right_child_types.size()) {
 			// child types are not of equal size, we can't cast
 			// return false
@@ -876,10 +878,15 @@ static bool CombineEqualTypes(const LogicalType &left, const LogicalType &right,
 		child_list_t<LogicalType> child_types;
 		for (idx_t i = 0; i < left_child_types.size(); i++) {
 			LogicalType child_type;
+			// Child names must be in the same order OR either one of the structs must be unnamed
+			if (!any_unnamed && !StringUtil::CIEquals(left_child_types[i].first, right_child_types[i].first)) {
+				return false;
+			}
 			if (!OP::Operation(left_child_types[i].second, right_child_types[i].second, child_type)) {
 				return false;
 			}
-			child_types.emplace_back(left_child_types[i].first, std::move(child_type));
+			auto &child_name = left_unnamed ? right_child_types[i].first : left_child_types[i].first;
+			child_types.emplace_back(child_name, std::move(child_type));
 		}
 		result = LogicalType::STRUCT(child_types);
 		return true;

package/src/duckdb/src/common/vector_operations/comparison_operators.cpp

@@ -90,7 +90,7 @@ bool GreaterThanEquals::Operation(const double &left, const double &right) {
 struct ComparisonSelector {
 	template <typename OP>
 	static idx_t Select(Vector &left, Vector &right, const SelectionVector *sel, idx_t count, SelectionVector *true_sel,
-	                    SelectionVector *false_sel) {
+	                    SelectionVector *false_sel, ValidityMask &null_mask) {
 		throw NotImplementedException("Unknown comparison operation!");
 	}
 };
@@ -98,44 +98,44 @@ struct ComparisonSelector {
 template <>
 inline idx_t ComparisonSelector::Select<duckdb::Equals>(Vector &left, Vector &right, const SelectionVector *sel,
                                                         idx_t count, SelectionVector *true_sel,
-                                                        SelectionVector *false_sel) {
-	return VectorOperations::Equals(left, right, sel, count, true_sel, false_sel);
+                                                        SelectionVector *false_sel, ValidityMask &null_mask) {
+	return VectorOperations::Equals(left, right, sel, count, true_sel, false_sel, &null_mask);
 }
 
 template <>
 inline idx_t ComparisonSelector::Select<duckdb::NotEquals>(Vector &left, Vector &right, const SelectionVector *sel,
                                                            idx_t count, SelectionVector *true_sel,
-                                                           SelectionVector *false_sel) {
-	return VectorOperations::NotEquals(left, right, sel, count, true_sel, false_sel);
+                                                           SelectionVector *false_sel, ValidityMask &null_mask) {
+	return VectorOperations::NotEquals(left, right, sel, count, true_sel, false_sel, &null_mask);
 }
 
 template <>
 inline idx_t ComparisonSelector::Select<duckdb::GreaterThan>(Vector &left, Vector &right, const SelectionVector *sel,
                                                              idx_t count, SelectionVector *true_sel,
-                                                             SelectionVector *false_sel) {
-	return VectorOperations::GreaterThan(left, right, sel, count, true_sel, false_sel);
+                                                             SelectionVector *false_sel, ValidityMask &null_mask) {
+	return VectorOperations::GreaterThan(left, right, sel, count, true_sel, false_sel, &null_mask);
 }
 
 template <>
-inline idx_t ComparisonSelector::Select<duckdb::GreaterThanEquals>(Vector &left, Vector &right,
-                                                                   const SelectionVector *sel, idx_t count,
-                                                                   SelectionVector *true_sel,
-                                                                   SelectionVector *false_sel) {
-	return VectorOperations::GreaterThanEquals(left, right, sel, count, true_sel, false_sel);
+inline idx_t
+ComparisonSelector::Select<duckdb::GreaterThanEquals>(Vector &left, Vector &right, const SelectionVector *sel,
+                                                      idx_t count, SelectionVector *true_sel,
+                                                      SelectionVector *false_sel, ValidityMask &null_mask) {
+	return VectorOperations::GreaterThanEquals(left, right, sel, count, true_sel, false_sel, &null_mask);
 }
 
 template <>
 inline idx_t ComparisonSelector::Select<duckdb::LessThan>(Vector &left, Vector &right, const SelectionVector *sel,
                                                           idx_t count, SelectionVector *true_sel,
-                                                          SelectionVector *false_sel) {
-	return VectorOperations::GreaterThan(right, left, sel, count, true_sel, false_sel);
+                                                          SelectionVector *false_sel, ValidityMask &null_mask) {
+	return VectorOperations::GreaterThan(right, left, sel, count, true_sel, false_sel, &null_mask);
 }
 
 template <>
 inline idx_t ComparisonSelector::Select<duckdb::LessThanEquals>(Vector &left, Vector &right, const SelectionVector *sel,
                                                                 idx_t count, SelectionVector *true_sel,
-                                                                SelectionVector *false_sel) {
-	return VectorOperations::GreaterThanEquals(right, left, sel, count, true_sel, false_sel);
+                                                                SelectionVector *false_sel, ValidityMask &null_mask) {
+	return VectorOperations::GreaterThanEquals(right, left, sel, count, true_sel, false_sel, &null_mask);
 }
 
 static void ComparesNotNull(UnifiedVectorFormat &ldata, UnifiedVectorFormat &rdata, ValidityMask &vresult,
@@ -164,8 +164,9 @@ static void NestedComparisonExecutor(Vector &left, Vector &right, Vector &result
 	if (left_constant && right_constant) {
 		// both sides are constant, and neither is NULL so just compare one element.
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+		auto &result_validity = ConstantVector::Validity(result);
 		SelectionVector true_sel(1);
-		auto match_count = ComparisonSelector::Select<OP>(left, right, nullptr, 1, &true_sel, nullptr);
+		auto match_count = ComparisonSelector::Select<OP>(left, right, nullptr, 1, &true_sel, nullptr, result_validity);
 		auto result_data = ConstantVector::GetData<bool>(result);
 		result_data[0] = match_count > 0;
 		return;
@@ -183,7 +184,8 @@ static void NestedComparisonExecutor(Vector &left, Vector &right, Vector &result
 	}
 	SelectionVector true_sel(count);
 	SelectionVector false_sel(count);
-	idx_t match_count = ComparisonSelector::Select<OP>(left, right, nullptr, count, &true_sel, &false_sel);
+	idx_t match_count =
+	    ComparisonSelector::Select<OP>(left, right, nullptr, count, &true_sel, &false_sel, result_validity);
 
 	for (idx_t i = 0; i < match_count; ++i) {
 		const auto idx = true_sel.get_index(i);

package/src/duckdb/src/common/vector_operations/generators.cpp

@@ -66,7 +66,7 @@ void TemplatedGenerateSequence(Vector &result, idx_t count, const SelectionVecto
 	auto result_data = FlatVector::GetData<T>(result);
 	auto value = (T)start;
 	for (idx_t i = 0; i < count; i++) {
-		auto idx = sel.get_index(i);
+		auto idx = UnsafeNumericCast<int64_t>(sel.get_index(i));
 		result_data[idx] = UnsafeNumericCast<T>(value + increment * idx);
 	}
 }