Inheritance diagram for duckdb::BinaryDeserializer:

Collaboration diagram for duckdb::BinaryDeserializer:

[legend]

Public Member Functions
	BinaryDeserializer (ReadStream &stream)

template<class T >
unique_ptr< T >	Deserialize ()

void	Begin ()

void	End ()

ReadStream &	GetStream ()

Public Member Functions inherited from duckdb::Deserializer
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)

Static Public Member Functions
template<class T >
static unique_ptr< T >	Deserialize (ReadStream &stream)

template<class T >
static unique_ptr< T >	Deserialize (ReadStream &stream, ClientContext &context, bound_parameter_map_t &parameters)

Private Member Functions
field_id_t	PeekField ()

void	ConsumeField ()

field_id_t	NextField ()

void	ReadData (data_ptr_t buffer, idx_t read_size)

template<class T >
T	ReadPrimitive ()

template<class T >
T	VarIntDecode ()

void	OnPropertyBegin (const field_id_t field_id, const char *tag) final

void	OnPropertyEnd () final

bool	OnOptionalPropertyBegin (const field_id_t field_id, const char *tag) final

void	OnOptionalPropertyEnd (bool present) final

void	OnObjectBegin () final

void	OnObjectEnd () final

idx_t	OnListBegin () final

void	OnListEnd () final

bool	OnNullableBegin () final

void	OnNullableEnd () final

bool	CanDeserializeProperty (const field_id_t field_id, const char *tag) final

bool	ReadBool () final

char	ReadChar () final

int8_t	ReadSignedInt8 () final

uint8_t	ReadUnsignedInt8 () final

int16_t	ReadSignedInt16 () final

uint16_t	ReadUnsignedInt16 () final

int32_t	ReadSignedInt32 () final

uint32_t	ReadUnsignedInt32 () final

int64_t	ReadSignedInt64 () final

uint64_t	ReadUnsignedInt64 () final

float	ReadFloat () final

double	ReadDouble () final

string	ReadString () final

hugeint_t	ReadHugeInt () final

uhugeint_t	ReadUhugeInt () final

void	ReadDataPtr (data_ptr_t &ptr, idx_t count) final

Private Attributes
ReadStream &	stream

idx_t	nesting_level = 0

bool	has_buffered_field = false

field_id_t	buffered_field = 0

Additional Inherited Members
Protected Attributes inherited from duckdb::Deserializer
bool	deserialize_enum_from_string = false

SerializationData	data

Constructor & Destructor Documentation

◆ BinaryDeserializer()

duckdb::BinaryDeserializer::BinaryDeserializer ( ReadStream & stream )

inlineexplicit

                                                    : stream(stream) {
        deserialize_enum_from_string = false;
    }

Member Function Documentation

◆ Deserialize() [1/3]

template<class T >

unique_ptr< T > duckdb::BinaryDeserializer::Deserialize ( )

inline

                                {
        OnObjectBegin();
        auto result = T::Deserialize(*this);
        OnObjectEnd();
        D_ASSERT(nesting_level == 0); // make sure we are at the root level
        return result;
    }

◆ Deserialize() [2/3]

template<class T >

static unique_ptr< T > duckdb::BinaryDeserializer::Deserialize ( ReadStream & stream )

inlinestatic

                                                         {
        BinaryDeserializer deserializer(stream);
        return deserializer.template Deserialize<T>();
    }

◆ Deserialize() [3/3]

template<class T >

static unique_ptr< T > duckdb::BinaryDeserializer::Deserialize	(	ReadStream &	stream,
		ClientContext &	context,
		bound_parameter_map_t &	parameters
	)

inlinestatic

                                                                                                                    {
        BinaryDeserializer deserializer(stream);
        deserializer.Set<ClientContext &>(context);
        deserializer.Set<bound_parameter_map_t &>(parameters);
        return deserializer.template Deserialize<T>();
    }

◆ Begin()

void duckdb::BinaryDeserializer::Begin ( )

inline

                 {
        OnObjectBegin();
    }

◆ End()

void duckdb::BinaryDeserializer::End ( )

inline

               {
        OnObjectEnd();
        D_ASSERT(nesting_level == 0); // make sure we are at the root level
    }

◆ GetStream()

ReadStream & duckdb::BinaryDeserializer::GetStream ( )

inline

                            {
        return stream;
    }

◆ PeekField()

field_id_t duckdb::BinaryDeserializer::PeekField ( )

inlineprivate

                           {
        if (!has_buffered_field) {
            buffered_field = ReadPrimitive<field_id_t>();
            has_buffered_field = true;
        }
        return buffered_field;
    }

◆ ConsumeField()

void duckdb::BinaryDeserializer::ConsumeField ( )

inlineprivate

                        {
        if (!has_buffered_field) {
            buffered_field = ReadPrimitive<field_id_t>();
        } else {
            has_buffered_field = false;
        }
    }

◆ NextField()

field_id_t duckdb::BinaryDeserializer::NextField ( )

inlineprivate

                           {
        if (has_buffered_field) {
            has_buffered_field = false;
            return buffered_field;
        }
        return ReadPrimitive<field_id_t>();
    }

◆ ReadData()

void duckdb::BinaryDeserializer::ReadData	(	data_ptr_t	buffer,
		idx_t	read_size
	)

inlineprivate

                                                      {
        D_ASSERT(!has_buffered_field);
        stream.ReadData(buffer, read_size);
    }

◆ ReadPrimitive()

template<class T >

T duckdb::BinaryDeserializer::ReadPrimitive ( )

inlineprivate

                      {
        T value;
        ReadData(data_ptr_cast(&value), sizeof(T));
        return value;
    }

◆ VarIntDecode()

template<class T >

T duckdb::BinaryDeserializer::VarIntDecode ( )

inlineprivate

                     {
        // FIXME: maybe we should pass a source to EncodingUtil instead
        uint8_t buffer[16] = {};
        idx_t varint_size;
        for (varint_size = 0; varint_size < 16; varint_size++) {
            ReadData(buffer + varint_size, 1);
            if (!(buffer[varint_size] & 0x80)) {
                varint_size++;
                break;
            }
        }
        T value;
        auto read_size = EncodingUtil::DecodeLEB128<T>(buffer, value);
        D_ASSERT(read_size == varint_size);
        (void)read_size;
        return value;
    }