if (!node) return;

// Free children first

AstNode* child = node->first_child;

while (child) {

AstNode* next = child->next_sibling;

free_ast(child);

child = next;

}

// Free value string

if (node->value_ptr) {

std::free(const_cast<char*>(node->value_ptr));

}

std::free(node);

uint32_t stmt_id;

StmtType stmt_type;

AstNode* ast; // heap-allocated deep copy

~CachedStmt() {

free_ast(ast);

}

// Non-copyable

CachedStmt(const CachedStmt&) = delete;

CachedStmt& operator=(const CachedStmt&) = delete;

CachedStmt(CachedStmt&& o) noexcept

: stmt_id(o.stmt_id), stmt_type(o.stmt_type), ast(o.ast) {

o.ast = nullptr;

}

CachedStmt& operator=(CachedStmt&& o) noexcept {

if (this != &o) {

free_ast(ast);

stmt_id = o.stmt_id;

stmt_type = o.stmt_type;

ast = o.ast;

o.ast = nullptr;

}

return *this;

}

CachedStmt() : stmt_id(0), stmt_type(StmtType::UNKNOWN), ast(nullptr) {}

CachedStmt(uint32_t id, StmtType type, AstNode* a)

: stmt_id(id), stmt_type(type), ast(a) {}

explicit StmtCache(size_t capacity = 128) : capacity_(capacity) {}

~StmtCache() { clear(); }

// Non-copyable

StmtCache(const StmtCache&) = delete;

StmtCache& operator=(const StmtCache&) = delete;

// Store a prepared statement. Deep-copies the AST from the arena.

// Evicts LRU entry if at capacity.

bool store(uint32_t stmt_id, StmtType stmt_type, const AstNode* ast) {

// If already exists, remove old entry

evict(stmt_id);

AstNode* copy = deep_copy_ast(ast);

if (!copy && ast) return false;

// Evict LRU if at capacity

if (lru_.size() >= capacity_) {

auto& oldest = lru_.back();

map_.erase(oldest.stmt_id);

lru_.pop_back();

}

lru_.emplace_front(stmt_id, stmt_type, copy);

map_[stmt_id] = lru_.begin();

return true;

}

// Look up a cached statement. Returns nullptr if not found.

// Moves the entry to front of LRU.

const CachedStmt* lookup(uint32_t stmt_id) {

auto it = map_.find(stmt_id);

if (it == map_.end()) return nullptr;

// Move to front (most recently used)

lru_.splice(lru_.begin(), lru_, it->second);

return &(*it->second);

}

// Evict a specific statement.

void evict(uint32_t stmt_id) {

auto it = map_.find(stmt_id);

if (it != map_.end()) {

lru_.erase(it->second);

map_.erase(it);

}

}

// Clear all entries.

void clear() {

lru_.clear();

map_.clear();

}

size_t size() const { return map_.size(); }

size_t capacity() const { return capacity_; }

size_t capacity_;

std::list<CachedStmt> lru_;

std::unordered_map<uint32_t, std::list<CachedStmt>::iterator> map_;