duckdb 0.7.2-dev0.0 → 0.7.2-dev1034.0

package/src/duckdb/src/include/duckdb/parser/parsed_data/{alter_function_info.hpp → alter_scalar_function_info.hpp}

@@ -1,29 +1,29 @@
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/alter_function_info.hpp
+// duckdb/parser/parsed_data/alter_scalar_function_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
 
 #pragma once
 
-#include "duckdb/parser/parsed_data/alter_info.hpp"
-#include "duckdb/function/scalar_function.hpp"
 #include "duckdb/function/function_set.hpp"
+#include "duckdb/function/scalar_function.hpp"
+#include "duckdb/parser/parsed_data/alter_info.hpp"
 
 namespace duckdb {
 
 //===--------------------------------------------------------------------===//
-// Alter Table
+// Alter Scalar Function
 //===--------------------------------------------------------------------===//
-enum class AlterFunctionType : uint8_t { INVALID = 0, ADD_FUNCTION_OVERLOADS = 1 };
+enum class AlterScalarFunctionType : uint8_t { INVALID = 0, ADD_FUNCTION_OVERLOADS = 1 };
 
-struct AlterFunctionInfo : public AlterInfo {
-	AlterFunctionInfo(AlterFunctionType type, AlterEntryData data);
-	virtual ~AlterFunctionInfo() override;
+struct AlterScalarFunctionInfo : public AlterInfo {
+	AlterScalarFunctionInfo(AlterScalarFunctionType type, AlterEntryData data);
+	virtual ~AlterScalarFunctionInfo() override;
 
-	AlterFunctionType alter_function_type;
+	AlterScalarFunctionType alter_scalar_function_type;
 
 public:
 	CatalogType GetCatalogType() const override;
@@ -32,11 +32,11 @@ public:
 };
 
 //===--------------------------------------------------------------------===//
-// AddFunctionOverloadInfo
+// AddScalarFunctionOverloadInfo
 //===--------------------------------------------------------------------===//
-struct AddFunctionOverloadInfo : public AlterFunctionInfo {
-	AddFunctionOverloadInfo(AlterEntryData data, ScalarFunctionSet new_overloads);
-	~AddFunctionOverloadInfo() override;
+struct AddScalarFunctionOverloadInfo : public AlterScalarFunctionInfo {
+	AddScalarFunctionOverloadInfo(AlterEntryData data, ScalarFunctionSet new_overloads);
+	~AddScalarFunctionOverloadInfo() override;
 
 	ScalarFunctionSet new_overloads;
 

package/src/duckdb/src/include/duckdb/parser/parsed_data/alter_table_function_info.hpp

@@ -0,0 +1,47 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/alter_scalar_function_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/function/function_set.hpp"
+#include "duckdb/function/table_function.hpp"
+#include "duckdb/parser/parsed_data/alter_info.hpp"
+
+namespace duckdb {
+
+//===--------------------------------------------------------------------===//
+// Alter Table Function
+//===--------------------------------------------------------------------===//
+enum class AlterTableFunctionType : uint8_t { INVALID = 0, ADD_FUNCTION_OVERLOADS = 1 };
+
+struct AlterTableFunctionInfo : public AlterInfo {
+	AlterTableFunctionInfo(AlterTableFunctionType type, AlterEntryData data);
+	virtual ~AlterTableFunctionInfo() override;
+
+	AlterTableFunctionType alter_table_function_type;
+
+public:
+	CatalogType GetCatalogType() const override;
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader);
+};
+
+//===--------------------------------------------------------------------===//
+// AddTableFunctionOverloadInfo
+//===--------------------------------------------------------------------===//
+struct AddTableFunctionOverloadInfo : public AlterTableFunctionInfo {
+	AddTableFunctionOverloadInfo(AlterEntryData data, TableFunctionSet new_overloads);
+	~AddTableFunctionOverloadInfo() override;
+
+	TableFunctionSet new_overloads;
+
+public:
+	unique_ptr<AlterInfo> Copy() const override;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/parsed_data/alter_table_info.hpp

@@ -137,6 +137,9 @@ public:
 	unique_ptr<AlterInfo> Copy() const override;
 	void SerializeAlterTable(FieldWriter &writer) const override;
 	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, AlterEntryData data);
+	string GetColumnName() const override {
+		return removed_column;
+	};
 };
 
 //===--------------------------------------------------------------------===//
@@ -158,6 +161,9 @@ public:
 	unique_ptr<AlterInfo> Copy() const override;
 	void SerializeAlterTable(FieldWriter &writer) const override;
 	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, AlterEntryData data);
+	string GetColumnName() const override {
+		return column_name;
+	};
 };
 
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/include/duckdb/parser/parsed_data/create_table_function_info.hpp

@@ -21,7 +21,8 @@ struct CreateTableFunctionInfo : public CreateFunctionInfo {
 	TableFunctionSet functions;
 
 public:
-	DUCKDB_API unique_ptr<CreateInfo> Copy() const;
+	DUCKDB_API unique_ptr<CreateInfo> Copy() const override;
+	DUCKDB_API unique_ptr<AlterInfo> GetAlterInfo() const override;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/parsed_data/sample_options.hpp

@@ -29,6 +29,8 @@ struct SampleOptions {
 	void Serialize(Serializer &serializer);
 	static unique_ptr<SampleOptions> Deserialize(Deserializer &source);
 	static bool Equals(SampleOptions *a, SampleOptions *b);
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<SampleOptions> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/parsed_expression.hpp

@@ -19,6 +19,8 @@ class Serializer;
 class Deserializer;
 class FieldWriter;
 class FieldReader;
+class FormatDeserializer;
+class FormatSerializer;
 
 //!  The ParsedExpression class is a base class that can represent any expression
 //!  part of a SQL statement.
@@ -60,6 +62,9 @@ public:
 	//! SerializationException]
 	static unique_ptr<ParsedExpression> Deserialize(Deserializer &source);
 
+	virtual void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<ParsedExpression> FormatDeserialize(FormatDeserializer &deserializer);
+
 protected:
 	//! Copy base Expression properties from another expression to this one,
 	//! used in Copy method

package/src/duckdb/src/include/duckdb/parser/query_node/recursive_cte_node.hpp

@@ -44,6 +44,9 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	//! Deserializes a blob back into a QueryNode
 	static unique_ptr<QueryNode> Deserialize(FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<QueryNode> FormatDeserialize(FormatDeserializer &source);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/query_node/select_node.hpp

@@ -49,13 +49,18 @@ public:
 	string ToString() const override;
 
 	bool Equals(const QueryNode *other) const override;
+
 	//! Create a copy of this SelectNode
 	unique_ptr<QueryNode> Copy() const override;
 
 	//! Serializes a QueryNode to a stand-alone binary blob
 	void Serialize(FieldWriter &writer) const override;
+
 	//! Deserializes a blob back into a QueryNode
 	static unique_ptr<QueryNode> Deserialize(FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<QueryNode> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/query_node/set_operation_node.hpp

@@ -43,6 +43,9 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	//! Deserializes a blob back into a QueryNode
 	static unique_ptr<QueryNode> Deserialize(FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<QueryNode> FormatDeserialize(FormatDeserializer &source);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/query_node.hpp

@@ -13,10 +13,14 @@
 #include "duckdb/parser/parsed_expression.hpp"
 #include "duckdb/parser/result_modifier.hpp"
 #include "duckdb/parser/common_table_expression_info.hpp"
+#include "duckdb/common/case_insensitive_map.hpp"
 
 namespace duckdb {
 
-enum QueryNodeType : uint8_t {
+class FormatDeserializer;
+class FormatSerializer;
+
+enum class QueryNodeType : uint8_t {
 	SELECT_NODE = 1,
 	SET_OPERATION_NODE = 2,
 	BOUND_SUBQUERY_NODE = 3,
@@ -29,11 +33,15 @@ class CommonTableExpressionMap {
 public:
 	CommonTableExpressionMap();
 
-	unordered_map<string, unique_ptr<CommonTableExpressionInfo>> map;
+	case_insensitive_map_t<unique_ptr<CommonTableExpressionInfo>> map;
 
 public:
 	string ToString() const;
 	CommonTableExpressionMap Copy() const;
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	// static void FormatDeserialize(FormatDeserializer &deserializer, CommonTableExpressionMap &ret);
+	static CommonTableExpressionMap FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 class QueryNode {
@@ -72,6 +80,9 @@ public:
 	//! Adds a distinct modifier to the query node
 	void AddDistinct();
 
+	virtual void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<QueryNode> FormatDeserialize(FormatDeserializer &deserializer);
+
 protected:
 	//! Copy base QueryNode properties from another expression to this one,
 	//! used in Copy method

package/src/duckdb/src/include/duckdb/parser/result_modifier.hpp

@@ -16,14 +16,19 @@
 namespace duckdb {
 class FieldWriter;
 class FieldReader;
+class FormatDeserializer;
+class FormatSerializer;
 
-enum ResultModifierType : uint8_t {
+enum class ResultModifierType : uint8_t {
 	LIMIT_MODIFIER = 1,
 	ORDER_MODIFIER = 2,
 	DISTINCT_MODIFIER = 3,
 	LIMIT_PERCENT_MODIFIER = 4
 };
 
+const char *ToString(ResultModifierType value);
+ResultModifierType ResultModifierFromString(const char *value);
+
 //! A ResultModifier
 class ResultModifier {
 public:
@@ -46,6 +51,9 @@ public:
 	virtual void Serialize(FieldWriter &writer) const = 0;
 	//! Deserializes a blob back into a ResultModifier
 	static unique_ptr<ResultModifier> Deserialize(Deserializer &source);
+
+	virtual void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<ResultModifier> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 //! Single node in ORDER BY statement
@@ -65,6 +73,9 @@ public:
 	void Serialize(Serializer &serializer) const;
 	string ToString() const;
 	static OrderByNode Deserialize(Deserializer &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static OrderByNode FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 class LimitModifier : public ResultModifier {
@@ -82,6 +93,9 @@ public:
 	unique_ptr<ResultModifier> Copy() const override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ResultModifier> Deserialize(FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ResultModifier> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 class OrderModifier : public ResultModifier {
@@ -97,6 +111,9 @@ public:
 	unique_ptr<ResultModifier> Copy() const override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ResultModifier> Deserialize(FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ResultModifier> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 class DistinctModifier : public ResultModifier {
@@ -112,6 +129,9 @@ public:
 	unique_ptr<ResultModifier> Copy() const override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ResultModifier> Deserialize(FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ResultModifier> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 class LimitPercentModifier : public ResultModifier {
@@ -129,6 +149,9 @@ public:
 	unique_ptr<ResultModifier> Copy() const override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ResultModifier> Deserialize(FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ResultModifier> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/sql_statement.hpp

@@ -19,7 +19,8 @@ namespace duckdb {
 //! SQLStatement is the base class of any type of SQL statement.
 class SQLStatement {
 public:
-	explicit SQLStatement(StatementType type) : type(type) {};
+	explicit SQLStatement(StatementType type) : type(type) {
+	}
 	virtual ~SQLStatement() {
 	}
 

package/src/duckdb/src/include/duckdb/parser/statement/multi_statement.hpp

@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/statement/multi_statement.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/parser/sql_statement.hpp"
+
+namespace duckdb {
+
+class MultiStatement : public SQLStatement {
+public:
+	MultiStatement();
+
+	vector<unique_ptr<SQLStatement>> statements;
+
+protected:
+	MultiStatement(const MultiStatement &other);
+
+public:
+	unique_ptr<SQLStatement> Copy() const override;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/statement/select_statement.hpp

@@ -10,13 +10,15 @@
 
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/query_node.hpp"
 #include "duckdb/parser/sql_statement.hpp"
 #include "duckdb/parser/tableref.hpp"
+#include "duckdb/parser/query_node.hpp"
 
 namespace duckdb {
 
 class QueryNode;
+class FormatSerializer;
+class FormatDeserializer;
 
 //! SelectStatement is a typical SELECT clause
 class SelectStatement : public SQLStatement {
@@ -42,5 +44,8 @@ public:
 	static unique_ptr<SelectStatement> Deserialize(Deserializer &source);
 	//! Whether or not the statements are equivalent
 	bool Equals(const SQLStatement *other) const;
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<SelectStatement> FormatDeserialize(FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/tableref/basetableref.hpp

@@ -38,5 +38,9 @@ public:
 	void Serialize(FieldWriter &serializer) const override;
 	//! Deserializes a blob back into a BaseTableRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &source);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/tableref/emptytableref.hpp

@@ -27,5 +27,7 @@ public:
 	void Serialize(FieldWriter &serializer) const override;
 	//! Deserializes a blob back into a DummyTableRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &source);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/tableref/expressionlistref.hpp

@@ -37,5 +37,8 @@ public:
 	void Serialize(FieldWriter &serializer) const override;
 	//! Deserializes a blob back into a ExpressionListRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &source);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/tableref/joinref.hpp

@@ -47,5 +47,8 @@ public:
 	void Serialize(FieldWriter &serializer) const override;
 	//! Deserializes a blob back into a JoinRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &source);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/tableref/list.hpp

@@ -2,5 +2,6 @@
 #include "duckdb/parser/tableref/emptytableref.hpp"
 #include "duckdb/parser/tableref/expressionlistref.hpp"
 #include "duckdb/parser/tableref/joinref.hpp"
+#include "duckdb/parser/tableref/pivotref.hpp"
 #include "duckdb/parser/tableref/subqueryref.hpp"
 #include "duckdb/parser/tableref/table_function_ref.hpp"

package/src/duckdb/src/include/duckdb/parser/tableref/pivotref.hpp

@@ -0,0 +1,87 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/tableref/pivotref.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/parser/tableref.hpp"
+
+namespace duckdb {
+
+struct PivotColumnEntry {
+	//! The set of values to match on
+	vector<Value> values;
+	//! The star expression (UNPIVOT only)
+	unique_ptr<ParsedExpression> star_expr;
+	//! The alias of the pivot column entry
+	string alias;
+
+	bool Equals(const PivotColumnEntry &other) const;
+	void Serialize(Serializer &serializer) const;
+	PivotColumnEntry Copy() const;
+	static PivotColumnEntry Deserialize(Deserializer &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static PivotColumnEntry FormatDeserialize(FormatDeserializer &source);
+};
+
+struct PivotColumn {
+	//! The set of expressions to pivot on
+	vector<unique_ptr<ParsedExpression>> pivot_expressions;
+	//! The set of unpivot names
+	vector<string> unpivot_names;
+	//! The set of values to pivot on
+	vector<PivotColumnEntry> entries;
+	//! The enum to read pivot values from (if any)
+	string pivot_enum;
+
+	string ToString() const;
+	bool Equals(const PivotColumn &other) const;
+	void Serialize(Serializer &serializer) const;
+	PivotColumn Copy() const;
+	static PivotColumn Deserialize(Deserializer &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static PivotColumn FormatDeserialize(FormatDeserializer &source);
+};
+
+//! Represents a PIVOT or UNPIVOT expression
+class PivotRef : public TableRef {
+public:
+	explicit PivotRef() : TableRef(TableReferenceType::PIVOT), include_nulls(false) {
+	}
+
+	//! The source table of the pivot
+	unique_ptr<TableRef> source;
+	//! The aggregates to compute over the pivot (PIVOT only)
+	vector<unique_ptr<ParsedExpression>> aggregates;
+	//! The names of the unpivot expressions (UNPIVOT only)
+	vector<string> unpivot_names;
+	//! The set of pivots
+	vector<PivotColumn> pivots;
+	//! The groups to pivot over. If none are specified all columns not included in the pivots/aggregate are chosen.
+	vector<string> groups;
+	//! Aliases for the column names
+	vector<string> column_name_alias;
+	//! Whether or not to include nulls in the result (UNPIVOT only)
+	bool include_nulls;
+
+public:
+	string ToString() const override;
+	bool Equals(const TableRef *other_p) const override;
+
+	unique_ptr<TableRef> Copy() override;
+
+	//! Serializes a blob into a JoinRef
+	void Serialize(FieldWriter &serializer) const override;
+	//! Deserializes a blob back into a JoinRef
+	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &source);
+};
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/tableref/subqueryref.hpp

@@ -32,5 +32,8 @@ public:
 	void Serialize(FieldWriter &serializer) const override;
 	//! Deserializes a blob back into a SubqueryRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &source);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/tableref/table_function_ref.hpp

@@ -40,5 +40,8 @@ public:
 	void Serialize(FieldWriter &serializer) const override;
 	//! Deserializes a blob back into a BaseTableRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &source);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/tableref.hpp

@@ -48,8 +48,10 @@ public:
 	DUCKDB_API virtual void Serialize(FieldWriter &writer) const = 0;
 	//! Deserializes a blob back into a TableRef
 	DUCKDB_API static unique_ptr<TableRef> Deserialize(Deserializer &source);
-
 	//! Copy the properties of this table ref to the target
 	void CopyProperties(TableRef &target) const;
+
+	virtual void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/tokens.hpp

@@ -41,6 +41,7 @@ class SetVariableStatement;
 class ResetVariableStatement;
 class LoadStatement;
 class LogicalPlanStatement;
+class MultiStatement;
 
 //===--------------------------------------------------------------------===//
 // Query Node
@@ -94,6 +95,7 @@ class SubqueryRef;
 class TableFunctionRef;
 class EmptyTableRef;
 class ExpressionListRef;
+class PivotRef;
 
 //===--------------------------------------------------------------------===//
 // Other