duckdb::ColumnIndex Struct Reference

Collaboration diagram for duckdb::ColumnIndex:

Public Member Functions
	ColumnIndex ()
	FIXME: this initializes the index to COLUMN_IDENTIFIER_ROW_ID (same numeric representation as INVALID_INDEX)
	ColumnIndex (idx_t index)
	ColumnIndex (const string &field)
	ColumnIndex (idx_t index, vector< ColumnIndex > child_indexes_p)
	ColumnIndex (const string &field, vector< ColumnIndex > child_indexes_p)
bool	operator== (const ColumnIndex &rhs) const
bool	operator!= (const ColumnIndex &rhs) const
bool	operator< (const ColumnIndex &rhs) const
bool	HasPrimaryIndex () const
idx_t	GetPrimaryIndex () const
const string &	GetFieldName () const
LogicalIndex	ToLogical () const
bool	HasChildren () const
bool	HasType () const
idx_t	ChildIndexCount () const
const ColumnIndex &	GetChildIndex (idx_t idx) const
ColumnIndex &	GetChildIndex (idx_t idx)
const vector< ColumnIndex > &	GetChildIndexes () const
vector< ColumnIndex > &	GetChildIndexesMutable ()
bool	IsPushdownExtract () const
void	SetType (const LogicalType &type_information)
void	SetPushdownExtractType (const LogicalType &type_information, optional_ptr< const LogicalType > cast_type=nullptr)
const LogicalType &	GetScanType () const
const LogicalType &	GetType () const
void	AddChildIndex (ColumnIndex new_index)
bool	IsRowIdColumn () const
bool	IsEmptyColumn () const
bool	IsVirtualColumn () const
void	VerifySinglePath () const
bool	IsChildPathOf (const ColumnIndex &path) const
void	Serialize (Serializer &serializer) const

Static Public Member Functions
static ColumnIndex	Deserialize (Deserializer &deserializer)

Private Attributes
bool	has_index = true
	The column/field index (if structured type)
idx_t	index
string	field
	The column/field name (if semi-structured type)
LogicalType	type = LogicalType::INVALID
	The logical type of the column this references (if pushdown extract)
ColumnIndexType	index_type
	The type of index, controlling how it's interpreted.
vector< ColumnIndex >	child_indexes

Constructor & Destructor Documentation

ColumnIndex() [1/5]

duckdb::ColumnIndex::ColumnIndex ( )

inline

FIXME: this initializes the index to COLUMN_IDENTIFIER_ROW_ID (same numeric representation as INVALID_INDEX)

                  : has_index(true), index(DConstants::INVALID_INDEX), index_type(ColumnIndexType::FULL_READ) {
    }

ColumnIndex() [2/5]

duckdb::ColumnIndex::ColumnIndex ( idx_t  index )

inlineexplicit

        : has_index(true), index(index), type(LogicalType::INVALID), index_type(ColumnIndexType::FULL_READ) {
    }

ColumnIndex() [3/5]

duckdb::ColumnIndex::ColumnIndex ( const string &  field )

inlineexplicit

        : has_index(false), field(field), type(LogicalType::INVALID), index_type(ColumnIndexType::FULL_READ) {
    }

ColumnIndex() [4/5]

duckdb::ColumnIndex::ColumnIndex ( idx_t  index, vector< ColumnIndex >  child_indexes_p  )

inline

        : has_index(true), index(index), index_type(ColumnIndexType::FULL_READ),
          child_indexes(std::move(child_indexes_p)) {
    }

ColumnIndex() [5/5]

duckdb::ColumnIndex::ColumnIndex ( const string &  field, vector< ColumnIndex >  child_indexes_p  )

inline

        : has_index(false), field(field), index_type(ColumnIndexType::FULL_READ),
          child_indexes(std::move(child_indexes_p)) {
    }

Member Function Documentation

operator==()

bool duckdb::ColumnIndex::operator== ( const ColumnIndex &  rhs ) const

