duckdb 0.3.3-dev255.0 → 0.3.3-dev332.0

package/src/duckdb.hpp

@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "39eec4822"
-#define DUCKDB_VERSION "v0.3.3-dev255"
+#define DUCKDB_SOURCE_ID "618e5518a"
+#define DUCKDB_VERSION "v0.3.3-dev332"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -2784,6 +2784,8 @@ public:
 	DUCKDB_API hash_t Hash() const;
 	//! Convert this value to a string
 	DUCKDB_API string ToString() const;
+	//! Convert this value to a SQL-parseable string
+	DUCKDB_API string ToSQLString() const;
 
 	DUCKDB_API uintptr_t GetPointer() const;
 
@@ -5552,6 +5554,9 @@ public:
 		}
 		return c;
 	}
+	DUCKDB_API static char CharacterIsAlpha(char c) {
+		return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
+	}
 
 	//! Returns true if the needle string exists in the haystack
 	DUCKDB_API static bool Contains(const string &haystack, const string &needle);
@@ -5993,6 +5998,157 @@ public:
 	bool operator==(const BaseExpression &rhs) {
 		return this->Equals(&rhs);
 	}
+
+	virtual void Verify() const;
+};
+
+} // namespace duckdb
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/qualified_name.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/keyword_helper.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+class KeywordHelper {
+public:
+	//! Returns true if the given text matches a keyword of the parser
+	static bool IsKeyword(const string &text);
+
+	//! Returns true if the given string needs to be quoted when written as an identifier
+	static bool RequiresQuotes(const string &text);
+
+	//! Writes a string that is optionally quoted + escaped so it can be used as an identifier
+	static string WriteOptionallyQuoted(const string &text);
+};
+
+} // namespace duckdb
+
+
+
+namespace duckdb {
+
+struct QualifiedName {
+	string schema;
+	string name;
+
+	//! Parse the (optional) schema and a name from a string in the format of e.g. "schema"."table"; if there is no dot
+	//! the schema will be set to INVALID_SCHEMA
+	static QualifiedName Parse(const string &input) {
+		string schema;
+		string name;
+		idx_t idx = 0;
+		vector<string> entries;
+		string entry;
+	normal:
+		//! quote
+		for (; idx < input.size(); idx++) {
+			if (input[idx] == '"') {
+				idx++;
+				goto quoted;
+			} else if (input[idx] == '.') {
+				goto separator;
+			}
+			entry += input[idx];
+		}
+		goto end;
+	separator:
+		entries.push_back(entry);
+		entry = "";
+		idx++;
+		goto normal;
+	quoted:
+		//! look for another quote
+		for (; idx < input.size(); idx++) {
+			if (input[idx] == '"') {
+				//! unquote
+				idx++;
+				goto normal;
+			}
+			entry += input[idx];
+		}
+		throw ParserException("Unterminated quote in qualified name!");
+	end:
+		if (entries.empty()) {
+			schema = INVALID_SCHEMA;
+			name = entry;
+		} else if (entries.size() == 1) {
+			schema = entries[0];
+			name = entry;
+		} else {
+			throw ParserException("Expected schema.entry or entry: too many entries found");
+		}
+		return QualifiedName {schema, name};
+	}
+};
+
+struct QualifiedColumnName {
+	QualifiedColumnName() {
+	}
+	QualifiedColumnName(string table_p, string column_p) : table(move(table_p)), column(move(column_p)) {
+	}
+
+	string schema;
+	string table;
+	string column;
+};
+
+} // namespace duckdb
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/expression_util.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+class ParsedExpression;
+class Expression;
+
+class ExpressionUtil {
+public:
+	//! ListEquals: check if a list of two expressions is equal (order is important)
+	static bool ListEquals(const vector<unique_ptr<ParsedExpression>> &a,
+	                       const vector<unique_ptr<ParsedExpression>> &b);
+	static bool ListEquals(const vector<unique_ptr<Expression>> &a, const vector<unique_ptr<Expression>> &b);
+	//! SetEquals: check if two sets of expressions are equal (order is not important)
+	static bool SetEquals(const vector<unique_ptr<ParsedExpression>> &a, const vector<unique_ptr<ParsedExpression>> &b);
+	static bool SetEquals(const vector<unique_ptr<Expression>> &a, const vector<unique_ptr<Expression>> &b);
+
+private:
+	template <class T>
+	static bool ExpressionListEquals(const vector<unique_ptr<T>> &a, const vector<unique_ptr<T>> &b);
+	template <class T>
+	static bool ExpressionSetEquals(const vector<unique_ptr<T>> &a, const vector<unique_ptr<T>> &b);
 };
 
 } // namespace duckdb
