duckdb::DictionaryVector Struct Reference

Static Public Member Functions
static void	VerifyDictionary (const Vector &vector)
static const SelectionVector &	SelVector (const Vector &vector)
static SelectionVector &	SelVector (Vector &vector)
static const Vector &	Child (const Vector &vector)
static Vector &	Child (Vector &vector)
static optional_idx	DictionarySize (const Vector &vector)
static const string &	DictionaryId (const Vector &vector)
static bool	CanCacheHashes (const LogicalType &type)
static bool	CanCacheHashes (const Vector &vector)
static buffer_ptr< VectorChildBuffer >	CreateReusableDictionary (const LogicalType &type, const idx_t &size)
static const Vector &	GetCachedHashes (Vector &input)

Member Function Documentation

VerifyDictionary()

static void duckdb::DictionaryVector::VerifyDictionary ( const Vector &  vector )

inlinestatic

                                                       {
#ifdef DUCKDB_DEBUG_NO_SAFETY
        D_ASSERT(vector.GetVectorType() == VectorType::DICTIONARY_VECTOR);
#else
        if (vector.GetVectorType() != VectorType::DICTIONARY_VECTOR) {
            throw InternalException(
                "Operation requires a dictionary vector but a non-dictionary vector was encountered");
        }
#endif
    }

SelVector() [1/2]

static const SelectionVector & duckdb::DictionaryVector::SelVector ( const Vector &  vector )

inlinestatic

                                                                         {
        VerifyDictionary(vector);
        return vector.buffer->Cast<DictionaryBuffer>().GetSelVector();
    }

SelVector() [2/2]

static SelectionVector & duckdb::DictionaryVector::SelVector ( Vector &  vector )

inlinestatic

                                                             {
        VerifyDictionary(vector);
        return vector.buffer->Cast<DictionaryBuffer>().GetSelVector();
    }

Child() [1/2]

static const Vector & duckdb::DictionaryVector::Child ( const Vector &  vector )

inlinestatic

                                                            {
        VerifyDictionary(vector);
        return vector.auxiliary->Cast<VectorChildBuffer>().data;
    }

Child() [2/2]

static Vector & duckdb::DictionaryVector::Child ( Vector &  vector )

inlinestatic

                                                {
        VerifyDictionary(vector);
        return vector.auxiliary->Cast<VectorChildBuffer>().data;
    }

DictionarySize()

static optional_idx duckdb::DictionaryVector::DictionarySize ( const Vector &  vector )

inlinestatic

                                                                    {
        VerifyDictionary(vector);
        const auto &child_buffer = vector.auxiliary->Cast<VectorChildBuffer>();
        if (child_buffer.size.IsValid()) {
            return child_buffer.size;
        }
        return vector.buffer->Cast<DictionaryBuffer>().GetDictionarySize();
    }

DictionaryId()

static const string & duckdb::DictionaryVector::DictionaryId ( const Vector &  vector )

inlinestatic

                                                                   {
        VerifyDictionary(vector);
        const auto &child_buffer = vector.auxiliary->Cast<VectorChildBuffer>();
        if (!child_buffer.id.empty()) {
            return child_buffer.id;
        }
        return vector.buffer->Cast<DictionaryBuffer>().GetDictionaryId();
    }

CanCacheHashes() [1/2]

static bool duckdb::DictionaryVector::CanCacheHashes ( const LogicalType &  type )

inlinestatic

                                                               {
        return type.InternalType() == PhysicalType::VARCHAR;
    }

CanCacheHashes() [2/2]

static bool duckdb::DictionaryVector::CanCacheHashes ( const Vector &  vector )

inlinestatic

                                                            {
        return DictionarySize(vector).IsValid() && CanCacheHashes(vector.GetType());
    }

---

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

• external/duckdb/duckdb.hpp