inline

                                                         {
        if (has_index != rhs.has_index) {
            return false;
        }
        if (has_index) {
            if (index != rhs.index) {
                return false;
            }
        } else {
            if (field != rhs.field) {
                return false;
            }
        }
        if (type != rhs.type) {
            return false;
        }
        if (index_type != rhs.index_type) {
            return false;
        }
 
        if (child_indexes.size() != rhs.child_indexes.size()) {
            return false;
        }
        for (idx_t i = 0; i < child_indexes.size(); i++) {
            auto &a = child_indexes[i];
            auto &b = rhs.child_indexes[i];
            if (a != b) {
                return false;
            }
        }
        return true;
    }

operator!=()

bool duckdb::ColumnIndex::operator!= ( const ColumnIndex &  rhs ) const

inline

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

operator<()

bool duckdb::ColumnIndex::operator< ( const ColumnIndex &  rhs ) const

inline

FIXME: does it make sense to check children here?

                                                        {
        return index < rhs.index;
    }

HasPrimaryIndex()

bool duckdb::ColumnIndex::HasPrimaryIndex ( ) const

inline

                                 {
        return has_index;
    }

GetPrimaryIndex()

idx_t duckdb::ColumnIndex::GetPrimaryIndex ( ) const

inline

                                  {
        if (!has_index) {
            throw InternalException("Attempted to get the primary index (numeric) for an index that consists of a "
                                    "field identifier (string: %s)",
                                    field);
        }
        return index;
    }

GetFieldName()

const string & duckdb::ColumnIndex::GetFieldName ( ) const

inline

                                       {
        if (has_index) {
            throw InternalException("Attempted to get the field identifier (string) for an index that consists of a "
                                    "primary index (numeric: %d)",
                                    index);
        }
        return field;
    }

ToLogical()

LogicalIndex duckdb::ColumnIndex::ToLogical ( ) const

inline

                                   {
        return LogicalIndex(GetPrimaryIndex());
    }

HasChildren()

bool duckdb::ColumnIndex::HasChildren ( ) const

inline

                             {
        return !child_indexes.empty();
    }

HasType()

bool duckdb::ColumnIndex::HasType ( ) const

inline

                         {
        return type.id() != LogicalTypeId::INVALID;
    }

ChildIndexCount()

idx_t duckdb::ColumnIndex::ChildIndexCount ( ) const

inline

                                  {
        return child_indexes.size();
    }

GetChildIndex() [1/2]

const ColumnIndex & duckdb::ColumnIndex::GetChildIndex ( idx_t  idx ) const

inline

                                                      {
        return child_indexes[idx];
    }

GetChildIndex() [2/2]

ColumnIndex & duckdb::ColumnIndex::GetChildIndex ( idx_t  idx )

inline

                                          {
        return child_indexes[idx];
    }

GetChildIndexes()

const vector< ColumnIndex > & duckdb::ColumnIndex::GetChildIndexes ( ) const

inline

                                                       {
        return child_indexes;
    }

GetChildIndexesMutable()

vector< ColumnIndex > & duckdb::ColumnIndex::GetChildIndexesMutable ( )

inline

                                                  {
        return child_indexes;
    }

IsPushdownExtract()

bool duckdb::ColumnIndex::IsPushdownExtract ( ) const

inline

                                   {
        return index_type == ColumnIndexType::PUSHDOWN_EXTRACT;
    }

SetType()

void duckdb::ColumnIndex::SetType ( const LogicalType &  type_information )

inline

                                                      {
        type = type_information;
    }

SetPushdownExtractType()

void duckdb::ColumnIndex::SetPushdownExtractType ( const LogicalType &  type_information, optional_ptr< const LogicalType >  cast_type = nullptr  )

inline

We can upgrade the optional prune hint to a PUSHDOWN_EXTRACT, which is no longer optional

