duckdb::string_t Struct Reference

Classes
struct	StringComparisonOperators

Public Member Functions
	string_t (uint32_t len)
	string_t (const char *data, uint32_t len)
	string_t (const char *data)
	string_t (const string &value)
bool	IsInlined () const
const char *	GetData () const
const char *	GetDataUnsafe () const
char *	GetDataWriteable () const
const char *	GetPrefix () const
char *	GetPrefixWriteable ()
idx_t	GetSize () const
void	SetSizeAndFinalize (uint32_t size, idx_t allocated_size)
bool	Empty () const
string	GetString () const
	operator string () const
char *	GetPointer () const
void	SetPointer (char *new_ptr)
void	Finalize ()
void	Verify () const
void	VerifyUTF8 () const
void	VerifyCharacters () const
void	VerifyNull () const
bool	operator== (const string_t &r) const
bool	operator!= (const string_t &r) const
bool	operator> (const string_t &r) const
bool	operator< (const string_t &r) const

Static Public Attributes
static constexpr idx_t	PREFIX_BYTES = 4 * sizeof(char)
static constexpr idx_t	INLINE_BYTES = 12 * sizeof(char)
static constexpr idx_t	HEADER_SIZE = sizeof(uint32_t) + PREFIX_BYTES
static constexpr idx_t	MAX_STRING_SIZE = NumericLimits<uint32_t>::Maximum()
static constexpr idx_t	PREFIX_LENGTH = PREFIX_BYTES
static constexpr idx_t	INLINE_LENGTH = INLINE_BYTES

Private Attributes
union {
struct {
uint32_t   length
char   prefix [4]
char *   ptr
}   pointer
struct {
uint32_t   length
char   inlined [12]
}   inlined
}	value

Friends
struct	StringComparisonOperators

Constructor & Destructor Documentation

string_t() [1/4]

duckdb::string_t::string_t ( uint32_t  len )

inlineexplicit

                                    {
        value.inlined.length = len;
    }

string_t() [2/4]

duckdb::string_t::string_t ( const char *  data, uint32_t  len  )

inline

                                             {
        value.inlined.length = len;
        D_ASSERT(data || GetSize() == 0);
        if (IsInlined()) {
            // zero initialize the prefix first
            // this makes sure that strings with length smaller than 4 still have an equal prefix
            memset(value.inlined.inlined, 0, INLINE_BYTES);
            if (GetSize() == 0) {
                return;
            }
            // small string: inlined
            memcpy(value.inlined.inlined, data, GetSize());
        } else {
            // large string: store pointer
#ifndef DUCKDB_DEBUG_NO_INLINE
            memcpy(value.pointer.prefix, data, PREFIX_LENGTH);
#else
            memset(value.pointer.prefix, 0, PREFIX_BYTES);
#endif
            value.pointer.ptr = (char *)data; // NOLINT
        }
    }

string_t() [3/4]

duckdb::string_t::string_t ( const char *  data )

inline

        : string_t(data, UnsafeNumericCast<uint32_t>(strlen(data))) {
    }

string_t() [4/4]

duckdb::string_t::string_t ( const string &  value )

inline

        : string_t(value.c_str(), UnsafeNumericCast<uint32_t>(value.size())) {
    }

Member Function Documentation

IsInlined()

bool duckdb::string_t::IsInlined ( ) const

inline

                           {
        return GetSize() <= INLINE_LENGTH;
    }

GetData()

const char * duckdb::string_t::GetData ( ) const

inline

                                {
        return IsInlined() ? const_char_ptr_cast(value.inlined.inlined) : value.pointer.ptr;
    }

GetDataUnsafe()

const char * duckdb::string_t::GetDataUnsafe ( ) const

inline

                                      {
        return GetData();
    }

GetDataWriteable()

char * duckdb::string_t::GetDataWriteable ( ) const

inline

                                   {
        return IsInlined() ? (char *)value.inlined.inlined : value.pointer.ptr; // NOLINT
    }

GetPrefix()

const char * duckdb::string_t::GetPrefix ( ) const

inline

                                  {
        return value.inlined.inlined;
    }

GetPrefixWriteable()

char * duckdb::string_t::GetPrefixWriteable ( )

inline

                               {
        return value.inlined.inlined;
    }

GetSize()

idx_t duckdb::string_t::GetSize ( ) const

inline

                          {
        return value.inlined.length;
    }

SetSizeAndFinalize()

void duckdb::string_t::SetSizeAndFinalize ( uint32_t  size, idx_t  allocated_size  )

inline

Data was written to the 'value.pointer.ptr', has to be copied to the inlined bytes

                                                                 {
        value.inlined.length = size;
        if (allocated_size > INLINE_LENGTH && IsInlined()) {
            D_ASSERT(value.pointer.ptr);
            auto ptr = value.pointer.ptr;
            memcpy(GetDataWriteable(), ptr, size);
        }
        Finalize();
        VerifyCharacters();
    }

Here is the call graph for this function:

Empty()

bool duckdb::string_t::Empty ( ) const

inline

                       {
        return value.inlined.length == 0;
    }

GetString()

string duckdb::string_t::GetString ( ) const

inline

                             {
        return string(GetData(), GetSize());
    }

operator string()

duckdb::string_t::operator string ( ) const

inlineexplicit

                                     {
        return GetString();
    }

GetPointer()

char * duckdb::string_t::GetPointer ( ) const

inline

                             {
        D_ASSERT(!IsInlined());
        return value.pointer.ptr;
    }

SetPointer()

void duckdb::string_t::SetPointer ( char *  new_ptr )

inline

                                   {
        D_ASSERT(!IsInlined());
        value.pointer.ptr = new_ptr;
    }

Finalize()

void duckdb::string_t::Finalize ( )

inline

                    {
        // set trailing NULL byte
        if (GetSize() <= INLINE_LENGTH) {
            // fill prefix with zeros if the length is smaller than the prefix length
            memset(value.inlined.inlined + GetSize(), 0, INLINE_BYTES - GetSize());
        } else {
            // copy the data into the prefix
#ifndef DUCKDB_DEBUG_NO_INLINE
            auto dataptr = GetData();
            memcpy(value.pointer.prefix, dataptr, PREFIX_LENGTH);
#else
            memset(value.pointer.prefix, 0, PREFIX_BYTES);
#endif
        }
    }

operator==()

bool duckdb::string_t::operator== ( const string_t &  r ) const

inline

                                             {
        return StringComparisonOperators::Equals(*this, r);
    }

operator!=()

bool duckdb::string_t::operator!= ( const string_t &  r ) const

inline

                                             {
        return !(*this == r);
    }

operator>()

bool duckdb::string_t::operator> ( const string_t &  r ) const

inline

                                            {
        return StringComparisonOperators::GreaterThan(*this, r);
    }

operator<()

bool duckdb::string_t::operator< ( const string_t &  r ) const

inline

                                            {
        return r > *this;
    }

---

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

• external/duckdb/duckdb.hpp