SpnWrapper.hpp

Go to the documentation of this file.

#pragma once
 
#include <mutable/util/Pool.hpp>
#include <unordered_map>
#include <util/Spn.hpp>
#include <vector>
 
 
namespace m {
 
struct SpnWrapper
{
    using Filter = std::unordered_map<unsigned, std::pair<Spn::SpnOperator, float>>;
    using AttrFilter = std::unordered_map<ThreadSafePooledString, std::pair<Spn::SpnOperator, float>>;
 
    private:
    Spn spn_;
    std::unordered_map<ThreadSafePooledString, unsigned> attribute_to_id_; 
 
    SpnWrapper(Spn spn, std::unordered_map<ThreadSafePooledString, unsigned> attribute_to_id)
        : spn_(std::move(spn))
        , attribute_to_id_(std::move(attribute_to_id))
    { }
 
    Filter translate_filter(const AttrFilter &attr_filter) const {
        Filter filter;
        for (auto &elem : attr_filter) { filter.emplace(translate_attribute(elem.first), elem.second); }
        return filter;
    };
 
    unsigned translate_attribute(const ThreadSafePooledString &attribute) const {
        unsigned spn_id = 0;
        if (auto it = attribute_to_id_.find(attribute); it != attribute_to_id_.end()) {
            spn_id = it->second;
        } else { std::cerr << "could not find attribute: " << attribute << std::endl; }
        return spn_id;
    }
 
    public:
    SpnWrapper(const SpnWrapper&) = delete;
    SpnWrapper(SpnWrapper&&) = default;
 
    const std::unordered_map<ThreadSafePooledString, unsigned> & get_attribute_to_id() const { return attribute_to_id_; }
 
    static SpnWrapper learn_spn_table(const ThreadSafePooledString &name_of_database,
                                      const ThreadSafePooledString &name_of_table,
                                      std::vector<Spn::LeafType> leaf_types = decltype(leaf_types)());
 
    static std::unordered_map<ThreadSafePooledString, SpnWrapper*>
    learn_spn_database(
        const ThreadSafePooledString &name_of_database,
        std::unordered_map<ThreadSafePooledString, std::vector<Spn::LeafType>> leaf_types = decltype(leaf_types)()
    );
 
 
    std::size_t num_rows() const { return spn_.num_rows(); }
 
    float likelihood(const AttrFilter &attr_filter) const { return spn_.likelihood(translate_filter(attr_filter)); };
    float likelihood(const Filter &filter) const { return spn_.likelihood(filter); };
 
    float upper_bound(const AttrFilter &attr_filter) const { return spn_.upper_bound(translate_filter(attr_filter)); };
    float upper_bound(const Filter &filter) const { return spn_.upper_bound(filter); };
 
    float lower_bound(const AttrFilter &attr_filter) const { return spn_.lower_bound(translate_filter(attr_filter)); };
    float lower_bound(const Filter &filter) const { return spn_.lower_bound(filter); };
 
    float expectation(const ThreadSafePooledString &attribute, const AttrFilter &attr_filter) const {
        return spn_.expectation(translate_attribute(attribute), translate_filter(attr_filter));
    }
    float expectation(unsigned attribute_id, const Filter &filter) const {
        return spn_.expectation(attribute_id, filter);
    };
 
    void update_row(Eigen::VectorXf &old_row, Eigen::VectorXf &updated_row) { spn_.update_row(old_row, updated_row); };
 
    void insert_row(Eigen::VectorXf &row) { spn_.insert_row(row); };
 
    void delete_row(Eigen::VectorXf &row) { spn_.delete_row(row); };
 
    std::size_t estimate_number_distinct_values(const ThreadSafePooledString &attribute) const {
        return spn_.estimate_number_distinct_values(translate_attribute(attribute));
    }
    std::size_t estimate_number_distinct_values(unsigned attribute_id) const {
        return spn_.estimate_number_distinct_values(attribute_id);
    };
 
    unsigned height() const { return spn_.height(); }
    unsigned breadth() const { return spn_.breadth(); }
    unsigned degree() const { return spn_.degree(); }
    std::size_t memory_usage() const { return spn_.memory_usage(); }
    void dump() const { spn_.dump(); };
    void dump(std::ostream &out) const { spn_.dump(out); };
};
 
}