duckdb::Serializer Class Reference

Inheritance diagram for duckdb::Serializer:

Collaboration diagram for duckdb::Serializer:

Classes
class	List

Public Member Functions
bool	ShouldSerialize (idx_t version_added)
SerializationOptions	GetOptions ()
SerializationData &	GetSerializationData ()
void	SetSerializationData (const SerializationData &other)
template<class T >
void	WriteProperty (const field_id_t field_id, const char *tag, const T &value)
template<class T >
void	WritePropertyWithDefault (const field_id_t field_id, const char *tag, const T &value)
template<class T >
void	WritePropertyWithDefault (const field_id_t field_id, const char *tag, const T &value, const T &default_value)
template<class T >
void	WritePropertyWithDefault (const field_id_t field_id, const char *tag, const CSVOption< T > &value, const T &default_value)
void	WriteProperty (const field_id_t field_id, const char *tag, const_data_ptr_t ptr, idx_t count)
template<class FUNC >
void	WriteObject (const field_id_t field_id, const char *tag, FUNC f)
template<class FUNC >
void	WriteList (const field_id_t field_id, const char *tag, idx_t count, FUNC func)
template<>
void	WriteValue (const vector< bool > &vec)
template<>
void	WritePropertyWithDefault (const field_id_t field_id, const char *tag, const Value &value, const Value &default_value)

Protected Member Functions
template<typename T >
std::enable_if< std::is_enum< T >::value, void >::type	WriteValue (const T value)
template<typename T >
void	WriteValue (const optionally_owned_ptr< T > &ptr)
template<typename T >
void	WriteValue (const unique_ptr< T > &ptr)
template<typename T >
void	WriteValue (const shared_ptr< T > &ptr)
template<typename T >
void	WriteValue (const T *ptr)
template<class K , class V >
void	WriteValue (const std::pair< K, V > &pair)
template<class T >
void	WriteValue (const reference< T > ref)
template<class T >
void	WriteValue (const vector< T > &vec)
template<class T >
void	WriteValue (const unsafe_vector< T > &vec)
template<class T , class HASH , class CMP >
void	WriteValue (const duckdb::unordered_set< T, HASH, CMP > &set)
template<class T , class HASH , class CMP >
void	WriteValue (const duckdb::set< T, HASH, CMP > &set)
template<class K , class V , class HASH , class CMP >
void	WriteValue (const duckdb::unordered_map< K, V, HASH, CMP > &map)
template<class K , class V , class HASH , class CMP >
void	WriteValue (const duckdb::map< K, V, HASH, CMP > &map)
template<class V >
void	WriteValue (const duckdb::InsertionOrderPreservingMap< V > &map)
template<typename T >
void	WriteValue (const std::priority_queue< T > &queue)
template<typename T >
std::enable_if< has_serialize< T >::value >::type	WriteValue (const T &value)
virtual void	OnPropertyBegin (const field_id_t field_id, const char *tag)=0
virtual void	OnPropertyEnd ()=0
virtual void	OnOptionalPropertyBegin (const field_id_t field_id, const char *tag, bool present)=0
virtual void	OnOptionalPropertyEnd (bool present)=0
virtual void	OnObjectBegin ()=0
virtual void	OnObjectEnd ()=0
virtual void	OnListBegin (idx_t count)=0
virtual void	OnListEnd ()=0
virtual void	OnNullableBegin (bool present)=0
virtual void	OnNullableEnd ()=0
virtual void	WriteNull ()=0
virtual void	WriteValue (char value)
virtual void	WriteValue (bool value)=0
virtual void	WriteValue (uint8_t value)=0
virtual void	WriteValue (int8_t value)=0
virtual void	WriteValue (uint16_t value)=0
virtual void	WriteValue (int16_t value)=0
virtual void	WriteValue (uint32_t value)=0
virtual void	WriteValue (int32_t value)=0
virtual void	WriteValue (uint64_t value)=0
virtual void	WriteValue (int64_t value)=0
virtual void	WriteValue (hugeint_t value)=0
virtual void	WriteValue (uhugeint_t value)=0
virtual void	WriteValue (float value)=0
virtual void	WriteValue (double value)=0
virtual void	WriteValue (const string_t value)=0
virtual void	WriteValue (const string &value)=0
virtual void	WriteValue (const char *str)=0
virtual void	WriteDataPtr (const_data_ptr_t ptr, idx_t count)=0
void	WriteValue (LogicalIndex value)
void	WriteValue (PhysicalIndex value)
void	WriteValue (optional_idx value)

Protected Attributes
SerializationOptions	options
SerializationData	data

Constructor & Destructor Documentation

~Serializer()

virtual duckdb::Serializer::~Serializer ( )

inlinevirtual

                          {
    }

Member Function Documentation

ShouldSerialize()

bool duckdb::Serializer::ShouldSerialize ( idx_t  version_added )

inline

                                              {
        return options.serialization_compatibility.Compare(version_added);
    }

GetOptions()