@@ -8596,42 +8752,32 @@ namespace duckdb {
 //! A ResultModifier
 class BoundResultModifier {
 public:
-	explicit BoundResultModifier(ResultModifierType type) : type(type) {
-	}
-	virtual ~BoundResultModifier() {
-	}
+	explicit BoundResultModifier(ResultModifierType type);
+	virtual ~BoundResultModifier();
 
 	ResultModifierType type;
 };
 
 struct BoundOrderByNode {
 public:
-	BoundOrderByNode(OrderType type, OrderByNullType null_order, unique_ptr<Expression> expression)
-	    : type(type), null_order(null_order), expression(move(expression)) {
-	}
+	BoundOrderByNode(OrderType type, OrderByNullType null_order, unique_ptr<Expression> expression);
 	BoundOrderByNode(OrderType type, OrderByNullType null_order, unique_ptr<Expression> expression,
-	                 unique_ptr<BaseStatistics> stats)
-	    : type(type), null_order(null_order), expression(move(expression)), stats(move(stats)) {
-	}
-
-	BoundOrderByNode Copy() const {
-		if (stats) {
-			return BoundOrderByNode(type, null_order, expression->Copy(), stats->Copy());
-		} else {
-			return BoundOrderByNode(type, null_order, expression->Copy());
-		}
-	}
+	                 unique_ptr<BaseStatistics> stats);
 
 	OrderType type;
 	OrderByNullType null_order;
 	unique_ptr<Expression> expression;
 	unique_ptr<BaseStatistics> stats;
+
+public:
+	BoundOrderByNode Copy() const;
+	string ToString() const;
 };
 
 class BoundLimitModifier : public BoundResultModifier {
 public:
-	BoundLimitModifier() : BoundResultModifier(ResultModifierType::LIMIT_MODIFIER) {
-	}
+	BoundLimitModifier();
+
 	//! LIMIT
 	int64_t limit_val = NumericLimits<int64_t>::Maximum();
 	//! OFFSET
@@ -8644,8 +8790,7 @@ public:
 
 class BoundOrderModifier : public BoundResultModifier {
 public:
-	BoundOrderModifier() : BoundResultModifier(ResultModifierType::ORDER_MODIFIER) {
-	}
+	BoundOrderModifier();
 
 	//! List of order nodes
 	vector<BoundOrderByNode> orders;
@@ -8653,8 +8798,7 @@ public:
 
 class BoundDistinctModifier : public BoundResultModifier {
 public:
-	BoundDistinctModifier() : BoundResultModifier(ResultModifierType::DISTINCT_MODIFIER) {
-	}
+	BoundDistinctModifier();
 
 	//! list of distinct on targets (if any)
 	vector<unique_ptr<Expression>> target_distincts;
@@ -8662,8 +8806,8 @@ public:
 
 class BoundLimitPercentModifier : public BoundResultModifier {
 public:
-	BoundLimitPercentModifier() : BoundResultModifier(ResultModifierType::LIMIT_PERCENT_MODIFIER) {
-	}
+	BoundLimitPercentModifier();
+
 	//! LIMIT %
 	double limit_percent = 100.0;
 	//! OFFSET
@@ -14438,13 +14582,13 @@ class FileBuffer;
 class BufferHandle {
 public:
 	BufferHandle(shared_ptr<BlockHandle> handle, FileBuffer *node);
-	~BufferHandle();
+	DUCKDB_API ~BufferHandle();
 
 	//! The block handle
 	shared_ptr<BlockHandle> handle;
 	//! The managed buffer node
 	FileBuffer *node;
-	data_ptr_t Ptr();
+	DUCKDB_API data_ptr_t Ptr();
 };
 
 } // namespace duckdb
@@ -14901,6 +15045,7 @@ public:
 	bool Equals(const BaseExpression *other) const override;
 
 	unique_ptr<Expression> Copy() override;
+	void Verify() const override;
 };
 } // namespace duckdb
 
@@ -15263,87 +15408,6 @@ public:
 
 
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/qualified_name.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct QualifiedName {
-	string schema;
-	string name;
-
-	//! Parse the (optional) schema and a name from a string in the format of e.g. "schema"."table"; if there is no dot
-	//! the schema will be set to INVALID_SCHEMA
-	static QualifiedName Parse(string input) {
-		string schema;
-		string name;
-		idx_t idx = 0;
-		vector<string> entries;
-		string entry;
-	normal:
-		//! quote
-		for (; idx < input.size(); idx++) {
-			if (input[idx] == '"') {
-				idx++;
-				goto quoted;
-			} else if (input[idx] == '.') {
-				goto separator;
-			}
-			entry += input[idx];
-		}
-		goto end;
-	separator:
-		entries.push_back(entry);
-		entry = "";
-		idx++;
-		goto normal;
-	quoted:
-		//! look for another quote
-		for (; idx < input.size(); idx++) {
-			if (input[idx] == '"') {
-				//! unquote
-				idx++;
-				goto normal;
-			}
-			entry += input[idx];
-		}
-		throw ParserException("Unterminated quote in qualified name!");
-	end:
-		if (entries.empty()) {
-			schema = INVALID_SCHEMA;
-			name = entry;
-		} else if (entries.size() == 1) {
-			schema = entries[0];
-			name = entry;
-		} else {
-			throw ParserException("Expected schema.entry or entry: too many entries found");
-		}
-		return QualifiedName {schema, name};
-	}
-};
-
-struct QualifiedColumnName {
-	QualifiedColumnName() {
-	}
-	QualifiedColumnName(string table_p, string column_p) : table(move(table_p)), column(move(column_p)) {
-	}
-
-	string schema;
-	string table;
-	string column;
-};
-
-} // namespace duckdb
 
 //===----------------------------------------------------------------------===//
 //                         DuckDB
