duckdb::String Class Reference

Public Member Functions
	String (const std::string &str)
	String (const char *str, const uint32_t size)
	String (const char *str)
	String (const String &other)=delete
String &	operator= (const String &other)=delete
	String (String &&other) noexcept
String &	operator= (String &&other) noexcept
bool	operator== (const String &other) const
bool	operator== (const std::string &other) const
bool	operator== (const char *other) const
bool	operator> (const String &other) const
bool	operator!= (const String &other) const
bool	operator< (const String &other) const
bool	operator>= (const String &other) const
bool	operator<= (const String &other) const
char	operator[] (const idx_t pos) const
uint32_t	size () const
bool	empty () const
const char *	data () const
const char *	begin () const
const char *	end () const
const char *	c_str () const
bool	IsOwning () const
bool	IsInlined () const
String	Copy () const
String	Reference () const
std::string	ToStdString () const
String	Lower () const

Static Public Member Functions
static bool	CanBeInlined (uint32_t size)
static String	Copy (const char *data, uint32_t size)
static String	Copy (const String &other)
static String	Copy (const char *data)
static String	Copy (const std::string &str)
static String	Reference (const char *data, uint32_t size)
static String	Reference (const String &other)
static String	Reference (const char *data)
static String	Reference (const std::string &str)
static uint32_t	SafeStrLen (const char *data)
static uint32_t	SafeStrLen (const std::string &data)
static char	CharacterToLower (char c)

Private Member Functions
void	AssignOwning (const char *new_data, uint32_t new_size)
void	Destroy ()
void	ReleaseOwning ()
void	TransferOwnership (String &other)

Private Attributes
uint32_t	len
union {
const char *   ptr
char   buf [INLINE_CAP]
};

Static Private Attributes
static constexpr auto	INLINE_CAP = sizeof(char *)
static constexpr auto	INLINE_MAX = INLINE_CAP - 1
static constexpr auto	NON_OWNING_BIT = 1UL << (sizeof(uint32_t) * 8 - 1)
static constexpr auto	LENGTH_MAX = (1UL << (sizeof(uint32_t) * 8 - 1)) - 1

Constructor & Destructor Documentation

String() [1/5]

duckdb::String::String ( )

inline

             : len(0), buf {0} {
    }

String() [2/5]

duckdb::String::String ( const std::string &  str )

inline

                                 { // NOLINT allowimplicit conversion
        AssignOwning(str.data(), SafeStrLen(str));
    }

String() [3/5]

duckdb::String::String ( const char *  str, const uint32_t  size  )

inline

                                                 {
        AssignOwning(str, size);
    }

String() [4/5]

duckdb::String::String ( const char *  str )

inline

        : String(str, str ? SafeStrLen(str) : 0) {
    }

String() [5/5]

duckdb::String::String ( String &&  other )

inlinenoexcept

                                    {
        TransferOwnership(other);
    }

~String()

duckdb::String::~String ( )

inline

              {
        Destroy();
    }

Member Function Documentation

operator=()

String & duckdb::String::operator= ( String &&  other )

inlinenoexcept

                                               {
        if (this != &other) {
            Destroy();
            TransferOwnership(other);
        }
        return *this;
    }

operator==() [1/3]

bool duckdb::String::operator== ( const String &  other ) const

inline

                                               {
        if (this == &other) {
            return true; // points to the same instance
        }
 
        if (size() != other.size()) {
            return false;
        }
 
        return memcmp(data(), other.data(), size()) == 0;
    }

operator==() [2/3]

bool duckdb::String::operator== ( const std::string &  other ) const

inline

                                                  {
        if (SafeStrLen(other) != size()) {
            return false;
        }
        return memcmp(data(), other.data(), size()) == 0;
    }

operator==() [3/3]

bool duckdb::String::operator== ( const char *  other ) const

inline

                                             {
        if (!other || SafeStrLen(other) != size()) {
            return false;
        }
 
        if (this->data() == other) {
            return true; // points to the same instance
        }
 
        return memcmp(data(), other, size()) == 0;
    }

operator>()

bool duckdb::String::operator> ( const String &  other ) const

inline

                                              {
        const auto this_size = size();
        const auto other_size = other.size();
        const auto min_size = MinValue<idx_t>(this_size, other_size);
 
        auto memcmp_res = memcmp(data(), other.data(), min_size);
        return memcmp_res > 0 || (memcmp_res == 0 && this_size > other_size);
    }

operator!=()

bool duckdb::String::operator!= ( const String &  other ) const

inline

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

operator<()

bool duckdb::String::operator< ( const String &  other ) const

inline

                                              {
        return other > *this;
    }

operator>=()

bool duckdb::String::operator>= ( const String &  other ) const

inline

                                               {
        return !(*this < other);
    }

operator<=()

bool duckdb::String::operator<= ( const String &  other ) const

inline

                                               {
        return !(*this > other);
    }

operator[]()

char duckdb::String::operator[] ( const idx_t  pos ) const

inline

                                           {
        D_ASSERT(pos < size());
 
        if (IsInlined()) {
            return buf[pos];
        }
        return ptr[pos];
    }

size()

uint32_t duckdb::String::size ( ) const

inline

                          {
        return len & ~NON_OWNING_BIT;
    }

empty()

bool duckdb::String::empty ( ) const

inline

                       {
        return len == 0;
    }

data()

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

inline

                             {
        return IsInlined() ? buf : ptr;
    }

begin()

const char * duckdb::String::begin ( ) const

inline

                              {
        return data();
    }

end()

const char * duckdb::String::end ( ) const

inline

                            {
        return data() + size();
    }

