duckdb 0.8.2-dev1968.0 → 0.8.2-dev2068.0

package/src/duckdb/src/common/extra_type_info.cpp

@@ -321,7 +321,6 @@ struct EnumTypeInfoTemplated : public EnumTypeInfo {
 	}
 
 	static shared_ptr<EnumTypeInfoTemplated> Deserialize(FieldReader &reader, uint32_t size, string enum_name) {
-
 		Vector values_insert_order(LogicalType::VARCHAR, size);
 		values_insert_order.Deserialize(size, reader.GetSource());
 		return make_shared<EnumTypeInfoTemplated>(std::move(enum_name), values_insert_order, size);
@@ -451,7 +450,7 @@ shared_ptr<ExtraTypeInfo> EnumTypeInfo::Deserialize(FieldReader &reader) {
 }
 
 shared_ptr<ExtraTypeInfo> EnumTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto enum_size = deserializer.ReadProperty<uint32_t>("enum_size");
+	auto enum_size = deserializer.ReadProperty<idx_t>("enum_size");
 	auto enum_internal_type = EnumTypeInfo::DictType(enum_size);
 	switch (enum_internal_type) {
 	case PhysicalType::UINT8:

package/src/duckdb/src/common/serializer/binary_deserializer.cpp

@@ -5,6 +5,9 @@ namespace duckdb {
 void BinaryDeserializer::SetTag(const char *tag) {
 	current_tag = tag;
 	stack.back().read_field_count++;
+	if (stack.back().read_field_count > stack.back().expected_field_count) {
+		throw SerializationException("Attempting to read a required field, but field is missing");
+	}
 }
 
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/common/serializer/binary_serializer.cpp

@@ -129,7 +129,7 @@ void BinarySerializer::WriteValue(const string &value) {
 	auto len = value.length();
 	Write<uint32_t>((uint32_t)len);
 	if (len > 0) {
-		WriteData(value.c_str(), len);
+		WriteDataInternal(value.c_str(), len);
 	}
 }
 
@@ -137,7 +137,7 @@ void BinarySerializer::WriteValue(const string_t value) {
 	auto len = value.GetSize();
 	Write<uint32_t>((uint32_t)len);
 	if (len > 0) {
-		WriteData(value.GetDataUnsafe(), len);
+		WriteDataInternal(value.GetDataUnsafe(), len);
 	}
 }
 
@@ -145,7 +145,7 @@ void BinarySerializer::WriteValue(const char *value) {
 	auto len = strlen(value);
 	Write<uint32_t>((uint32_t)len);
 	if (len > 0) {
-		WriteData(value, len);
+		WriteDataInternal(value, len);
 	}
 }
 
@@ -154,7 +154,7 @@ void BinarySerializer::WriteValue(bool value) {
 }
 
 void BinarySerializer::WriteDataPtr(const_data_ptr_t ptr, idx_t count) {
-	WriteData(ptr, count);
+	WriteDataInternal(ptr, count);
 }
 
 } // namespace duckdb

package/src/duckdb/src/common/types/column/column_data_collection.cpp

@@ -6,6 +6,8 @@
 #include "duckdb/common/types/value_map.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -1057,4 +1059,45 @@ const vector<unique_ptr<ColumnDataCollectionSegment>> &ColumnDataCollection::Get
 	return segments;
 }
 
+void ColumnDataCollection::FormatSerialize(FormatSerializer &serializer) const {
+	vector<vector<Value>> values;
+	values.resize(ColumnCount());
+	for (auto &chunk : Chunks()) {
+		for (idx_t c = 0; c < chunk.ColumnCount(); c++) {
+			for (idx_t r = 0; r < chunk.size(); r++) {
+				values[c].push_back(chunk.GetValue(c, r));
+			}
+		}
+	}
+	serializer.WriteProperty("types", types);
+	serializer.WriteProperty("values", values);
+}
+
+unique_ptr<ColumnDataCollection> ColumnDataCollection::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto types = deserializer.ReadProperty<vector<LogicalType>>("types");
+	auto values = deserializer.ReadProperty<vector<vector<Value>>>("values");
+
+	auto collection = make_uniq<ColumnDataCollection>(Allocator::DefaultAllocator(), types);
+	if (values.empty()) {
+		return collection;
+	}
+	DataChunk chunk;
+	chunk.Initialize(Allocator::DefaultAllocator(), types);
+
+	for (idx_t r = 0; r < values[0].size(); r++) {
+		for (idx_t c = 0; c < types.size(); c++) {
+			chunk.SetValue(c, chunk.size(), values[c][r]);
+		}
+		chunk.SetCardinality(chunk.size() + 1);
+		if (chunk.size() == STANDARD_VECTOR_SIZE) {
+			collection->Append(chunk);
+			chunk.Reset();
+		}
+	}
+	if (chunk.size() > 0) {
+		collection->Append(chunk);
+	}
+	return collection;
+}
+
 } // namespace duckdb