@@ -15469,6 +15533,9 @@ public:
 
 public:
 	string ToString() const override {
+		if (!expr) {
+			throw InternalException("ToString(): BoundExpression does not have a child");
+		}
 		return expr->ToString();
 	}
 
@@ -16545,8 +16612,6 @@ public:
 		return true;
 	}
 
-	//! Get the name of the expression
-	string GetName() const override;
 	//! Convert the Expression to a String
 	string ToString() const override;
 
@@ -16556,6 +16621,129 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+
+public:
+	template <class T, class BASE, class ORDER_NODE>
+	static string ToString(const T &entry, const string &schema, const string &function_name) {
+		// Start with function call
+		string result = schema.empty() ? function_name : schema + "." + function_name;
+		result += "(";
+		result += StringUtil::Join(entry.children, entry.children.size(), ", ",
+		                           [](const unique_ptr<BASE> &child) { return child->ToString(); });
+		// Lead/Lag extra arguments
+		if (entry.offset_expr.get()) {
+			result += ", ";
+			result += entry.offset_expr->ToString();
+		}
+		if (entry.default_expr.get()) {
+			result += ", ";
+			result += entry.default_expr->ToString();
+		}
+		// IGNORE NULLS
+		if (entry.ignore_nulls) {
+			result += " IGNORE NULLS";
+		}
+		// Over clause
+		result += ") OVER(";
+		string sep;
+
+		// Partitions
+		if (!entry.partitions.empty()) {
+			result += "PARTITION BY ";
+			result += StringUtil::Join(entry.partitions, entry.partitions.size(), ", ",
+			                           [](const unique_ptr<BASE> &partition) { return partition->ToString(); });
+			sep = " ";
+		}
+
+		// Orders
+		if (!entry.orders.empty()) {
+			result += sep;
+			result += "ORDER BY ";
+			result += StringUtil::Join(entry.orders, entry.orders.size(), ", ",
+			                           [](const ORDER_NODE &order) { return order.ToString(); });
+			sep = " ";
+		}
+
+		// Rows/Range
+		string units = "ROWS";
+		string from;
+		switch (entry.start) {
+		case WindowBoundary::CURRENT_ROW_RANGE:
+		case WindowBoundary::CURRENT_ROW_ROWS:
+			from = "CURRENT ROW";
+			units = (entry.start == WindowBoundary::CURRENT_ROW_RANGE) ? "RANGE" : "ROWS";
+			break;
+		case WindowBoundary::UNBOUNDED_PRECEDING:
+			if (entry.end != WindowBoundary::CURRENT_ROW_RANGE) {
+				from = "UNBOUNDED PRECEDING";
+			}
+			break;
+		case WindowBoundary::EXPR_PRECEDING_ROWS:
+		case WindowBoundary::EXPR_PRECEDING_RANGE:
+			from = entry.start_expr->ToString() + " PRECEDING";
+			units = (entry.start == WindowBoundary::EXPR_PRECEDING_RANGE) ? "RANGE" : "ROWS";
+			break;
+		case WindowBoundary::EXPR_FOLLOWING_ROWS:
+		case WindowBoundary::EXPR_FOLLOWING_RANGE:
+			from = entry.start_expr->ToString() + " FOLLOWING";
+			units = (entry.start == WindowBoundary::EXPR_FOLLOWING_RANGE) ? "RANGE" : "ROWS";
+			break;
+		default:
+			throw InternalException("Unrecognized FROM in WindowExpression");
+		}
+
+		string to;
+		switch (entry.end) {
+		case WindowBoundary::CURRENT_ROW_RANGE:
+			if (entry.start != WindowBoundary::UNBOUNDED_PRECEDING) {
+				to = "CURRENT ROW";
+				units = "RANGE";
+			}
+			break;
+		case WindowBoundary::CURRENT_ROW_ROWS:
+			to = "CURRENT ROW";
+			units = "ROWS";
+			break;
+		case WindowBoundary::UNBOUNDED_PRECEDING:
+			to = "UNBOUNDED PRECEDING";
+			break;
+		case WindowBoundary::UNBOUNDED_FOLLOWING:
+			to = "UNBOUNDED FOLLOWING";
+			break;
+		case WindowBoundary::EXPR_PRECEDING_ROWS:
+		case WindowBoundary::EXPR_PRECEDING_RANGE:
+			to = entry.end_expr->ToString() + " PRECEDING";
+			units = (entry.end == WindowBoundary::EXPR_PRECEDING_RANGE) ? "RANGE" : "ROWS";
+			break;
+		case WindowBoundary::EXPR_FOLLOWING_ROWS:
+		case WindowBoundary::EXPR_FOLLOWING_RANGE:
+			to = entry.end_expr->ToString() + " FOLLOWING";
+			units = (entry.end == WindowBoundary::EXPR_FOLLOWING_RANGE) ? "RANGE" : "ROWS";
+			break;
+		default:
+			throw InternalException("Unrecognized TO in WindowExpression");
+		}
+
+		if (!from.empty() || !to.empty()) {
+			result += sep + units;
+		}
+		if (!from.empty() && !to.empty()) {
+			result += " BETWEEN ";
+			result += from;
+			result += " AND ";
+			result += to;
+		} else if (!from.empty()) {
+			result += " ";
+			result += from;
+		} else if (!to.empty()) {
+			result += " ";
+			result += to;
+		}
+
+		result += ")";
+
+		return result;
+	}
 };
 } // namespace duckdb
 
