Relation.h

Go to the documentation of this file.

/*
 * Souffle - A Datalog Compiler
 * Copyright (c) 2018, The Souffle Developers. All rights reserved
 * Licensed under the Universal Permissive License v 1.0 as shown at:
 * - https://opensource.org/licenses/UPL
 * - <souffle root>/licenses/SOUFFLE-UPL.txt
 */
 
#pragma once
 
#include "ram/Relation.h"
#include "ram/analysis/Index.h"
#include <cstddef>
#include <cstdint>
#include <memory>
#include <ostream>
#include <set>
#include <string>
#include <unordered_set>
#include <vector>
 
namespace souffle::synthesiser {
 
using ram::analysis::MinIndexSelection;
 
class Relation {
public:
    Relation(const ram::Relation& rel, const MinIndexSelection& indices, const bool isProvenance = false)
            : relation(rel), indices(indices), isProvenance(isProvenance) {}
 
    virtual ~Relation() = default;
 
    /** Compute the final list of indices to be used */
    virtual void computeIndices() = 0;
 
    /** Get arity of relation */
    size_t getArity() const {
        return relation.getArity();
    }
 
    /** Get data structure of relation */
    const std::string& getDataStructure() const {
        return dataStructure;
    }
 
    /** Get list of indices used for relation,
     * guaranteed that original indices in analysis::MinIndexSelection
     * come before any generated indices */
    MinIndexSelection::OrderCollection getIndices() const {
        return computedIndices;
    }
 
    std::set<int> getProvenenceIndexNumbers() const {
        return provenanceIndexNumbers;
    }
 
    /** Get stored analysis::MinIndexSelection */
    const MinIndexSelection& getMinIndexSelection() const {
        return indices;
    }
 
    /** Get stored ram::Relation */
    const ram::Relation& getRelation() const {
        return relation;
    }
 
    /** Print type name */
    virtual std::string getTypeName() = 0;
 
    /** Helper function to convert attribute types to a single string */
    std::string getTypeAttributeString(const std::vector<std::string>& attributeTypes,
            const std::unordered_set<uint32_t>& attributesUsed) const;
 
    /** Generate relation type struct */
    virtual void generateTypeStruct(std::ostream& out) = 0;
 
    /** Factory method to generate a SynthesiserRelation */
    static Own<Relation> getSynthesiserRelation(
            const ram::Relation& ramRel, const MinIndexSelection& indexSet, bool isProvenance);
 
protected:
    /** Ram relation referred to by this */
    const ram::Relation& relation;
 
    /** Indices used for this relation */
    const MinIndexSelection& indices;
 
    /** The data structure used for the relation */
    std::string dataStructure;
 
    /** The final list of indices used */
    MinIndexSelection::OrderCollection computedIndices;
 
    /** The list of indices added for provenance computation */
    std::set<int> provenanceIndexNumbers;
 
    /** The number of the master index */
    size_t masterIndex = -1;
 
    /** Is this relation used with provenance */
    const bool isProvenance;
};
 
class NullaryRelation : public Relation {
public:
    NullaryRelation(const ram::Relation& ramRel, const MinIndexSelection& indexSet, bool isProvenance)
            : Relation(ramRel, indexSet, isProvenance) {}
 
    void computeIndices() override;
    std::string getTypeName() override;
    void generateTypeStruct(std::ostream& out) override;
};
 
class InfoRelation : public Relation {
public:
    InfoRelation(const ram::Relation& ramRel, const MinIndexSelection& indexSet, bool isProvenance)
            : Relation(ramRel, indexSet, isProvenance) {}
 
    void computeIndices() override;
    std::string getTypeName() override;
    void generateTypeStruct(std::ostream& out) override;
};
 
class DirectRelation : public Relation {
public:
    DirectRelation(const ram::Relation& ramRel, const MinIndexSelection& indexSet, bool isProvenance)
            : Relation(ramRel, indexSet, isProvenance) {}
 
    void computeIndices() override;
    std::string getTypeName() override;
    void generateTypeStruct(std::ostream& out) override;
};
 
class IndirectRelation : public Relation {
public:
    IndirectRelation(const ram::Relation& ramRel, const MinIndexSelection& indexSet, bool isProvenance)
            : Relation(ramRel, indexSet, isProvenance) {}
 
    void computeIndices() override;
    std::string getTypeName() override;
    void generateTypeStruct(std::ostream& out) override;
};
 
class BrieRelation : public Relation {
public:
    BrieRelation(const ram::Relation& ramRel, const MinIndexSelection& indexSet, bool isProvenance)
            : Relation(ramRel, indexSet, isProvenance) {}
 
    void computeIndices() override;
    std::string getTypeName() override;
    void generateTypeStruct(std::ostream& out) override;
};
 
class EqrelRelation : public Relation {
public:
    EqrelRelation(const ram::Relation& ramRel, const MinIndexSelection& indexSet, bool isProvenance)
            : Relation(ramRel, indexSet, isProvenance) {}
 
    void computeIndices() override;
    std::string getTypeName() override;
    void generateTypeStruct(std::ostream& out) override;
};
}  // namespace souffle::synthesiser