SerializationOptions duckdb::Serializer::GetOptions ( )

inline

                                      {
        return options;
    }

GetSerializationData()

SerializationData & duckdb::Serializer::GetSerializationData ( )

inline

                                              {
        return data;
    }

SetSerializationData()

void duckdb::Serializer::SetSerializationData ( const SerializationData &  other )

inline

                                                              {
        data = other;
    }

WriteProperty() [1/2]

template<class T >

void duckdb::Serializer::WriteProperty ( const field_id_t  field_id, const char *  tag, const T &  value  )

inline

                                                                                   {
        OnPropertyBegin(field_id, tag);
        WriteValue(value);
        OnPropertyEnd();
    }

WritePropertyWithDefault() [1/3]

template<class T >

void duckdb::Serializer::WritePropertyWithDefault ( const field_id_t  field_id, const char *  tag, const T &  value  )

inline

                                                                                              {
        // If current value is default, don't write it
        if (!options.serialize_default_values && SerializationDefaultValue::IsDefault<T>(value)) {
            OnOptionalPropertyBegin(field_id, tag, false);
            OnOptionalPropertyEnd(false);
            return;
        }
        OnOptionalPropertyBegin(field_id, tag, true);
        WriteValue(value);
        OnOptionalPropertyEnd(true);
    }

WritePropertyWithDefault() [2/3]

template<class T >

void duckdb::Serializer::WritePropertyWithDefault ( const field_id_t  field_id, const char *  tag, const T &  value, const T &  default_value  )

inline

                                                                                                                      {
        // If current value is default, don't write it
        if (!options.serialize_default_values && (value == default_value)) {
            OnOptionalPropertyBegin(field_id, tag, false);
            OnOptionalPropertyEnd(false);
            return;
        }
        OnOptionalPropertyBegin(field_id, tag, true);
        WriteValue(value);
        OnOptionalPropertyEnd(true);
    }

WritePropertyWithDefault() [3/3]

template<class T >

void duckdb::Serializer::WritePropertyWithDefault ( const field_id_t  field_id, const char *  tag, const CSVOption< T > &  value, const T &  default_value  )

inline

                                                          {
        // If current value is default, don't write it
        if (!options.serialize_default_values && (value == default_value)) {
            OnOptionalPropertyBegin(field_id, tag, false);
            OnOptionalPropertyEnd(false);
            return;
        }
        OnOptionalPropertyBegin(field_id, tag, true);
        WriteValue(value.GetValue());
        OnOptionalPropertyEnd(true);
    }

WriteProperty() [2/2]

void duckdb::Serializer::WriteProperty ( const field_id_t  field_id, const char *  tag, const_data_ptr_t  ptr, idx_t  count  )

inline

                                                                                                      {
        OnPropertyBegin(field_id, tag);
        WriteDataPtr(ptr, count);
        OnPropertyEnd();
    }

WriteObject()

template<class FUNC >

void duckdb::Serializer::WriteObject ( const field_id_t  field_id, const char *  tag, FUNC  f  )

inline

                                                                         {
        OnPropertyBegin(field_id, tag);
        OnObjectBegin();
        f(*this);
        OnObjectEnd();
        OnPropertyEnd();
    }

WriteList()

template<class FUNC >

void duckdb::Serializer::WriteList ( const field_id_t  field_id, const char *  tag, idx_t  count, FUNC  func  )

inline

                                                                                       {
        OnPropertyBegin(field_id, tag);
        OnListBegin(count);
        List list {*this};
        for (idx_t i = 0; i < count; i++) {
            func(list, i);
        }
        OnListEnd();
        OnPropertyEnd();
    }

WriteValue() [1/20]

template<typename T >

std::enable_if< std::is_enum< T >::value, void >::type duckdb::Serializer::WriteValue ( const T  value )

inlineprotected

                                                                                  {
        if (options.serialize_enum_as_string) {
            // Use the enum serializer to lookup tostring function
            auto str = EnumUtil::ToChars(value);
            WriteValue(str);
        } else {
            // Use the underlying type
            WriteValue(static_cast<typename std::underlying_type<T>::type>(value));
        }
    }

WriteValue() [2/20]

template<typename T >

void duckdb::Serializer::WriteValue ( const optionally_owned_ptr< T > &  ptr )

inlineprotected

                                                        {
        WriteValue(ptr.get());
    }

WriteValue() [3/20]

template<typename T >

void duckdb::Serializer::WriteValue ( const unique_ptr< T > &  ptr )

inlineprotected

                                              {
        WriteValue(ptr.get());
    }

WriteValue() [4/20]

template<typename T >

void duckdb::Serializer::WriteValue ( const shared_ptr< T > &  ptr )

inlineprotected

                                              {
        WriteValue(ptr.get());
    }

WriteValue() [5/20]

template<typename T >

void duckdb::Serializer::WriteValue ( const T *  ptr )

inlineprotected

                                  {
        if (ptr == nullptr) {
            OnNullableBegin(false);
            OnNullableEnd();
        } else {
            OnNullableBegin(true);
            WriteValue(*ptr);
            OnNullableEnd();
        }
    }