@@ -19243,7 +19431,7 @@ public:
 
 	//! Allocate an in-memory buffer with a single pin.
 	//! The allocated memory is released when the buffer handle is destroyed.
-	unique_ptr<BufferHandle> Allocate(idx_t block_size);
+	DUCKDB_API unique_ptr<BufferHandle> Allocate(idx_t block_size);
 
 	//! Reallocate an in-memory buffer that is pinned.
 	void ReAllocate(shared_ptr<BlockHandle> &handle, idx_t block_size);
@@ -19258,7 +19446,7 @@ public:
 	void SetLimit(idx_t limit = (idx_t)-1);
 
 	static BufferManager &GetBufferManager(ClientContext &context);
-	static BufferManager &GetBufferManager(DatabaseInstance &db);
+	DUCKDB_API static BufferManager &GetBufferManager(DatabaseInstance &db);
 
 	idx_t GetUsedMemory() {
 		return current_memory;
@@ -21120,6 +21308,19 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+
+public:
+	template <class T, class BASE>
+	static string ToString(const T &entry) {
+		string case_str = "CASE ";
+		for (auto &check : entry.case_checks) {
+			case_str += " WHEN (" + check.when_expr->ToString() + ")";
+			case_str += " THEN (" + check.then_expr->ToString() + ")";
+		}
+		case_str += " ELSE " + entry.else_expr->ToString();
+		case_str += " END";
+		return case_str;
+	}
 };
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
@@ -21158,6 +21359,16 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+
+public:
+	template <class T, class BASE>
+	static string ToString(const T &entry) {
+		string result = entry.children[0]->ToString();
+		for (idx_t i = 1; i < entry.children.size(); i++) {
+			result += " " + ExpressionTypeToOperator(entry.type) + " " + entry.children[i]->ToString();
+		}
+		return result;
+	}
 };
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
@@ -21215,6 +21426,63 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+
+	void Verify() const override;
+
+public:
+	template <class T, class BASE>
+	static string ToString(const T &entry, const string &schema, const string &function_name, bool is_operator = false,
+	                       bool distinct = false, BASE *filter = nullptr, OrderModifier *order_bys = nullptr,
+	                       bool export_state = false) {
+		if (is_operator) {
+			// built-in operator
+			D_ASSERT(!distinct);
+			if (entry.children.size() == 1) {
+				if (StringUtil::Contains(function_name, "__postfix")) {
+					return "(" + entry.children[0]->ToString() + ")" +
+					       StringUtil::Replace(function_name, "__postfix", "");
+				} else {
+					return function_name + "(" + entry.children[0]->ToString() + ")";
+				}
+			} else if (entry.children.size() == 2) {
+				return "(" + entry.children[0]->ToString() + " " + function_name + " " + entry.children[1]->ToString() +
+				       ")";
+			}
+		}
+		// standard function call
+		string result = schema.empty() ? function_name : schema + "." + function_name;
+		result += "(";
+		if (distinct) {
+			result += "DISTINCT ";
+		}
+		result += StringUtil::Join(entry.children, entry.children.size(), ", ",
+		                           [](const unique_ptr<BASE> &child) { return child->ToString(); });
+		// ordered aggregate
+		if (order_bys && !order_bys->orders.empty()) {
+			if (entry.children.empty()) {
+				result += ") WITHIN GROUP (";
+			}
+			result += " ORDER BY ";
+			for (idx_t i = 0; i < order_bys->orders.size(); i++) {
+				if (i > 0) {
+					result += ", ";
+				}
+				result += order_bys->orders[i].ToString();
+			}
+		}
+		result += ")";
+
+		// filtered aggregate
+		if (filter) {
+			result += " FILTER (WHERE " + filter->ToString() + ")";
+		}
+
+		if (export_state) {
+			result += " EXPORT_STATE";
+		}
+
+		return result;
+	}
 };
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
@@ -21280,6 +21548,12 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+
+public:
+	template <class T, class BASE>
+	static string ToString(const T &entry) {
+		return entry.left->ToString() + " " + ExpressionTypeToOperator(entry.type) + " " + entry.right->ToString();
+	}
 };
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
@@ -21331,6 +21605,8 @@ public:
 
 
 
