duckdb::ARTScanner< HANDLING, NODE > Class Template Reference

ARTScanner scans the entire ART and processes each node. More...

Collaboration diagram for duckdb::ARTScanner< HANDLING, NODE >:

Classes
struct	NodeEntry

Public Member Functions
template<class FUNC >
	ARTScanner (ART &art, FUNC &&handler, NODE &root)
template<class FUNC >
void	Scan (FUNC &&handler)

Private Member Functions
template<class FUNC >
void	Emplace (FUNC &&handler, NODE &node)
template<class FUNC >
void	Pop (FUNC &&handler, NODE &node)
template<class FUNC , class NODE_TYPE >
void	IterateChildren (FUNC &&handler, NODE &node, const NType type)

Private Attributes
ART &	art
stack< NodeEntry >	s

Detailed Description

template<ARTScanHandling HANDLING, class NODE>
class duckdb::ARTScanner< HANDLING, NODE >

ARTScanner scans the entire ART and processes each node.

Constructor & Destructor Documentation

ARTScanner()

template<ARTScanHandling HANDLING, class NODE >

template<class FUNC >

duckdb::ARTScanner< HANDLING, NODE >::ARTScanner ( ART &  art, FUNC &&  handler, NODE &  root  )

inlineexplicit

                                                              : art(art) {
        Emplace(handler, root);
    }

Member Function Documentation

Scan()

template<ARTScanHandling HANDLING, class NODE >

template<class FUNC >

void duckdb::ARTScanner< HANDLING, NODE >::Scan ( FUNC &&  handler )

inline

                              {
        while (!s.empty()) {
            auto &entry = s.top();
            if (entry.exhausted) {
                Pop(handler, entry.node);
                continue;
            }
            entry.exhausted = true;
 
            const auto type = entry.node.GetType();
            switch (type) {
            case NType::LEAF_INLINED:
            case NType::LEAF:
            case NType::NODE_7_LEAF:
            case NType::NODE_15_LEAF:
            case NType::NODE_256_LEAF:
                break;
            case NType::PREFIX: {
                Prefix prefix(art, entry.node, true);
                Emplace(handler, *prefix.ptr);
                break;
            }
 
            case NType::NODE_4: {
                IterateChildren<FUNC, Node4>(handler, entry.node, type);
                break;
            }
            case NType::NODE_16: {
                IterateChildren<FUNC, Node16>(handler, entry.node, type);
                break;
            }
            case NType::NODE_48: {
                IterateChildren<FUNC, Node48>(handler, entry.node, type);
                break;
            }
            case NType::NODE_256: {
                IterateChildren<FUNC, Node256>(handler, entry.node, type);
                break;
            }
            default:
                throw InternalException("invalid node type for ART ARTScanner: %d", type);
            }
        }
    }

Emplace()

template<ARTScanHandling HANDLING, class NODE >

template<class FUNC >

void duckdb::ARTScanner< HANDLING, NODE >::Emplace ( FUNC &&  handler, NODE &  node  )

inlineprivate

                                             {
        if (HANDLING == ARTScanHandling::EMPLACE) {
            auto result = handler(node);
            if (result == ARTHandlingResult::SKIP) {
                return;
            }
            D_ASSERT(result == ARTHandlingResult::CONTINUE);
        }
        s.emplace(node);
    }

Pop()

template<ARTScanHandling HANDLING, class NODE >

template<class FUNC >

void duckdb::ARTScanner< HANDLING, NODE >::Pop ( FUNC &&  handler, NODE &  node  )

inlineprivate

                                         {
        if (HANDLING == ARTScanHandling::POP) {
            handler(node);
        }
        s.pop();
    }

IterateChildren()

template<ARTScanHandling HANDLING, class NODE >

template<class FUNC , class NODE_TYPE >

void duckdb::ARTScanner< HANDLING, NODE >::IterateChildren ( FUNC &&  handler, NODE &  node, const NType  type  )

inlineprivate

                                                                       {
        auto &n = Node::Ref<NODE_TYPE>(art, node, type);
        NODE_TYPE::Iterator(n, [&](NODE &child) { Emplace(handler, child); });
    }

---

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

• external/duckdb/duckdb.cpp