duckdb::Deserializer Class Reference

Inheritance diagram for duckdb::Deserializer:

Collaboration diagram for duckdb::Deserializer:

Classes
class	List

Public Member Functions
virtual bool	CanDeserializeProperty (const field_id_t field_id, const char *tag)=0
template<typename T >
void	ReadProperty (const field_id_t field_id, const char *tag, T &ret)
template<typename T >
T	ReadProperty (const field_id_t field_id, const char *tag)
template<typename T >
T	ReadPropertyWithDefault (const field_id_t field_id, const char *tag)
template<typename T >
T	ReadPropertyWithExplicitDefault (const field_id_t field_id, const char *tag, T default_value)
template<typename T >
void	ReadPropertyWithDefault (const field_id_t field_id, const char *tag, T &ret)
template<typename T >
void	ReadPropertyWithExplicitDefault (const field_id_t field_id, const char *tag, T &ret, T default_value)
template<typename T >
void	ReadPropertyWithExplicitDefault (const field_id_t field_id, const char *tag, CSVOption< T > &ret, T default_value)
void	ReadProperty (const field_id_t field_id, const char *tag, data_ptr_t ret, idx_t count)
template<typename T >
void	ReadDeletedProperty (const field_id_t field_id, const char *tag)
template<class T >
void	Set (T entry)
	Set a serialization property.
template<class T >
T	Get ()
	Retrieve the last set serialization property of this type.
template<class T >
optional_ptr< T >	TryGet ()
template<class T >
void	Unset ()
	Unset a serialization property.
SerializationData &	GetSerializationData ()
void	SetSerializationData (const SerializationData &other)
template<class FUNC >
void	ReadListInternal (FUNC func)
template<class FUNC >
void	ReadList (const field_id_t field_id, const char *tag, FUNC func)
template<class FUNC >
void	ReadOptionalList (const field_id_t field_id, const char *tag, FUNC func)
template<class FUNC >
void	ReadObject (const field_id_t field_id, const char *tag, FUNC func)

Protected Member Functions
virtual void	OnPropertyBegin (const field_id_t field_id, const char *tag)=0
virtual void	OnPropertyEnd ()=0
virtual bool	OnOptionalPropertyBegin (const field_id_t field_id, const char *tag)=0
virtual void	OnOptionalPropertyEnd (bool present)=0
virtual void	OnObjectBegin ()=0
virtual void	OnObjectEnd ()=0
virtual idx_t	OnListBegin ()=0
virtual void	OnListEnd ()=0
virtual bool	OnNullableBegin ()=0
virtual void	OnNullableEnd ()=0
virtual bool	ReadBool ()=0
virtual char	ReadChar ()
virtual int8_t	ReadSignedInt8 ()=0
virtual uint8_t	ReadUnsignedInt8 ()=0
virtual int16_t	ReadSignedInt16 ()=0
virtual uint16_t	ReadUnsignedInt16 ()=0
virtual int32_t	ReadSignedInt32 ()=0
virtual uint32_t	ReadUnsignedInt32 ()=0
virtual int64_t	ReadSignedInt64 ()=0
virtual uint64_t	ReadUnsignedInt64 ()=0
virtual hugeint_t	ReadHugeInt ()=0
virtual uhugeint_t	ReadUhugeInt ()=0
virtual float	ReadFloat ()=0
virtual double	ReadDouble ()=0
virtual string	ReadString ()=0
virtual void	ReadDataPtr (data_ptr_t &ptr, idx_t count)=0

Protected Attributes
bool	deserialize_enum_from_string = false
SerializationData	data