+
+
 namespace duckdb {
 //! Represents a built-in operator expression
 class OperatorExpression : public ParsedExpression {
@@ -21350,7 +21626,71 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+
+public:
+	template <class T, class BASE>
+	static string ToString(const T &entry) {
+		auto op = ExpressionTypeToOperator(entry.type);
+		if (!op.empty()) {
+			// use the operator string to represent the operator
+			D_ASSERT(entry.children.size() == 2);
+			return entry.children[0]->ToString() + " " + op + " " + entry.children[1]->ToString();
+		}
+		switch (entry.type) {
+		case ExpressionType::COMPARE_IN:
+		case ExpressionType::COMPARE_NOT_IN: {
+			string op_type = entry.type == ExpressionType::COMPARE_IN ? " IN " : " NOT IN ";
+			string in_child = entry.children[0]->ToString();
+			string child_list = "(";
+			for (idx_t i = 1; i < entry.children.size(); i++) {
+				if (i > 1) {
+					child_list += ", ";
+				}
+				child_list += entry.children[i]->ToString();
+			}
+			child_list += ")";
+			return "(" + in_child + op_type + child_list + ")";
+		}
+		case ExpressionType::OPERATOR_NOT:
+		case ExpressionType::GROUPING_FUNCTION:
+		case ExpressionType::OPERATOR_COALESCE: {
+			string result = ExpressionTypeToString(entry.type);
+			result += "(";
+			result += StringUtil::Join(entry.children, entry.children.size(), ", ",
+			                           [](const unique_ptr<BASE> &child) { return child->ToString(); });
+			result += ")";
+			return result;
+		}
+		case ExpressionType::OPERATOR_IS_NULL:
+			return "(" + entry.children[0]->ToString() + " IS NULL)";
+		case ExpressionType::OPERATOR_IS_NOT_NULL:
+			return "(" + entry.children[0]->ToString() + " IS NOT NULL)";
+		case ExpressionType::ARRAY_EXTRACT:
+			return entry.children[0]->ToString() + "[" + entry.children[1]->ToString() + "]";
+		case ExpressionType::ARRAY_SLICE:
+			return entry.children[0]->ToString() + "[" + entry.children[1]->ToString() + ":" +
+			       entry.children[2]->ToString() + "]";
+		case ExpressionType::STRUCT_EXTRACT: {
+			D_ASSERT(entry.children[1]->type == ExpressionType::VALUE_CONSTANT);
+			auto child_string = entry.children[1]->ToString();
+			D_ASSERT(child_string.size() >= 3);
+			D_ASSERT(child_string[0] == '\'' && child_string[child_string.size() - 1] == '\'');
+			return "(" + entry.children[0]->ToString() + ")." +
+			       KeywordHelper::WriteOptionallyQuoted(child_string.substr(1, child_string.size() - 2));
+		}
+		case ExpressionType::ARRAY_CONSTRUCTOR: {
+			string result = "ARRAY[";
+			result += StringUtil::Join(entry.children, entry.children.size(), ", ",
+			                           [](const unique_ptr<BASE> &child) { return child->ToString(); });
+			result += "]";
+			return result;
+		}
+		default:
+			throw InternalException("Unrecognized operator type");
+		}
+	}
 };
+
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
@@ -21384,6 +21724,12 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+
+public:
+	template <class T, class BASE>
+	static string ToString(const T &entry) {
+		return entry.input->ToString() + " BETWEEN " + entry.lower->ToString() + " AND " + entry.upper->ToString();
+	}
 };
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
@@ -21459,6 +21805,13 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+
+public:
+	template <class T, class BASE>
+	static string ToString(const T &entry) {
+		return (entry.try_cast ? "TRY_CAST(" : "CAST(") + entry.child->ToString() + " AS " +
+		       entry.cast_type.ToString() + ")";
+	}
 };
 } // namespace duckdb