duckdb 1.0.1-dev22.0 → 1.0.1-dev27.0

package/src/duckdb/src/common/sort/sorted_block.cpp

@@ -25,12 +25,11 @@ idx_t SortedData::Count() {
 }
 
 void SortedData::CreateBlock() {
-	auto capacity =
-	    MaxValue(((idx_t)Storage::BLOCK_SIZE + layout.GetRowWidth() - 1) / layout.GetRowWidth(), state.block_capacity);
+	const auto block_size = buffer_manager.GetBlockSize();
+	auto capacity = MaxValue((block_size + layout.GetRowWidth() - 1) / layout.GetRowWidth(), state.block_capacity);
 	data_blocks.push_back(make_uniq<RowDataBlock>(MemoryTag::ORDER_BY, buffer_manager, capacity, layout.GetRowWidth()));
 	if (!layout.AllConstant() && state.external) {
-		heap_blocks.push_back(
-		    make_uniq<RowDataBlock>(MemoryTag::ORDER_BY, buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1U));
+		heap_blocks.push_back(make_uniq<RowDataBlock>(MemoryTag::ORDER_BY, buffer_manager, block_size, 1U));
 		D_ASSERT(data_blocks.size() == heap_blocks.size());
 	}
 }
@@ -104,8 +103,8 @@ void SortedBlock::InitializeWrite() {
 }
 
 void SortedBlock::CreateBlock() {
-	auto capacity = MaxValue(((idx_t)Storage::BLOCK_SIZE + sort_layout.entry_size - 1) / sort_layout.entry_size,
-	                         state.block_capacity);
+	const auto block_size = buffer_manager.GetBlockSize();
+	auto capacity = MaxValue((block_size + sort_layout.entry_size - 1) / sort_layout.entry_size, state.block_capacity);
 	radix_sorting_data.push_back(
 	    make_uniq<RowDataBlock>(MemoryTag::ORDER_BY, buffer_manager, capacity, sort_layout.entry_size));
 }
