duckdb 0.8.2-dev4142.0 → 0.8.2-dev4314.0

package/src/duckdb/src/storage/serialization/serialize_expression.cpp

@@ -3,19 +3,19 @@
 // Do not edit this file manually, your changes will be overwritten
 //===----------------------------------------------------------------------===//
 
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 #include "duckdb/planner/expression/list.hpp"
 
 namespace duckdb {
 
-void Expression::FormatSerialize(FormatSerializer &serializer) const {
+void Expression::Serialize(Serializer &serializer) const {
 	serializer.WriteProperty(100, "expression_class", expression_class);
 	serializer.WriteProperty(101, "type", type);
 	serializer.WriteProperty(102, "alias", alias);
 }
 
-unique_ptr<Expression> Expression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<Expression> Expression::Deserialize(Deserializer &deserializer) {
 	auto expression_class = deserializer.ReadProperty<ExpressionClass>(100, "expression_class");
 	auto type = deserializer.ReadProperty<ExpressionType>(101, "type");
 	auto alias = deserializer.ReadProperty<string>(102, "alias");
@@ -23,55 +23,55 @@ unique_ptr<Expression> Expression::FormatDeserialize(FormatDeserializer &deseria
 	unique_ptr<Expression> result;
 	switch (expression_class) {
 	case ExpressionClass::BOUND_AGGREGATE:
-		result = BoundAggregateExpression::FormatDeserialize(deserializer);
+		result = BoundAggregateExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::BOUND_BETWEEN:
-		result = BoundBetweenExpression::FormatDeserialize(deserializer);
+		result = BoundBetweenExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::BOUND_CASE:
-		result = BoundCaseExpression::FormatDeserialize(deserializer);
+		result = BoundCaseExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::BOUND_CAST:
-		result = BoundCastExpression::FormatDeserialize(deserializer);
+		result = BoundCastExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::BOUND_COLUMN_REF:
-		result = BoundColumnRefExpression::FormatDeserialize(deserializer);
+		result = BoundColumnRefExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::BOUND_COMPARISON:
-		result = BoundComparisonExpression::FormatDeserialize(deserializer);
+		result = BoundComparisonExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::BOUND_CONJUNCTION:
-		result = BoundConjunctionExpression::FormatDeserialize(deserializer);
+		result = BoundConjunctionExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::BOUND_CONSTANT:
-		result = BoundConstantExpression::FormatDeserialize(deserializer);
+		result = BoundConstantExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::BOUND_DEFAULT:
-		result = BoundDefaultExpression::FormatDeserialize(deserializer);
+		result = BoundDefaultExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::BOUND_FUNCTION:
-		result = BoundFunctionExpression::FormatDeserialize(deserializer);
+		result = BoundFunctionExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::BOUND_LAMBDA:
-		result = BoundLambdaExpression::FormatDeserialize(deserializer);
+		result = BoundLambdaExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::BOUND_LAMBDA_REF:
-		result = BoundLambdaRefExpression::FormatDeserialize(deserializer);
+		result = BoundLambdaRefExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::BOUND_OPERATOR:
-		result = BoundOperatorExpression::FormatDeserialize(deserializer);
+		result = BoundOperatorExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::BOUND_PARAMETER:
-		result = BoundParameterExpression::FormatDeserialize(deserializer);
+		result = BoundParameterExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::BOUND_REF:
-		result = BoundReferenceExpression::FormatDeserialize(deserializer);
+		result = BoundReferenceExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::BOUND_UNNEST:
-		result = BoundUnnestExpression::FormatDeserialize(deserializer);
+		result = BoundUnnestExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::BOUND_WINDOW:
-		result = BoundWindowExpression::FormatDeserialize(deserializer);
+		result = BoundWindowExpression::Deserialize(deserializer);
 		break;
 	default:
 		throw SerializationException("Unsupported type for deserialization of Expression!");
@@ -81,8 +81,8 @@ unique_ptr<Expression> Expression::FormatDeserialize(FormatDeserializer &deseria
 	return result;
 }
 
-void BoundBetweenExpression::FormatSerialize(FormatSerializer &serializer) const {
-	Expression::FormatSerialize(serializer);
+void BoundBetweenExpression::Serialize(Serializer &serializer) const {
+	Expression::Serialize(serializer);
 	serializer.WriteProperty(200, "input", input);
 	serializer.WriteProperty(201, "lower", lower);
 	serializer.WriteProperty(202, "upper", upper);
@@ -90,7 +90,7 @@ void BoundBetweenExpression::FormatSerialize(FormatSerializer &serializer) const
 	serializer.WriteProperty(204, "upper_inclusive", upper_inclusive);
 }
 
-unique_ptr<Expression> BoundBetweenExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<Expression> BoundBetweenExpression::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<BoundBetweenExpression>(new BoundBetweenExpression());
 	deserializer.ReadProperty(200, "input", result->input);
 	deserializer.ReadProperty(201, "lower", result->lower);
@@ -100,14 +100,14 @@ unique_ptr<Expression> BoundBetweenExpression::FormatDeserialize(FormatDeseriali
 	return std::move(result);
 }
 
-void BoundCaseExpression::FormatSerialize(FormatSerializer &serializer) const {
-	Expression::FormatSerialize(serializer);
+void BoundCaseExpression::Serialize(Serializer &serializer) const {
+	Expression::Serialize(serializer);
 	serializer.WriteProperty(200, "return_type", return_type);
 	serializer.WriteProperty(201, "case_checks", case_checks);
 	serializer.WriteProperty(202, "else_expr", else_expr);
 }
 
-unique_ptr<Expression> BoundCaseExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<Expression> BoundCaseExpression::Deserialize(Deserializer &deserializer) {
 	auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
 	auto result = duckdb::unique_ptr<BoundCaseExpression>(new BoundCaseExpression(std::move(return_type)));
 	deserializer.ReadProperty(201, "case_checks", result->case_checks);
@@ -115,14 +115,14 @@ unique_ptr<Expression> BoundCaseExpression::FormatDeserialize(FormatDeserializer
 	return std::move(result);
 }
 
-void BoundCastExpression::FormatSerialize(FormatSerializer &serializer) const {
-	Expression::FormatSerialize(serializer);
+void BoundCastExpression::Serialize(Serializer &serializer) const {
+	Expression::Serialize(serializer);
 	serializer.WriteProperty(200, "child", child);
 	serializer.WriteProperty(201, "return_type", return_type);
 	serializer.WriteProperty(202, "try_cast", try_cast);
 }
 
-unique_ptr<Expression> BoundCastExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<Expression> BoundCastExpression::Deserialize(Deserializer &deserializer) {
 	auto child = deserializer.ReadProperty<unique_ptr<Expression>>(200, "child");
 	auto return_type = deserializer.ReadProperty<LogicalType>(201, "return_type");
 	auto result = duckdb::unique_ptr<BoundCastExpression>(new BoundCastExpression(deserializer.Get<ClientContext &>(), std::move(child), std::move(return_type)));
@@ -130,14 +130,14 @@ unique_ptr<Expression> BoundCastExpression::FormatDeserialize(FormatDeserializer
 	return std::move(result);
 }
 
-void BoundColumnRefExpression::FormatSerialize(FormatSerializer &serializer) const {
-	Expression::FormatSerialize(serializer);
+void BoundColumnRefExpression::Serialize(Serializer &serializer) const {
+	Expression::Serialize(serializer);
 	serializer.WriteProperty(200, "return_type", return_type);
 	serializer.WriteProperty(201, "binding", binding);
 	serializer.WriteProperty(202, "depth", depth);
 }
 
-unique_ptr<Expression> BoundColumnRefExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<Expression> BoundColumnRefExpression::Deserialize(Deserializer &deserializer) {
 	auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
 	auto binding = deserializer.ReadProperty<ColumnBinding>(201, "binding");
 	auto depth = deserializer.ReadProperty<idx_t>(202, "depth");
@@ -145,61 +145,61 @@ unique_ptr<Expression> BoundColumnRefExpression::FormatDeserialize(FormatDeseria
 	return std::move(result);
 }
 
-void BoundComparisonExpression::FormatSerialize(FormatSerializer &serializer) const {
-	Expression::FormatSerialize(serializer);
+void BoundComparisonExpression::Serialize(Serializer &serializer) const {
+	Expression::Serialize(serializer);
 	serializer.WriteProperty(200, "left", left);
 	serializer.WriteProperty(201, "right", right);
 }
 
-unique_ptr<Expression> BoundComparisonExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<Expression> BoundComparisonExpression::Deserialize(Deserializer &deserializer) {
 	auto left = deserializer.ReadProperty<unique_ptr<Expression>>(200, "left");
 	auto right = deserializer.ReadProperty<unique_ptr<Expression>>(201, "right");
 	auto result = duckdb::unique_ptr<BoundComparisonExpression>(new BoundComparisonExpression(deserializer.Get<ExpressionType>(), std::move(left), std::move(right)));
 	return std::move(result);
 }
 
-void BoundConjunctionExpression::FormatSerialize(FormatSerializer &serializer) const {
-	Expression::FormatSerialize(serializer);
+void BoundConjunctionExpression::Serialize(Serializer &serializer) const {
+	Expression::Serialize(serializer);
 	serializer.WriteProperty(200, "children", children);
 }
 
-unique_ptr<Expression> BoundConjunctionExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<Expression> BoundConjunctionExpression::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<BoundConjunctionExpression>(new BoundConjunctionExpression(deserializer.Get<ExpressionType>()));
 	deserializer.ReadProperty(200, "children", result->children);
 	return std::move(result);
 }
 
-void BoundConstantExpression::FormatSerialize(FormatSerializer &serializer) const {
-	Expression::FormatSerialize(serializer);
+void BoundConstantExpression::Serialize(Serializer &serializer) const {
+	Expression::Serialize(serializer);
 	serializer.WriteProperty(200, "value", value);
 }
 
-unique_ptr<Expression> BoundConstantExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<Expression> BoundConstantExpression::Deserialize(Deserializer &deserializer) {
 	auto value = deserializer.ReadProperty<Value>(200, "value");
 	auto result = duckdb::unique_ptr<BoundConstantExpression>(new BoundConstantExpression(value));
 	return std::move(result);
 }
 
-void BoundDefaultExpression::FormatSerialize(FormatSerializer &serializer) const {
-	Expression::FormatSerialize(serializer);
+void BoundDefaultExpression::Serialize(Serializer &serializer) const {
+	Expression::Serialize(serializer);
 	serializer.WriteProperty(200, "return_type", return_type);
 }
 
-unique_ptr<Expression> BoundDefaultExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<Expression> BoundDefaultExpression::Deserialize(Deserializer &deserializer) {
 	auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
 	auto result = duckdb::unique_ptr<BoundDefaultExpression>(new BoundDefaultExpression(std::move(return_type)));
 	return std::move(result);
 }
 
-void BoundLambdaExpression::FormatSerialize(FormatSerializer &serializer) const {
-	Expression::FormatSerialize(serializer);
+void BoundLambdaExpression::Serialize(Serializer &serializer) const {
+	Expression::Serialize(serializer);
 	serializer.WriteProperty(200, "return_type", return_type);
 	serializer.WriteProperty(201, "lambda_expr", lambda_expr);
 	serializer.WriteProperty(202, "captures", captures);
 	serializer.WriteProperty(203, "parameter_count", parameter_count);
 }
 
-unique_ptr<Expression> BoundLambdaExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<Expression> BoundLambdaExpression::Deserialize(Deserializer &deserializer) {
 	auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
 	auto lambda_expr = deserializer.ReadProperty<unique_ptr<Expression>>(201, "lambda_expr");
 	auto captures = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(202, "captures");
@@ -209,15 +209,15 @@ unique_ptr<Expression> BoundLambdaExpression::FormatDeserialize(FormatDeserializ
 	return std::move(result);
 }
 
-void BoundLambdaRefExpression::FormatSerialize(FormatSerializer &serializer) const {
-	Expression::FormatSerialize(serializer);
+void BoundLambdaRefExpression::Serialize(Serializer &serializer) const {
+	Expression::Serialize(serializer);
 	serializer.WriteProperty(200, "return_type", return_type);
 	serializer.WriteProperty(201, "binding", binding);
 	serializer.WriteProperty(202, "lambda_index", lambda_index);
 	serializer.WriteProperty(203, "depth", depth);
 }
 
-unique_ptr<Expression> BoundLambdaRefExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<Expression> BoundLambdaRefExpression::Deserialize(Deserializer &deserializer) {
 	auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
 	auto binding = deserializer.ReadProperty<ColumnBinding>(201, "binding");
 	auto lambda_index = deserializer.ReadProperty<idx_t>(202, "lambda_index");
@@ -226,27 +226,27 @@ unique_ptr<Expression> BoundLambdaRefExpression::FormatDeserialize(FormatDeseria
 	return std::move(result);
 }
 
-void BoundOperatorExpression::FormatSerialize(FormatSerializer &serializer) const {
-	Expression::FormatSerialize(serializer);
+void BoundOperatorExpression::Serialize(Serializer &serializer) const {
+	Expression::Serialize(serializer);
 	serializer.WriteProperty(200, "return_type", return_type);
 	serializer.WriteProperty(201, "children", children);
 }
 
-unique_ptr<Expression> BoundOperatorExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<Expression> BoundOperatorExpression::Deserialize(Deserializer &deserializer) {
 	auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
 	auto result = duckdb::unique_ptr<BoundOperatorExpression>(new BoundOperatorExpression(deserializer.Get<ExpressionType>(), std::move(return_type)));
 	deserializer.ReadProperty(201, "children", result->children);
 	return std::move(result);
 }
 
-void BoundParameterExpression::FormatSerialize(FormatSerializer &serializer) const {
-	Expression::FormatSerialize(serializer);
+void BoundParameterExpression::Serialize(Serializer &serializer) const {
+	Expression::Serialize(serializer);
 	serializer.WriteProperty(200, "identifier", identifier);
 	serializer.WriteProperty(201, "return_type", return_type);
 	serializer.WriteProperty(202, "parameter_data", parameter_data);
 }
 
-unique_ptr<Expression> BoundParameterExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<Expression> BoundParameterExpression::Deserialize(Deserializer &deserializer) {
 	auto identifier = deserializer.ReadProperty<string>(200, "identifier");
 	auto return_type = deserializer.ReadProperty<LogicalType>(201, "return_type");
 	auto parameter_data = deserializer.ReadProperty<shared_ptr<BoundParameterData>>(202, "parameter_data");
@@ -254,26 +254,26 @@ unique_ptr<Expression> BoundParameterExpression::FormatDeserialize(FormatDeseria
 	return std::move(result);
 }
 
-void BoundReferenceExpression::FormatSerialize(FormatSerializer &serializer) const {
-	Expression::FormatSerialize(serializer);
+void BoundReferenceExpression::Serialize(Serializer &serializer) const {
+	Expression::Serialize(serializer);
 	serializer.WriteProperty(200, "return_type", return_type);
 	serializer.WriteProperty(201, "index", index);
 }
 
-unique_ptr<Expression> BoundReferenceExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<Expression> BoundReferenceExpression::Deserialize(Deserializer &deserializer) {
 	auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
 	auto index = deserializer.ReadProperty<idx_t>(201, "index");
 	auto result = duckdb::unique_ptr<BoundReferenceExpression>(new BoundReferenceExpression(std::move(return_type), index));
 	return std::move(result);
 }
 
-void BoundUnnestExpression::FormatSerialize(FormatSerializer &serializer) const {
-	Expression::FormatSerialize(serializer);
+void BoundUnnestExpression::Serialize(Serializer &serializer) const {
+	Expression::Serialize(serializer);
 	serializer.WriteProperty(200, "return_type", return_type);
 	serializer.WriteProperty(201, "child", child);
 }
 
-unique_ptr<Expression> BoundUnnestExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<Expression> BoundUnnestExpression::Deserialize(Deserializer &deserializer) {
 	auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
 	auto result = duckdb::unique_ptr<BoundUnnestExpression>(new BoundUnnestExpression(std::move(return_type)));
 	deserializer.ReadProperty(201, "child", result->child);