query_result.h

Go to the documentation of this file.

#pragma once
 
#include <string>
 
#include "api.h"
#include "arrow.h"
#include "types.h"
#include "kuzu_fwd.h"
#include "flat_tuple.h"
#include "query_summary.h"
 
namespace kuzu {
namespace main {

class QueryResult {
    friend class Connection;
    friend class ClientContext;
    class QueryResultIterator {
    private:
        QueryResult* currentResult;
 
    public:
        QueryResultIterator() = default;
 
        explicit QueryResultIterator(QueryResult* startResult) : currentResult(startResult) {}
 
        void operator++() {
            if (currentResult) {
                currentResult = currentResult->nextQueryResult.get();
            }
        }
 
        bool isEnd() const { return currentResult == nullptr; }
 
        bool hasNextQueryResult() const { return currentResult->nextQueryResult != nullptr; }
 
        QueryResult* getCurrentResult() const { return currentResult; }
    };
 
public:
    KUZU_API QueryResult();
 
    explicit QueryResult(const PreparedSummary& preparedSummary);
    KUZU_API ~QueryResult();
    KUZU_API bool isSuccess() const;
    KUZU_API std::string getErrorMessage() const;
    KUZU_API size_t getNumColumns() const;
    KUZU_API std::vector<std::string> getColumnNames() const;
    KUZU_API std::vector<common::LogicalType> getColumnDataTypes() const;
    KUZU_API uint64_t getNumTuples() const;
    KUZU_API QuerySummary* getQuerySummary() const;
    KUZU_API bool hasNext() const;
    KUZU_API bool hasNextQueryResult() const;
    KUZU_API QueryResult* getNextQueryResult();
 
    std::unique_ptr<QueryResult> nextQueryResult;
    KUZU_API std::shared_ptr<processor::FlatTuple> getNext();
    KUZU_API std::string toString() const;

    KUZU_API void resetIterator();
 
    processor::FactorizedTable* getTable() { return factorizedTable.get(); }

    KUZU_API std::unique_ptr<ArrowSchema> getArrowSchema() const;

    KUZU_API std::unique_ptr<ArrowArray> getNextArrowChunk(int64_t chunkSize);
 
private:
    void setColumnHeader(std::vector<std::string> columnNames,
        std::vector<common::LogicalType> columnTypes);
    void initResultTableAndIterator(std::shared_ptr<processor::FactorizedTable> factorizedTable_);
    void validateQuerySucceed() const;
    std::pair<std::unique_ptr<processor::FlatTuple>, std::unique_ptr<processor::FlatTupleIterator>>
    getIterator() const;
 
private:
    // execution status
    bool success = true;
    std::string errMsg;
 
    // header information
    std::vector<std::string> columnNames;
    std::vector<common::LogicalType> columnDataTypes;
    // data
    std::shared_ptr<processor::FactorizedTable> factorizedTable;
    std::unique_ptr<processor::FlatTupleIterator> iterator;
    std::shared_ptr<processor::FlatTuple> tuple;
 
    // execution statistics
    std::unique_ptr<QuerySummary> querySummary;
 
    // query iterator
    QueryResultIterator queryResultIterator;
};
 
} // namespace main
} // namespace kuzu