Private Member Functions
template<typename T = void>
std::enable_if< has_deserialize< T >::value, T >::type	Read ()
template<class T , typename ELEMENT_TYPE = typename is_optionally_owned_ptr<T>::ELEMENT_TYPE>
std::enable_if< is_optionally_owned_ptr< T >::value, T >::type	Read ()
template<class T , typename ELEMENT_TYPE = typename is_unique_ptr<T>::ELEMENT_TYPE>
std::enable_if< is_unique_ptr< T >::value &&has_deserialize< ELEMENT_TYPE >::value, T >::type	Read ()
template<class T , typename ELEMENT_TYPE = typename is_unique_ptr<T>::ELEMENT_TYPE>
std::enable_if< is_unique_ptr< T >::value &&!has_deserialize< ELEMENT_TYPE >::value, T >::type	Read ()
template<typename T = void>
std::enable_if< is_shared_ptr< T >::value, T >::type	Read ()
template<typename T = void>
std::enable_if< is_vector< T >::value, T >::type	Read ()
template<typename T = void>
std::enable_if< is_unsafe_vector< T >::value, T >::type	Read ()
template<typename T = void>
std::enable_if< is_unordered_map< T >::value, T >::type	Read ()
template<typename T = void>
std::enable_if< is_map< T >::value, T >::type	Read ()
template<typename T = void>
std::enable_if< is_insertion_preserving_map< T >::value, T >::type	Read ()
template<typename T = void>
std::enable_if< is_unordered_set< T >::value, T >::type	Read ()
template<typename T = void>
std::enable_if< is_set< T >::value, T >::type	Read ()
template<typename T = void>
std::enable_if< is_pair< T >::value, T >::type	Read ()
template<typename T = void>
std::enable_if< is_queue< T >::value, T >::type	Read ()
template<typename T = void>
std::enable_if< std::is_same< T, bool >::value, T >::type	Read ()
template<typename T = void>
std::enable_if< std::is_same< T, char >::value, T >::type	Read ()
template<typename T = void>
std::enable_if< std::is_same< T, int8_t >::value, T >::type	Read ()
template<typename T = void>
std::enable_if< std::is_same< T, uint8_t >::value, T >::type	Read ()
template<typename T = void>
std::enable_if< std::is_same< T, int16_t >::value, T >::type	Read ()
template<typename T = void>
std::enable_if< std::is_same< T, uint16_t >::value, T >::type	Read ()
template<typename T = void>
std::enable_if< std::is_same< T, int32_t >::value, T >::type	Read ()
template<typename T = void>
std::enable_if< std::is_same< T, uint32_t >::value, T >::type	Read ()
template<typename T = void>
std::enable_if< std::is_same< T, int64_t >::value, T >::type	Read ()
template<typename T = void>
std::enable_if< std::is_same< T, uint64_t >::value, T >::type	Read ()
template<typename T = void>
std::enable_if< std::is_same< T, float >::value, T >::type	Read ()
template<typename T = void>
std::enable_if< std::is_same< T, double >::value, T >::type	Read ()
template<typename T = void>
std::enable_if< std::is_same< T, string >::value, T >::type	Read ()
template<typename T = void>
std::enable_if< std::is_enum< T >::value, T >::type	Read ()
template<typename T = void>
std::enable_if< std::is_same< T, hugeint_t >::value, T >::type	Read ()
template<typename T = void>
std::enable_if< std::is_same< T, uhugeint_t >::value, T >::type	Read ()
template<typename T = void>
std::enable_if< std::is_same< T, LogicalIndex >::value, T >::type	Read ()
template<typename T = void>
std::enable_if< std::is_same< T, PhysicalIndex >::value, T >::type	Read ()
template<typename T = void>
std::enable_if< std::is_same< T, optional_idx >::value, T >::type	Read ()

Constructor & Destructor Documentation

~Deserializer()

virtual duckdb::Deserializer::~Deserializer ( )

inlinevirtual

                            {
    }

Member Function Documentation

ReadProperty() [1/3]

template<typename T >

void duckdb::Deserializer::ReadProperty ( const field_id_t  field_id, const char *  tag, T &  ret  )

inline

                                                                                 {
        OnPropertyBegin(field_id, tag);
        ret = Read<T>();
        OnPropertyEnd();
    }

ReadProperty() [2/3]

template<typename T >

T duckdb::Deserializer::ReadProperty ( const field_id_t  field_id, const char *  tag  )

