duckdb 0.8.2-dev4126.0 → 0.8.2-dev4203.0

package/src/duckdb/src/planner/expression/bound_default_expression.cpp

@@ -1,16 +0,0 @@
-#include "duckdb/planner/expression/bound_default_expression.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
-
-namespace duckdb {
-
-void BoundDefaultExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(return_type);
-}
-
-unique_ptr<Expression> BoundDefaultExpression::Deserialize(ExpressionDeserializationState &state, FieldReader &reader) {
-	auto return_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-	return make_uniq<BoundDefaultExpression>(return_type);
-}
-
-} // namespace duckdb

package/src/duckdb/src/planner/operator/logical_execute.cpp

@@ -1,12 +0,0 @@
-#include "duckdb/planner/operator/logical_execute.hpp"
-
-namespace duckdb {
-
-void LogicalExecute::Serialize(FieldWriter &writer) const {
-	throw NotImplementedException(LogicalOperatorToString(type));
-}
-
-unique_ptr<LogicalOperator> LogicalExecute::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	throw NotImplementedException(LogicalOperatorToString(state.type));
-}
-} // namespace duckdb

package/src/duckdb/src/planner/operator/logical_explain.cpp

@@ -1,22 +0,0 @@
-#include "duckdb/common/field_writer.hpp"
-#include "duckdb/planner/operator/logical_explain.hpp"
-
-namespace duckdb {
-
-void LogicalExplain::Serialize(FieldWriter &writer) const {
-	writer.WriteField(explain_type);
-	writer.WriteString(physical_plan);
-	writer.WriteString(logical_plan_unopt);
-	writer.WriteString(logical_plan_opt);
-}
-
-unique_ptr<LogicalOperator> LogicalExplain::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto explain_type = reader.ReadRequired<ExplainType>();
-	auto result = unique_ptr<LogicalExplain>(new LogicalExplain(explain_type));
-	result->physical_plan = reader.ReadRequired<string>();
-	result->logical_plan_unopt = reader.ReadRequired<string>();
-	result->logical_plan_opt = reader.ReadRequired<string>();
-	return std::move(result);
-}
-
-} // namespace duckdb

package/src/duckdb/src/planner/operator/logical_export.cpp

@@ -1,13 +0,0 @@
-#include "duckdb/planner/operator/logical_export.hpp"
-
-namespace duckdb {
-
-void LogicalExport::Serialize(FieldWriter &writer) const {
-	throw NotImplementedException(LogicalOperatorToString(type));
-}
-
-unique_ptr<LogicalOperator> LogicalExport::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	throw NotImplementedException(LogicalOperatorToString(state.type));
-}
-
-} // namespace duckdb

package/src/duckdb/src/planner/operator/logical_show.cpp

@@ -1,21 +0,0 @@
-#include "duckdb/common/field_writer.hpp"
-#include "duckdb/planner/operator/logical_show.hpp"
-
-namespace duckdb {
-
-void LogicalShow::Serialize(FieldWriter &writer) const {
-	writer.WriteRegularSerializableList(types_select);
-	writer.WriteList<string>(aliases);
-}
-
-unique_ptr<LogicalOperator> LogicalShow::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto types_select = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	auto aliases = reader.ReadRequiredList<string>();
-
-	// TODO(stephwang): review if we need to pass unique_ptr<LogicalOperator> plan
-	auto result = unique_ptr<LogicalShow>(new LogicalShow());
-	result->types_select = types_select;
-	result->aliases = aliases;
-	return std::move(result);
-}
-} // namespace duckdb

package/src/duckdb/src/planner/parsed_data/bound_create_table_info.cpp

@@ -1,22 +0,0 @@
-#include "duckdb/planner/parsed_data/bound_create_table_info.hpp"
-#include "duckdb/parser/parsed_data/create_schema_info.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/common/field_writer.hpp"
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
-
-namespace duckdb {
-
-void BoundCreateTableInfo::Serialize(Serializer &serializer) const {
-	serializer.WriteOptional(base);
-}
-
-unique_ptr<BoundCreateTableInfo> BoundCreateTableInfo::Deserialize(Deserializer &source,
-                                                                   PlanDeserializationState &state) {
-	auto info = source.ReadOptional<CreateInfo>();
-	auto binder = Binder::CreateBinder(state.context);
-	auto bound_info = binder->BindCreateTableInfo(std::move(info));
-	return bound_info;
-}
-
-} // namespace duckdb

package/src/duckdb/src/planner/plan_serialization.cpp

@@ -1,20 +0,0 @@
-#include "duckdb/planner/plan_serialization.hpp"
-#include "duckdb/planner/expression/bound_parameter_data.hpp"
-
-namespace duckdb {
-
-PlanDeserializationState::PlanDeserializationState(ClientContext &context) : context(context) {
-}
-PlanDeserializationState::~PlanDeserializationState() {
-}
-
-LogicalDeserializationState::LogicalDeserializationState(PlanDeserializationState &gstate, LogicalOperatorType type,
-                                                         vector<unique_ptr<LogicalOperator>> &children)
-    : gstate(gstate), type(type), children(children) {
-}
-
-ExpressionDeserializationState::ExpressionDeserializationState(PlanDeserializationState &gstate, ExpressionType type)
-    : gstate(gstate), type(type) {
-}
-
-} // namespace duckdb

package/src/duckdb/src/verification/deserialized_statement_verifier_v2.cpp

@@ -1,34 +0,0 @@
-#include "duckdb/verification/deserialized_statement_verifier_v2.hpp"
-#include "duckdb/common/serializer/buffered_deserializer.hpp"
-#include "duckdb/common/serializer/binary_serializer.hpp"
-#include "duckdb/common/serializer/binary_deserializer.hpp"
-namespace duckdb {
-
-DeserializedStatementVerifierV2::DeserializedStatementVerifierV2(unique_ptr<SQLStatement> statement_p)
-    : StatementVerifier(VerificationType::DESERIALIZED_V2, "Deserialized V2", std::move(statement_p)) {
-}
-
-unique_ptr<StatementVerifier> DeserializedStatementVerifierV2::Create(const SQLStatement &statement) {
-	auto &select_stmt = statement.Cast<SelectStatement>();
-
-	auto blob = BinarySerializer::Serialize(select_stmt, true);
-	auto result = BinaryDeserializer::Deserialize<SelectStatement>(blob.data(), blob.size());
-
-	return make_uniq<DeserializedStatementVerifierV2>(std::move(result));
-}
-
-DeserializedStatementVerifierNoDefaultV2::DeserializedStatementVerifierNoDefaultV2(unique_ptr<SQLStatement> statement_p)
-    : StatementVerifier(VerificationType::DESERIALIZED_V2_NO_DEFAULT, "Deserialized V2 without default values",
-                        std::move(statement_p)) {
-}
-
-unique_ptr<StatementVerifier> DeserializedStatementVerifierNoDefaultV2::Create(const SQLStatement &statement) {
-	auto &select_stmt = statement.Cast<SelectStatement>();
-
-	auto blob = BinarySerializer::Serialize(select_stmt, false);
-	auto result = BinaryDeserializer::Deserialize<SelectStatement>(blob.data(), blob.size());
-
-	return make_uniq<DeserializedStatementVerifierNoDefaultV2>(std::move(result));
-}
-
-} // namespace duckdb

package/src/duckdb/ub_src_planner_parsed_data.cpp

@@ -1,2 +0,0 @@
-#include "src/planner/parsed_data/bound_create_table_info.cpp"
-