@@ -289,12 +288,13 @@ void SBScanState::SetIndices(idx_t block_idx_to, idx_t entry_idx_to) {
 PayloadScanner::PayloadScanner(SortedData &sorted_data, GlobalSortState &global_sort_state, bool flush_p) {
 	auto count = sorted_data.Count();
 	auto &layout = sorted_data.layout;
+	const auto block_size = global_sort_state.buffer_manager.GetBlockSize();
 
 	// Create collections to put the data into so we can use RowDataCollectionScanner
-	rows = make_uniq<RowDataCollection>(global_sort_state.buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1U);
+	rows = make_uniq<RowDataCollection>(global_sort_state.buffer_manager, block_size, 1U);
 	rows->count = count;
 
-	heap = make_uniq<RowDataCollection>(global_sort_state.buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1U);
+	heap = make_uniq<RowDataCollection>(global_sort_state.buffer_manager, block_size, 1U);
 	if (!sorted_data.layout.AllConstant()) {
 		heap->count = count;
 	}
@@ -328,9 +328,10 @@ PayloadScanner::PayloadScanner(GlobalSortState &global_sort_state, idx_t block_i
 	auto &sorted_data = *global_sort_state.sorted_blocks[0]->payload_data;
 	auto count = sorted_data.data_blocks[block_idx]->count;
 	auto &layout = sorted_data.layout;
+	const auto block_size = global_sort_state.buffer_manager.GetBlockSize();
 
 	// Create collections to put the data into so we can use RowDataCollectionScanner
-	rows = make_uniq<RowDataCollection>(global_sort_state.buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1U);
+	rows = make_uniq<RowDataCollection>(global_sort_state.buffer_manager, block_size, 1U);
 	if (flush_p) {
 		rows->blocks.emplace_back(std::move(sorted_data.data_blocks[block_idx]));
 	} else {
@@ -338,7 +339,7 @@ PayloadScanner::PayloadScanner(GlobalSortState &global_sort_state, idx_t block_i
 	}
 	rows->count = count;
 
-	heap = make_uniq<RowDataCollection>(global_sort_state.buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1U);
+	heap = make_uniq<RowDataCollection>(global_sort_state.buffer_manager, block_size, 1U);
 	if (!sorted_data.layout.AllConstant() && sorted_data.swizzled) {
 		if (flush_p) {
 			heap->blocks.emplace_back(std::move(sorted_data.heap_blocks[block_idx]));

package/src/duckdb/src/common/string_util.cpp

@@ -5,6 +5,7 @@
 #include "duckdb/common/to_string.hpp"
 #include "duckdb/common/helper.hpp"
 #include "duckdb/function/scalar/string_functions.hpp"
+#include "jaro_winkler.hpp"
 
 #include <algorithm>
 #include <cctype>
@@ -27,9 +28,8 @@ string StringUtil::GenerateRandomName(idx_t length) {
 	std::uniform_int_distribution<> dis(0, 15);
 
 	std::stringstream ss;
-	ss << std::hex;
 	for (idx_t i = 0; i < length; i++) {
-		ss << dis(gen);
+		ss << "0123456789abcdef"[dis(gen)];
 	}
 	return ss.str();
 }
@@ -212,6 +212,26 @@ string StringUtil::Lower(const string &str) {
 	return (copy);
 }
 
+string StringUtil::Title(const string &str) {
+	string copy;
+	bool first_character = true;
+	for (auto c : str) {
+		bool is_alpha = StringUtil::CharacterIsAlpha(c);
+		if (is_alpha) {
+			if (first_character) {
+				copy += StringUtil::CharacterToUpper(c);
+				first_character = false;
+			} else {
+				copy += StringUtil::CharacterToLower(c);
+			}
+		} else {
+			first_character = true;
+			copy += c;
+		}
+	}
+	return copy;
+}
+
 bool StringUtil::IsLower(const string &str) {
 	return str == Lower(str);
 }
@@ -308,17 +328,17 @@ string StringUtil::Replace(string source, const string &from, const string &to)
 	return source;
 }
 
-vector<string> StringUtil::TopNStrings(vector<pair<string, idx_t>> scores, idx_t n, idx_t threshold) {
+vector<string> StringUtil::TopNStrings(vector<pair<string, double>> scores, idx_t n, double threshold) {
 	if (scores.empty()) {
 		return vector<string>();
 	}
-	sort(scores.begin(), scores.end(), [](const pair<string, idx_t> &a, const pair<string, idx_t> &b) -> bool {
-		return a.second < b.second || (a.second == b.second && a.first.size() < b.first.size());
+	sort(scores.begin(), scores.end(), [](const pair<string, double> &a, const pair<string, double> &b) -> bool {
+		return a.second > b.second || (a.second == b.second && a.first.size() < b.first.size());
 	});
 	vector<string> result;
 	result.push_back(scores[0].first);
 	for (idx_t i = 1; i < MinValue<idx_t>(scores.size(), n); i++) {
-		if (scores[i].second > threshold) {
+		if (scores[i].second < threshold) {
 			break;
 		}
 		result.push_back(scores[i].first);
@@ -326,6 +346,27 @@ vector<string> StringUtil::TopNStrings(vector<pair<string, idx_t>> scores, idx_t
 	return result;
 }
 
+static double NormalizeScore(idx_t score, idx_t max_score) {
+	return 1.0 - static_cast<double>(score) / static_cast<double>(max_score);
+}
+
+vector<string> StringUtil::TopNStrings(const vector<pair<string, idx_t>> &scores, idx_t n, idx_t threshold) {
+	// obtain the max score to normalize
+	idx_t max_score = threshold;
+	for (auto &score : scores) {
+		if (score.second > max_score) {
+			max_score = score.second;
+		}
+	}
+
+	// normalize
+	vector<pair<string, double>> normalized_scores;
+	for (auto &score : scores) {
+		normalized_scores.push_back(make_pair(score.first, NormalizeScore(score.second, max_score)));
+	}
+	return TopNStrings(std::move(normalized_scores), n, NormalizeScore(threshold, max_score));
+}
+
 struct LevenshteinArray {
 	LevenshteinArray(idx_t len1, idx_t len2) : len1(len1) {
 		dist = make_unsafe_uniq_array<idx_t>(len1 * len2);
@@ -385,6 +426,11 @@ idx_t StringUtil::SimilarityScore(const string &s1, const string &s2) {
 	return LevenshteinDistance(s1, s2, 3);
 }
 
+double StringUtil::SimilarityRating(const string &s1, const string &s2) {
+	return duckdb_jaro_winkler::jaro_winkler_similarity(s1.data(), s1.data() + s1.size(), s2.data(),
+	                                                    s2.data() + s2.size());
+}
+
 vector<string> StringUtil::TopNLevenshtein(const vector<string> &strings, const string &target, idx_t n,
                                            idx_t threshold) {
 	vector<pair<string, idx_t>> scores;
@@ -399,6 +445,16 @@ vector<string> StringUtil::TopNLevenshtein(const vector<string> &strings, const
 	return TopNStrings(scores, n, threshold);
 }
 
+vector<string> StringUtil::TopNJaroWinkler(const vector<string> &strings, const string &target, idx_t n,
+                                           double threshold) {
+	vector<pair<string, double>> scores;
+	scores.reserve(strings.size());
+	for (auto &str : strings) {
+		scores.emplace_back(str, SimilarityRating(str, target));
+	}
+	return TopNStrings(scores, n, threshold);
+}
+
 string StringUtil::CandidatesMessage(const vector<string> &candidates, const string &candidate) {
 	string result_str;
 	if (!candidates.empty()) {
@@ -472,8 +528,8 @@ string StringUtil::ToJSONMap(ExceptionType type, const string &message, const un
 
 	yyjson_write_err err;
 	size_t len;
-	yyjson_write_flag flags = YYJSON_WRITE_ALLOW_INVALID_UNICODE;
-	const char *json = yyjson_mut_write_opts(doc, flags, nullptr, &len, &err);
+	constexpr yyjson_write_flag flags = YYJSON_WRITE_ALLOW_INVALID_UNICODE;
+	char *json = yyjson_mut_write_opts(doc, flags, nullptr, &len, &err);
 	if (!json) {
 		yyjson_mut_doc_free(doc);
 		throw SerializationException("Failed to write JSON string: %s", err.msg);
@@ -482,7 +538,7 @@ string StringUtil::ToJSONMap(ExceptionType type, const string &message, const un
 	string result(json, len);
 
 	// Free the JSON and the document
-	free((void *)json);
+	free(json);
 	yyjson_mut_doc_free(doc);
 
 	// Return the result
@@ -537,7 +593,6 @@ string StringUtil::GetFileStem(const string &file_name) {
 }
 
 string StringUtil::GetFilePath(const string &file_path) {
-
 	// Trim the trailing slashes
 	auto end = file_path.size() - 1;
 	while (end > 0 && (file_path[end] == '/' || file_path[end] == '\\')) {
@@ -556,4 +611,106 @@ string StringUtil::GetFilePath(const string &file_path) {
 	return file_path.substr(0, pos + 1);
 }
 
+struct URLEncodeLength {
+	using RESULT_TYPE = idx_t;
+
+	static void ProcessCharacter(idx_t &result, char) {
+		result++;
+	}
+
+	static void ProcessHex(idx_t &result, const char *, idx_t) {
+		result++;
+	}
+};
+
+struct URLEncodeWrite {
+	using RESULT_TYPE = char *;
+
+	static void ProcessCharacter(char *&result, char c) {
+		*result = c;
+		result++;
+	}
+
+	static void ProcessHex(char *&result, const char *input, idx_t idx) {
+		uint32_t hex_first = StringUtil::GetHexValue(input[idx + 1]);
+		uint32_t hex_second = StringUtil::GetHexValue(input[idx + 2]);
+		uint32_t hex_value = (hex_first << 4) + hex_second;
+		ProcessCharacter(result, static_cast<char>(hex_value));
+	}
+};
+
+template <class OP>
+void URLEncodeInternal(const char *input, idx_t input_size, typename OP::RESULT_TYPE &result, bool encode_slash) {
+	// https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html
+	static const char *HEX_DIGIT = "0123456789ABCDEF";
+	for (idx_t i = 0; i < input_size; i++) {
+		char ch = input[i];
+		if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9') || ch == '_' ||
+		    ch == '-' || ch == '~' || ch == '.') {
+			OP::ProcessCharacter(result, ch);
+		} else if (ch == '/' && !encode_slash) {
+			OP::ProcessCharacter(result, ch);
+		} else {
+			OP::ProcessCharacter(result, '%');
+			OP::ProcessCharacter(result, HEX_DIGIT[static_cast<unsigned char>(ch) >> 4]);
+			OP::ProcessCharacter(result, HEX_DIGIT[static_cast<unsigned char>(ch) & 15]);
+		}
+	}
+}
+
+idx_t StringUtil::URLEncodeSize(const char *input, idx_t input_size, bool encode_slash) {
+	idx_t result_length = 0;
+	URLEncodeInternal<URLEncodeLength>(input, input_size, result_length, encode_slash);
+	return result_length;
+}
+
+void StringUtil::URLEncodeBuffer(const char *input, idx_t input_size, char *output, bool encode_slash) {
+	URLEncodeInternal<URLEncodeWrite>(input, input_size, output, encode_slash);
+}
+
+string StringUtil::URLEncode(const string &input, bool encode_slash) {
+	idx_t result_size = URLEncodeSize(input.c_str(), input.size(), encode_slash);
+	auto result_data = make_uniq_array<char>(result_size);
+	URLEncodeBuffer(input.c_str(), input.size(), result_data.get(), encode_slash);
+	return string(result_data.get(), result_size);
+}
+
+template <class OP>
+void URLDecodeInternal(const char *input, idx_t input_size, typename OP::RESULT_TYPE &result, bool plus_to_space) {
+	for (idx_t i = 0; i < input_size; i++) {
+		char ch = input[i];
+		if (plus_to_space && ch == '+') {
+			OP::ProcessCharacter(result, ' ');
+		} else if (ch == '%' && i + 2 < input_size && StringUtil::CharacterIsHex(input[i + 1]) &&
+		           StringUtil::CharacterIsHex(input[i + 2])) {
+			OP::ProcessHex(result, input, i);
+			i += 2;
+		} else {
+			OP::ProcessCharacter(result, ch);
+		}
+	}
+}
+
+idx_t StringUtil::URLDecodeSize(const char *input, idx_t input_size, bool plus_to_space) {
+	idx_t result_length = 0;
+	URLDecodeInternal<URLEncodeLength>(input, input_size, result_length, plus_to_space);
+	return result_length;
+}
+
+void StringUtil::URLDecodeBuffer(const char *input, idx_t input_size, char *output, bool plus_to_space) {
+	char *output_start = output;
+	URLDecodeInternal<URLEncodeWrite>(input, input_size, output, plus_to_space);
+	if (!Utf8Proc::IsValid(output_start, NumericCast<idx_t>(output - output_start))) {
+		throw InvalidInputException("Failed to decode string \"%s\" using URL decoding - decoded value is invalid UTF8",
+		                            string(input, input_size));
+	}
+}
+
+string StringUtil::URLDecode(const string &input, bool plus_to_space) {
+	idx_t result_size = URLDecodeSize(input.c_str(), input.size(), plus_to_space);
+	auto result_data = make_uniq_array<char>(result_size);
+	URLDecodeBuffer(input.c_str(), input.size(), result_data.get(), plus_to_space);
+	return string(result_data.get(), result_size);
+}
+
 } // namespace duckdb

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

@@ -0,0 +1,108 @@
+#include "duckdb/common/tree_renderer/graphviz_tree_renderer.hpp"
+
+#include "duckdb/common/pair.hpp"
+#include "duckdb/common/string_util.hpp"
+#include "duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp"
+#include "duckdb/execution/operator/join/physical_delim_join.hpp"
+#include "duckdb/execution/operator/scan/physical_positional_scan.hpp"
+#include "duckdb/execution/physical_operator.hpp"
+#include "duckdb/parallel/pipeline.hpp"
+#include "duckdb/planner/logical_operator.hpp"
+#include "duckdb/main/query_profiler.hpp"
+#include "utf8proc_wrapper.hpp"
+
+#include <sstream>
+
+namespace duckdb {
+
+string GRAPHVIZTreeRenderer::ToString(const LogicalOperator &op) {
+	std::stringstream ss;
+	Render(op, ss);
+	return ss.str();
+}
+
+string GRAPHVIZTreeRenderer::ToString(const PhysicalOperator &op) {
+	std::stringstream ss;
+	Render(op, ss);
+	return ss.str();
+}
+
+string GRAPHVIZTreeRenderer::ToString(const ProfilingNode &op) {
+	std::stringstream ss;
+	Render(op, ss);
+	return ss.str();
+}
+
+string GRAPHVIZTreeRenderer::ToString(const Pipeline &op) {
+	std::stringstream ss;
+	Render(op, ss);
+	return ss.str();
+}
+
+void GRAPHVIZTreeRenderer::Render(const LogicalOperator &op, std::ostream &ss) {
+	auto tree = RenderTree::CreateRenderTree(op);
+	ToStream(*tree, ss);
+}
+
+void GRAPHVIZTreeRenderer::Render(const PhysicalOperator &op, std::ostream &ss) {
+	auto tree = RenderTree::CreateRenderTree(op);
+	ToStream(*tree, ss);
+}
+
+void GRAPHVIZTreeRenderer::Render(const ProfilingNode &op, std::ostream &ss) {
+	auto tree = RenderTree::CreateRenderTree(op);
+	ToStream(*tree, ss);
+}
+
+void GRAPHVIZTreeRenderer::Render(const Pipeline &op, std::ostream &ss) {
+	auto tree = RenderTree::CreateRenderTree(op);
+	ToStream(*tree, ss);
+}
+
+void GRAPHVIZTreeRenderer::ToStreamInternal(RenderTree &root, std::ostream &ss) {
+	const string digraph_format = R"(
+digraph G {
+    node [shape=box, style=rounded, fontname="Courier New", fontsize=10];
+%s
+%s
+}
+	)";
+
+	vector<string> nodes;
+	vector<string> edges;
+
+	const string node_format = R"(    node_%d_%d [label="%s"];)";
+
+	for (idx_t y = 0; y < root.height; y++) {
+		for (idx_t x = 0; x < root.width; x++) {
+			auto node = root.GetNode(x, y);
+			if (!node) {
+				continue;
+			}
+
+			// Create Node
+			vector<string> body;
+			body.push_back(node->name);
+			for (auto &item : node->extra_text) {
+				auto &key = item.first;
+				auto &value_raw = item.second;
+
+				auto value = QueryProfiler::JSONSanitize(value_raw);
+				body.push_back(StringUtil::Format("%s:\\n%s", key, value));
+			}
+			nodes.push_back(StringUtil::Format(node_format, x, y, StringUtil::Join(body, "\\n───\\n")));
+
+			// Create Edge(s)
+			for (auto &coord : node->child_positions) {
+				edges.push_back(StringUtil::Format("    node_%d_%d -> node_%d_%d;", x, y, coord.x, coord.y));
+			}
+		}
+	}
+	auto node_lines = StringUtil::Join(nodes, "\n");
+	auto edge_lines = StringUtil::Join(edges, "\n");
+
+	string result = StringUtil::Format(digraph_format, node_lines, edge_lines);
+	ss << result;
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,267 @@
+#include "duckdb/common/tree_renderer/html_tree_renderer.hpp"
+
+#include "duckdb/common/pair.hpp"
+#include "duckdb/common/string_util.hpp"
+#include "duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp"
+#include "duckdb/execution/operator/join/physical_delim_join.hpp"
+#include "duckdb/execution/operator/scan/physical_positional_scan.hpp"
+#include "duckdb/execution/physical_operator.hpp"
+#include "duckdb/parallel/pipeline.hpp"
+#include "duckdb/planner/logical_operator.hpp"
+#include "utf8proc_wrapper.hpp"
+
+#include <sstream>
+
+namespace duckdb {
+
+string HTMLTreeRenderer::ToString(const LogicalOperator &op) {
+	std::stringstream ss;
+	Render(op, ss);
+	return ss.str();
+}
+
+string HTMLTreeRenderer::ToString(const PhysicalOperator &op) {
+	std::stringstream ss;
+	Render(op, ss);
+	return ss.str();
+}
+
+string HTMLTreeRenderer::ToString(const ProfilingNode &op) {
+	std::stringstream ss;
+	Render(op, ss);
+	return ss.str();
+}
+
+string HTMLTreeRenderer::ToString(const Pipeline &op) {
+	std::stringstream ss;
+	Render(op, ss);
+	return ss.str();
+}
+
+void HTMLTreeRenderer::Render(const LogicalOperator &op, std::ostream &ss) {
+	auto tree = RenderTree::CreateRenderTree(op);
+	ToStream(*tree, ss);
+}
+
+void HTMLTreeRenderer::Render(const PhysicalOperator &op, std::ostream &ss) {
+	auto tree = RenderTree::CreateRenderTree(op);
+	ToStream(*tree, ss);
+}
+
+void HTMLTreeRenderer::Render(const ProfilingNode &op, std::ostream &ss) {
+	auto tree = RenderTree::CreateRenderTree(op);
+	ToStream(*tree, ss);
+}
+
+void HTMLTreeRenderer::Render(const Pipeline &op, std::ostream &ss) {
+	auto tree = RenderTree::CreateRenderTree(op);
+	ToStream(*tree, ss);
+}
+
+static string CreateStyleSection(RenderTree &root) {
+	return R"(
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+        }
+
+        .tf-tree .tf-nc {
+            padding: 0px;
+            border: 1px solid #E5E5E5;
+        }
+
+        .tf-nc {
+            border-radius: 0.5rem;
+            padding: 0px;
+            min-width: 150px;
+            width: auto;
+            background-color: #FAFAFA;
+            text-align: center;
+            position: relative;
+        }
+
+        .collapse_button {
+            position:relative;
+            color: black;
+            z-index: 2;
+            width: 2em;
+            background-color: white;
+            height: 2em;
+            border-radius: 50%;
+            top: 2.25em;
+        }
+
+        .collapse_button:hover {
+            background-color: #f0f0f0; /* Light gray */
+        }
+
+        .collapse_button:active {
+            background-color: #e0e0e0; /* Slightly darker gray */
+        }
+
+        .hidden {
+            display: none !important;
+        }
+
+        .title {
+            font-weight: bold;
+            padding-bottom: 5px;
+            color: #fff100;
+            box-sizing: border-box;
+            background-color: black;
+            border-top-left-radius: 0.5rem;
+            border-top-right-radius: 0.5rem;
+            padding: 10px;
+        }
+
+        .content {
+            border-top: 1px solid #000;
+            text-align: center;
+            border-bottom-left-radius: 0.5rem;
+            border-bottom-right-radius: 0.5rem;
+            padding: 10px;
+        }
+
+        .sub-title {
+            color: black;
+            font-weight: bold;
+            padding-top: 5px;
+        }
+
+        .sub-title:not(:first-child) {
+            border-top: 1px solid #ADADAD;
+        }
+
+        .value {
+            margin-left: 10px;
+            margin-top: 5px;
+            color: #3B3B3B;
+            margin-bottom: 5px;
+        }
+
+        .tf-tree {
+            width: 100%;
+            height: 100%;
+            overflow: visible;
+        }
+    </style>
+    )";
+}
+
+static string CreateHeadSection(RenderTree &root) {
+	string head_section = R"(
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <link rel="stylesheet" href="https://unpkg.com/treeflex/dist/css/treeflex.css">
+    <title>DuckDB Query Plan</title>
+    %s
+</head>
+    )";
+	return StringUtil::Format(head_section, CreateStyleSection(root));
+}
+
+static string CreateGridItemContent(RenderTreeNode &node) {
+	const string content_format = R"(
+            <div class="content">
+%s
+            </div>
+    )";
+
+	vector<string> items;
+	for (auto &item : node.extra_text) {
+		auto &key = item.first;
+		auto &value = item.second;
+		if (value.empty()) {
+			continue;
+		}
+		items.push_back(StringUtil::Format(R"(                <div class="sub-title">%s</div>)", key));
+		auto splits = StringUtil::Split(value, "\n");
+		for (auto &split : splits) {
+			items.push_back(StringUtil::Format(R"(                <div class="value">%s</div>)", split));
+		}
+	}
+	string result;
+	if (!items.empty()) {
+		result = StringUtil::Format(content_format, StringUtil::Join(items, "\n"));
+	}
+	if (!node.child_positions.empty()) {
+		result += "<button class=\"collapse_button\", onclick=\"toggleDisplay(this)\">-</button>";
+	}
+	return result;
+}
+
+static string CreateGridItem(RenderTree &root, idx_t x, idx_t y) {
+	const string grid_item_format = R"(
+        <div class="tf-nc">
+            <div class="title">%s</div>%s
+        </div>
+    )";
+
+	auto node = root.GetNode(x, y);
+	if (!node) {
+		return "";
+	}
+
+	auto title = node->name;
+	auto content = CreateGridItemContent(*node);
+	return StringUtil::Format(grid_item_format, title, content);
+}
+
+static string CreateTreeRecursive(RenderTree &root, idx_t x, idx_t y) {
+	string result;
+
+	result += "<li>";
+	result += CreateGridItem(root, x, y);
+	auto node = root.GetNode(x, y);
+	if (!node->child_positions.empty()) {
+		result += "<ul class=\"list-inline\">";
+		for (auto &coord : node->child_positions) {
+			result += CreateTreeRecursive(root, coord.x, coord.y);
+		}
+		result += "</ul>";
+	}
+	result += "</li>";
+	return result;
+}
+
+static string CreateBodySection(RenderTree &root) {
+	const string body_section = R"(
+<body>
+    <div class="tf-tree">
+        <ul>%s</ul>
+    </div>
+
+<script>
+function toggleDisplay(button) {
+    const parentLi = button.closest('li');
+    const nestedUl = parentLi.querySelector('ul');
+    if (nestedUl) {
+        const currentDisplay = getComputedStyle(nestedUl).getPropertyValue('display');
+        if (currentDisplay === 'none') {
+            nestedUl.classList.toggle('hidden');
+            button.textContent = '-';
+        } else {
+            nestedUl.classList.toggle('hidden');
+            button.textContent = '+';
+        }
+    }
+}
+</script>
+
+</body>
+</html>
+    )";
+	return StringUtil::Format(body_section, CreateTreeRecursive(root, 0, 0));
+}
+
+void HTMLTreeRenderer::ToStreamInternal(RenderTree &root, std::ostream &ss) {
+	string result;
+	result += CreateHeadSection(root);
+	result += CreateBodySection(root);
+	ss << result;
+}
+
+} // namespace duckdb