inline

                                                                      {
        OnPropertyBegin(field_id, tag);
        auto ret = Read<T>();
        OnPropertyEnd();
        return ret;
    }

ReadPropertyWithDefault() [1/2]

template<typename T >

T duckdb::Deserializer::ReadPropertyWithDefault ( const field_id_t  field_id, const char *  tag  )

inline

                                                                                 {
        if (!OnOptionalPropertyBegin(field_id, tag)) {
            OnOptionalPropertyEnd(false);
            return std::forward<T>(SerializationDefaultValue::GetDefault<T>());
        }
        auto ret = Read<T>();
        OnOptionalPropertyEnd(true);
        return ret;
    }

ReadPropertyWithExplicitDefault() [1/3]

template<typename T >

T duckdb::Deserializer::ReadPropertyWithExplicitDefault ( const field_id_t  field_id, const char *  tag, T  default_value  )

inline

                                                                                                          {
        if (!OnOptionalPropertyBegin(field_id, tag)) {
            OnOptionalPropertyEnd(false);
            return std::forward<T>(default_value);
        }
        auto ret = Read<T>();
        OnOptionalPropertyEnd(true);
        return ret;
    }

ReadPropertyWithDefault() [2/2]

template<typename T >

void duckdb::Deserializer::ReadPropertyWithDefault ( const field_id_t  field_id, const char *  tag, T &  ret  )

inline

                                                                                            {
        if (!OnOptionalPropertyBegin(field_id, tag)) {
            ret = std::forward<T>(SerializationDefaultValue::GetDefault<T>());
            OnOptionalPropertyEnd(false);
            return;
        }
        ret = Read<T>();
        OnOptionalPropertyEnd(true);
    }

ReadPropertyWithExplicitDefault() [2/3]

template<typename T >

void duckdb::Deserializer::ReadPropertyWithExplicitDefault ( const field_id_t  field_id, const char *  tag, T &  ret, T  default_value  )

inline

                                                                                                                     {
        if (!OnOptionalPropertyBegin(field_id, tag)) {
            ret = std::forward<T>(default_value);
            OnOptionalPropertyEnd(false);
            return;
        }
        ret = Read<T>();
        OnOptionalPropertyEnd(true);
    }

ReadPropertyWithExplicitDefault() [3/3]

template<typename T >

void duckdb::Deserializer::ReadPropertyWithExplicitDefault ( const field_id_t  field_id, const char *  tag, CSVOption< T > &  ret, T  default_value  )

inline

                                                                 {
        if (!OnOptionalPropertyBegin(field_id, tag)) {
            ret = std::forward<T>(default_value);
            OnOptionalPropertyEnd(false);
            return;
        }
        ret = Read<T>();
        OnOptionalPropertyEnd(true);
    }

ReadProperty() [3/3]

void duckdb::Deserializer::ReadProperty ( const field_id_t  field_id, const char *  tag, data_ptr_t  ret, idx_t  count  )

inline

                                                                                                      {
        OnPropertyBegin(field_id, tag);
        ReadDataPtr(ret, count);
        OnPropertyEnd();
    }

ReadDeletedProperty()

template<typename T >

void duckdb::Deserializer::ReadDeletedProperty ( const field_id_t  field_id, const char *  tag  )

inline

                                                                                {
        // Try to read the property. If not present, great!
        if (!OnOptionalPropertyBegin(field_id, tag)) {
            OnOptionalPropertyEnd(false);
            return;
        }
        // Otherwise read and discard the value
        (void)Read<T>();
        OnOptionalPropertyEnd(true);
    }

Set()

template<class T >

void duckdb::Deserializer::Set ( T  entry )

inline

Set a serialization property.

                      {
        return data.Set<T>(entry);
    }

Get()

template<class T >

T duckdb::Deserializer::Get ( )

inline

Retrieve the last set serialization property of this type.

            {
        return data.Get<T>();
    }

TryGet()

template<class T >