package/src/duckdb/src/common/types/vector.cpp

@@ -977,7 +977,7 @@ void Vector::FormatSerialize(FormatSerializer &serializer, idx_t count) {
 	UnifiedVectorFormat vdata;
 	ToUnifiedFormat(count, vdata);
 
-	const auto all_valid = (count > 0) && !vdata.validity.AllValid();
+	const bool all_valid = (count > 0) && !vdata.validity.AllValid();
 	serializer.WriteProperty("all_valid", all_valid);
 	if (all_valid) {
 		ValidityMask flat_mask(count);

package/src/duckdb/src/common/types.cpp

@@ -1108,18 +1108,6 @@ LogicalType LogicalType::Deserialize(Deserializer &source) {
 	return LogicalType(id, std::move(info));
 }
 
-void LogicalType::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("id", id_);
-	serializer.WriteOptionalProperty("type_info", type_info_.get());
-}
-
-LogicalType LogicalType::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto id = deserializer.ReadProperty<LogicalTypeId>("id");
-	auto info = deserializer.ReadOptionalProperty<shared_ptr<ExtraTypeInfo>>("type_info");
-
-	return LogicalType(id, std::move(info));
-}
-
 bool LogicalType::EqualTypeInfo(const LogicalType &rhs) const {
 	if (type_info_.get() == rhs.type_info_.get()) {
 		return true;

package/src/duckdb/src/execution/physical_plan/plan_comparison_join.cpp

@@ -305,7 +305,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalComparison
 		CheckForPerfectJoinOpt(op, perfect_join_stats);
 		plan = make_uniq<PhysicalHashJoin>(op, std::move(left), std::move(right), std::move(op.conditions),
 		                                   op.join_type, op.left_projection_map, op.right_projection_map,
-		                                   std::move(op.delim_types), op.estimated_cardinality, perfect_join_stats);
+		                                   std::move(op.mark_types), op.estimated_cardinality, perfect_join_stats);
 
 	} else {
 		static constexpr const idx_t NESTED_LOOP_JOIN_THRESHOLD = 5;

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.2-dev1968"
+#define DUCKDB_VERSION "0.8.2-dev2068"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "b1d5e20f31"
+#define DUCKDB_SOURCE_ID "83481168e0"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/index_catalog_entry.hpp

@@ -33,9 +33,8 @@ public:
 	vector<unique_ptr<ParsedExpression>> parsed_expressions;
 
 public:
+	unique_ptr<CreateInfo> GetInfo() const override;
 	string ToSQL() const override;
-	void Serialize(Serializer &serializer) const;
-	static unique_ptr<CreateIndexInfo> Deserialize(Deserializer &source, ClientContext &context);
 
 	virtual string GetSchemaName() const = 0;
 	virtual string GetTableName() const = 0;

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/macro_catalog_entry.hpp

@@ -24,10 +24,7 @@ public:
 	unique_ptr<MacroFunction> function;
 
 public:
-	virtual unique_ptr<CreateMacroInfo> GetInfoForSerialization() const;
-	//! Serialize the meta information
-	virtual void Serialize(Serializer &serializer) const;
-	static unique_ptr<CreateMacroInfo> Deserialize(Deserializer &main_source, ClientContext &context);
+	unique_ptr<CreateInfo> GetInfo() const override;
 
 	string ToSQL() const override {
 		return function->ToSQL(schema.name, name);

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/schema_catalog_entry.hpp

@@ -49,17 +49,14 @@ public:
 	SchemaCatalogEntry(Catalog &catalog, string name, bool is_internal);
 
 public:
+	unique_ptr<CreateInfo> GetInfo() const override;
+
 	//! Scan the specified catalog set, invoking the callback method for every entry
 	virtual void Scan(ClientContext &context, CatalogType type,
 	                  const std::function<void(CatalogEntry &)> &callback) = 0;
 	//! Scan the specified catalog set, invoking the callback method for every committed entry
 	virtual void Scan(CatalogType type, const std::function<void(CatalogEntry &)> &callback) = 0;
 
-	//! Serialize the meta information of the SchemaCatalogEntry a serializer
-	virtual void Serialize(Serializer &serializer) const;
-	//! Deserializes to a CreateSchemaInfo
-	static unique_ptr<CreateSchemaInfo> Deserialize(Deserializer &source);
-
 	string ToSQL() const override;
 
 	//! Creates an index with the given name in the schema

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp

@@ -57,13 +57,8 @@ public:
 	bool cycle;
 
 public:
-	//! Serialize the meta information of the SequenceCatalogEntry a serializer
-	virtual void Serialize(Serializer &serializer) const;
-	//! Deserializes to a CreateTableInfo
-	static unique_ptr<CreateSequenceInfo> Deserialize(Deserializer &source);
+	unique_ptr<CreateInfo> GetInfo() const override;
 
 	string ToSQL() const override;
-
-	CatalogEntry *AlterOwnership(ClientContext &context, AlterInfo *info);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_catalog_entry.hpp

@@ -55,6 +55,8 @@ public:
 	DUCKDB_API TableCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateTableInfo &info);
 
 public:
+	DUCKDB_API unique_ptr<CreateInfo> GetInfo() const override;
+
 	DUCKDB_API bool HasGeneratedColumns() const;
 
 	//! Returns whether or not a column with the given name exists
@@ -83,11 +85,6 @@ public:
 	//! Get statistics of a column (physical or virtual) within the table
 	virtual unique_ptr<BaseStatistics> GetStatistics(ClientContext &context, column_t column_id) = 0;
 
-	//! Serialize the meta information of the TableCatalogEntry a serializer
-	void Serialize(Serializer &serializer) const;
-	//! Deserializes to a CreateTableInfo
-	static unique_ptr<CreateTableInfo> Deserialize(Deserializer &source, ClientContext &context);
-
 	//! Returns the column index of the specified column name.
 	//! If the column does not exist:
 	//! If if_column_exists is true, returns DConstants::INVALID_INDEX
@@ -113,12 +110,6 @@ public:
 	                                   ClientContext &context);
 
 protected:
