duckdb::string_t::StringComparisonOperators Struct Reference

Static Public Member Functions
static bool	Equals (const string_t &a, const string_t &b)
static bool	GreaterThan (const string_t &left, const string_t &right)

Member Function Documentation

Equals()

static bool duckdb::string_t::StringComparisonOperators::Equals ( const string_t &  a, const string_t &  b  )

inlinestatic

                                                                        {
#ifdef DUCKDB_DEBUG_NO_INLINE
            if (a.GetSize() != b.GetSize()) {
                return false;
            }
            return (memcmp(a.GetData(), b.GetData(), a.GetSize()) == 0);
#endif
            uint64_t a_bulk_comp = Load<uint64_t>(const_data_ptr_cast(&a));
            uint64_t b_bulk_comp = Load<uint64_t>(const_data_ptr_cast(&b));
            if (a_bulk_comp != b_bulk_comp) {
                // Either length or prefix are different -> not equal
                return false;
            }
            // they have the same length and same prefix!
            a_bulk_comp = Load<uint64_t>(const_data_ptr_cast(&a) + 8u);
            b_bulk_comp = Load<uint64_t>(const_data_ptr_cast(&b) + 8u);
            if (a_bulk_comp == b_bulk_comp) {
                // either they are both inlined (so compare equal) or point to the same string (so compare equal)
                return true;
            }
            if (!a.IsInlined()) {
                // 'long' strings of the same length -> compare pointed value
                if (memcmp(a.value.pointer.ptr, b.value.pointer.ptr, a.GetSize()) == 0) {
                    return true;
                }
            }
            // either they are short string of same length but different content
            //     or they point to string with different content
            //     either way, they can't represent the same underlying string
            return false;
        }

GreaterThan()

static bool duckdb::string_t::StringComparisonOperators::GreaterThan ( const string_t &  left, const string_t &  right  )

inlinestatic

                                                                             {
            const uint32_t left_length = UnsafeNumericCast<uint32_t>(left.GetSize());
            const uint32_t right_length = UnsafeNumericCast<uint32_t>(right.GetSize());
            const uint32_t min_length = std::min<uint32_t>(left_length, right_length);
 
#ifndef DUCKDB_DEBUG_NO_INLINE
            uint32_t a_prefix = Load<uint32_t>(const_data_ptr_cast(left.GetPrefix()));
            uint32_t b_prefix = Load<uint32_t>(const_data_ptr_cast(right.GetPrefix()));
 
            // Check on prefix -----
            // We don't need to mask since:
            //  if the prefix is greater(after bswap), it will stay greater regardless of the extra bytes
            //  if the prefix is smaller(after bswap), it will stay smaller regardless of the extra bytes
            //  if the prefix is equal, the extra bytes are guaranteed to be /0 for the shorter one
 
            if (a_prefix != b_prefix) {
                return BSwapIfLE(a_prefix) > BSwapIfLE(b_prefix);
            }
#endif
            auto memcmp_res = memcmp(left.GetData(), right.GetData(), min_length);
            return memcmp_res > 0 || (memcmp_res == 0 && left_length > right_length);
        }

---

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

• external/duckdb/duckdb.hpp