optional_ptr< T > duckdb::Deserializer::TryGet ( )

inline

                             {
        return data.TryGet<T>();
    }

Unset()

template<class T >

void duckdb::Deserializer::Unset ( )

inline

Unset a serialization property.

                 {
        return data.Unset<T>();
    }

GetSerializationData()

SerializationData & duckdb::Deserializer::GetSerializationData ( )

inline

                                              {
        return data;
    }

SetSerializationData()

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

inline

                                                              {
        data = other;
    }

ReadListInternal()

template<class FUNC >

void duckdb::Deserializer::ReadListInternal ( FUNC  func )

inline

                                     {
        auto size = OnListBegin();
        List list {*this};
        for (idx_t i = 0; i < size; i++) {
            func(list, i);
        }
        OnListEnd();
    }

ReadList()

template<class FUNC >

void duckdb::Deserializer::ReadList ( const field_id_t  field_id, const char *  tag, FUNC  func  )

inline

                                                                         {
        OnPropertyBegin(field_id, tag);
        ReadListInternal(func);
        OnPropertyEnd();
    }

ReadOptionalList()

template<class FUNC >

void duckdb::Deserializer::ReadOptionalList ( const field_id_t  field_id, const char *  tag, FUNC  func  )

inline

                                                                                 {
        if (!OnOptionalPropertyBegin(field_id, tag)) {
            OnOptionalPropertyEnd(false);
            return;
        }
        ReadListInternal(func);
        OnOptionalPropertyEnd(true);
    }

ReadObject()

template<class FUNC >

void duckdb::Deserializer::ReadObject ( const field_id_t  field_id, const char *  tag, FUNC  func  )

inline

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

Read() [1/33]

template<typename T = void>

std::enable_if< has_deserialize< T >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                                        {
        OnObjectBegin();
        auto val = T::Deserialize(*this);
        OnObjectEnd();
        return val;
    }

Read() [2/33]

template<class T , typename ELEMENT_TYPE = typename is_optionally_owned_ptr<T>::ELEMENT_TYPE>

std::enable_if< is_optionally_owned_ptr< T >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                                                {
        return optionally_owned_ptr<ELEMENT_TYPE>(Read<unique_ptr<ELEMENT_TYPE>>());
    }

Read() [3/33]

template<class T , typename ELEMENT_TYPE = typename is_unique_ptr<T>::ELEMENT_TYPE>

std::enable_if< is_unique_ptr< T >::value &&has_deserialize< ELEMENT_TYPE >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                                                                            {
        unique_ptr<ELEMENT_TYPE> ptr = nullptr;
        auto is_present = OnNullableBegin();
        if (is_present) {
            OnObjectBegin();
            ptr = ELEMENT_TYPE::Deserialize(*this);
            OnObjectEnd();
        }
        OnNullableEnd();
        return ptr;
    }

Read() [4/33]

template<class T , typename ELEMENT_TYPE = typename is_unique_ptr<T>::ELEMENT_TYPE>

std::enable_if< is_unique_ptr< T >::value &&!has_deserialize< ELEMENT_TYPE >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                                                                             {
        unique_ptr<ELEMENT_TYPE> ptr = nullptr;
        auto is_present = OnNullableBegin();
        if (is_present) {
            OnObjectBegin();
            ptr = make_uniq<ELEMENT_TYPE>(Read<ELEMENT_TYPE>());
            OnObjectEnd();
        }
        OnNullableEnd();
        return ptr;
    }

Read() [5/33]

template<typename T = void>

std::enable_if< is_shared_ptr< T >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                                      {
        using ELEMENT_TYPE = typename is_shared_ptr<T>::ELEMENT_TYPE;
        shared_ptr<ELEMENT_TYPE> ptr = nullptr;
        auto is_present = OnNullableBegin();
        if (is_present) {
            OnObjectBegin();
            ptr = ELEMENT_TYPE::Deserialize(*this);
            OnObjectEnd();
        }
        OnNullableEnd();
        return ptr;
    }