c_str()

const char * duckdb::String::c_str ( ) const

inline

                              {
        return data();
    }

IsOwning()

bool duckdb::String::IsOwning ( ) const

inline

                          {
        return (len & NON_OWNING_BIT) == 0;
    }

IsInlined()

bool duckdb::String::IsInlined ( ) const

inline

                           {
        return len <= INLINE_MAX;
    }

CanBeInlined()

static bool duckdb::String::CanBeInlined ( uint32_t  size )

inlinestatic

                                            {
        return size <= INLINE_MAX;
    }

Copy() [1/5]

static String duckdb::String::Copy ( const char *  data, uint32_t  size  )

inlinestatic

                                                        {
        if (data == nullptr) {
            return String(); // Return an empty String
        }
 
        String result;
        result.AssignOwning(data, size);
        return result;
    }

Copy() [2/5]

static String duckdb::String::Copy ( const String &  other )

inlinestatic

                                            {
        return Copy(other.data(), other.size());
    }

Copy() [3/5]

static String duckdb::String::Copy ( const char *  data )

inlinestatic

                                         {
        return Copy(data, data ? SafeStrLen(data) : 0);
    }

Copy() [4/5]

static String duckdb::String::Copy ( const std::string &  str )

inlinestatic

                                             {
        return Copy(str.data(), SafeStrLen(str));
    }

Copy() [5/5]

String duckdb::String::Copy ( ) const

inline

                        {
        return String::Copy(data(), size());
    }

Reference() [1/5]

static String duckdb::String::Reference ( const char *  data, uint32_t  size  )

inlinestatic

                                                             {
        if (data == nullptr) {
            return String(); // Return an empty String
        }
 
        String result;
        // If we reference, and we can inline it, we make owning anyway
        if (size <= INLINE_MAX) {
            result.AssignOwning(data, size);
        } else {
            result.ptr = const_cast<char *>(data); // NOLINT allow const cast
            result.len = size | NON_OWNING_BIT;    // Set the non-owning bit
        }
        return result;
    }

Reference() [2/5]

static String duckdb::String::Reference ( const String &  other )

inlinestatic

                                                 {
        return Reference(other.data(), other.size());
    }

Reference() [3/5]

static String duckdb::String::Reference ( const char *  data )

inlinestatic

                                              {
        return Reference(data, data ? SafeStrLen(data) : 0);
    }

Reference() [4/5]

static String duckdb::String::Reference ( const std::string &  str )

inlinestatic

                                                  {
        return Reference(str.data(), SafeStrLen(str));
    }

Reference() [5/5]

String duckdb::String::Reference ( ) const

inline

                             {
        return String::Reference(data(), size());
    }

ToStdString()

std::string duckdb::String::ToStdString ( ) const

inline

                                  {
        if (IsInlined()) {
            return std::string(buf, size());
        }
        return std::string(ptr, size());
    }

SafeStrLen() [1/2]

static uint32_t duckdb::String::SafeStrLen ( const char *  data )

inlinestatic

                                                 {
        if (!data) {
            return 0;
        }
 
        const auto len = strlen(data);
        D_ASSERT(len < NumericLimits<uint32_t>::Maximum());
        return static_cast<uint32_t>(len);
    }

SafeStrLen() [2/2]

static uint32_t duckdb::String::SafeStrLen ( const std::string &  data )

inlinestatic

                                                      {
        const auto len = data.size();
        D_ASSERT(len < NumericLimits<uint32_t>::Maximum());
        return static_cast<uint32_t>(len);
    }

CharacterToLower()

static char duckdb::String::CharacterToLower ( char  c )

inlinestatic

                                         {
        if (c >= 'A' && c <= 'Z') {
            return UnsafeNumericCast<char>(c + ('a' - 'A'));
        }
        return c;
    }

Lower()

String duckdb::String::Lower ( ) const

inline

                         {
        const auto str_data = data();
        const auto str_size = size();
 
        std::string lowercase_str;
        lowercase_str.reserve(str_size);
        for (idx_t i = 0; i < str_size; ++i) {
            lowercase_str.push_back(CharacterToLower(str_data[i]));
        }
        return String(lowercase_str);
    }

AssignOwning()

void duckdb::String::AssignOwning ( const char *  new_data, uint32_t  new_size  )

inlineprivate

                                                               {
        len = new_data ? new_size : 0;
 
        if (len == 0) {
            buf[len] = '\0'; // Null-terminate the inline buffer
            return;
        }
 
        if (len <= INLINE_MAX) {
            memcpy(buf, new_data, len);
            buf[len] = '\0'; // Null-terminate the inline buffer
            return;
        }
 
        auto new_ptr = new char[len + 1]; // +1 for null-termination
        memcpy(new_ptr, new_data, len);
        new_ptr[len] = '\0';
 
        ptr = new_ptr;
    }

Destroy()

void duckdb::String::Destroy ( )

inlineprivate

                   {
        if (IsOwning() && !IsInlined()) {
            delete[] ptr;
        }
    }

ReleaseOwning()

void duckdb::String::ReleaseOwning ( )

inlineprivate

                         {
        // Set the non-owning bit
        if (IsOwning() && !IsInlined()) {
            len |= NON_OWNING_BIT;
        }
    }

TransferOwnership()

void duckdb::String::TransferOwnership ( String &  other )

inlineprivate

                                          {
        len = other.len;
        if (IsInlined()) {
            AssignOwning(other.data(), other.size());
        } else {
            ptr = other.ptr;
            len = other.len;
        }
        other.ReleaseOwning();
    }

---

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

• external/duckdb/duckdb.hpp