-	// This is used to serialize the entry by #Serialize(Serializer& ). It is virtual to allow
-	// Custom catalog implementations to override the default implementation. We can not make
-	// The Serialize method itself virtual as the logic is tightly coupled to the static
-	// Deserialize method.
-	virtual CreateTableInfo GetTableInfoForSerialization() const;
-
 	//! A list of columns that are part of this table
 	ColumnList columns;
 	//! A list of constraints that are part of this table

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/view_catalog_entry.hpp

@@ -38,12 +38,9 @@ public:
 	vector<LogicalType> types;
 
 public:
-	unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo &info) override;
+	unique_ptr<CreateInfo> GetInfo() const override;
 
-	//! Serialize the meta information of the ViewCatalogEntry a serializer
-	virtual void Serialize(Serializer &serializer) const;
-	//! Deserializes to a CreateTableInfo
-	static unique_ptr<CreateViewInfo> Deserialize(Deserializer &source, ClientContext &context);
+	unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo &info) override;
 
 	unique_ptr<CatalogEntry> Copy(ClientContext &context) const override;
 

package/src/duckdb/src/include/duckdb/catalog/catalog_entry.hpp

@@ -21,6 +21,10 @@ class Catalog;
 class CatalogSet;
 class ClientContext;
 class SchemaCatalogEntry;
