duckdb 0.3.5-dev116.0 → 0.3.5-dev154.0

package/src/duckdb.cpp

@@ -6397,7 +6397,7 @@ string JoinTypeToString(JoinType type) {
 	case JoinType::INNER:
 		return "INNER";
 	case JoinType::OUTER:
-		return "OUTER";
+		return "FULL";
 	case JoinType::SEMI:
 		return "SEMI";
 	case JoinType::ANTI:
@@ -34594,9 +34594,6 @@ bool ChunkCollection::Equals(ChunkCollection &other) {
 	if (ColumnCount() != other.ColumnCount()) {
 		return false;
 	}
-	if (types != other.types) {
-		return false;
-	}
 	// if count is equal amount of chunks should be equal
 	for (idx_t row_idx = 0; row_idx < count; row_idx++) {
 		for (idx_t col_idx = 0; col_idx < ColumnCount(); col_idx++) {
@@ -39769,6 +39766,11 @@ DUCKDB_API interval_t Value::GetValue() const {
 	return GetValueInternal<interval_t>();
 }
 
+template <>
+DUCKDB_API Value Value::GetValue() const {
+	return Value(*this);
+}
+
 uintptr_t Value::GetPointer() const {
 	D_ASSERT(type() == LogicalType::POINTER);
 	return value_.pointer;
@@ -40684,6 +40686,9 @@ bool Value::ValuesAreEqual(const Value &result_value, const Value &value) {
 		return left == right;
 	}
 	default:
+		if (result_value.type_.id() == LogicalTypeId::FLOAT || result_value.type_.id() == LogicalTypeId::DOUBLE) {
+			return Value::ValuesAreEqual(value, result_value);
+		}
 		return value == result_value;
 	}
 }
@@ -101200,6 +101205,9 @@ static unique_ptr<FunctionData> DuckDBFunctionsBind(ClientContext &context, Tabl
 	names.emplace_back("macro_definition");
 	return_types.emplace_back(LogicalType::VARCHAR);
 
+	names.emplace_back("has_side_effects");
+	return_types.emplace_back(LogicalType::BOOLEAN);
+
 	return nullptr;
 }
 
@@ -101272,6 +101280,10 @@ struct ScalarFunctionExtractor {
 	static Value GetMacroDefinition(ScalarFunctionCatalogEntry &entry, idx_t offset) {
 		return Value();
 	}
+
+	static Value HasSideEffects(ScalarFunctionCatalogEntry &entry, idx_t offset) {
+		return Value::BOOLEAN(entry.functions[offset].has_side_effects);
+	}
 };
 
 struct AggregateFunctionExtractor {
@@ -101316,6 +101328,10 @@ struct AggregateFunctionExtractor {
 	static Value GetMacroDefinition(AggregateFunctionCatalogEntry &entry, idx_t offset) {
 		return Value();
 	}
+
+	static Value HasSideEffects(AggregateFunctionCatalogEntry &entry, idx_t offset) {
+		return Value::BOOLEAN(entry.functions[offset].has_side_effects);
+	}
 };
 
 struct MacroExtractor {
@@ -101364,10 +101380,12 @@ struct MacroExtractor {
 	}
 
 	static Value GetMacroDefinition(ScalarMacroCatalogEntry &entry, idx_t offset) {
-		if (entry.function->type == MacroType::SCALAR_MACRO) {
-			auto &func = (ScalarMacroFunction &)*entry.function;
-			return func.expression->ToString();
-		}
+		D_ASSERT(entry.function->type == MacroType::SCALAR_MACRO);
+		auto &func = (ScalarMacroFunction &)*entry.function;
+		return func.expression->ToString();
+	}
+
+	static Value HasSideEffects(ScalarMacroCatalogEntry &entry, idx_t offset) {
 		return Value();
 	}
 };
@@ -101424,6 +101442,10 @@ struct TableMacroExtractor {
 		}
 		return Value();
 	}
+
+	static Value HasSideEffects(TableMacroCatalogEntry &entry, idx_t offset) {
+		return Value();
+	}
 };
 
 struct TableFunctionExtractor {
@@ -101474,6 +101496,10 @@ struct TableFunctionExtractor {
 	static Value GetMacroDefinition(TableFunctionCatalogEntry &entry, idx_t offset) {
 		return Value();
 	}
+
+	static Value HasSideEffects(TableFunctionCatalogEntry &entry, idx_t offset) {
+		return Value();
+	}
 };
 
 struct PragmaFunctionExtractor {
@@ -101524,6 +101550,10 @@ struct PragmaFunctionExtractor {
 	static Value GetMacroDefinition(PragmaFunctionCatalogEntry &entry, idx_t offset) {
 		return Value();
 	}
+
+	static Value HasSideEffects(PragmaFunctionCatalogEntry &entry, idx_t offset) {
+		return Value();
+	}
 };
 
 template <class T, class OP>
@@ -101556,6 +101586,9 @@ bool ExtractFunctionData(StandardEntry *entry, idx_t function_idx, DataChunk &ou
 	// macro_definition, LogicalType::VARCHAR
 	output.SetValue(8, output_offset, OP::GetMacroDefinition(function, function_idx));
 
+	// has_side_effects, LogicalType::BOOLEAN
+	output.SetValue(9, output_offset, OP::HasSideEffects(function, function_idx));
+
 	return function_idx + 1 == OP::FunctionCount(function);
 }
 
@@ -103478,6 +103511,9 @@ public:
 	}
 
 public:
+	//! Convert the query node to a string
+	string ToString() const override;
+
 	bool Equals(const QueryNode *other) const override;
 	//! Create a copy of this SelectNode
 	unique_ptr<QueryNode> Copy() const override;
@@ -108079,7 +108115,8 @@ unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatemen
 		// create a copy of the statement, and use the copy
 		// this way we verify that the copy correctly copies all properties
 		auto copied_statement = statement->Copy();
-		if (statement->type == StatementType::SELECT_STATEMENT) {
+		switch (statement->type) {
+		case StatementType::SELECT_STATEMENT: {
 			// in case this is a select query, we verify the original statement
 			string error;
 			try {
@@ -108091,8 +108128,22 @@ unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatemen
 				// error in verifying query
 				return make_unique<PendingQueryResult>(error);
 			}
+			statement = move(copied_statement);
+			break;
+		}
+		case StatementType::INSERT_STATEMENT:
+		case StatementType::DELETE_STATEMENT:
+		case StatementType::UPDATE_STATEMENT: {
+			auto sql = statement->ToString();
+			Parser parser;
+			parser.ParseQuery(sql);
+			statement = move(parser.statements[0]);
+			break;
+		}
+		default:
+			statement = move(copied_statement);
+			break;
 		}
-		statement = move(copied_statement);
 	}
 	return PendingStatementOrPreparedStatement(lock, query, move(statement), prepared, values);
 }
@@ -108272,6 +108323,18 @@ void ClientContext::DisableProfiling() {
 	config.enable_profiler = false;
 }
 
+struct VerifyStatement {
+	VerifyStatement(unique_ptr<SelectStatement> statement_p, string statement_name_p, bool require_equality = true)
+	    : statement(move(statement_p)), statement_name(move(statement_name_p)), require_equality(require_equality),
+	      select_list(statement->node->GetSelectList()) {
+	}
+
+	unique_ptr<SelectStatement> statement;
+	string statement_name;
+	bool require_equality;
+	const vector<unique_ptr<ParsedExpression>> &select_list;
+};
+
 string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query, unique_ptr<SQLStatement> statement) {
 	D_ASSERT(statement->type == StatementType::SELECT_STATEMENT);
 	// aggressive query verification
@@ -108281,8 +108344,10 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 	// Serialize()/Deserialize() of expressions
 	// Hash() of expressions
 	// Equality() of statements and expressions
+	// ToString() of statements and expressions
 	// Correctness of plans both with and without optimizers
-	// Correctness of plans both with and without parallelism
+
+	vector<VerifyStatement> verify_statements;
 
 	// copy the statement
 	auto select_stmt = (SelectStatement *)statement.get();
@@ -108293,42 +108358,60 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 	select_stmt->Serialize(serializer);
 	BufferedDeserializer source(serializer);
 	auto deserialized_stmt = SelectStatement::Deserialize(source);
+
+	Parser parser;
+	parser.ParseQuery(select_stmt->ToString());
+	D_ASSERT(parser.statements.size() == 1);
+	D_ASSERT(parser.statements[0]->type == StatementType::SELECT_STATEMENT);
+	auto parsed_statement = move(parser.statements[0]);
+
+	verify_statements.emplace_back(unique_ptr_cast<SQLStatement, SelectStatement>(move(statement)),
+	                               "Original statement");
+	verify_statements.emplace_back(move(copied_stmt), "Copied statement");
+	verify_statements.emplace_back(move(deserialized_stmt), "Deserialized statement");
+	verify_statements.emplace_back(unique_ptr_cast<SQLStatement, SelectStatement>(move(parsed_statement)),
+	                               "Parsed statement", false);
+
 	// all the statements should be equal
-	D_ASSERT(copied_stmt->Equals(statement.get()));
-	D_ASSERT(deserialized_stmt->Equals(statement.get()));
-	D_ASSERT(copied_stmt->Equals(deserialized_stmt.get()));
+	for (idx_t i = 1; i < verify_statements.size(); i++) {
+		if (!verify_statements[i].require_equality) {
+			continue;
+		}
+		D_ASSERT(verify_statements[i].statement->Equals(verify_statements[0].statement.get()));
+	}
 
 	// now perform checking on the expressions
 #ifdef DEBUG
-	auto &orig_expr_list = select_stmt->node->GetSelectList();
-	auto &de_expr_list = deserialized_stmt->node->GetSelectList();
-	auto &cp_expr_list = copied_stmt->node->GetSelectList();
-	D_ASSERT(orig_expr_list.size() == de_expr_list.size() && cp_expr_list.size() == de_expr_list.size());
-	for (idx_t i = 0; i < orig_expr_list.size(); i++) {
+	for (idx_t i = 1; i < verify_statements.size(); i++) {
+		D_ASSERT(verify_statements[i].select_list.size() == verify_statements[0].select_list.size());
+	}
+	auto expr_count = verify_statements[0].select_list.size();
+	auto &orig_expr_list = verify_statements[0].select_list;
+	for (idx_t i = 0; i < expr_count; i++) {
 		// run the ToString, to verify that it doesn't crash
 		auto str = orig_expr_list[i]->ToString();
-		// check that the expressions are equivalent
-		D_ASSERT(orig_expr_list[i]->Equals(de_expr_list[i].get()));
-		D_ASSERT(orig_expr_list[i]->Equals(cp_expr_list[i].get()));
-		D_ASSERT(de_expr_list[i]->Equals(cp_expr_list[i].get()));
-		// check that the hashes are equivalent too
-		D_ASSERT(orig_expr_list[i]->Hash() == de_expr_list[i]->Hash());
-		D_ASSERT(orig_expr_list[i]->Hash() == cp_expr_list[i]->Hash());
+		for (idx_t v_idx = 0; v_idx < verify_statements.size(); v_idx++) {
+			if (!verify_statements[v_idx].require_equality && orig_expr_list[i]->HasSubquery()) {
+				continue;
+			}
+			// check that the expressions are equivalent
+			D_ASSERT(orig_expr_list[i]->Equals(verify_statements[v_idx].select_list[i].get()));
+			// check that the hashes are equivalent too
+			D_ASSERT(orig_expr_list[i]->Hash() == verify_statements[v_idx].select_list[i]->Hash());
 
+			verify_statements[v_idx].select_list[i]->Verify();
+		}
 		D_ASSERT(!orig_expr_list[i]->Equals(nullptr));
-		orig_expr_list[i]->Verify();
-		de_expr_list[i]->Verify();
-		cp_expr_list[i]->Verify();
 
-		// ToString round trip
 		if (orig_expr_list[i]->HasSubquery()) {
 			continue;
 		}
+		// ToString round trip
 		auto parsed_list = Parser::ParseExpressionList(str);
 		D_ASSERT(parsed_list.size() == 1);
 		D_ASSERT(parsed_list[0]->Equals(orig_expr_list[i].get()));
 	}
-	// now perform additional checking within the expressions
+	// perform additional checking within the expressions
 	for (idx_t outer_idx = 0; outer_idx < orig_expr_list.size(); outer_idx++) {
 		auto hash = orig_expr_list[outer_idx]->Hash();
 		for (idx_t inner_idx = 0; inner_idx < orig_expr_list.size(); inner_idx++) {
@@ -108351,27 +108434,20 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 	// see below
 	auto statement_copy_for_explain = select_stmt->Copy();
 
-	unique_ptr<MaterializedQueryResult> original_result =
-	                                        make_unique<MaterializedQueryResult>(StatementType::SELECT_STATEMENT),
-	                                    copied_result =
-	                                        make_unique<MaterializedQueryResult>(StatementType::SELECT_STATEMENT),
-	                                    deserialized_result =
-	                                        make_unique<MaterializedQueryResult>(StatementType::SELECT_STATEMENT),
-	                                    unoptimized_result =
-	                                        make_unique<MaterializedQueryResult>(StatementType::SELECT_STATEMENT);
-
 	// execute the original statement
-	try {
-		auto result = RunStatementInternal(lock, query, move(statement), false, false);
-		original_result = unique_ptr_cast<QueryResult, MaterializedQueryResult>(move(result));
-	} catch (std::exception &ex) {
-		original_result->error = ex.what();
-		original_result->success = false;
+	vector<unique_ptr<MaterializedQueryResult>> results;
+	for (idx_t i = 0; i < verify_statements.size(); i++) {
+		interrupted = false;
+		try {
+			auto result = RunStatementInternal(lock, query, move(verify_statements[i].statement), false, false);
+			results.push_back(unique_ptr_cast<QueryResult, MaterializedQueryResult>(move(result)));
+		} catch (std::exception &ex) {
+			results.push_back(make_unique<MaterializedQueryResult>(ex.what()));
+		}
 	}
-	interrupted = false;
 
 	// check explain, only if q does not already contain EXPLAIN
-	if (original_result->success) {
+	if (results[0]->success) {
 		auto explain_q = "EXPLAIN " + query;
 		auto explain_stmt = make_unique<ExplainStatement>(move(statement_copy_for_explain));
 		try {
@@ -108381,34 +108457,6 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 		} // LCOV_EXCL_STOP
 	}
 
-	// now execute the copied statement
-	try {
-		auto result = RunStatementInternal(lock, query, move(copied_stmt), false, false);
-		copied_result = unique_ptr_cast<QueryResult, MaterializedQueryResult>(move(result));
-	} catch (std::exception &ex) {
-		copied_result->error = ex.what();
-		copied_result->success = false;
-	}
-	interrupted = false;
-	// now execute the deserialized statement
-	try {
-		auto result = RunStatementInternal(lock, query, move(deserialized_stmt), false, false);
-		deserialized_result = unique_ptr_cast<QueryResult, MaterializedQueryResult>(move(result));
-	} catch (std::exception &ex) {
-		deserialized_result->error = ex.what();
-		deserialized_result->success = false;
-	}
-	interrupted = false;
-	// now execute the unoptimized statement
-	config.enable_optimizer = false;
-	try {
-		auto result = RunStatementInternal(lock, query, move(unoptimized_stmt), false, false);
-		unoptimized_result = unique_ptr_cast<QueryResult, MaterializedQueryResult>(move(result));
-	} catch (std::exception &ex) {
-		unoptimized_result->error = ex.what();
-		unoptimized_result->success = false;
-	}
-	interrupted = false;
 	config.enable_optimizer = true;
 
 	if (profiling_is_enabled) {
@@ -108417,22 +108465,18 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 
 	// now compare the results
 	// the results of all runs should be identical
-	vector<unique_ptr<MaterializedQueryResult>> results;
-	results.push_back(move(copied_result));
-	results.push_back(move(deserialized_result));
-	results.push_back(move(unoptimized_result));
-	vector<string> names = {"Copied Result", "Deserialized Result", "Unoptimized Result"};
-	for (idx_t i = 0; i < results.size(); i++) {
-		if (original_result->success != results[i]->success) { // LCOV_EXCL_START
-			string result = names[i] + " differs from original result!\n";
-			result += "Original Result:\n" + original_result->ToString();
-			result += names[i] + ":\n" + results[i]->ToString();
+	for (idx_t i = 1; i < results.size(); i++) {
+		auto name = verify_statements[i].statement_name;
+		if (results[0]->success != results[i]->success) { // LCOV_EXCL_START
+			string result = name + " differs from original result!\n";
+			result += "Original Result:\n" + results[0]->ToString();
+			result += name + ":\n" + results[i]->ToString();
 			return result;
-		}                                                                  // LCOV_EXCL_STOP
-		if (!original_result->collection.Equals(results[i]->collection)) { // LCOV_EXCL_START
-			string result = names[i] + " differs from original result!\n";
-			result += "Original Result:\n" + original_result->ToString();
-			result += names[i] + ":\n" + results[i]->ToString();
+		}                                                             // LCOV_EXCL_STOP
+		if (!results[0]->collection.Equals(results[i]->collection)) { // LCOV_EXCL_START
+			string result = name + " differs from original result!\n";
+			result += "Original Result:\n" + results[0]->ToString();
+			result += name + ":\n" + results[i]->ToString();
 			return result;
 		} // LCOV_EXCL_STOP
 	}
@@ -109930,11 +109974,15 @@ void DuckDB::SetExtensionLoaded(const std::string &name) {
 #include "excel-extension.hpp"
 #endif
 
+#if defined(BUILD_SQLSMITH_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
+#include "sqlsmith-extension.hpp"
+#endif
+
 namespace duckdb {
 
 void ExtensionHelper::LoadAllExtensions(DuckDB &db) {
-	unordered_set<string> extensions {"parquet", "icu",       "tpch",       "tpcds", "fts",
-	                                  "httpfs",  "substrait", "visualizer", "json",  "excel"};
+	unordered_set<string> extensions {"parquet",   "icu",        "tpch", "tpcds", "fts",     "httpfs",
+	                                  "substrait", "visualizer", "json", "excel", "sqlsmith"};
 	for (auto &ext : extensions) {
 		LoadExtensionInternal(db, ext, true);
 	}
@@ -110034,6 +110082,13 @@ ExtensionLoadResult ExtensionHelper::LoadExtensionInternal(DuckDB &db, const std
 #else
 		// excel extension required but not build: skip this test
 		return ExtensionLoadResult::NOT_LOADED;
+#endif
+	} else if (extension == "sqlsmith") {
+#if defined(BUILD_SQLSMITH_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
+		db.LoadExtension<SQLSmithExtension>();
+#else
+		// excel extension required but not build: skip this test
+		return ExtensionLoadResult::NOT_LOADED;
 #endif
 	} else {
 		// unknown extension
@@ -120211,6 +120266,7 @@ protected:
 	DeleteStatement(const DeleteStatement &other);
 
 public:
+	string ToString() const override;
 	unique_ptr<SQLStatement> Copy() const override;
 };
 
@@ -120477,6 +120533,9 @@ public:
 	}
 
 public:
+	//! Convert the query node to a string
+	string ToString() const override;
+
 	bool Equals(const QueryNode *other) const override;
 	//! Create a copy of this SelectNode
 	unique_ptr<QueryNode> Copy() const override;
@@ -120588,6 +120647,7 @@ public:
 
 
 namespace duckdb {
+class ExpressionListRef;
 
 class InsertStatement : public SQLStatement {
 public:
@@ -120610,7 +120670,12 @@ protected:
 	InsertStatement(const InsertStatement &other);
 
 public:
+	string ToString() const override;
 	unique_ptr<SQLStatement> Copy() const override;
+
+	//! If the INSERT statement is inserted DIRECTLY from a values list (i.e. INSERT INTO tbl VALUES (...)) this returns
+	//! the expression list Otherwise, this returns NULL
+	ExpressionListRef *GetValuesList() const;
 };
 
 } // namespace duckdb
@@ -121525,6 +121590,7 @@ protected:
 	UpdateStatement(const UpdateStatement &other);
 
 public:
+	string ToString() const override;
 	unique_ptr<SQLStatement> Copy() const override;
 };
 
@@ -138425,7 +138491,7 @@ FunctionExpression::FunctionExpression(const string &function_name, vector<uniqu
 
 string FunctionExpression::ToString() const {
 	return ToString<FunctionExpression, ParsedExpression>(*this, schema, function_name, is_operator, distinct,
-	                                                      filter.get(), order_bys.get(), export_state);
+	                                                      filter.get(), order_bys.get(), export_state, true);
 }
 
 bool FunctionExpression::Equals(const FunctionExpression *a, const FunctionExpression *b) {
@@ -138818,7 +138884,19 @@ SubqueryExpression::SubqueryExpression()
 }
 
 string SubqueryExpression::ToString() const {
-	return "SUBQUERY";
+	switch (subquery_type) {
+	case SubqueryType::ANY:
+		return child->ToString() + " " + ExpressionTypeToOperator(comparison_type) + " ANY(" + subquery->ToString() +
+		       ")";
+	case SubqueryType::EXISTS:
+		return "EXISTS(" + subquery->ToString() + ")";
+	case SubqueryType::NOT_EXISTS:
+		return "NOT EXISTS(" + subquery->ToString() + ")";
+	case SubqueryType::SCALAR:
+		return "(" + subquery->ToString() + ")";
+	default:
+		throw InternalException("Unrecognized type for subquery");
+	}
 }
 
 bool SubqueryExpression::Equals(const SubqueryExpression *a, const SubqueryExpression *b) {
@@ -139122,11 +139200,11 @@ bool KeywordHelper::RequiresQuotes(const string &text) {
 	return IsKeyword(text);
 }
 
-string KeywordHelper::WriteOptionallyQuoted(const string &text) {
+string KeywordHelper::WriteOptionallyQuoted(const string &text, char quote) {
 	if (!RequiresQuotes(text)) {
 		return text;
 	}
-	return "\"" + StringUtil::Replace(text, "\"", "\"\"") + "\"";
+	return string(1, quote) + StringUtil::Replace(text, string(1, quote), string(2, quote)) + string(1, quote);
 }
 
 } // namespace duckdb
@@ -139756,6 +139834,9 @@ public:
 	}
 
 public:
+	//! Convert the query node to a string
+	string ToString() const override;
+
 	bool Equals(const QueryNode *other) const override;
 	//! Create a copy of this SelectNode
 	unique_ptr<QueryNode> Copy() const override;
@@ -145782,6 +145863,17 @@ string QueryErrorContext::FormatErrorRecursive(const string &msg, vector<Excepti
 
 namespace duckdb {
 
+string RecursiveCTENode::ToString() const {
+	string result;
+	result += "(" + left->ToString() + ")";
+	result += " UNION ";
+	if (union_all) {
+		result += " ALL ";
+	}
+	result += "(" + right->ToString() + ")";
+	return result;
+}
+
 bool RecursiveCTENode::Equals(const QueryNode *other_p) const {
 	if (!QueryNode::Equals(other_p)) {
 		return false;
@@ -145837,12 +145929,108 @@ unique_ptr<QueryNode> RecursiveCTENode::Deserialize(FieldReader &reader) {
 
 
 
+
 namespace duckdb {
 
 SelectNode::SelectNode()
     : QueryNode(QueryNodeType::SELECT_NODE), aggregate_handling(AggregateHandling::STANDARD_HANDLING) {
 }
 
+string SelectNode::ToString() const {
+	string result;
+	result = CTEToString();
+	result += "SELECT ";
+
+	// search for a distinct modifier
+	for (idx_t modifier_idx = 0; modifier_idx < modifiers.size(); modifier_idx++) {
+		if (modifiers[modifier_idx]->type == ResultModifierType::DISTINCT_MODIFIER) {
+			auto &distinct_modifier = (DistinctModifier &)*modifiers[modifier_idx];
+			result += "DISTINCT ";
+			if (!distinct_modifier.distinct_on_targets.empty()) {
+				result += "ON (";
+				for (idx_t k = 0; k < distinct_modifier.distinct_on_targets.size(); k++) {
+					if (k > 0) {
+						result += ", ";
+					}
+					result += distinct_modifier.distinct_on_targets[k]->ToString();
+				}
+				result += ") ";
+			}
+		}
+	}
+	for (idx_t i = 0; i < select_list.size(); i++) {
+		if (i > 0) {
+			result += ", ";
+		}
+		result += select_list[i]->ToString();
+		if (!select_list[i]->alias.empty()) {
+			result += " AS " + KeywordHelper::WriteOptionallyQuoted(select_list[i]->alias);
+		}
+	}
+	if (from_table && from_table->type != TableReferenceType::EMPTY) {
+		result += " FROM " + from_table->ToString();
+	}
+	if (where_clause) {
+		result += " WHERE " + where_clause->ToString();
+	}
+	if (!groups.grouping_sets.empty()) {
+		result += " GROUP BY ";
+		// if we are dealing with multiple grouping sets, we have to add a few additional brackets
+		bool grouping_sets = groups.grouping_sets.size() > 1;
+		if (grouping_sets) {
+			result += "GROUPING SETS (";
+		}
+		for (idx_t i = 0; i < groups.grouping_sets.size(); i++) {
+			auto &grouping_set = groups.grouping_sets[i];
+			if (i > 0) {
+				result += ",";
+			}
+			if (grouping_set.empty()) {
+				result += "()";
+				continue;
+			}
+			if (grouping_sets) {
+				result += "(";
+			}
+			bool first = true;
+			for (auto &grp : grouping_set) {
+				if (!first) {
+					result += ", ";
+				}
+				result += groups.group_expressions[grp]->ToString();
+				first = false;
+			}
+			if (grouping_sets) {
+				result += ")";
+			}
+		}
+		if (grouping_sets) {
+			result += ")";
+		}
+	} else if (aggregate_handling == AggregateHandling::FORCE_AGGREGATES) {
+		result += " GROUP BY ALL";
+	}
+	if (having) {
+		result += " HAVING " + having->ToString();
+	}
+	if (qualify) {
+		result += " QUALIFY " + qualify->ToString();
+	}
+	if (sample) {
+		result += " USING SAMPLE ";
+		result += sample->sample_size.ToString();
+		if (sample->is_percentage) {
+			result += "%";
+		}
+		result += " (" + SampleMethodToString(sample->method);
+		if (sample->seed >= 0) {
+			result += ", " + std::to_string(sample->seed);
+		}
+		result += ")";
+	}
+	return result + ResultModifiersToString();
+}
+
 bool SelectNode::Equals(const QueryNode *other_p) const {
 	if (!QueryNode::Equals(other_p)) {
 		return false;
@@ -145961,6 +146149,37 @@ unique_ptr<QueryNode> SelectNode::Deserialize(FieldReader &reader) {
 
 namespace duckdb {
 
+string SetOperationNode::ToString() const {
+	string result;
+	result = CTEToString();
+	result += "(" + left->ToString() + ") ";
+	bool is_distinct = false;
+	for (idx_t modifier_idx = 0; modifier_idx < modifiers.size(); modifier_idx++) {
+		if (modifiers[modifier_idx]->type == ResultModifierType::DISTINCT_MODIFIER) {
+			is_distinct = true;
+			break;
+		}
+	}
+
+	switch (setop_type) {
+	case SetOperationType::UNION:
+		result += is_distinct ? "UNION" : "UNION ALL";
+		break;
+	case SetOperationType::EXCEPT:
+		D_ASSERT(is_distinct);
+		result += "EXCEPT";
+		break;
+	case SetOperationType::INTERSECT:
+		D_ASSERT(is_distinct);
+		result += "INTERSECT";
+		break;
+	default:
+		throw InternalException("Unsupported set operation type");
+	}
+	result += " (" + right->ToString() + ")";
+	return result + ResultModifiersToString();
+}
+
 bool SetOperationNode::Equals(const QueryNode *other_p) const {
 	if (!QueryNode::Equals(other_p)) {
 		return false;
@@ -146015,6 +146234,81 @@ unique_ptr<QueryNode> SetOperationNode::Deserialize(FieldReader &reader) {
 
 namespace duckdb {
 
+string QueryNode::CTEToString() const {
+	if (cte_map.empty()) {
+		return string();
+	}
+	// check if there are any recursive CTEs
+	bool has_recursive = false;
+	for (auto &kv : cte_map) {
+		if (kv.second->query->node->type == QueryNodeType::RECURSIVE_CTE_NODE) {
+			has_recursive = true;
+			break;
+		}
+	}
+	string result = "WITH ";
+	if (has_recursive) {
+		result += "RECURSIVE ";
+	}
+	bool first_cte = true;
+	for (auto &kv : cte_map) {
+		if (!first_cte) {
+			result += ", ";
+		}
+		auto &cte = *kv.second;
+		result += KeywordHelper::WriteOptionallyQuoted(kv.first);
+		if (!cte.aliases.empty()) {
+			result += " (";
+			for (idx_t k = 0; k < cte.aliases.size(); k++) {
+				if (k > 0) {
+					result += ", ";
+				}
+				result += KeywordHelper::WriteOptionallyQuoted(cte.aliases[k]);
+			}
+			result += ")";
+		}
+		result += " AS (";
+		result += cte.query->ToString();
+		result += ")";
+		first_cte = false;
+	}
+	return result;
+}
+
+string QueryNode::ResultModifiersToString() const {
+	string result;
+	for (idx_t modifier_idx = 0; modifier_idx < modifiers.size(); modifier_idx++) {
+		auto &modifier = *modifiers[modifier_idx];
+		if (modifier.type == ResultModifierType::ORDER_MODIFIER) {
+			auto &order_modifier = (OrderModifier &)modifier;
+			result += " ORDER BY ";
+			for (idx_t k = 0; k < order_modifier.orders.size(); k++) {
+				if (k > 0) {
+					result += ", ";
+				}
+				result += order_modifier.orders[k].ToString();
+			}
+		} else if (modifier.type == ResultModifierType::LIMIT_MODIFIER) {
+			auto &limit_modifier = (LimitModifier &)modifier;
+			if (limit_modifier.limit) {
+				result += " LIMIT " + limit_modifier.limit->ToString();
+			}
+			if (limit_modifier.offset) {
+				result += " OFFSET " + limit_modifier.offset->ToString();
+			}
+		} else if (modifier.type == ResultModifierType::LIMIT_PERCENT_MODIFIER) {
+			auto &limit_p_modifier = (LimitPercentModifier &)modifier;
+			if (limit_p_modifier.limit) {
+				result += " LIMIT " + limit_p_modifier.limit->ToString() + " %";
+			}
+			if (limit_p_modifier.offset) {
+				result += " OFFSET " + limit_p_modifier.offset->ToString();
+			}
+		}
+	}
+	return result;
+}
+
 bool QueryNode::Equals(const QueryNode *other) const {
 	if (!other) {
 		return false;
@@ -146484,6 +146778,35 @@ DeleteStatement::DeleteStatement(const DeleteStatement &other) : SQLStatement(ot
 	}
 }
 
+string DeleteStatement::ToString() const {
+	string result;
+	result += "DELETE FROM ";
+	result += table->ToString();
+	if (!using_clauses.empty()) {
+		result += " USING ";
+		for (idx_t i = 0; i < using_clauses.size(); i++) {
+			if (i > 0) {
+				result += ", ";
+			}
+			result += using_clauses[i]->ToString();
+		}
+	}
+	if (condition) {
+		result += " WHERE " + condition->ToString();
+	}
+
+	if (!returning_list.empty()) {
+		result += " RETURNING ";
+		for (idx_t i = 0; i < returning_list.size(); i++) {
+			if (i > 0) {
+				result += ", ";
+			}
+			result += returning_list[i]->ToString();
+		}
+	}
+	return result;
+}
+
 unique_ptr<SQLStatement> DeleteStatement::Copy() const {
 	return unique_ptr<DeleteStatement>(new DeleteStatement(*this));
 }
@@ -146617,6 +146940,8 @@ unique_ptr<SQLStatement> ExportStatement::Copy() const {
 } // namespace duckdb
 
 
+
+
 namespace duckdb {
 
 InsertStatement::InsertStatement() : SQLStatement(StatementType::INSERT_STATEMENT), schema(DEFAULT_SCHEMA) {
@@ -146628,10 +146953,73 @@ InsertStatement::InsertStatement(const InsertStatement &other)
       columns(other.columns), table(other.table), schema(other.schema) {
 }
 
+string InsertStatement::ToString() const {
+	string result;
+	result = "INSERT INTO ";
+	if (!schema.empty()) {
+		result += KeywordHelper::WriteOptionallyQuoted(schema) + ".";
+	}
+	result += KeywordHelper::WriteOptionallyQuoted(table);
+	if (!columns.empty()) {
+		result += " (";
+		for (idx_t i = 0; i < columns.size(); i++) {
+			if (i > 0) {
+				result += ", ";
+			}
+			result += KeywordHelper::WriteOptionallyQuoted(columns[i]);
+		}
+		result += " )";
+	}
+	result += " ";
+	auto values_list = GetValuesList();
+	if (values_list) {
+		values_list->alias = string();
+		result += values_list->ToString();
+	} else {
+		result += select_statement->ToString();
+	}
+	if (!returning_list.empty()) {
+		result += " RETURNING ";
+		for (idx_t i = 0; i < returning_list.size(); i++) {
+			if (i > 0) {
+				result += ", ";
+			}
+			result += returning_list[i]->ToString();
+		}
+	}
+	return result;
+}
+
 unique_ptr<SQLStatement> InsertStatement::Copy() const {
 	return unique_ptr<InsertStatement>(new InsertStatement(*this));
 }
 
+ExpressionListRef *InsertStatement::GetValuesList() const {
+	if (select_statement->node->type != QueryNodeType::SELECT_NODE) {
+		return nullptr;
+	}
+	auto &node = (SelectNode &)*select_statement->node;
+	if (node.where_clause || node.qualify || node.having) {
+		return nullptr;
+	}
+	if (!node.cte_map.empty()) {
+		return nullptr;
+	}
+	if (!node.groups.grouping_sets.empty()) {
+		return nullptr;
+	}
+	if (node.aggregate_handling != AggregateHandling::STANDARD_HANDLING) {
+		return nullptr;
+	}
+	if (node.select_list.size() != 1 || node.select_list[0]->type != ExpressionType::STAR) {
+		return nullptr;
+	}
+	if (!node.from_table || node.from_table->type != TableReferenceType::EXPRESSION_LIST) {
+		return nullptr;
+	}
+	return (ExpressionListRef *)node.from_table.get();
+}
+
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
@@ -146780,6 +147168,10 @@ bool SelectStatement::Equals(const SQLStatement *other_p) const {
 	return node->Equals(other->node.get());
 }
 
+string SelectStatement::ToString() const {
+	return node->ToString();
+}
+
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
@@ -146934,6 +147326,38 @@ UpdateStatement::UpdateStatement(const UpdateStatement &other)
 	}
 }
 
+string UpdateStatement::ToString() const {
+	string result;
+	result = "UPDATE ";
+	result += table->ToString();
+	result += " SET ";
+	D_ASSERT(columns.size() == expressions.size());
+	for (idx_t i = 0; i < columns.size(); i++) {
+		if (i > 0) {
+			result += ", ";
+		}
+		result += KeywordHelper::WriteOptionallyQuoted(columns[i]);
+		result += "=";
+		result += expressions[i]->ToString();
+	}
+	if (from_table) {
+		result += " FROM " + from_table->ToString();
+	}
+	if (condition) {
+		result += " WHERE " + condition->ToString();
+	}
+	if (!returning_list.empty()) {
+		result += " RETURNING ";
+		for (idx_t i = 0; i < returning_list.size(); i++) {
+			if (i > 0) {
+				result += ", ";
+			}
+			result += returning_list[i]->ToString();
+		}
+	}
+	return result;
+}
+
 unique_ptr<SQLStatement> UpdateStatement::Copy() const {
 	return unique_ptr<UpdateStatement>(new UpdateStatement(*this));
 }
@@ -146985,10 +147409,13 @@ unique_ptr<SQLStatement> VacuumStatement::Copy() const {
 
 
 
+
 namespace duckdb {
 
 string BaseTableRef::ToString() const {
-	return "GET(" + schema_name + "." + table_name + ")";
+	string schema = schema_name.empty() ? "" : KeywordHelper::WriteOptionallyQuoted(schema_name) + ".";
+	string result = schema + KeywordHelper::WriteOptionallyQuoted(table_name);
+	return BaseToString(result, column_name_alias);
 }
 
 bool BaseTableRef::Equals(const TableRef *other_p) const {
@@ -147033,6 +147460,10 @@ unique_ptr<TableRef> BaseTableRef::Copy() {
 
 namespace duckdb {
 
+string CrossProductRef::ToString() const {
+	return left->ToString() + ", " + right->ToString();
+}
+
 bool CrossProductRef::Equals(const TableRef *other_p) const {
 	if (!TableRef::Equals(other_p)) {
 		return false;
@@ -147072,6 +147503,10 @@ unique_ptr<TableRef> CrossProductRef::Deserialize(FieldReader &reader) {
 
 namespace duckdb {
 
+string EmptyTableRef::ToString() const {
+	return "";
+}
+
 bool EmptyTableRef::Equals(const TableRef *other) const {
 	return TableRef::Equals(other);
 }
@@ -147094,6 +147529,27 @@ unique_ptr<TableRef> EmptyTableRef::Deserialize(FieldReader &reader) {
 
 namespace duckdb {
 
+string ExpressionListRef::ToString() const {
+	D_ASSERT(!values.empty());
+	string result = "(VALUES ";
+	for (idx_t row_idx = 0; row_idx < values.size(); row_idx++) {
+		if (row_idx > 0) {
+			result += ", ";
+		}
+		auto &row = values[row_idx];
+		result += "(";
+		for (idx_t col_idx = 0; col_idx < row.size(); col_idx++) {
+			if (col_idx > 0) {
+				result += ", ";
+			}
+			result += row[col_idx]->ToString();
+		}
+		result += ")";
+	}
+	result += ")";
+	return BaseToString(result, expected_names);
+}
+
 bool ExpressionListRef::Equals(const TableRef *other_p) const {
 	if (!TableRef::Equals(other_p)) {
 		return false;
@@ -147165,6 +147621,32 @@ unique_ptr<TableRef> ExpressionListRef::Deserialize(FieldReader &reader) {
 
 namespace duckdb {
 
+string JoinRef::ToString() const {
+	string result;
+	result = left->ToString() + " ";
+	if (is_natural) {
+		result += "NATURAL ";
+	}
+	result += JoinTypeToString(type) + " JOIN ";
+	result += right->ToString();
+	if (condition) {
+		D_ASSERT(using_columns.empty());
+		result += " ON (";
+		result += condition->ToString();
+		result += ")";
+	} else if (!using_columns.empty()) {
+		result += " USING (";
+		for (idx_t i = 0; i < using_columns.size(); i++) {
+			if (i > 0) {
+				result += ", ";
+			}
+			result += using_columns[i];
+		}
+		result += ")";
+	}
+	return result;
+}
+
 bool JoinRef::Equals(const TableRef *other_p) const {
 	if (!TableRef::Equals(other_p)) {
 		return false;
@@ -147224,6 +147706,11 @@ unique_ptr<TableRef> JoinRef::Deserialize(FieldReader &reader) {
 
 namespace duckdb {
 
+string SubqueryRef::ToString() const {
+	string result = "(" + subquery->ToString() + ")";
+	return BaseToString(result, column_name_alias);
+}
+
 SubqueryRef::SubqueryRef(unique_ptr<SelectStatement> subquery_p, string alias_p)
     : TableRef(TableReferenceType::SUBQUERY), subquery(move(subquery_p)) {
 	this->alias = move(alias_p);
@@ -147264,7 +147751,7 @@ unique_ptr<TableRef> SubqueryRef::Deserialize(FieldReader &reader) {
 namespace duckdb {
 
 string TableFunctionRef::ToString() const {
-	return function->ToString();
+	return BaseToString(function->ToString(), column_name_alias);
 }
 
 bool TableFunctionRef::Equals(const TableRef *other_p) const {
@@ -147306,10 +147793,38 @@ unique_ptr<TableRef> TableFunctionRef::Copy() {
 
 
 
+
 namespace duckdb {
 
-string TableRef::ToString() const {
-	return string();
+string TableRef::BaseToString(string result) const {
+	vector<string> column_name_alias;
+	return BaseToString(move(result), column_name_alias);
+}
+
+string TableRef::BaseToString(string result, const vector<string> &column_name_alias) const {
+	if (!alias.empty()) {
+		result += " AS " + KeywordHelper::WriteOptionallyQuoted(alias);
+	}
+	if (!column_name_alias.empty()) {
+		D_ASSERT(!alias.empty());
+		result += "(";
+		for (idx_t i = 0; i < column_name_alias.size(); i++) {
+			if (i > 0) {
+				result += ", ";
+			}
+			result += KeywordHelper::WriteOptionallyQuoted(column_name_alias[i]);
+		}
+		result += ")";
+	}
+	if (sample) {
+		result += " TABLESAMPLE " + SampleMethodToString(sample->method);
+		result += "(" + sample->sample_size.ToString() + " " + string(sample->is_percentage ? "PERCENT" : "ROWS") + ")";
+		if (sample->seed >= 0) {
+			result += "REPEATABLE (" + to_string(sample->seed) + ")";
+		}
+	}
+
+	return result;
 }
 
 bool TableRef::Equals(const TableRef *other) const {
@@ -153980,11 +154495,14 @@ public:
 		throw InternalException("Cannot get select list of bound subquery node");
 	}
 
+	string ToString() const override {
+		throw InternalException("Cannot ToString bound subquery node");
+	}
 	unique_ptr<QueryNode> Copy() const override {
 		throw InternalException("Cannot copy bound subquery node");
 	}
 	void Serialize(FieldWriter &writer) const override {
-		throw InternalException("Cannot copy bound subquery node");
+		throw InternalException("Cannot serialize bound subquery node");
 	}
 };
 
@@ -157447,37 +157965,36 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 	}
 
 	idx_t expected_columns = stmt.columns.empty() ? table->columns.size() : stmt.columns.size();
+
 	// special case: check if we are inserting from a VALUES statement
-	if (stmt.select_statement->node->type == QueryNodeType::SELECT_NODE) {
-		auto &node = (SelectNode &)*stmt.select_statement->node;
-		if (node.from_table->type == TableReferenceType::EXPRESSION_LIST) {
-			auto &expr_list = (ExpressionListRef &)*node.from_table;
-			expr_list.expected_types.resize(expected_columns);
-			expr_list.expected_names.resize(expected_columns);
-
-			D_ASSERT(expr_list.values.size() > 0);
-			CheckInsertColumnCountMismatch(expected_columns, expr_list.values[0].size(), !stmt.columns.empty(),
-			                               table->name.c_str());
-
-			// VALUES list!
-			for (idx_t col_idx = 0; col_idx < expected_columns; col_idx++) {
-				idx_t table_col_idx = stmt.columns.empty() ? col_idx : named_column_map[col_idx];
-				D_ASSERT(table_col_idx < table->columns.size());
-
-				// set the expected types as the types for the INSERT statement
-				auto &column = table->columns[table_col_idx];
-				expr_list.expected_types[col_idx] = column.type;
-				expr_list.expected_names[col_idx] = column.name;
-
-				// now replace any DEFAULT values with the corresponding default expression
-				for (idx_t list_idx = 0; list_idx < expr_list.values.size(); list_idx++) {
-					if (expr_list.values[list_idx][col_idx]->type == ExpressionType::VALUE_DEFAULT) {
-						// DEFAULT value! replace the entry
-						if (column.default_value) {
-							expr_list.values[list_idx][col_idx] = column.default_value->Copy();
-						} else {
-							expr_list.values[list_idx][col_idx] = make_unique<ConstantExpression>(Value(column.type));
-						}
+	auto values_list = stmt.GetValuesList();
+	if (values_list) {
+		auto &expr_list = (ExpressionListRef &)*values_list;
+		expr_list.expected_types.resize(expected_columns);
+		expr_list.expected_names.resize(expected_columns);
+
+		D_ASSERT(expr_list.values.size() > 0);
+		CheckInsertColumnCountMismatch(expected_columns, expr_list.values[0].size(), !stmt.columns.empty(),
+		                               table->name.c_str());
+
+		// VALUES list!
+		for (idx_t col_idx = 0; col_idx < expected_columns; col_idx++) {
+			idx_t table_col_idx = stmt.columns.empty() ? col_idx : named_column_map[col_idx];
+			D_ASSERT(table_col_idx < table->columns.size());
+
+			// set the expected types as the types for the INSERT statement
+			auto &column = table->columns[table_col_idx];
+			expr_list.expected_types[col_idx] = column.type;
+			expr_list.expected_names[col_idx] = column.name;
+
+			// now replace any DEFAULT values with the corresponding default expression
+			for (idx_t list_idx = 0; list_idx < expr_list.values.size(); list_idx++) {
+				if (expr_list.values[list_idx][col_idx]->type == ExpressionType::VALUE_DEFAULT) {
+					// DEFAULT value! replace the entry
+					if (column.default_value) {
+						expr_list.values[list_idx][col_idx] = column.default_value->Copy();
+					} else {
+						expr_list.values[list_idx][col_idx] = make_unique<ConstantExpression>(Value(column.type));
 					}
 				}
 			}