duckdb 0.7.2-dev12.0 → 0.7.2-dev1238.0

package/src/duckdb/src/parser/query_node/set_operation_node.cpp

@@ -1,6 +1,8 @@
 #include "duckdb/parser/query_node/set_operation_node.hpp"
 
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -81,4 +83,19 @@ unique_ptr<QueryNode> SetOperationNode::Deserialize(FieldReader &reader) {
 	return std::move(result);
 }
 
+void SetOperationNode::FormatSerialize(duckdb::FormatSerializer &serializer) const {
+	QueryNode::FormatSerialize(serializer);
+	serializer.WriteProperty("set_op_type", setop_type);
+	serializer.WriteProperty("left", *left);
+	serializer.WriteProperty("right", *right);
+}
+
+unique_ptr<QueryNode> SetOperationNode::FormatDeserialize(duckdb::FormatDeserializer &deserializer) {
+	auto result = make_unique<SetOperationNode>();
+	deserializer.ReadProperty("set_op_type", result->setop_type);
+	deserializer.ReadProperty("left", result->left);
+	deserializer.ReadProperty("right", result->right);
+	return std::move(result);
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/query_node.cpp

@@ -5,6 +5,8 @@
 #include "duckdb/parser/query_node/recursive_cte_node.hpp"
 #include "duckdb/common/limits.hpp"
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -65,6 +67,16 @@ string CommonTableExpressionMap::ToString() const {
 	return result;
 }
 
+void CommonTableExpressionMap::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("map", map);
+}
+
+CommonTableExpressionMap CommonTableExpressionMap::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = CommonTableExpressionMap();
+	deserializer.ReadProperty("map", result.map);
+	return result;
+}
+
 string QueryNode::ResultModifiersToString() const {
 	string result;
 	for (idx_t modifier_idx = 0; modifier_idx < modifiers.size(); modifier_idx++) {
@@ -155,6 +167,7 @@ void QueryNode::Serialize(Serializer &main_serializer) const {
 	writer.WriteField<QueryNodeType>(type);
 	writer.WriteSerializableList(modifiers);
 	// cte_map
+
 	writer.WriteField<uint32_t>((uint32_t)cte_map.map.size());
 	auto &serializer = writer.GetSerializer();
 	for (auto &cte : cte_map.map) {
@@ -163,9 +176,46 @@ void QueryNode::Serialize(Serializer &main_serializer) const {
 		cte.second->query->Serialize(serializer);
 	}
 	Serialize(writer);
+
 	writer.Finalize();
 }
 
+// Children should call the base method before their own.
+void QueryNode::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("type", type);
+	serializer.WriteProperty("modifiers", modifiers);
+	serializer.WriteProperty("cte_map", cte_map);
+}
+
+unique_ptr<QueryNode> QueryNode::FormatDeserialize(FormatDeserializer &deserializer) {
+
+	auto type = deserializer.ReadProperty<QueryNodeType>("type");
+
+	auto modifiers = deserializer.ReadProperty<vector<unique_ptr<ResultModifier>>>("modifiers");
+	auto cte_map = deserializer.ReadProperty<CommonTableExpressionMap>("cte_map");
+
+	unique_ptr<QueryNode> result;
+
+	switch (type) {
+	case QueryNodeType::SELECT_NODE:
+		result = SelectNode::FormatDeserialize(deserializer);
+		break;
+	case QueryNodeType::SET_OPERATION_NODE:
+		result = SetOperationNode::FormatDeserialize(deserializer);
+		break;
+	case QueryNodeType::RECURSIVE_CTE_NODE:
+		result = RecursiveCTENode::FormatDeserialize(deserializer);
+		break;
+	default:
+		throw SerializationException("Could not deserialize Query Node: unknown type!");
+	}
+
+	result->type = type;
+	result->modifiers = std::move(modifiers);
+	result->cte_map = std::move(cte_map);
+	return result;
+}
+
 unique_ptr<QueryNode> QueryNode::Deserialize(Deserializer &main_source) {
 	FieldReader reader(main_source);
 
@@ -174,7 +224,7 @@ unique_ptr<QueryNode> QueryNode::Deserialize(Deserializer &main_source) {
 	// cte_map
 	auto cte_count = reader.ReadRequired<uint32_t>();
 	auto &source = reader.GetSource();
-	unordered_map<string, unique_ptr<CommonTableExpressionInfo>> new_map;
+	case_insensitive_map_t<unique_ptr<CommonTableExpressionInfo>> new_map;
 	for (idx_t i = 0; i < cte_count; i++) {
 		auto name = source.Read<string>();
 		auto info = make_unique<CommonTableExpressionInfo>();

package/src/duckdb/src/parser/result_modifier.cpp

@@ -1,6 +1,8 @@
 #include "duckdb/parser/result_modifier.hpp"
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/expression_util.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -18,6 +20,33 @@ void ResultModifier::Serialize(Serializer &serializer) const {
 	writer.Finalize();
 }
 
+void ResultModifier::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("type", type);
+}
+
+std::unique_ptr<ResultModifier> ResultModifier::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto type = deserializer.ReadProperty<ResultModifierType>("type");
+
+	unique_ptr<ResultModifier> result;
+	switch (type) {
+	case ResultModifierType::LIMIT_MODIFIER:
+		result = LimitModifier::FormatDeserialize(deserializer);
+		break;
+	case ResultModifierType::ORDER_MODIFIER:
+		result = OrderModifier::FormatDeserialize(deserializer);
+		break;
+	case ResultModifierType::DISTINCT_MODIFIER:
+		result = DistinctModifier::FormatDeserialize(deserializer);
+		break;
+	case ResultModifierType::LIMIT_PERCENT_MODIFIER:
+		result = LimitPercentModifier::FormatDeserialize(deserializer);
+		break;
+	default:
+		throw InternalException("Unrecognized ResultModifierType for Deserialization");
+	}
+	return result;
+}
+
 unique_ptr<ResultModifier> ResultModifier::Deserialize(Deserializer &source) {
 	FieldReader reader(source);
 	auto type = reader.ReadRequired<ResultModifierType>();
@@ -73,6 +102,16 @@ void LimitModifier::Serialize(FieldWriter &writer) const {
 	writer.WriteOptional(offset);
 }
 
+void LimitModifier::FormatSerialize(FormatSerializer &serializer) const {
+	ResultModifier::FormatSerialize(serializer);
+	serializer.WriteOptionalProperty("limit", limit);
+	serializer.WriteOptionalProperty("offset", offset);
+}
+
+unique_ptr<ResultModifier> LimitModifier::FormatDeserialize(FormatDeserializer &deserializer) {
+	throw NotImplementedException("err");
+}
+
 unique_ptr<ResultModifier> LimitModifier::Deserialize(FieldReader &reader) {
 	auto mod = make_unique<LimitModifier>();
 	mod->limit = reader.ReadOptional<ParsedExpression>(nullptr);
@@ -103,6 +142,16 @@ void DistinctModifier::Serialize(FieldWriter &writer) const {
 	writer.WriteSerializableList(distinct_on_targets);
 }
 
+void DistinctModifier::FormatSerialize(duckdb::FormatSerializer &serializer) const {
+	ResultModifier::FormatSerialize(serializer);
+	serializer.WriteProperty("distinct_on_targets", distinct_on_targets);
+}
+
+unique_ptr<ResultModifier> DistinctModifier::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto mod = make_unique<DistinctModifier>();
+	throw NotImplementedException("");
+}
+
 unique_ptr<ResultModifier> DistinctModifier::Deserialize(FieldReader &reader) {
 	auto mod = make_unique<DistinctModifier>();
 	mod->distinct_on_targets = reader.ReadRequiredSerializableList<ParsedExpression>();
@@ -170,6 +219,16 @@ void OrderByNode::Serialize(Serializer &serializer) const {
 	writer.Finalize();
 }
 
+void OrderByNode::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("type", type);
+	serializer.WriteProperty("null_order", null_order);
+	serializer.WriteProperty("expression", expression);
+}
+
+OrderByNode OrderByNode::FormatDeserialize(FormatDeserializer &deserializer) {
+	throw NotImplementedException("err");
+}
+
 OrderByNode OrderByNode::Deserialize(Deserializer &source) {
 	FieldReader reader(source);
 	auto type = reader.ReadRequired<OrderType>();
@@ -183,6 +242,14 @@ void OrderModifier::Serialize(FieldWriter &writer) const {
 	writer.WriteRegularSerializableList(orders);
 }
 
+void OrderModifier::FormatSerialize(FormatSerializer &serializer) const {
+	ResultModifier::FormatSerialize(serializer);
+	serializer.WriteProperty("orders", orders);
+}
+unique_ptr<ResultModifier> OrderModifier::FormatDeserialize(FormatDeserializer &deserializer) {
+	throw NotImplementedException("err");
+}
+
 unique_ptr<ResultModifier> OrderModifier::Deserialize(FieldReader &reader) {
 	auto mod = make_unique<OrderModifier>();
 	mod->orders = reader.ReadRequiredSerializableList<OrderByNode, OrderByNode>();
@@ -219,6 +286,12 @@ void LimitPercentModifier::Serialize(FieldWriter &writer) const {
 	writer.WriteOptional(offset);
 }
 
+void LimitPercentModifier::FormatSerialize(FormatSerializer &serializer) const {
+	ResultModifier::FormatSerialize(serializer);
+	serializer.WriteProperty("limit", limit);
+	serializer.WriteProperty("offset", offset);
+}
+
 unique_ptr<ResultModifier> LimitPercentModifier::Deserialize(FieldReader &reader) {
 	auto mod = make_unique<LimitPercentModifier>();
 	mod->limit = reader.ReadOptional<ParsedExpression>(nullptr);
@@ -226,4 +299,9 @@ unique_ptr<ResultModifier> LimitPercentModifier::Deserialize(FieldReader &reader
 	return std::move(mod);
 }
 
+unique_ptr<ResultModifier> LimitPercentModifier::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto mod = make_unique<LimitPercentModifier>();
+	throw NotImplementedException("err");
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/statement/multi_statement.cpp

@@ -0,0 +1,18 @@
+#include "duckdb/parser/statement/multi_statement.hpp"
+
+namespace duckdb {
+
+MultiStatement::MultiStatement() : SQLStatement(StatementType::MULTI_STATEMENT) {
+}
+
+MultiStatement::MultiStatement(const MultiStatement &other) : SQLStatement(other) {
+	for (auto &stmt : other.statements) {
+		statements.push_back(stmt->Copy());
+	}
+}
+
+unique_ptr<SQLStatement> MultiStatement::Copy() const {
+	return unique_ptr<MultiStatement>(new MultiStatement(*this));
+}
+
+} // namespace duckdb

package/src/duckdb/src/parser/statement/select_statement.cpp

@@ -1,6 +1,8 @@
 #include "duckdb/parser/statement/select_statement.hpp"
 
 #include "duckdb/common/serializer.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -15,12 +17,22 @@ void SelectStatement::Serialize(Serializer &serializer) const {
 	node->Serialize(serializer);
 }
 
+void SelectStatement::FormatSerialize(FormatSerializer &serializer) const {
+	node->FormatSerialize(serializer);
+}
+
 unique_ptr<SelectStatement> SelectStatement::Deserialize(Deserializer &source) {
 	auto result = make_unique<SelectStatement>();
 	result->node = QueryNode::Deserialize(source);
 	return result;
 }
 
+unique_ptr<SelectStatement> SelectStatement::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = make_unique<SelectStatement>();
+	deserializer.ReadProperty("node", result->node);
+	return result;
+}
+
 bool SelectStatement::Equals(const SQLStatement *other_p) const {
 	if (type != other_p->type) {
 		return false;

package/src/duckdb/src/parser/tableref/basetableref.cpp

@@ -2,6 +2,8 @@
 
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/keyword_helper.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -29,6 +31,25 @@ void BaseTableRef::Serialize(FieldWriter &writer) const {
 	writer.WriteString(catalog_name);
 }
 
+void BaseTableRef::FormatSerialize(FormatSerializer &serializer) const {
+	TableRef::FormatSerialize(serializer);
+	serializer.WriteProperty("schema_name", schema_name);
+	serializer.WriteProperty("table_name", table_name);
+	serializer.WriteProperty("column_name_alias", column_name_alias);
+	serializer.WriteProperty("catalog_name", catalog_name);
+}
+
+unique_ptr<TableRef> BaseTableRef::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = make_unique<BaseTableRef>();
+
+	deserializer.ReadProperty("schema_name", result->schema_name);
+	deserializer.ReadProperty("table_name", result->table_name);
+	deserializer.ReadProperty("column_name_alias", result->column_name_alias);
+	deserializer.ReadProperty("catalog_name", result->catalog_name);
+
+	return std::move(result);
+}
+
 unique_ptr<TableRef> BaseTableRef::Deserialize(FieldReader &reader) {
 	auto result = make_unique<BaseTableRef>();
 

package/src/duckdb/src/parser/tableref/emptytableref.cpp

@@ -23,4 +23,8 @@ unique_ptr<TableRef> EmptyTableRef::Deserialize(FieldReader &reader) {
 	return make_unique<EmptyTableRef>();
 }
 
+unique_ptr<TableRef> EmptyTableRef::FormatDeserialize(FormatDeserializer &source) {
+	return make_unique<EmptyTableRef>();
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/tableref/expressionlistref.cpp

@@ -1,6 +1,8 @@
 #include "duckdb/parser/tableref/expressionlistref.hpp"
 
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -73,6 +75,21 @@ void ExpressionListRef::Serialize(FieldWriter &writer) const {
 	}
 }
 
+void ExpressionListRef::FormatSerialize(FormatSerializer &serializer) const {
+	TableRef::FormatSerialize(serializer);
+	serializer.WriteProperty("expected_names", expected_names);
+	serializer.WriteProperty("expected_types", expected_types);
+	serializer.WriteProperty("values", values);
+}
+
+unique_ptr<TableRef> ExpressionListRef::FormatDeserialize(FormatDeserializer &source) {
+	auto result = make_unique<ExpressionListRef>();
+	source.ReadProperty("expected_names", result->expected_names);
+	source.ReadProperty("expected_types", result->expected_types);
+	source.ReadProperty("values", result->values);
+	return std::move(result);
+}
+
 unique_ptr<TableRef> ExpressionListRef::Deserialize(FieldReader &reader) {
 	auto result = make_unique<ExpressionListRef>();
 	// value list

package/src/duckdb/src/parser/tableref/joinref.cpp

@@ -2,6 +2,8 @@
 
 #include "duckdb/common/limits.hpp"
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -16,6 +18,10 @@ string JoinRef::ToString() const {
 		result += "NATURAL ";
 		result += JoinTypeToString(type) + " JOIN ";
 		break;
+	case JoinRefType::ASOF:
+		result += "ASOF ";
+		result += JoinTypeToString(type) + " JOIN ";
+		break;
 	case JoinRefType::CROSS:
 		result += ", ";
 		break;
@@ -82,6 +88,29 @@ void JoinRef::Serialize(FieldWriter &writer) const {
 	writer.WriteList<string>(using_columns);
 }
 
+void JoinRef::FormatSerialize(FormatSerializer &serializer) const {
+	TableRef::FormatSerialize(serializer);
+	serializer.WriteProperty("left", *left);
+	serializer.WriteProperty("right", *right);
+	serializer.WriteOptionalProperty("condition", condition);
+	serializer.WriteProperty("join_type", type);
+	serializer.WriteProperty("ref_type", ref_type);
+	serializer.WriteProperty("using_columns", using_columns);
+}
+
+unique_ptr<TableRef> JoinRef::FormatDeserialize(FormatDeserializer &source) {
+	auto result = make_unique<JoinRef>(JoinRefType::REGULAR);
+
+	source.ReadProperty("left", result->left);
+	source.ReadProperty("right", result->right);
+	source.ReadOptionalProperty("condition", result->condition);
+	source.ReadProperty("join_type", result->type);
+	source.ReadProperty("ref_type", result->ref_type);
+	source.ReadProperty("using_columns", result->using_columns);
+
+	return std::move(result);
+}
+
 unique_ptr<TableRef> JoinRef::Deserialize(FieldReader &reader) {
 	auto result = make_unique<JoinRef>(JoinRefType::REGULAR);
 	result->left = reader.ReadRequiredSerializable<TableRef>();