Without a cast, the child will always be VARIANT

                                                                                     {
        index_type = ColumnIndexType::PUSHDOWN_EXTRACT;
        type = type_information;
        D_ASSERT(child_indexes.size() == 1);
 
        auto &child = child_indexes[0];
        if (child.HasPrimaryIndex()) {
            auto &child_types = StructType::GetChildTypes(type);
            auto &child_type = child_types[child.GetPrimaryIndex()].second;
            if (child.child_indexes.empty()) {
                if (cast_type) {
                    child.SetType(*cast_type);
                } else {
                    child.SetType(child_type);
                }
            } else {
                child.SetPushdownExtractType(child_type, cast_type);
            }
        } else {
            D_ASSERT(type_information.id() == LogicalTypeId::VARIANT);
            if (child.child_indexes.empty()) {
                if (cast_type) {
                    child.SetType(*cast_type);
                } else {
                    child.SetType(type_information);
                }
            } else {
                child.SetPushdownExtractType(type_information, cast_type);
            }
        }
    }

GetScanType()

const LogicalType & duckdb::ColumnIndex::GetScanType ( ) const

inline

                                           {
        D_ASSERT(HasType());
        if (IsPushdownExtract()) {
            return child_indexes[0].GetScanType();
        }
        return GetType();
    }

GetType()

const LogicalType & duckdb::ColumnIndex::GetType ( ) const

inline

                                       {
        D_ASSERT(type.id() != LogicalTypeId::INVALID);
        return type;
    }

AddChildIndex()

void duckdb::ColumnIndex::AddChildIndex ( ColumnIndex  new_index )

inline

                                              {
        this->child_indexes.push_back(std::move(new_index));
    }

IsRowIdColumn()

bool duckdb::ColumnIndex::IsRowIdColumn ( ) const

inline

                               {
        if (!has_index) {
            return false;
        }
        return index == COLUMN_IDENTIFIER_ROW_ID;
    }

IsEmptyColumn()

bool duckdb::ColumnIndex::IsEmptyColumn ( ) const

inline

                               {
        if (!has_index) {
            return false;
        }
        return index == COLUMN_IDENTIFIER_EMPTY;
    }

IsVirtualColumn()

bool duckdb::ColumnIndex::IsVirtualColumn ( ) const

inline

                                 {
        if (!has_index) {
            return false;
        }
        return index >= VIRTUAL_COLUMN_START;
    }

VerifySinglePath()

void duckdb::ColumnIndex::VerifySinglePath ( ) const

inline

                                  {
        if (child_indexes.empty()) {
            return;
        }
        if (child_indexes.size() != 1) {
            throw InternalException(
                "We were expecting to find a single path in the index, meaning 0 or 1 children, found: %d",
                child_indexes.size());
        }
        child_indexes[0].VerifySinglePath();
    }

IsChildPathOf()

bool duckdb::ColumnIndex::IsChildPathOf ( const ColumnIndex &  path ) const

inline

a's path has stopped short of b's path

b's path is a subset of a's path, so it's a parent path

                                                      {
        VerifySinglePath();
        path.VerifySinglePath();
        reference<const ColumnIndex> a(*this);
        reference<const ColumnIndex> b(path);
 
        while (true) {
            if (a.get().HasPrimaryIndex()) {
                if (!b.get().HasPrimaryIndex()) {
                    return false;
                }
                if (a.get().GetPrimaryIndex() != b.get().GetPrimaryIndex()) {
                    return false;
                }
            } else {
                if (b.get().HasPrimaryIndex()) {
                    return false;
                }
                if (a.get().GetFieldName() != b.get().GetFieldName()) {
                    return false;
                }
            }
            const bool a_has_children = a.get().HasChildren();
            const bool b_has_children = b.get().HasChildren();
            if (!a_has_children && !b_has_children) {
                return false;
            }
            if (!a_has_children) {
                return false;
            }
            if (!b_has_children) {
                return true;
            }
            a = a.get().GetChildIndexes()[0];
            b = b.get().GetChildIndexes()[0];
        }
        return true;
    }

---

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

• external/duckdb/duckdb.hpp