Read() [6/33]

template<typename T = void>

std::enable_if< is_vector< T >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                                  {
        using ELEMENT_TYPE = typename is_vector<T>::ELEMENT_TYPE;
        T vec;
        auto size = OnListBegin();
        for (idx_t i = 0; i < size; i++) {
            vec.push_back(Read<ELEMENT_TYPE>());
        }
        OnListEnd();
        return vec;
    }

Read() [7/33]

template<typename T = void>

std::enable_if< is_unsafe_vector< T >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                                         {
        using ELEMENT_TYPE = typename is_unsafe_vector<T>::ELEMENT_TYPE;
        T vec;
        auto size = OnListBegin();
        for (idx_t i = 0; i < size; i++) {
            vec.push_back(Read<ELEMENT_TYPE>());
        }
        OnListEnd();
 
        return vec;
    }

Read() [8/33]

template<typename T = void>

std::enable_if< is_unordered_map< T >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                                         {
        using KEY_TYPE = typename is_unordered_map<T>::KEY_TYPE;
        using VALUE_TYPE = typename is_unordered_map<T>::VALUE_TYPE;
 
        T map;
        auto size = OnListBegin();
        for (idx_t i = 0; i < size; i++) {
            OnObjectBegin();
            auto key = ReadProperty<KEY_TYPE>(0, "key");
            auto value = ReadProperty<VALUE_TYPE>(1, "value");
            OnObjectEnd();
            map[std::move(key)] = std::move(value);
        }
        OnListEnd();
        return map;
    }

Read() [9/33]

template<typename T = void>

std::enable_if< is_map< T >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                               {
        using KEY_TYPE = typename is_map<T>::KEY_TYPE;
        using VALUE_TYPE = typename is_map<T>::VALUE_TYPE;
 
        T map;
        auto size = OnListBegin();
        for (idx_t i = 0; i < size; i++) {
            OnObjectBegin();
            auto key = ReadProperty<KEY_TYPE>(0, "key");
            auto value = ReadProperty<VALUE_TYPE>(1, "value");
            OnObjectEnd();
            map[std::move(key)] = std::move(value);
        }
        OnListEnd();
        return map;
    }

Read() [10/33]

template<typename T = void>

std::enable_if< is_insertion_preserving_map< T >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                                                    {
        using VALUE_TYPE = typename is_insertion_preserving_map<T>::VALUE_TYPE;
 
        T map;
        auto size = OnListBegin();
        for (idx_t i = 0; i < size; i++) {
            OnObjectBegin();
            auto key = ReadProperty<string>(0, "key");
            auto value = ReadProperty<VALUE_TYPE>(1, "value");
            OnObjectEnd();
            map[key] = std::move(value);
        }
        OnListEnd();
        return map;
    }

Read() [11/33]

template<typename T = void>

std::enable_if< is_unordered_set< T >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                                         {
        using ELEMENT_TYPE = typename is_unordered_set<T>::ELEMENT_TYPE;
        auto size = OnListBegin();
        T set;
        for (idx_t i = 0; i < size; i++) {
            set.insert(Read<ELEMENT_TYPE>());
        }
        OnListEnd();
        return set;
    }

Read() [12/33]

template<typename T = void>

std::enable_if< is_set< T >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                               {
        using ELEMENT_TYPE = typename is_set<T>::ELEMENT_TYPE;
        auto size = OnListBegin();
        T set;
        for (idx_t i = 0; i < size; i++) {
            set.insert(Read<ELEMENT_TYPE>());
        }
        OnListEnd();
        return set;
    }

Read() [13/33]

template<typename T = void>

std::enable_if< is_pair< T >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                                {
        using FIRST_TYPE = typename is_pair<T>::FIRST_TYPE;
        using SECOND_TYPE = typename is_pair<T>::SECOND_TYPE;
        OnObjectBegin();
        auto first = ReadProperty<FIRST_TYPE>(0, "first");
        auto second = ReadProperty<SECOND_TYPE>(1, "second");
        OnObjectEnd();
        return std::make_pair(first, second);
    }