+class FormatSerializer;
+class FormatDeserializer;
+
+struct CreateInfo;
 
 //! Abstract base class of an entry in the catalog
 class CatalogEntry {
@@ -56,6 +60,8 @@ public:
 
 	virtual unique_ptr<CatalogEntry> Copy(ClientContext &context) const;
 
+	virtual unique_ptr<CreateInfo> GetInfo() const;
+
 	//! Sets the CatalogEntry as the new root entry (i.e. the newest entry)
 	// this is called on a rollback to an AlterEntry
 	virtual void SetAsRoot();
@@ -68,6 +74,14 @@ public:
 
 	virtual void Verify(Catalog &catalog);
 
+	//! Serialize the meta information of the CatalogEntry a serializer
+	void Serialize(Serializer &serializer) const;
+	//! Deserializes to a CreateInfo
+	static unique_ptr<CreateInfo> Deserialize(Deserializer &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<CreateInfo> FormatDeserialize(FormatDeserializer &deserializer);
+
 public:
 	template <class TARGET>
 	TARGET &Cast() {

package/src/duckdb/src/include/duckdb/common/assert.hpp

@@ -10,7 +10,7 @@
 
 #pragma once
 
-#if (defined(DUCKDB_USE_STANDARD_ASSERT) || !defined(DEBUG)) && !defined(DUCKDB_FORCE_ASSERT)
+#if (defined(DUCKDB_USE_STANDARD_ASSERT) || !defined(DEBUG)) && !defined(DUCKDB_FORCE_ASSERT) && !defined(__MVS__)
 
 #include <assert.h>
 #define D_ASSERT assert

package/src/duckdb/src/include/duckdb/common/constants.hpp

@@ -17,6 +17,8 @@
 namespace duckdb {
 class Serializer;
 class Deserializer;
+class FormatSerializer;
+class FormatDeserializer;
 
 //! inline std directives that we use frequently
 #ifndef DUCKDB_DEBUG_MOVE

package/src/duckdb/src/include/duckdb/common/enum_util.hpp

@@ -40,6 +40,8 @@ enum class AggregateOrderDependent : uint8_t;
 
 enum class AggregateType : uint8_t;
 
+enum class AlterForeignKeyType : uint8_t;
+
 enum class AlterScalarFunctionType : uint8_t;
 
 enum class AlterTableFunctionType : uint8_t;
@@ -128,6 +130,8 @@ enum class FunctionNullHandling : uint8_t;
 
 enum class FunctionSideEffects : uint8_t;
 
+enum class IndexConstraintType : uint8_t;
+
 enum class IndexType : uint8_t;
 
 enum class InsertColumnOrder : uint8_t;
@@ -140,6 +144,8 @@ enum class JoinType : uint8_t;
 
 enum class KeywordCategory : uint8_t;
 
+enum class LoadType : uint8_t;
+
 enum class LogicalOperatorType : uint8_t;
 
 enum class LogicalTypeId : uint8_t;
@@ -174,6 +180,8 @@ enum class OrderType : uint8_t;
 
 enum class OutputStream : uint8_t;
 
+enum class ParseInfoType : uint8_t;
+
 enum class ParserExtensionResultType : uint8_t;
 
 enum class ParserMode : uint8_t;
@@ -285,6 +293,9 @@ const char* EnumUtil::ToChars<AggregateOrderDependent>(AggregateOrderDependent v
 template<>
 const char* EnumUtil::ToChars<AggregateType>(AggregateType value);
 
+template<>
+const char* EnumUtil::ToChars<AlterForeignKeyType>(AlterForeignKeyType value);
+
 template<>
 const char* EnumUtil::ToChars<AlterScalarFunctionType>(AlterScalarFunctionType value);
 
@@ -417,6 +428,9 @@ const char* EnumUtil::ToChars<FunctionNullHandling>(FunctionNullHandling value);
 template<>
 const char* EnumUtil::ToChars<FunctionSideEffects>(FunctionSideEffects value);
 
+template<>
+const char* EnumUtil::ToChars<IndexConstraintType>(IndexConstraintType value);
+
 template<>
 const char* EnumUtil::ToChars<IndexType>(IndexType value);
 
@@ -435,6 +449,9 @@ const char* EnumUtil::ToChars<JoinType>(JoinType value);
 template<>
 const char* EnumUtil::ToChars<KeywordCategory>(KeywordCategory value);
 
+template<>
+const char* EnumUtil::ToChars<LoadType>(LoadType value);
+
 template<>
 const char* EnumUtil::ToChars<LogicalOperatorType>(LogicalOperatorType value);
 
@@ -486,6 +503,9 @@ const char* EnumUtil::ToChars<OrderType>(OrderType value);
 template<>
 const char* EnumUtil::ToChars<OutputStream>(OutputStream value);
 
+template<>
+const char* EnumUtil::ToChars<ParseInfoType>(ParseInfoType value);
+
 template<>
 const char* EnumUtil::ToChars<ParserExtensionResultType>(ParserExtensionResultType value);
 
@@ -646,6 +666,9 @@ AggregateOrderDependent EnumUtil::FromString<AggregateOrderDependent>(const char
 template<>
 AggregateType EnumUtil::FromString<AggregateType>(const char *value);
 
+template<>
+AlterForeignKeyType EnumUtil::FromString<AlterForeignKeyType>(const char *value);
+
 template<>
 AlterScalarFunctionType EnumUtil::FromString<AlterScalarFunctionType>(const char *value);
 
@@ -778,6 +801,9 @@ FunctionNullHandling EnumUtil::FromString<FunctionNullHandling>(const char *valu
 template<>
 FunctionSideEffects EnumUtil::FromString<FunctionSideEffects>(const char *value);
 
+template<>
+IndexConstraintType EnumUtil::FromString<IndexConstraintType>(const char *value);
+
 template<>
 IndexType EnumUtil::FromString<IndexType>(const char *value);
 
@@ -796,6 +822,9 @@ JoinType EnumUtil::FromString<JoinType>(const char *value);
 template<>
 KeywordCategory EnumUtil::FromString<KeywordCategory>(const char *value);
 
+template<>
+LoadType EnumUtil::FromString<LoadType>(const char *value);
+
 template<>
 LogicalOperatorType EnumUtil::FromString<LogicalOperatorType>(const char *value);
 
@@ -847,6 +876,9 @@ OrderType EnumUtil::FromString<OrderType>(const char *value);
 template<>
 OutputStream EnumUtil::FromString<OutputStream>(const char *value);
 
+template<>
+ParseInfoType EnumUtil::FromString<ParseInfoType>(const char *value);
+
 template<>
 ParserExtensionResultType EnumUtil::FromString<ParserExtensionResultType>(const char *value);
 

package/src/duckdb/src/include/duckdb/common/enums/index_type.hpp

@@ -23,7 +23,7 @@ enum class IndexType : uint8_t {
 //===--------------------------------------------------------------------===//
 // Index Constraint Types
 //===--------------------------------------------------------------------===//
-enum IndexConstraintType : uint8_t {
+enum class IndexConstraintType : uint8_t {
 	NONE = 0,    // index is an index don't built to any constraint
 	UNIQUE = 1,  // index is an index built to enforce a UNIQUE constraint
 	PRIMARY = 2, // index is an index built to enforce a PRIMARY KEY constraint

package/src/duckdb/src/include/duckdb/common/index_vector.hpp

@@ -10,6 +10,8 @@
 
 #include "duckdb/common/constants.hpp"
 #include "duckdb/common/vector.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -59,6 +61,16 @@ public:
 		return internal_vector.end();
 	}
 
+	void FormatSerialize(FormatSerializer &serializer) const {
+		serializer.WriteProperty("internal_vector", internal_vector);
+	}
+
+	static IndexVector<T, INDEX_TYPE> FormatDeserialize(FormatDeserializer &deserializer) {
+		IndexVector<T, INDEX_TYPE> result;
+		deserializer.ReadProperty("internal_vector", result.internal_vector);
+		return result;
+	}
+
 private:
 	vector<T> internal_vector;
 };

package/src/duckdb/src/include/duckdb/common/serializer/binary_deserializer.hpp

@@ -1,17 +1,41 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/serializer/binary_deserializer.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
 #pragma once
+
 #include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
+class ClientContext;
 
 class BinaryDeserializer : public FormatDeserializer {
 public:
+	template <class T>
+	unique_ptr<T> Deserialize() {
+		OnObjectBegin();
+		auto result = T::FormatDeserialize(*this);
+		OnObjectEnd();
+		return result;
+	}
+
 	template <class T>
 	static unique_ptr<T> Deserialize(data_ptr_t ptr, idx_t length) {
 		BinaryDeserializer deserializer(ptr, length);
-		deserializer.OnObjectBegin();
-		auto result = T::FormatDeserialize(deserializer);
-		deserializer.OnObjectEnd();
-		return result;
+		return deserializer.template Deserialize<T>();
+	}
+
+	template <class T>
+	static unique_ptr<T> Deserialize(ClientContext &context, bound_parameter_map_t &parameters, data_ptr_t ptr,
+	                                 idx_t length) {
+		BinaryDeserializer deserializer(ptr, length);
+		deserializer.Set<ClientContext &>(context);
+		deserializer.Set<bound_parameter_map_t &>(parameters);
+		return deserializer.template Deserialize<T>();
 	}
 
 private:

package/src/duckdb/src/include/duckdb/common/serializer/binary_serializer.hpp

@@ -1,3 +1,11 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/serializer/binary_serializer.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
 #pragma once
 
 #include "duckdb/common/serializer/format_serializer.hpp"
@@ -5,7 +13,6 @@
 namespace duckdb {
 
 struct BinarySerializer : public FormatSerializer {
-
 private:
 	struct State {
 		// how many fields are present in the object
@@ -24,14 +31,14 @@ private:
 	template <class T>
 	void Write(T element) {
 		static_assert(std::is_trivially_destructible<T>(), "Write element must be trivially destructible");
-		WriteData(const_data_ptr_cast(&element), sizeof(T));
+		WriteDataInternal(const_data_ptr_cast(&element), sizeof(T));
 	}
-	void WriteData(const_data_ptr_t buffer, idx_t write_size) {
+	void WriteDataInternal(const_data_ptr_t buffer, idx_t write_size) {
 		data.insert(data.end(), buffer, buffer + write_size);
 		stack.back().size += write_size;
 	}
-	void WriteData(const char *ptr, idx_t write_size) {
-		WriteData(const_data_ptr_cast(ptr), write_size);
+	void WriteDataInternal(const char *ptr, idx_t write_size) {
+		WriteDataInternal(const_data_ptr_cast(ptr), write_size);
 	}
 
 	explicit BinarySerializer() {