duckdb::SerializationData Struct Reference

Collaboration diagram for duckdb::SerializationData:

Classes
struct	CustomData

Public Member Functions
template<class T >
void	Set (T entry)=delete
template<class T >
T	Get ()=delete
template<class T >
optional_ptr< T >	TryGet ()=delete
template<class T >
void	Unset ()=delete
template<class T >
void	AssertNotEmpty (const stack< T > &e)
template<typename T >
std::enable_if< std::is_base_of< CustomData, T >::value, T & >::type	GetCustom () const
template<typename T >
std::enable_if< std::is_base_of< CustomData, T >::value, void >::type	SetCustom (T &data)
template<>
void	Unset ()
template<>
void	Unset ()
template<>
void	Unset ()
template<>
void	Unset ()
template<>
void	Unset ()
template<>
void	Unset ()
template<>
void	Unset ()
template<>
void	Unset ()
template<>
void	Unset ()
template<>
void	Unset ()
template<>
void	Unset ()

Public Attributes
stack< reference< ClientContext > >	contexts
stack< reference< DatabaseInstance > >	databases
stack< reference< Catalog > >	catalogs
stack< idx_t >	enums
stack< reference< bound_parameter_map_t > >	parameter_data
stack< const_reference< LogicalType > >	types
stack< const_reference< CompressionInfo > >	compression_infos
duckdb::unordered_map< std::string, duckdb::stack< duckdb::reference< CustomData > > >	customs

Private Member Functions
template<>
void	Set (ExpressionType type)
template<>
ExpressionType	Get ()
template<>
void	Set (LogicalOperatorType type)
template<>
LogicalOperatorType	Get ()
template<>
void	Set (CompressionType type)
template<>
CompressionType	Get ()
template<>
void	Set (CatalogType type)
template<>
CatalogType	Get ()
template<>
void	Set (ClientContext &context)
template<>
ClientContext &	Get ()
template<>
void	Set (Catalog &catalog)
template<>
Catalog &	Get ()
template<>
optional_ptr< Catalog >	TryGet ()
template<>
void	Set (DatabaseInstance &db)
template<>
DatabaseInstance &	Get ()
template<>
void	Set (bound_parameter_map_t &context)
template<>
bound_parameter_map_t &	Get ()
template<>
void	Set (LogicalType &type)
template<>
void	Set (const LogicalType &type)
template<>
const LogicalType &	Get ()
template<>
void	Set (const CompressionInfo &compression_info)
template<>
const CompressionInfo &	Get ()

Member Function Documentation

AssertNotEmpty()

template<class T >

void duckdb::SerializationData::AssertNotEmpty ( const stack< T > &  e )

inline

                                                  {
        if (e.empty()) {
            throw InternalException("SerializationData - unexpected empty stack");
        }
    }

GetCustom()

template<typename T >

std::enable_if< std::is_base_of< CustomData, T >::value, T & >::type duckdb::SerializationData::GetCustom ( ) const

inline

                                                                                        {
        std::string type = T::GetType();
        auto iter = customs.find(type);
        if (iter == customs.end()) {
            throw duckdb::InternalException("SeserializationData - no stack for %s", type);
        }
        auto &stack = iter->second;
        if (stack.empty()) {
            throw duckdb::InternalException("SerializationData - unexpected empty stack for %s", type);
        }
        return dynamic_cast<T &>(stack.top().get());
    }

SetCustom()

template<typename T >

std::enable_if< std::is_base_of< CustomData, T >::value, void >::type duckdb::SerializationData::SetCustom ( T &  data )

inline

                                                                                          {
        std::string type = T::GetType();
        auto iter = customs.find(type);
        if (iter == customs.end()) {
            iter = customs.emplace(type, duckdb::stack<duckdb::reference<CustomData>> {}).first;
        }
        auto &stack = iter->second;
        stack.push(data);
    }

Set() [1/11]

template<>

void duckdb::SerializationData::Set ( ExpressionType  type )

inlineprivate

                                                      {
    enums.push(idx_t(type));
}

Get() [1/10]

template<>

ExpressionType duckdb::SerializationData::Get ( )

inlineprivate

                                             {
    AssertNotEmpty(enums);
    return ExpressionType(enums.top());
}

Unset() [1/11]

template<>

void duckdb::SerializationData::Unset ( )

inline

                                                     {
    AssertNotEmpty(enums);
    enums.pop();
}

Set() [2/11]

template<>

void duckdb::SerializationData::Set ( LogicalOperatorType  type )

inlineprivate

                                                           {
    enums.push(idx_t(type));
}

Get() [2/10]

template<>

LogicalOperatorType duckdb::SerializationData::Get ( )

inlineprivate

                                                  {
    AssertNotEmpty(enums);
    return LogicalOperatorType(enums.top());
}

Unset() [2/11]

template<>

void duckdb::SerializationData::Unset ( )

inline

                                                          {
    AssertNotEmpty(enums);
    enums.pop();
}