Read() [14/33]

template<typename T = void>

std::enable_if< is_queue< T >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                                 {
        using ELEMENT_TYPE = typename is_queue<T>::ELEMENT_TYPE;
        T queue;
        auto size = OnListBegin();
        for (idx_t i = 0; i < size; i++) {
            queue.emplace(Read<ELEMENT_TYPE>());
        }
        OnListEnd();
        return queue;
    }

Read() [15/33]

template<typename T = void>

std::enable_if< std::is_same< T, bool >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                                         {
        return ReadBool();
    }

Read() [16/33]

template<typename T = void>

std::enable_if< std::is_same< T, char >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                                         {
        return ReadChar();
    }

Read() [17/33]

template<typename T = void>

std::enable_if< std::is_same< T, int8_t >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                                           {
        return ReadSignedInt8();
    }

Read() [18/33]

template<typename T = void>

std::enable_if< std::is_same< T, uint8_t >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                                            {
        return ReadUnsignedInt8();
    }

Read() [19/33]

template<typename T = void>

std::enable_if< std::is_same< T, int16_t >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                                            {
        return ReadSignedInt16();
    }

Read() [20/33]

template<typename T = void>

std::enable_if< std::is_same< T, uint16_t >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                                             {
        return ReadUnsignedInt16();
    }

Read() [21/33]

template<typename T = void>

std::enable_if< std::is_same< T, int32_t >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                                            {
        return ReadSignedInt32();
    }

Read() [22/33]

template<typename T = void>

std::enable_if< std::is_same< T, uint32_t >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                                             {
        return ReadUnsignedInt32();
    }

Read() [23/33]

template<typename T = void>

std::enable_if< std::is_same< T, int64_t >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                                            {
        return ReadSignedInt64();
    }

Read() [24/33]

template<typename T = void>

std::enable_if< std::is_same< T, uint64_t >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                                             {
        return ReadUnsignedInt64();
    }

Read() [25/33]

template<typename T = void>

std::enable_if< std::is_same< T, float >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                                          {
        return ReadFloat();
    }

Read() [26/33]

template<typename T = void>

std::enable_if< std::is_same< T, double >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                                           {
        return ReadDouble();
    }

Read() [27/33]

template<typename T = void>

std::enable_if< std::is_same< T, string >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                                           {
        return ReadString();
    }

Read() [28/33]

template<typename T = void>

std::enable_if< std::is_enum< T >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                                   {
        if (deserialize_enum_from_string) {
            auto str = ReadString();
            return EnumUtil::FromString<T>(str.c_str());
        } else {
            return (T)Read<typename std::underlying_type<T>::type>();
        }
    }

Read() [29/33]

template<typename T = void>

std::enable_if< std::is_same< T, hugeint_t >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                                              {
        return ReadHugeInt();
    }

Read() [30/33]

template<typename T = void>

std::enable_if< std::is_same< T, uhugeint_t >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                                               {
        return ReadUhugeInt();
    }

Read() [31/33]

template<typename T = void>

std::enable_if< std::is_same< T, LogicalIndex >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                                                 {
        return LogicalIndex(ReadUnsignedInt64());
    }

Read() [32/33]

template<typename T = void>

std::enable_if< std::is_same< T, PhysicalIndex >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                                                  {
        return PhysicalIndex(ReadUnsignedInt64());
    }

Read() [33/33]

template<typename T = void>

std::enable_if< std::is_same< T, optional_idx >::value, T >::type duckdb::Deserializer::Read ( )

inlineprivate

                                                                                 {
        auto idx = ReadUnsignedInt64();
        return idx == DConstants::INVALID_INDEX ? optional_idx() : optional_idx(idx);
    }

ReadChar()

virtual char duckdb::Deserializer::ReadChar ( )

inlineprotectedvirtual

                            {
        throw NotImplementedException("ReadChar not implemented");
    }

---

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

• external/duckdb/duckdb.hpp