This file is indexed.

/usr/include/dballe/db/summary.h is in libdballe-dev 7.21-1build1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
#ifndef DBALLE_DB_SUMMARY_H
#define DBALLE_DB_SUMMARY_H

#include <dballe/core/query.h>
#include <dballe/db/db.h>
#include <vector>
#include <set>

namespace dballe {
namespace db {

class Matcher;
class Summary;

namespace summary {

/// Represent whether a summary can satisfy a given query
enum Support
{
    /// It cannot.
    UNSUPPORTED = 0,
    /// The query may select less data than this summary can estimate.
    OVERESTIMATED = 1,
    /// The query selects data that this summary can estimate exactly.
    EXACT = 2,
};

struct Entry
{
    int ana_id;
    std::string rep_memo;
    dballe::Level level;
    dballe::Trange trange;
    wreport::Varcode varcode;
    dballe::DatetimeRange dtrange;
    int count = MISSING_INT;

    Entry(db::CursorSummary& cur, bool want_details);
};

}

/**
 * High level objects for working with DB-All.e DB summaries
 */
class Summary
{
protected:
    // Query that generated this summary
    core::Query query;

    // Summary of items for the currently active filter
    std::vector<summary::Entry> summary;

    void aggregate(const summary::Entry& entry);

public:
    Summary(const dballe::Query& query);

    // True if the summary has been filled with data
    bool valid = false;

    std::set<int> all_stations;
    std::set<std::string> all_reports;
    std::set<dballe::Level> all_levels;
    std::set<dballe::Trange> all_tranges;
    std::set<wreport::Varcode> all_varcodes;

    // Last known datetime range for the data that we have
    dballe::DatetimeRange dtrange;
    // Last known count for the data that we have
    unsigned count = MISSING_INT;

    /// Return true if the summary has been filled with data
    bool is_valid() const { return valid; }

    const Datetime& datetime_min() const { return dtrange.min; }
    const Datetime& datetime_max() const { return dtrange.max; }
    unsigned data_count() const { return count; }

    /**
     * Checks if this summary correctly generate a
     * summary for the given query.
     */
    summary::Support supports(const Query& query) const;

    /// Add an entry to the summary taken from the current status of \a cur
    void add_summary(db::CursorSummary& cur, bool with_details);

    /// Add a copy of an existing entry
    void add_entry(const summary::Entry& entry);

    /// Iterate all values in the summary
    bool iterate(std::function<bool(const summary::Entry&)> f) const;
};

namespace summary {

/**
 * Stack of summary in increasing order of selectivity.
 *
 * This is used to keep enough context to refine a summary as a query is
 * refined, and to go back to a wider summary if the query is relaxed.
 *
 * Ideally, there could be several levels in the stack, so that each subquery
 * takes the previous one as a starting point, and the process gets faster and
 * faster; however, a summary may support a query (in the sense that it knows
 * that that query selects no data at all) while a more general summary may
 * support it and return data (e.g. ask first for rep_memo=synop, then change
 * one's mind and ask for rep_memo=temp.
 *
 * Supporting such scenarios would require implementing nontrivial logic for an
 * optimization that it is still unclear to me if it would be required. At the
 * moment, I simplify implementation by just supporting two levels, and having
 * each query always start from the topmost summary.
 */
class Stack
{
protected:
    /**
     * Summaries for the current query.
     *
     * summaries[0] is always the summary for the whole database;
     * further summaries are appended as the query is refined.
     */
    std::vector<Summary> summaries;

public:
    /// Check if the stack is empty
    bool empty() const { return summaries.empty(); }

    /// Return the stack size. Only really useful for tests.
    unsigned size() const { return summaries.size(); }

    /// Add a new summary to the stack, and return a reference to it
    Summary& push(const Query& query);

    /// Return the topmost summary
    const Summary& top() const { return summaries.back(); }

    /**
     * If the current summary stack can support the given query, append the
     * resulting summary to the stack, else, remove all entries from the stack
     * except the most general one.
     *
     * @returns how the resulting stack supports the query.
     */
    Support query(const Query& query, bool exact, std::function<bool(const Entry&)> match);
};

}

}
}

#endif