Set() [3/11]

template<>

void duckdb::SerializationData::Set ( CompressionType  type )

inlineprivate

                                                       {
    enums.push(idx_t(type));
}

Get() [3/10]

template<>

CompressionType duckdb::SerializationData::Get ( )

inlineprivate

                                              {
    AssertNotEmpty(enums);
    return CompressionType(enums.top());
}

Unset() [3/11]

template<>

void duckdb::SerializationData::Unset ( )

inline

                                                      {
    AssertNotEmpty(enums);
    enums.pop();
}

Set() [4/11]

template<>

void duckdb::SerializationData::Set ( CatalogType  type )

inlineprivate

                                                   {
    enums.push(idx_t(type));
}

Get() [4/10]

template<>

CatalogType duckdb::SerializationData::Get ( )

inlineprivate

                                          {
    AssertNotEmpty(enums);
    return CatalogType(enums.top());
}

Unset() [4/11]

template<>

void duckdb::SerializationData::Unset ( )

inline

                                                  {
    AssertNotEmpty(enums);
    enums.pop();
}

Set() [5/11]

template<>

void duckdb::SerializationData::Set ( ClientContext &  context )

inlineprivate

                                                         {
    contexts.emplace(context);
}

Get() [5/10]

template<>

ClientContext & duckdb::SerializationData::Get ( )

inlineprivate

                                             {
    AssertNotEmpty(contexts);
    return contexts.top();
}

Unset() [5/11]

template<>

void duckdb::SerializationData::Unset ( )

inline

                                                    {
    AssertNotEmpty(contexts);
    contexts.pop();
}

Set() [6/11]

template<>

void duckdb::SerializationData::Set ( Catalog &  catalog )

inlineprivate

                                                   {
    catalogs.emplace(catalog);
}

Get() [6/10]

template<>

Catalog & duckdb::SerializationData::Get ( )

inlineprivate

                                       {
    AssertNotEmpty(catalogs);
    return catalogs.top();
}

TryGet()

template<>

optional_ptr< Catalog > duckdb::SerializationData::TryGet ( )

inlineprivate

                                                       {
    return catalogs.empty() ? nullptr : &catalogs.top().get();
}

Unset() [6/11]

template<>

void duckdb::SerializationData::Unset ( )

inline

                                              {
    AssertNotEmpty(catalogs);
    catalogs.pop();
}

Set() [7/11]

template<>

void duckdb::SerializationData::Set ( DatabaseInstance &  db )

inlineprivate

                                                       {
    databases.emplace(db);
}

Get() [7/10]

template<>

DatabaseInstance & duckdb::SerializationData::Get ( )

inlineprivate

                                                {
    AssertNotEmpty(databases);
    return databases.top();
}

Unset() [7/11]

template<>

void duckdb::SerializationData::Unset ( )

inline

                                                       {
    AssertNotEmpty(databases);
    databases.pop();
}

Set() [8/11]

template<>

void duckdb::SerializationData::Set ( bound_parameter_map_t &  context )

inlineprivate

                                                                 {
    parameter_data.emplace(context);
}

Get() [8/10]

template<>

bound_parameter_map_t & duckdb::SerializationData::Get ( )

inlineprivate

                                                     {
    AssertNotEmpty(parameter_data);
    return parameter_data.top();
}

Unset() [8/11]

template<>

void duckdb::SerializationData::Unset ( )

inline

                                                            {
    AssertNotEmpty(parameter_data);
    parameter_data.pop();
}

Set() [9/11]

template<>

void duckdb::SerializationData::Set ( LogicalType &  type )

inlineprivate

                                                    {
    types.emplace(type);
}

Unset() [9/11]

template<>

void duckdb::SerializationData::Unset ( )

inline

                                                  {
    AssertNotEmpty(types);
    types.pop();
}

Set() [10/11]

template<>

void duckdb::SerializationData::Set ( const LogicalType &  type )

inlineprivate

                                                          {
    types.emplace(type);
}

Get() [9/10]

template<>

const LogicalType & duckdb::SerializationData::Get ( )

inlineprivate

                                                 {
    AssertNotEmpty(types);
    return types.top();
}

Unset() [10/11]

template<>

void duckdb::SerializationData::Unset ( )

inline

                                                        {
    AssertNotEmpty(types);
    types.pop();
}

Set() [11/11]

template<>

void duckdb::SerializationData::Set ( const CompressionInfo &  compression_info )

inlineprivate

                                                                          {
    compression_infos.emplace(compression_info);
}

Get() [10/10]

template<>

const CompressionInfo & duckdb::SerializationData::Get ( )

inlineprivate

                                                     {
    AssertNotEmpty(compression_infos);
    return compression_infos.top();
}

Unset() [11/11]

template<>

void duckdb::SerializationData::Unset ( )

inline

                                                            {
    AssertNotEmpty(compression_infos);
    compression_infos.pop();
}

---

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

• external/duckdb/duckdb.hpp