duckdb::BaseNode< CAPACITY, TYPE > Class Template Reference

Collaboration diagram for duckdb::BaseNode< CAPACITY, TYPE >:

Public Member Functions
	BaseNode (const BaseNode &)=delete
BaseNode &	operator= (const BaseNode &)=delete
NodeChildren	ExtractChildren (ArenaAllocator &arena)

Static Public Member Functions
static NodeHandle< BaseNode >	New (ART &art, Node &node)
	Get a new BaseNode handle and initialize the base node.
static void	ReplaceChild (BaseNode &n, const uint8_t byte, const Node child)
	Replace the child at byte.
static unsafe_optional_ptr< Node >	GetChild (BaseNode &n, const uint8_t byte, const bool unsafe=false)
	Get the child at byte.
static unsafe_optional_ptr< Node >	GetNextChild (BaseNode &n, uint8_t &byte)
	Get the first child greater than or equal to the byte.
template<class F >
static void	Iterator (BaseNode< CAPACITY, TYPE > &n, F &&lambda)

Static Private Member Functions
static void	InsertChildInternal (BaseNode &n, const uint8_t byte, const Node child)
static NodeHandle< BaseNode >	DeleteChildInternal (ART &art, Node &node, const uint8_t byte)

Private Attributes
uint8_t	count
uint8_t	key [CAPACITY]
Node	children [CAPACITY]

Friends
class	Node4
class	Node16
class	Node48

Member Function Documentation

New()

template<uint8_t CAPACITY, NType TYPE>

static NodeHandle< BaseNode > duckdb::BaseNode< CAPACITY, TYPE >::New ( ART &  art, Node &  node  )

inlinestatic

Get a new BaseNode handle and initialize the base node.

                                                          {
        node = Node::GetAllocator(art, TYPE).New();
        node.SetMetadata(static_cast<uint8_t>(TYPE));
 
        NodeHandle<BaseNode> handle(art, node);
        auto &n = handle.Get();
 
        // Reset the node (count).
        n.count = 0;
        // Zero-initialize the node.
        for (uint8_t i = 0; i < CAPACITY; i++) {
            n.key[i] = 0;
            n.children[i].Clear();
        }
 
        return handle;
    }

Here is the call graph for this function:

ReplaceChild()

template<uint8_t CAPACITY, NType TYPE>

static void duckdb::BaseNode< CAPACITY, TYPE >::ReplaceChild ( BaseNode< CAPACITY, TYPE > &  n, const uint8_t  byte, const Node  child  )

inlinestatic

Replace the child at byte.

                                                                                {
        D_ASSERT(n.count != 0);
        for (uint8_t i = 0; i < n.count; i++) {
            if (n.key[i] == byte) {
                auto status = n.children[i].GetGateStatus();
                n.children[i] = child;
 
                if (status == GateStatus::GATE_SET && child.HasMetadata()) {
                    n.children[i].SetGateStatus(status);
                }
                return;
            }
        }
    }

Here is the call graph for this function:

GetChild()

template<uint8_t CAPACITY, NType TYPE>

static unsafe_optional_ptr< Node > duckdb::BaseNode< CAPACITY, TYPE >::GetChild ( BaseNode< CAPACITY, TYPE > &  n, const uint8_t  byte, const bool  unsafe = false  )

inlinestatic

Get the child at byte.

                                                                                                          {
        for (uint8_t i = 0; i < n.count; i++) {
            if (n.key[i] == byte) {
                if (!unsafe && !n.children[i].HasMetadata()) {
                    throw InternalException("empty child i = %d for byte %d in BaseNode::GetChild", i, byte);
                }
                return &n.children[i];
            }
        }
        return nullptr;
    }

Here is the call graph for this function:

GetNextChild()

template<uint8_t CAPACITY, NType TYPE>

static unsafe_optional_ptr< Node > duckdb::BaseNode< CAPACITY, TYPE >::GetNextChild ( BaseNode< CAPACITY, TYPE > &  n, uint8_t &  byte  )

inlinestatic

Get the first child greater than or equal to the byte.

                                                                              {
        for (uint8_t i = 0; i < n.count; i++) {
            if (n.key[i] >= byte) {
                byte = n.key[i];
                return &n.children[i];
            }
        }
        return nullptr;
    }

ExtractChildren()

template<uint8_t CAPACITY, NType TYPE>

NodeChildren duckdb::BaseNode< CAPACITY, TYPE >::ExtractChildren ( ArenaAllocator &  arena )

inline

Extracts the bytes and their respective children. The return value is valid as long as the arena is valid. The node must be freed after calling into this function.

                                                        {
        auto mem_bytes = arena.AllocateAligned(sizeof(uint8_t) * count);
        array_ptr<uint8_t> bytes(mem_bytes, count);
        auto mem_children = arena.AllocateAligned(sizeof(Node) * count);
        array_ptr<Node> children_ptr(reinterpret_cast<Node *>(mem_children), count);
 
        for (uint8_t i = 0; i < count; i++) {
            bytes[i] = key[i];
            children_ptr[i] = children[i];
        }
 
        return NodeChildren(bytes, children_ptr);
    }

Iterator()

template<uint8_t CAPACITY, NType TYPE>

template<class F >

static void duckdb::BaseNode< CAPACITY, TYPE >::Iterator ( BaseNode< CAPACITY, TYPE > &  n, F &&  lambda  )

inlinestatic

                                                                  {
        for (uint8_t i = 0; i < n.count; i++) {
            lambda(n.children[i]);
        }
    }

---

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

• external/duckdb/duckdb.cpp