duckdb 1.3.2 → 1.3.3-dev4.0

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

@@ -538,6 +538,46 @@ string StringUtil::CandidatesErrorMessage(const vector<string> &strings, const s
 	return StringUtil::CandidatesMessage(closest_strings, message_prefix);
 }
 
+static unique_ptr<ComplexJSON> ParseJSON(const string &json, yyjson_doc *doc, yyjson_val *root, bool ignore_errors) {
+	auto result = make_uniq<ComplexJSON>();
+	switch (yyjson_get_tag(root)) {
+	case YYJSON_TYPE_ARR | YYJSON_SUBTYPE_NONE: {
+		size_t idx, max;
+		yyjson_val *val;
+		yyjson_arr_foreach(root, idx, max, val) {
+			result->AddArrayElement(ParseJSON(json, doc, val, ignore_errors));
+		}
+		return result;
+	}
+	case YYJSON_TYPE_OBJ | YYJSON_SUBTYPE_NONE: {
+		size_t idx, max;
+		yyjson_val *key, *value;
+		yyjson_obj_foreach(root, idx, max, key, value) {
+			const auto key_val = yyjson_get_str(key);
+			const auto key_len = yyjson_get_len(key);
+			result->AddObjectEntry(string(key_val, key_len), ParseJSON(json, doc, value, ignore_errors));
+		}
+		return result;
+	}
+	case YYJSON_TYPE_STR | YYJSON_SUBTYPE_NOESC:
+	case YYJSON_TYPE_STR | YYJSON_SUBTYPE_NONE: {
+		// Since this is a string, we can directly add the value
+		const auto value_val = yyjson_get_str(root);
+		const auto value_len = yyjson_get_len(root);
+		return make_uniq<ComplexJSON>(string(value_val, value_len));
+	}
+	case YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_TRUE:
+	case YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_FALSE: {
+		// boolean values
+		const bool bool_val = yyjson_get_bool(root);
+		return make_uniq<ComplexJSON>(bool_val ? "true" : "false");
+	}
+	default:
+		yyjson_doc_free(doc);
+		throw SerializationException("Failed to parse JSON string: %s", json);
+	}
+}
+
 unique_ptr<ComplexJSON> StringUtil::ParseJSONMap(const string &json, bool ignore_errors) {
 	auto result = make_uniq<ComplexJSON>(json);
 	if (json.empty()) {
@@ -559,48 +599,8 @@ unique_ptr<ComplexJSON> StringUtil::ParseJSONMap(const string &json, bool ignore
 		}
 		throw SerializationException("Failed to parse JSON string: %s", json);
 	}
-	yyjson_obj_iter iter;
-	yyjson_obj_iter_init(root, &iter);
-	yyjson_val *key, *value;
-	while ((key = yyjson_obj_iter_next(&iter))) {
-		value = yyjson_obj_iter_get_val(key);
-		const auto key_val = yyjson_get_str(key);
-		const auto key_len = yyjson_get_len(key);
-		auto type = yyjson_get_type(value);
-		if (type == YYJSON_TYPE_STR) {
-			// Since this is a string, we can directly add the value
-			const auto value_val = yyjson_get_str(value);
-			const auto value_len = yyjson_get_len(value);
-			result->AddObject(string(key_val, key_len), make_uniq<ComplexJSON>(string(value_val, value_len)));
-		} else if (type == YYJSON_TYPE_BOOL) {
-			// boolean values
-			bool bool_val = yyjson_get_bool(value);
-			result->AddObject(string(key_val, key_len), make_uniq<ComplexJSON>(bool_val ? "true" : "false"));
-		} else if (type == YYJSON_TYPE_OBJ) {
-			// We recurse, this is a complex json
-			// Convert the object value to a JSON string and recurse
-			size_t json_str_len;
-			char *json_str = yyjson_val_write(value, 0, &json_str_len);
-			if (json_str) {
-				auto nested_result = ParseJSONMap(string(json_str, json_str_len), ignore_errors);
-				result->AddObject(string(key_val, key_len), std::move(nested_result));
-				free(json_str); // Clean up the allocated string
-			} else {
-				yyjson_doc_free(doc);
-				if (ignore_errors) {
-					return result;
-				}
-				throw SerializationException("Failed to stringify nested JSON object");
-			}
-		} else {
-			// Anything else is invalid.
-			yyjson_doc_free(doc);
-			if (ignore_errors) {
-				return result;
-			}
-			throw SerializationException("Failed to parse JSON string: %s", json);
-		}
-	}
+
+	result = ParseJSON(json, doc, root, ignore_errors);
 	yyjson_doc_free(doc);
 	return result;
 }