WriteValue() [6/20]

template<class K , class V >

void duckdb::Serializer::WriteValue ( const std::pair< K, V > &  pair )

inlineprotected

                                               {
        OnObjectBegin();
        WriteProperty(0, "first", pair.first);
        WriteProperty(1, "second", pair.second);
        OnObjectEnd();
    }

WriteValue() [7/20]

template<class T >

void duckdb::Serializer::WriteValue ( const reference< T >  ref )

inlineprotected

                                            {
        WriteValue(ref.get());
    }

WriteValue() [8/20]

template<class T >

void duckdb::Serializer::WriteValue ( const vector< T > &  vec )

inlineprotected

                                          {
        auto count = vec.size();
        OnListBegin(count);
        for (auto &item : vec) {
            WriteValue(item);
        }
        OnListEnd();
    }

WriteValue() [9/20]

template<class T >

void duckdb::Serializer::WriteValue ( const unsafe_vector< T > &  vec )

inlineprotected

                                                 {
        auto count = vec.size();
        OnListBegin(count);
        for (auto &item : vec) {
            WriteValue(item);
        }
        OnListEnd();
    }

WriteValue() [10/20]

template<class T , class HASH , class CMP >

void duckdb::Serializer::WriteValue ( const duckdb::unordered_set< T, HASH, CMP > &  set )

inlineprotected

                                                                  {
        auto count = set.size();
        OnListBegin(count);
        for (auto &item : set) {
            WriteValue(item);
        }
        OnListEnd();
    }

WriteValue() [11/20]

template<class T , class HASH , class CMP >

void duckdb::Serializer::WriteValue ( const duckdb::set< T, HASH, CMP > &  set )

inlineprotected

                                                        {
        auto count = set.size();
        OnListBegin(count);
        for (auto &item : set) {
            WriteValue(item);
        }
        OnListEnd();
    }

WriteValue() [12/20]

template<class K , class V , class HASH , class CMP >

void duckdb::Serializer::WriteValue ( const duckdb::unordered_map< K, V, HASH, CMP > &  map )

inlineprotected

                                                                     {
        auto count = map.size();
        OnListBegin(count);
        for (auto &item : map) {
            OnObjectBegin();
            WriteProperty(0, "key", item.first);
            WriteProperty(1, "value", item.second);
            OnObjectEnd();
        }
        OnListEnd();
    }

WriteValue() [13/20]

template<class K , class V , class HASH , class CMP >

void duckdb::Serializer::WriteValue ( const duckdb::map< K, V, HASH, CMP > &  map )

inlineprotected

                                                           {
        auto count = map.size();
        OnListBegin(count);
        for (auto &item : map) {
            OnObjectBegin();
            WriteProperty(0, "key", item.first);
            WriteProperty(1, "value", item.second);
            OnObjectEnd();
        }
        OnListEnd();
    }

WriteValue() [14/20]

template<class V >

void duckdb::Serializer::WriteValue ( const duckdb::InsertionOrderPreservingMap< V > &  map )

inlineprotected

                                                                     {
        auto count = map.size();
        OnListBegin(count);
        for (auto &entry : map) {
            OnObjectBegin();
            WriteProperty(0, "key", entry.first);
            WriteProperty(1, "value", entry.second);
            OnObjectEnd();
        }
        OnListEnd();
    }

WriteValue() [15/20]

template<typename T >

void duckdb::Serializer::WriteValue ( const std::priority_queue< T > &  queue )

inlineprotected

                                                       {
        vector<T> placeholder;
        auto queue_copy = std::priority_queue<T>(queue);
        while (queue_copy.size() > 0) {
            placeholder.emplace_back(queue_copy.top());
            queue_copy.pop();
        }
        WriteValue(placeholder);
    }

WriteValue() [16/20]

template<typename T >

std::enable_if< has_serialize< T >::value >::type duckdb::Serializer::WriteValue ( const T &  value )

inlineprotected

                                                                                {
        OnObjectBegin();
        value.Serialize(*this);
        OnObjectEnd();
    }

WriteValue() [17/20]

virtual void duckdb::Serializer::WriteValue ( char  value )

inlineprotectedvirtual

                                        {
        throw NotImplementedException("Write char value not implemented");
    }

WriteValue() [18/20]

void duckdb::Serializer::WriteValue ( LogicalIndex  value )

inlineprotected

                                        {
        WriteValue(value.index);
    }

WriteValue() [19/20]

void duckdb::Serializer::WriteValue ( PhysicalIndex  value )

inlineprotected

                                         {
        WriteValue(value.index);
    }

WriteValue() [20/20]

void duckdb::Serializer::WriteValue ( optional_idx  value )

inlineprotected

                                        {
        WriteValue(value.IsValid() ? value.GetIndex() : DConstants::INVALID_INDEX);
    }

---

The documentation for this class was generated from the following file:

• external/duckdb/duckdb.hpp