Function bindFunc

src/function/table/show_indexes.cpp:105–160

}

static std::unique_ptr<TableFuncBindData> bindFunc(const main::ClientContext* context,
    const TableFuncBindInput* input) {
    std::vector<IndexInfo> indexesInfo;
    auto catalog = Catalog::Get(*context);
    auto transaction = transaction::Transaction::Get(*context);
    std::unordered_set<std::string> seenIndexes;
    auto indexEntries = catalog->getIndexEntries(transaction);
    for (auto indexEntry : indexEntries) {
        auto tableEntry = catalog->getTableCatalogEntry(transaction, indexEntry->getTableID());
        auto tableName = tableEntry->getName();
        auto indexName = indexEntry->getIndexName();
        auto indexType = indexEntry->getIndexType();
        auto propertyNames = getPropertyNames(*tableEntry, indexEntry->getPropertyIDs());
        auto dependencyLoaded = indexEntry->isLoaded();
        std::string indexDefinition;
        if (dependencyLoaded) {
            auto& auxInfo = indexEntry->getAuxInfo();
            common::FileScanInfo exportFileInfo{};
            IndexToCypherInfo info{context, exportFileInfo};
            indexDefinition = auxInfo.toCypher(*indexEntry, info);
        }
        indexesInfo.emplace_back(std::move(tableName), std::move(indexName), std::move(indexType),
            std::move(propertyNames), dependencyLoaded, std::move(indexDefinition));
        seenIndexes.insert(getSeenKey(indexEntry->getTableID(), indexEntry->getIndexName()));
    }

    auto* storageManager = storage::StorageManager::Get(*context);
    for (auto* tableEntry :
        catalog->getNodeTableEntries(transaction, context->useInternalCatalogEntry())) {
        const auto tableID = tableEntry->getTableID();
        const auto hasCatalogPKIndex =
            catalog->containsIndex(transaction, tableID, tableEntry->getPrimaryKeyID());
        auto* nodeTable = storageManager->getTable(tableID)->ptrCast<storage::NodeTable>();
        for (auto& indexHolder : nodeTable->getIndexes()) {
            const auto& storageIndexInfo = indexHolder.getIndexInfo();
            if (!storageIndexInfo.isPrimary || !storageIndexInfo.isBuiltin) {
                continue;
            }
            if (seenIndexes.contains(getSeenKey(tableID, storageIndexInfo.name))) {
                continue;
            }
            if (storageIndexInfo.isPrimary && hasCatalogPKIndex) {
                continue;
            }
            if (!indexHolder.isLoaded()) {
                continue;
            }
            indexesInfo.emplace_back(tableEntry->getName(), storageIndexInfo.name,
                storageIndexInfo.indexType,
                getPropertyNames(*tableEntry, storageIndexInfo.columnIDs), true,
                "" /* indexDefinition */);
        }
    }
    return std::make_unique<ShowIndexesBindData>(indexesInfo, bindColumns(*input),
        indexesInfo.size());
}

function_set ShowIndexesFunction::getFunctionSet() {