@@ -642,7 +642,7 @@ string StringUtil::ToJSONMap(const unordered_map<string, string> &map) {
 }
 
 string ComplexJSON::GetValue(const string &key) const {
-	if (is_object) {
+	if (type == ComplexJSONType::OBJECT) {
 		if (obj_value.find(key) != obj_value.end()) {
 			return GetValueRecursive(*obj_value.at(key));
 		}
@@ -651,8 +651,18 @@ string ComplexJSON::GetValue(const string &key) const {
 	return "";
 }
 
+string ComplexJSON::GetValue(const idx_t &index) const {
+	if (type == ComplexJSONType::ARRAY) {
+		if (index >= arr_value.size()) {
+			return "";
+		}
+		return GetValueRecursive(*arr_value[index]);
+	}
+	return "";
+}
+
 string ComplexJSON::GetValueRecursive(const ComplexJSON &child) {
-	if (child.is_object) {
+	if (child.type == ComplexJSONType::OBJECT) {
 		// We have to construct the nested json
 		yyjson_mut_doc *doc = yyjson_mut_doc_new(nullptr);
 		yyjson_mut_val *root = yyjson_mut_obj(doc);
@@ -664,6 +674,16 @@ string ComplexJSON::GetValueRecursive(const ComplexJSON &child) {
 			yyjson_mut_obj_add(root, key, value);
 		}
 		return WriteJsonToString(doc);
+	} else if (child.type == ComplexJSONType::ARRAY) {
+		yyjson_mut_doc *doc = yyjson_mut_doc_new(nullptr);
+		yyjson_mut_val *root = yyjson_mut_arr(doc);
+		yyjson_mut_doc_set_root(doc, root);
+		for (const auto &elem : child.arr_value) {
+			auto value_str = GetValueRecursive(*elem);
+			auto value = yyjson_mut_strncpy(doc, value_str.c_str(), value_str.size());
+			yyjson_mut_arr_append(root, value);
+		}
+		return WriteJsonToString(doc);
 	} else {
 		// simple string we can just write
 		return child.str_value;

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

@@ -160,6 +160,41 @@ string AdjustTextForRendering(string source, idx_t max_render_width) {
 	return string(half_spaces + extra_left_space, ' ') + source + string(half_spaces, ' ');
 }
 
+string TextTreeRenderer::FormatNumber(const string &input) {
+	if (config.decimal_separator == '\0' && config.thousand_separator == '\0') {
+		// no thousand separator
+		return input;
+	}
+	// first check how many digits there are (preceding any decimal point)
+	idx_t character_count = 0;
+	for (auto c : input) {
+		if (!StringUtil::CharacterIsDigit(c)) {
+			break;
+		}
+		character_count++;
+	}
+	// find the position of the first thousand separator
+	idx_t separator_position = character_count % 3 == 0 ? 3 : character_count % 3;
+	// now add the thousand separators
+	string result;
+	for (idx_t c = 0; c < character_count; c++) {
+		if (c == separator_position && config.thousand_separator != '\0') {
+			result += config.thousand_separator;
+			separator_position += 3;
+		}
+		result += input[c];
+	}
+	// add any remaining characters
+	for (idx_t c = character_count; c < input.size(); c++) {
+		if (input[c] == '.' && config.decimal_separator != '\0') {
+			result += config.decimal_separator;
+		} else {
+			result += input[c];
+		}
+	}
+	return result;
+}
+
 void TextTreeRenderer::RenderBoxContent(RenderTree &root, std::ostream &ss, idx_t y) {
 	// we first need to figure out how high our boxes are going to be
 	vector<vector<string>> extra_info;
@@ -246,7 +281,7 @@ void TextTreeRenderer::RenderBoxContent(RenderTree &root, std::ostream &ss, idx_
 				if (render_y + 1 == extra_height && render_text.empty()) {
 					auto entry = node->extra_text.find(RenderTreeNode::CARDINALITY);
 					if (entry != node->extra_text.end()) {
-						render_text = entry->second + " Rows";
+						render_text = FormatNumber(entry->second) + " row" + (entry->second == "1" ? "" : "s");
 					}
 				}
 				if (render_y == extra_height && render_text.empty()) {
@@ -257,14 +292,16 @@ void TextTreeRenderer::RenderBoxContent(RenderTree &root, std::ostream &ss, idx_
 						// we only render estimated cardinality if there is no real cardinality
 						auto entry = node->extra_text.find(RenderTreeNode::ESTIMATED_CARDINALITY);
 						if (entry != node->extra_text.end()) {
-							render_text = "~" + entry->second + " Rows";
+							render_text =
+							    "~" + FormatNumber(entry->second) + " row" + (entry->second == "1" ? "" : "s");
 						}
 					}
 					if (node->extra_text.find(RenderTreeNode::CARDINALITY) == node->extra_text.end()) {
 						// we only render estimated cardinality if there is no real cardinality
 						auto entry = node->extra_text.find(RenderTreeNode::ESTIMATED_CARDINALITY);
 						if (entry != node->extra_text.end()) {
-							render_text = "~" + entry->second + " Rows";
+							render_text =
+							    "~" + FormatNumber(entry->second) + " row" + (entry->second == "1" ? "" : "s");
 						}
 					}
 				}

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

@@ -0,0 +1,144 @@
+#include "duckdb/common/tree_renderer/yaml_tree_renderer.hpp"
+
+#include "duckdb/common/string_util.hpp"
+#include "duckdb/common/typedefs.hpp"
+#include "duckdb/execution/physical_operator.hpp"
+#include "duckdb/parallel/pipeline.hpp"
+#include "duckdb/planner/logical_operator.hpp"
+#include "fmt/printf.h"
+
+#include <ostream>
+#include <sstream>
+
+namespace duckdb {
+
+string YAMLTreeRenderer::ToString(const LogicalOperator &op) {
+	std::stringstream ss;
+	Render(op, ss);
+	return ss.str();
+}
+
+string YAMLTreeRenderer::ToString(const PhysicalOperator &op) {
+	std::stringstream ss;
+	Render(op, ss);
+	return ss.str();
+}
+
+string YAMLTreeRenderer::ToString(const ProfilingNode &op) {
+	std::stringstream ss;
+	Render(op, ss);
+	return ss.str();
+}
+
+string YAMLTreeRenderer::ToString(const Pipeline &op) {
+	std::stringstream ss;
+	Render(op, ss);
+	return ss.str();
+}
+
+void YAMLTreeRenderer::Render(const LogicalOperator &op, std::ostream &ss) {
+	auto tree = RenderTree::CreateRenderTree(op);
+	ToStream(*tree, ss);
+}
+
+void YAMLTreeRenderer::Render(const PhysicalOperator &op, std::ostream &ss) {
+	auto tree = RenderTree::CreateRenderTree(op);
+	ToStream(*tree, ss);
+}
+
+void YAMLTreeRenderer::Render(const ProfilingNode &op, std::ostream &ss) {
+	auto tree = RenderTree::CreateRenderTree(op);
+	ToStream(*tree, ss);
+}
+
+void YAMLTreeRenderer::Render(const Pipeline &op, std::ostream &ss) {
+	auto tree = RenderTree::CreateRenderTree(op);
+	ToStream(*tree, ss);
+}
+
+void YAMLTreeRenderer::ToStreamInternal(RenderTree &root, std::ostream &ss) {
+	RenderRecursive(root, ss, 0, 0, 0);
+}
+
+struct EscapedString {
+	explicit EscapedString(const string &str) : str(str) {};
+	const string &str;
+};
+
+std::ostream &operator<<(std::ostream &out, const EscapedString &es) {
+	out << '"';
+
+	// escape
+	for (auto &ch : es.str) {
+		switch (ch) {
+		case '\b':
+			out << "\\b";
+			break;
+		case '\f':
+			out << "\\f";
+			break;
+		case '\n':
+			out << "\\n";
+			break;
+		case '\r':
+			out << "\\r";
+			break;
+		case '\t':
+			out << "\\t";
+			break;
+		case '"':
+			out << "\\\"";
+			break;
+		case '\\':
+			out << "\\\\";
+			break;
+		default:
+			if ((unsigned char)ch < ' ') {
+				out << duckdb_fmt::sprintf("\\u%04x", (int)ch);
+			} else {
+				out << ch;
+			}
+			break;
+		}
+	}
+
+	out << '"';
+	return out;
+}
+
+void YAMLTreeRenderer::RenderRecursive(RenderTree &node, std::ostream &ss, idx_t indent, idx_t x, idx_t y) {
+	auto node_p = node.GetNode(x, y);
+	D_ASSERT(node_p);
+	auto &current_node = *node_p;
+
+	ss << string(indent, ' ') << "- name: " << EscapedString(current_node.name) << '\n';
+
+	indent += 2; // rest attributes should align with leading "- "
+
+	if (!current_node.extra_text.empty()) {
+		for (const auto &info : current_node.extra_text) {
+			auto &key = info.first;
+			auto &value = info.second;
+			auto splits = StringUtil::Split(value, "\n");
+			ss << string(indent, ' ') << EscapedString(key) << ":";
+			if (splits.size() > 1) { // list
+				ss << '\n';
+				for (const auto &split : splits) {
+					ss << string(indent + 2, ' ') << "- " << EscapedString(split) << '\n';
+				}
+			} else {
+				ss << ' ' << EscapedString(value) << '\n';
+			}
+		}
+	}
+
+	// Render children
+	if (!current_node.child_positions.empty()) {
+		ss << string(indent, ' ') << "children: \n";
+		for (const auto &child_pos : current_node.child_positions) {
+			RenderRecursive(node, ss, indent + 2, child_pos.x, child_pos.y);
+		}
+	}
+}
+
+} // namespace duckdb

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

@@ -3,6 +3,7 @@
 #include "duckdb/common/tree_renderer/json_tree_renderer.hpp"
 #include "duckdb/common/tree_renderer/html_tree_renderer.hpp"
 #include "duckdb/common/tree_renderer/graphviz_tree_renderer.hpp"
+#include "duckdb/common/tree_renderer/yaml_tree_renderer.hpp"
 
 #include <sstream>
 
@@ -19,6 +20,8 @@ unique_ptr<TreeRenderer> TreeRenderer::CreateRenderer(ExplainFormat format) {
 		return make_uniq<HTMLTreeRenderer>();
 	case ExplainFormat::GRAPHVIZ:
 		return make_uniq<GRAPHVIZTreeRenderer>();
+	case ExplainFormat::YAML:
+		return make_uniq<YAMLTreeRenderer>();
 	default:
 		throw NotImplementedException("ExplainFormat %s not implemented", EnumUtil::ToString(format));
 	}