#include <Generator.h>

Inheritance diagram for souffle::interpreter::NodeGenerator:

Collaboration diagram for souffle::interpreter::NodeGenerator:

Data Structures
class	OrderingContext
	This class help generator reordering tuple access based on the index oder. More...

Public Member Functions
NodePtr	generateTree (const ram::Node &root)
	Generate the tree based on given entry. More...

	NodeGenerator (Engine &engine)

NodePtr	visitAggregate (const ram::Aggregate &aggregate) override

NodePtr	visitAutoIncrement (const ram::AutoIncrement &inc) override

NodePtr	visitBreak (const ram::Break &breakOp) override

NodePtr	visitCall (const ram::Call &call) override

NodePtr	visitChoice (const ram::Choice &choice) override

NodePtr	visitClear (const ram::Clear &clear) override

NodePtr	visitConjunction (const ram::Conjunction &conj) override

NodePtr	visitConstant (const ram::Constant &num) override

NodePtr	visitConstraint (const ram::Constraint &relOp) override

NodePtr	visitDebugInfo (const ram::DebugInfo &dbg) override

NodePtr	visitEmptinessCheck (const ram::EmptinessCheck &emptiness) override

NodePtr	visitExistenceCheck (const ram::ExistenceCheck &exists) override

NodePtr	visitExit (const ram::Exit &exit) override

NodePtr	visitExtend (const ram::Extend &extend) override

NodePtr	visitFalse (const ram::False &lfalse) override

NodePtr	visitFilter (const ram::Filter &filter) override

NodePtr	visitIndexAggregate (const ram::IndexAggregate &iAggregate) override

NodePtr	visitIndexChoice (const ram::IndexChoice &iChoice) override

NodePtr	visitIndexScan (const ram::IndexScan &iScan) override

NodePtr	visitIntrinsicOperator (const ram::IntrinsicOperator &op) override

NodePtr	visitIO (const ram::IO &io) override

NodePtr	visitLogRelationTimer (const ram::LogRelationTimer &timer) override

NodePtr	visitLogSize (const ram::LogSize &size) override

NodePtr	visitLogTimer (const ram::LogTimer &timer) override

NodePtr	visitLoop (const ram::Loop &loop) override

NodePtr	visitNegation (const ram::Negation &neg) override

NodePtr	visitNestedIntrinsicOperator (const ram::NestedIntrinsicOperator &op) override

NodePtr	visitNestedOperation (const ram::NestedOperation &nested) override

NodePtr	visitNode (const ram::Node &node) override

NodePtr	visitPackRecord (const ram::PackRecord &pr) override

NodePtr	visitParallel (const ram::Parallel &parallel) override

NodePtr	visitParallelAggregate (const ram::ParallelAggregate &pAggregate) override

NodePtr	visitParallelChoice (const ram::ParallelChoice &pChoice) override

NodePtr	visitParallelIndexAggregate (const ram::ParallelIndexAggregate &piAggregate) override

NodePtr	visitParallelIndexChoice (const ram::ParallelIndexChoice &piChoice) override

NodePtr	visitParallelIndexScan (const ram::ParallelIndexScan &piscan) override

NodePtr	visitParallelScan (const ram::ParallelScan &pScan) override

NodePtr	visitProject (const ram::Project &project) override

NodePtr	visitProvenanceExistenceCheck (const ram::ProvenanceExistenceCheck &provExists) override

NodePtr	visitQuery (const ram::Query &query) override

NodePtr	visitRelationSize (const ram::RelationSize &size) override

NodePtr	visitScan (const ram::Scan &scan) override

NodePtr	visitSequence (const ram::Sequence &seq) override

NodePtr	visitSubroutineArgument (const ram::SubroutineArgument &arg) override

NodePtr	visitSubroutineReturn (const ram::SubroutineReturn &ret) override

NodePtr	visitSwap (const ram::Swap &swap) override

NodePtr	visitTrue (const ram::True &ltrue) override

NodePtr	visitTupleElement (const ram::TupleElement &access) override

NodePtr	visitTupleOperation (const ram::TupleOperation &search) override

NodePtr	visitUndefValue (const ram::UndefValue &) override

NodePtr	visitUnpackRecord (const ram::UnpackRecord &unpack) override

NodePtr	visitUserDefinedOperator (const ram::UserDefinedOperator &op) override

Public Member Functions inherited from souffle::ram::Visitor< Own< Node > >
Own< Node >	operator() (const Node &node, Params... args)
	The main entry for the user allowing visitors to be utilized as functions. More...

Own< Node >	operator() (const Node *node, Params... args)
	The main entry for the user allowing visitors to be utilized as functions. More...

virtual Own< Node >	visit (const Node &node, Params... args)
	The main entry for a visit process conducting the dispatching of a visit to the various sub-types of Nodes. More...

virtual Own< Node >	visit (const Node *node, Params... args)

virtual	~Visitor ()=default
	A virtual destructor. More...

Private Types
using	NodePtr = Own< Node >

using	NodePtrVec = std::vector< NodePtr >

using	RelationHandle = Own< RelationWrapper >

Private Member Functions
template<class RamNode >
size_t	encodeIndexPos (RamNode &node)
	Return operation index id from the result of indexAnalysis. More...

size_t	encodeRelation (const std::string &relName)
	Encode and create the relation, return the relation id. More...

size_t	encodeView (const ram::Node *node)
	Encode and return the View id of an operation. More...

size_t	getArity (const std::string &relName)
	get arity of relation More...

SuperInstruction	getExistenceSuperInstInfo (const ram::AbstractExistenceCheck &abstractExist)
	Encode and return the super-instruction information about an existence check operation. More...

SuperInstruction	getIndexSuperInstInfo (const ram::IndexOperation &ramIndex)
	Encode and return the super-instruction information about a index operation. More...

size_t	getNewRelId ()
	Get a valid relation id for encoding. More...

size_t	getNextViewId ()
	Get a valid view id for encoding. More...

SuperInstruction	getProjectSuperInstInfo (const ram::Project &exist)
	Encode and return the super-instruction information about a project operation. More...

RelationHandle *	getRelationHandle (const size_t idx)

const std::string &	getViewRelation (const ram::Node *node)
	Return the associated relation of a operation which requires a view. More...

const ram::Relation &	lookup (const std::string &relName)
	get arity of relation More...

void	newQueryBlock ()
	Reset view allocation system, since view's life time is within each query. More...

bool	requireView (const ram::Node *node)
	Return true if the given operation requires a view. More...

Private Attributes
Engine &	engine
	Reference to the engine instance. More...

std::unordered_map< const ram::Node *, size_t >	indexTable
	Environment encoding, store a mapping from ram::Node to its operation index id. More...

OrderingContext	orderingContext = OrderingContext(*this)
	ordering context More...

std::shared_ptr< ViewContext >	parentQueryViewContext = nullptr
	Points to the current viewContext during the generation. More...

std::unordered_map< std::string, const ram::Relation * >	relationMap
	name / relation mapping More...

size_t	relId = 0
	Next available location to encode a relation. More...

std::unordered_map< std::string, size_t >	relTable
	Environment encoding, store a mapping from ram::Relation to its id. More...

size_t	viewId = 0
	Next available location to encode View. More...

std::unordered_map< const ram::Node *, size_t >	viewTable
	Environment encoding, store a mapping from ram::Node to its View id. More...

Additional Inherited Members
Protected Member Functions inherited from souffle::ram::Visitor< Own< Node > >
	LINK (AbstractConditional, NestedOperation)

	LINK (AbstractExistenceCheck, Condition)

	LINK (AbstractOperator, Expression)

	LINK (Aggregate, RelationOperation)

	LINK (AutoIncrement, Expression)

	LINK (BinRelationStatement, Statement)

	LINK (Break, AbstractConditional)

	LINK (Call, Statement)

	LINK (Choice, RelationOperation)

	LINK (Clear, RelationStatement)

	LINK (Condition, Node)

	LINK (Conjunction, Condition)

	LINK (Constant, Expression)

	LINK (Constraint, Condition)

	LINK (DebugInfo, Statement)

	LINK (EmptinessCheck, Condition)

	LINK (ExistenceCheck, AbstractExistenceCheck)

	LINK (Exit, Statement)

	LINK (Expression, Node)

	LINK (Extend, BinRelationStatement)

	LINK (False, Condition)

	LINK (Filter, AbstractConditional)

	LINK (FloatConstant, Constant)

	LINK (IndexAggregate, IndexOperation)

	LINK (IndexChoice, IndexOperation)

	LINK (IndexOperation, RelationOperation)

	LINK (IndexScan, IndexOperation)

	LINK (IntrinsicOperator, AbstractOperator)

	LINK (IO, RelationStatement)

	LINK (ListStatement, Statement)

	LINK (LogRelationTimer, Statement)

	LINK (LogSize, RelationStatement)

	LINK (LogTimer, Statement)

	LINK (Loop, Statement)

	LINK (Negation, Condition)

	LINK (NestedOperation, Operation)

	LINK (Operation, Node)

	LINK (PackRecord, Expression)

	LINK (Parallel, ListStatement)

	LINK (ParallelAggregate, Aggregate)

	LINK (ParallelChoice, Choice)

	LINK (ParallelIndexAggregate, IndexAggregate)

	LINK (ParallelIndexChoice, IndexChoice)

	LINK (ParallelIndexScan, IndexScan)

	LINK (ParallelScan, Scan)

	LINK (Program, Node)

	LINK (Project, Operation)

	LINK (ProvenanceExistenceCheck, AbstractExistenceCheck)

	LINK (Query, Statement)

	LINK (Relation, Node)

	LINK (RelationOperation, TupleOperation)

	LINK (RelationSize, Expression)

	LINK (RelationStatement, Statement)

	LINK (Scan, RelationOperation)

	LINK (Sequence, ListStatement)

	LINK (SignedConstant, Constant)

	LINK (Statement, Node)

	LINK (SubroutineArgument, Expression)

	LINK (SubroutineReturn, Operation)

	LINK (Swap, BinRelationStatement)

	LINK (True, Condition)

	LINK (TupleElement, Expression)

	LINK (TupleOperation, NestedOperation)

	LINK (UndefValue, Expression)

	LINK (UnpackRecord, TupleOperation)

	LINK (UnsignedConstant, Constant)

	LINK (UserDefinedOperator, AbstractOperator)

virtual Own< Node >	visitNode (const Node &, Params...)
	The base case for all visitors – if no more specific overload was defined. More...

Detailed Description

Definition at line 119 of file Generator.h.

Member Typedef Documentation

◆ NodePtr

using souffle::interpreter::NodeGenerator::NodePtr = Own<Node>

private

Definition at line 120 of file Generator.h.

◆ NodePtrVec

using souffle::interpreter::NodeGenerator::NodePtrVec = std::vector<NodePtr>

private

Definition at line 121 of file Generator.h.

◆ RelationHandle

using souffle::interpreter::NodeGenerator::RelationHandle = Own<RelationWrapper>

private

Definition at line 122 of file Generator.h.

Constructor & Destructor Documentation

◆ NodeGenerator()

souffle::interpreter::NodeGenerator::NodeGenerator ( Engine & engine )

Definition at line 30 of file Generator.cpp.

                                                        {
     // Encode all relation, indexPos and viewId.
     visitDepthFirst(root, [&](const ram::Node& node) {
         if (isA<ram::Query>(&node)) {

Member Function Documentation

◆ encodeIndexPos()

template<class RamNode >

size_t souffle::interpreter::NodeGenerator::encodeIndexPos ( RamNode & node )

private

Return operation index id from the result of indexAnalysis.

Definition at line 497 of file Generator.cpp.

                            {
         signature = ram::analysis::SearchSignature::getFullSearchSignature(signature.arity());
     }
     auto i = orderSet.getLexOrderNum(signature);
     indexTable[&node] = i;
     return i;
 };
  
 size_t NodeGenerator::encodeView(const ram::Node* node) {
     auto pos = viewTable.find(node);
     if (pos != viewTable.end()) {
         return pos->second;

References souffle::ram::analysis::SearchSignature::arity(), and souffle::ram::analysis::SearchSignature::getFullSearchSignature().

Here is the call graph for this function:

◆ encodeRelation()

size_t souffle::interpreter::NodeGenerator::encodeRelation ( const std::string & relName )

private

Encode and create the relation, return the relation id.

Definition at line 531 of file Generator.cpp.

                                                                  {
     return engine.relations[idx].get();
 }
  

◆ encodeView()

size_t souffle::interpreter::NodeGenerator::encodeView ( const ram::Node * node )

private

Encode and return the View id of an operation.

Definition at line 510 of file Generator.cpp.

                                                                  {
     auto it = relationMap.find(relName);
     assert(it != relationMap.end() && "relation not found");
     return *it->second;

◆ generateTree()

NodePtr souffle::interpreter::NodeGenerator::generateTree ( const ram::Node & root )

Generate the tree based on given entry.

Return a NodePtr to the root.

Definition at line 37 of file Generator.cpp.

                                                                                      {
             encodeIndexPos(*indexSearch);
             encodeView(indexSearch);
         } else if (const auto* exists = dynamic_cast<const ram::ExistenceCheck*>(&node)) {
             encodeIndexPos(*exists);
             encodeView(exists);
         } else if (const auto* provExists = dynamic_cast<const ram::ProvenanceExistenceCheck*>(&node)) {
             encodeIndexPos(*provExists);
             encodeView(provExists);
         }
     });
     // Parse program
     return visit(root);
 }
  
 NodePtr NodeGenerator::visitConstant(const ram::Constant& num) {
     return mk<Constant>(I_Constant, &num);
 }
  

◆ getArity()

size_t souffle::interpreter::NodeGenerator::getArity ( const std::string & relName )

private

get arity of relation

Definition at line 526 of file Generator.cpp.

                                                              {
     auto pos = relTable.find(relName);
     if (pos != relTable.end()) {
         return pos->second;

◆ getExistenceSuperInstInfo()

SuperInstruction souffle::interpreter::NodeGenerator::getExistenceSuperInstInfo ( const ram::AbstractExistenceCheck & abstractExist )

private

Encode and return the super-instruction information about an existence check operation.

Definition at line 634 of file Generator.cpp.

                                                                  {
         indexId = encodeIndexPos(*dynamic_cast<const ram::ProvenanceExistenceCheck*>(&abstractExist));
     } else {
         fatal("Unrecognized ram::AbstractExistenceCheck.");
     }
     auto order = (*getRelationHandle(interpreterRel))->getIndexOrder(indexId);
     size_t arity = getArity(abstractExist.getRelation());
     SuperInstruction superOp(arity);
     const auto& children = abstractExist.getValues();
     for (size_t i = 0; i < arity; ++i) {
         auto& child = children[order[i]];
  
         // Unbounded
         if (isUndefValue(child)) {
             superOp.first[i] = MIN_RAM_SIGNED;
             superOp.second[i] = MAX_RAM_SIGNED;
             continue;
         }
  
         // Constant
         if (isA<ram::Constant>(child)) {
             superOp.first[i] = dynamic_cast<ram::Constant*>(child)->getConstant();
             superOp.second[i] = superOp.first[i];
             continue;
         }
  
         // TupleElement
         if (isA<ram::TupleElement>(child)) {
             auto tuple = dynamic_cast<ram::TupleElement*>(child);
             size_t tupleId = tuple->getTupleId();
             size_t elementId = tuple->getElement();
             size_t newElementId = orderingContext.mapOrder(tupleId, elementId);
             superOp.tupleFirst.push_back({i, tupleId, newElementId});
             continue;
         }
  
         // Generic expression
         superOp.exprFirst.push_back(std::pair<size_t, Own<Node>>(i, visit(child)));
     }
     return superOp;
 }
  
 SuperInstruction NodeGenerator::getProjectSuperInstInfo(const ram::Project& exist) {
     size_t arity = getArity(exist.getRelation());
     SuperInstruction superOp(arity);
     const auto& children = exist.getValues();

◆ getIndexSuperInstInfo()

SuperInstruction souffle::interpreter::NodeGenerator::getIndexSuperInstInfo ( const ram::IndexOperation & ramIndex )

private

Encode and return the super-instruction information about a index operation.

Definition at line 565 of file Generator.cpp.

                                        {
         // Note: unlike orderingContext::mapOrder, where we try to decode the order,
         // here we have to encode the order.
         auto& low = first[order[i]];
  
         // Unbounded
         if (isUndefValue(low)) {
             indexOperation.first[i] = MIN_RAM_SIGNED;
             continue;
         }
  
         // Constant
         if (isA<ram::Constant>(low)) {
             indexOperation.first[i] = dynamic_cast<ram::Constant*>(low)->getConstant();
             continue;
         }
  
         // TupleElement
         if (isA<ram::TupleElement>(low)) {
             auto lowTuple = dynamic_cast<ram::TupleElement*>(low);
             size_t tupleId = lowTuple->getTupleId();
             size_t elementId = lowTuple->getElement();
             size_t newElementId = orderingContext.mapOrder(tupleId, elementId);
             indexOperation.tupleFirst.push_back({i, tupleId, newElementId});
             continue;
         }
  
         // Generic expression
         indexOperation.exprFirst.push_back(std::pair<size_t, Own<Node>>(i, visit(low)));
     }
     const auto& second = ramIndex.getRangePattern().second;
     for (size_t i = 0; i < arity; ++i) {
         auto& hig = second[order[i]];
  
         // Unbounded
         if (isUndefValue(hig)) {
             indexOperation.second[i] = MAX_RAM_SIGNED;
             continue;
         }
  
         // Constant
         if (isA<ram::Constant>(hig)) {
             indexOperation.second[i] = dynamic_cast<ram::Constant*>(hig)->getConstant();
             continue;
         }
  
         // TupleElement
         if (isA<ram::TupleElement>(hig)) {
             auto highTuple = dynamic_cast<ram::TupleElement*>(hig);
             size_t tupleId = highTuple->getTupleId();
             size_t elementId = highTuple->getElement();
             size_t newElementId = orderingContext.mapOrder(tupleId, elementId);
             indexOperation.tupleSecond.push_back({i, tupleId, newElementId});
             continue;
         }
  
         // Generic expression
         indexOperation.exprSecond.push_back(std::pair<size_t, Own<Node>>(i, visit(hig)));
     }
     return indexOperation;
 }
  
 SuperInstruction NodeGenerator::getExistenceSuperInstInfo(const ram::AbstractExistenceCheck& abstractExist) {
     auto interpreterRel = encodeRelation(abstractExist.getRelation());
     size_t indexId = 0;
     if (isA<ram::ExistenceCheck>(&abstractExist)) {

◆ getNewRelId()

size_t souffle::interpreter::NodeGenerator::getNewRelId ( )

private

Get a valid relation id for encoding.

Definition at line 488 of file Generator.cpp.

◆ getNextViewId()

size_t souffle::interpreter::NodeGenerator::getNextViewId ( )

private

Get a valid view id for encoding.

Definition at line 492 of file Generator.cpp.

                                                   {
     const std::string& name = node.getRelation();
     auto& orderSet = engine.isa->getIndexes(name);

◆ getProjectSuperInstInfo()

SuperInstruction souffle::interpreter::NodeGenerator::getProjectSuperInstInfo ( const ram::Project & exist )

private

Encode and return the super-instruction information about a project operation.

No reordering needed for projection as project can have more then one target indexes and reordering can only be done during runtime.

Definition at line 681 of file Generator.cpp.

                                      {
             superOp.first[i] = dynamic_cast<ram::Constant*>(child)->getConstant();
             continue;
         }
  
         // TupleElement
         if (isA<ram::TupleElement>(child)) {
             auto tuple = dynamic_cast<ram::TupleElement*>(child);
             size_t tupleId = tuple->getTupleId();
             size_t elementId = tuple->getElement();
             size_t newElementId = orderingContext.mapOrder(tupleId, elementId);
             superOp.tupleFirst.push_back({i, tupleId, newElementId});
             continue;
         }
  
         // Generic expression
         superOp.exprFirst.push_back(std::pair<size_t, Own<Node>>(i, visit(child)));
     }
     return superOp;
 }
  
 // -- Definition of OrderingContext --
  
 NodeGenerator::OrderingContext::OrderingContext(NodeGenerator& generator) : generator(generator) {}
  

References souffle::interpreter::SuperInstruction::first, and i.

◆ getRelationHandle()

RelationHandle * souffle::interpreter::NodeGenerator::getRelationHandle ( const size_t idx )

private

Definition at line 542 of file Generator.cpp.

                                               {
         return true;
     } else if (isA<ram::IndexOperation>(node)) {

◆ getViewRelation()

const std::string & souffle::interpreter::NodeGenerator::getViewRelation ( const ram::Node * node )

private

Return the associated relation of a operation which requires a view.

This function assume the operation does requires a view.

Definition at line 555 of file Generator.cpp.

                                                                                        {
     size_t arity = getArity(ramIndex.getRelation());
     auto interpreterRel = encodeRelation(ramIndex.getRelation());
     auto indexId = encodeIndexPos(ramIndex);

◆ lookup()

const ram::Relation & souffle::interpreter::NodeGenerator::lookup ( const std::string & relName )

private

get arity of relation

Definition at line 520 of file Generator.cpp.

                                                        {
     auto rel = lookup(relName);
     return rel.getArity();
 }

References rel().

Here is the call graph for this function:

◆ newQueryBlock()

void souffle::interpreter::NodeGenerator::newQueryBlock ( )

private

Reset view allocation system, since view's life time is within each query.

Definition at line 483 of file Generator.cpp.

                                   {
     return relId++;
 }
  

◆ requireView()

bool souffle::interpreter::NodeGenerator::requireView ( const ram::Node * node )

private

Return true if the given operation requires a view.

Definition at line 546 of file Generator.cpp.

                                                                    {
     if (const auto* exist = dynamic_cast<const ram::AbstractExistenceCheck*>(node)) {
         return exist->getRelation();
     } else if (const auto* index = dynamic_cast<const ram::IndexOperation*>(node)) {

◆ visitAggregate()

NodePtr souffle::interpreter::NodeGenerator::visitAggregate ( const ram::Aggregate & aggregate )

override

Definition at line 263 of file Generator.cpp.

                                                                                     {
     orderingContext.addTupleWithDefaultOrder(pAggregate.getTupleId(), pAggregate);
     NodePtr expr = visit(pAggregate.getExpression());
     NodePtr cond = visit(pAggregate.getCondition());

◆ visitAutoIncrement()

NodePtr souffle::interpreter::NodeGenerator::visitAutoIncrement ( const ram::AutoIncrement & inc )

override

Definition at line 69 of file Generator.cpp.

70 : op.getArguments()) {

71 children.push_back(visit(arg));

◆ visitBreak()

NodePtr souffle::interpreter::NodeGenerator::visitBreak ( const ram::Break & breakOp )

override

Definition at line 324 of file Generator.cpp.

◆ visitCall()

NodePtr souffle::interpreter::NodeGenerator::visitCall ( const ram::Call & call )

override

Definition at line 373 of file Generator.cpp.

                                                                              {
     size_t relId = encodeRelation(timer.getRelation());
     auto rel = getRelationHandle(relId);
     return mk<LogRelationTimer>(I_LogRelationTimer, &timer, visit(timer.getStatement()), rel);

◆ visitChoice()

NodePtr souffle::interpreter::NodeGenerator::visitChoice ( const ram::Choice & choice )

override

Definition at line 218 of file Generator.cpp.

                                                                            {
     orderingContext.addTupleWithDefaultOrder(pChoice.getTupleId(), pChoice);
     size_t relId = encodeRelation(pChoice.getRelation());
     auto rel = getRelationHandle(relId);

◆ visitClear()

NodePtr souffle::interpreter::NodeGenerator::visitClear ( const ram::Clear & clear )

override

Definition at line 398 of file Generator.cpp.

                                                           {
     size_t relId = encodeRelation(size.getRelation());
     auto rel = getRelationHandle(relId);
     return mk<LogSize>(I_LogSize, &size, rel);

◆ visitConjunction()

NodePtr souffle::interpreter::NodeGenerator::visitConjunction ( const ram::Conjunction & conj )

override

Definition at line 121 of file Generator.cpp.

◆ visitConstant()

NodePtr souffle::interpreter::NodeGenerator::visitConstant ( const ram::Constant & num )

override

Definition at line 58 of file Generator.cpp.

◆ visitConstraint()

NodePtr souffle::interpreter::NodeGenerator::visitConstraint ( const ram::Constraint & relOp )

override

Definition at line 165 of file Generator.cpp.

◆ visitDebugInfo()

NodePtr souffle::interpreter::NodeGenerator::visitDebugInfo ( const ram::DebugInfo & dbg )

override

Definition at line 394 of file Generator.cpp.

◆ visitEmptinessCheck()

NodePtr souffle::interpreter::NodeGenerator::visitEmptinessCheck ( const ram::EmptinessCheck & emptiness )

override

Definition at line 129 of file Generator.cpp.

                                                                     {
     size_t relId = encodeRelation(size.getRelation());
     auto rel = getRelationHandle(relId);
     NodeType type = constructNodeType("RelationSize", lookup(size.getRelation()));

◆ visitExistenceCheck()

NodePtr souffle::interpreter::NodeGenerator::visitExistenceCheck ( const ram::ExistenceCheck & exists )

override

Definition at line 143 of file Generator.cpp.

                                {
             isTotal = false;
         }
     }
     auto ramRelation = lookup(exists.getRelation());
     NodeType type = constructNodeType("ExistenceCheck", ramRelation);
     return mk<ExistenceCheck>(type, &exists, isTotal, encodeView(&exists), std::move(superOp),
             ramRelation.isTemp(), ramRelation.getName());
 }
  
 NodePtr NodeGenerator::visitProvenanceExistenceCheck(const ram::ProvenanceExistenceCheck& provExists) {
     SuperInstruction superOp = getExistenceSuperInstInfo(provExists);
     NodeType type = constructNodeType("ProvenanceExistenceCheck", lookup(provExists.getRelation()));
     return mk<ProvenanceExistenceCheck>(type, &provExists, visit(provExists.getChildNodes().back()),

◆ visitExit()

NodePtr souffle::interpreter::NodeGenerator::visitExit ( const ram::Exit & exit )

override

Definition at line 369 of file Generator.cpp.

◆ visitExtend()

NodePtr souffle::interpreter::NodeGenerator::visitExtend ( const ram::Extend & extend )

override

Definition at line 463 of file Generator.cpp.

                                                     {
     size_t src = encodeRelation(swap.getFirstRelation());
     size_t target = encodeRelation(swap.getSecondRelation());
     return mk<Swap>(I_Swap, &swap, src, target);

References souffle::ram::BinRelationStatement::getFirstRelation(), and souffle::ram::BinRelationStatement::getSecondRelation().

Here is the call graph for this function:

◆ visitFalse()

NodePtr souffle::interpreter::NodeGenerator::visitFalse ( const ram::False & lfalse )

override

Definition at line 117 of file Generator.cpp.

◆ visitFilter()

NodePtr souffle::interpreter::NodeGenerator::visitFilter ( const ram::Filter & filter )

override

Definition at line 328 of file Generator.cpp.

◆ visitIndexAggregate()

NodePtr souffle::interpreter::NodeGenerator::visitIndexAggregate ( const ram::IndexAggregate & iAggregate )

override

Definition at line 294 of file Generator.cpp.

                                                                                                {
     orderingContext.addTupleWithIndexOrder(piAggregate.getTupleId(), piAggregate);
     SuperInstruction indexOperation = getIndexSuperInstInfo(piAggregate);
     NodePtr expr = visit(piAggregate.getExpression());

◆ visitIndexChoice()

NodePtr souffle::interpreter::NodeGenerator::visitIndexChoice ( const ram::IndexChoice & iChoice )

override

Definition at line 237 of file Generator.cpp.

                                                                                       {
     orderingContext.addTupleWithIndexOrder(piChoice.getTupleId(), piChoice);
     SuperInstruction indexOperation = getIndexSuperInstInfo(piChoice);
     size_t relId = encodeRelation(piChoice.getRelation());

◆ visitIndexScan()

NodePtr souffle::interpreter::NodeGenerator::visitIndexScan ( const ram::IndexScan & iScan )

override

Definition at line 198 of file Generator.cpp.

                                                                                 {
     orderingContext.addTupleWithIndexOrder(piscan.getTupleId(), piscan);
     SuperInstruction indexOperation = getIndexSuperInstInfo(piscan);
     size_t relId = encodeRelation(piscan.getRelation());

◆ visitIntrinsicOperator()

NodePtr souffle::interpreter::NodeGenerator::visitIntrinsicOperator ( const ram::IntrinsicOperator & op )

override

Definition at line 73 of file Generator.cpp.

                                                                                 {
     NodePtrVec children;
     for (const auto& arg : op.getArguments()) {
         children.push_back(visit(arg));

◆ visitIO()

NodePtr souffle::interpreter::NodeGenerator::visitIO ( const ram::IO & io )

override

Definition at line 411 of file Generator.cpp.

                                                        {
     std::shared_ptr<ViewContext> viewContext = std::make_shared<ViewContext>();
     parentQueryViewContext = viewContext;
     // split terms of conditions of outer-most filter operation

◆ visitLogRelationTimer()

NodePtr souffle::interpreter::NodeGenerator::visitLogRelationTimer ( const ram::LogRelationTimer & timer )

override

Definition at line 384 of file Generator.cpp.

                                                              {
     return mk<LogTimer>(I_LogTimer, &timer, visit(timer.getStatement()));
 }
  

References souffle::ram::AbstractLog::getStatement().

Here is the call graph for this function:

◆ visitLogSize()

NodePtr souffle::interpreter::NodeGenerator::visitLogSize ( const ram::LogSize & size )

override

Definition at line 405 of file Generator.cpp.

                                               {
     size_t relId = encodeRelation(io.getRelation());
     auto rel = getRelationHandle(relId);
     return mk<IO>(I_IO, &io, rel);

References souffle::ram::RelationStatement::getRelation(), and rel().

Here is the call graph for this function:

◆ visitLogTimer()

NodePtr souffle::interpreter::NodeGenerator::visitLogTimer ( const ram::LogTimer & timer )

override

Definition at line 390 of file Generator.cpp.

◆ visitLoop()

NodePtr souffle::interpreter::NodeGenerator::visitLoop ( const ram::Loop & loop )

override

Definition at line 365 of file Generator.cpp.

◆ visitNegation()

NodePtr souffle::interpreter::NodeGenerator::visitNegation ( const ram::Negation & neg )

override

Definition at line 125 of file Generator.cpp.

◆ visitNestedIntrinsicOperator()

NodePtr souffle::interpreter::NodeGenerator::visitNestedIntrinsicOperator ( const ram::NestedIntrinsicOperator & op )

override

Definition at line 89 of file Generator.cpp.

                                                               {
     NodePtrVec children;
     for (const auto& arg : pr.getArguments()) {
         children.push_back(visit(arg));

◆ visitNestedOperation()

NodePtr souffle::interpreter::NodeGenerator::visitNestedOperation ( const ram::NestedOperation & nested )

override

Definition at line 169 of file Generator.cpp.

                                {
         return mk<TupleOperation>(I_TupleOperation, &search, visit(search.getOperation()));
     }

References souffle::ram::NestedOperation::getOperation().

Here is the call graph for this function:

◆ visitNode()

NodePtr souffle::interpreter::NodeGenerator::visitNode ( const ram::Node & node )

override

Definition at line 479 of file Generator.cpp.

◆ visitPackRecord()

NodePtr souffle::interpreter::NodeGenerator::visitPackRecord ( const ram::PackRecord & pr )

override

Definition at line 100 of file Generator.cpp.

                                                                                {
     return mk<SubroutineArgument>(I_SubroutineArgument, &arg);
 }
  

◆ visitParallel()

NodePtr souffle::interpreter::NodeGenerator::visitParallel ( const ram::Parallel & parallel )

override

Definition at line 356 of file Generator.cpp.

                                                     {
     return mk<Loop>(I_Loop, &loop, visit(loop.getBody()));
 }
  

◆ visitParallelAggregate()

NodePtr souffle::interpreter::NodeGenerator::visitParallelAggregate ( const ram::ParallelAggregate & pAggregate )

override

Definition at line 278 of file Generator.cpp.

                                                                               {
     orderingContext.addTupleWithIndexOrder(iAggregate.getTupleId(), iAggregate);
     SuperInstruction indexOperation = getIndexSuperInstInfo(iAggregate);
     NodePtr expr = visit(iAggregate.getExpression());

◆ visitParallelChoice()

NodePtr souffle::interpreter::NodeGenerator::visitParallelChoice ( const ram::ParallelChoice & pChoice )

override

Definition at line 226 of file Generator.cpp.

                                                                      {
     orderingContext.addTupleWithIndexOrder(iChoice.getTupleId(), iChoice);
     SuperInstruction indexOperation = getIndexSuperInstInfo(iChoice);
     NodeType type = constructNodeType("IndexChoice", lookup(iChoice.getRelation()));

◆ visitParallelIndexAggregate()

NodePtr souffle::interpreter::NodeGenerator::visitParallelIndexAggregate ( const ram::ParallelIndexAggregate & piAggregate )

override

Definition at line 308 of file Generator.cpp.

                                                          {
     return mk<Break>(I_Break, &breakOp, visit(breakOp.getCondition()), visit(breakOp.getOperation()));
 }
  

◆ visitParallelIndexChoice()

NodePtr souffle::interpreter::NodeGenerator::visitParallelIndexChoice ( const ram::ParallelIndexChoice & piChoice )

override

Definition at line 245 of file Generator.cpp.

                                                                       {  // get reference
     orderingContext.addNewTuple(unpack.getTupleId(), unpack.getArity());
     return mk<UnpackRecord>(
             I_UnpackRecord, &unpack, visit(unpack.getExpression()), visitTupleOperation(unpack));

◆ visitParallelIndexScan()

NodePtr souffle::interpreter::NodeGenerator::visitParallelIndexScan ( const ram::ParallelIndexScan & piscan )

override

Definition at line 206 of file Generator.cpp.

                                                           {
     orderingContext.addTupleWithDefaultOrder(choice.getTupleId(), choice);
     size_t relId = encodeRelation(choice.getRelation());
     auto rel = getRelationHandle(relId);

◆ visitParallelScan()

NodePtr souffle::interpreter::NodeGenerator::visitParallelScan ( const ram::ParallelScan & pScan )

override

Definition at line 188 of file Generator.cpp.

                                                                {
     orderingContext.addTupleWithIndexOrder(iScan.getTupleId(), iScan);
     SuperInstruction indexOperation = getIndexSuperInstInfo(iScan);
     NodeType type = constructNodeType("IndexScan", lookup(iScan.getRelation()));

◆ visitProject()

NodePtr souffle::interpreter::NodeGenerator::visitProject ( const ram::Project & project )

override

Definition at line 332 of file Generator.cpp.

                                                                            {
     NodePtrVec children;
     for (const auto& value : ret.getValues()) {
         children.push_back(visit(value));

◆ visitProvenanceExistenceCheck()

NodePtr souffle::interpreter::NodeGenerator::visitProvenanceExistenceCheck ( const ram::ProvenanceExistenceCheck & provExists )

override

Definition at line 158 of file Generator.cpp.

                                                                  {
     return mk<Constraint>(I_Constraint, &relOp, visit(relOp.getLHS()), visit(relOp.getRHS()));
 }
  

◆ visitQuery()

NodePtr souffle::interpreter::NodeGenerator::visitQuery ( const ram::Query & query )

override

Definition at line 417 of file Generator.cpp.

                                                                                     {
         next = &filter->getOperation();
         // Check terms of outer filter operation whether they can be pushed before
         // the view-generation for speed improvements
         auto conditions = findConjunctiveTerms(&filter->getCondition());
         for (auto const& cur : conditions) {
             bool needView = false;
             visitDepthFirst(*cur, [&](const ram::Node& node) {
                 if (requireView(&node)) {
                     needView = true;
                     const auto& rel = getViewRelation(&node);
                     viewContext->addViewInfoForFilter(
                             encodeRelation(rel), indexTable[&node], encodeView(&node));
                 }
             });
  
             if (needView) {
                 viewContext->addViewOperationForFilter(visit(*cur));
             } else {
                 viewContext->addViewFreeOperationForFilter(visit(*cur));
             }
         }
     }
  
     visitDepthFirst(*next, [&](const ram::Node& node) {
         if (requireView(&node)) {
             const auto& rel = getViewRelation(&node);
             viewContext->addViewInfoForNested(encodeRelation(rel), indexTable[&node], encodeView(&node));
         };
     });
  
     visitDepthFirst(*next, [&](const ram::AbstractParallel&) { viewContext->isParallel = true; });
  
     auto res = mk<Query>(I_Query, &query, visit(*next));
     res->setViewContext(parentQueryViewContext);
     return res;
 }
  
 NodePtr NodeGenerator::visitExtend(const ram::Extend& extend) {
     size_t src = encodeRelation(extend.getFirstRelation());
     size_t target = encodeRelation(extend.getSecondRelation());
     return mk<Extend>(I_Extend, &extend, src, target);

References souffle::filter(), souffle::ram::findConjunctiveTerms(), rel(), and souffle::ast::visitDepthFirst().

Here is the call graph for this function:

◆ visitRelationSize()

NodePtr souffle::interpreter::NodeGenerator::visitRelationSize ( const ram::RelationSize & size )

override

Definition at line 136 of file Generator.cpp.

                                                                           {
     SuperInstruction superOp = getExistenceSuperInstInfo(exists);
     // Check if the search signature is a total signature
     bool isTotal = true;

◆ visitScan()

NodePtr souffle::interpreter::NodeGenerator::visitScan ( const ram::Scan & scan )

override

Definition at line 180 of file Generator.cpp.

                                                                      {
     orderingContext.addTupleWithDefaultOrder(pScan.getTupleId(), pScan);
     size_t relId = encodeRelation(pScan.getRelation());
     auto rel = getRelationHandle(relId);

◆ visitSequence()

NodePtr souffle::interpreter::NodeGenerator::visitSequence ( const ram::Sequence & seq )

override

Definition at line 348 of file Generator.cpp.

                                                                 {
     // Parallel statements are executed in sequence for now.
     NodePtrVec children;
     for (const auto& value : parallel.getStatements()) {

◆ visitSubroutineArgument()

NodePtr souffle::interpreter::NodeGenerator::visitSubroutineArgument ( const ram::SubroutineArgument & arg )

override

Definition at line 108 of file Generator.cpp.

                                                      {
     return mk<True>(I_True, &ltrue);
 }

◆ visitSubroutineReturn()

NodePtr souffle::interpreter::NodeGenerator::visitSubroutineReturn ( const ram::SubroutineReturn & ret )

override

Definition at line 340 of file Generator.cpp.

                                                            {
     NodePtrVec children;
     for (const auto& value : seq.getStatements()) {
         children.push_back(visit(value));

◆ visitSwap()

NodePtr souffle::interpreter::NodeGenerator::visitSwap ( const ram::Swap & swap )

override

Definition at line 469 of file Generator.cpp.

                                                            {
     return nullptr;
 }
  

◆ visitTrue()

NodePtr souffle::interpreter::NodeGenerator::visitTrue ( const ram::True & ltrue )

override

Definition at line 113 of file Generator.cpp.

◆ visitTupleElement()

NodePtr souffle::interpreter::NodeGenerator::visitTupleElement ( const ram::TupleElement & access )

override

Definition at line 62 of file Generator.cpp.

                                                                      {
     return mk<AutoIncrement>(I_AutoIncrement, &inc);
 }
  

◆ visitTupleOperation()

NodePtr souffle::interpreter::NodeGenerator::visitTupleOperation ( const ram::TupleOperation & search )

override

Definition at line 173 of file Generator.cpp.

                                                     {
     orderingContext.addTupleWithDefaultOrder(scan.getTupleId(), scan);
     size_t relId = encodeRelation(scan.getRelation());
     auto rel = getRelationHandle(relId);

◆ visitUndefValue()

NodePtr souffle::interpreter::NodeGenerator::visitUndefValue ( const ram::UndefValue & )

override

Definition at line 475 of file Generator.cpp.

                                 : %s", typeid(node).name());
 }
  

◆ visitUnpackRecord()

NodePtr souffle::interpreter::NodeGenerator::visitUnpackRecord ( const ram::UnpackRecord & unpack )

override

Definition at line 257 of file Generator.cpp.

                                                                    {
     // Notice: Aggregate is sensitive to the visiting order of the subexprs in order to make
     // orderCtxt consistent. The order of visiting should be the same as the order of execution during
     // runtime.

References souffle::ram::TupleOperation::getTupleId().

Here is the call graph for this function:

◆ visitUserDefinedOperator()

NodePtr souffle::interpreter::NodeGenerator::visitUserDefinedOperator ( const ram::UserDefinedOperator & op )

override

Definition at line 81 of file Generator.cpp.

                                                                                         {
     auto arity = op.getArguments().size();
     orderingContext.addNewTuple(op.getTupleId(), arity);
     NodePtrVec children;

Field Documentation

◆ engine

Engine& souffle::interpreter::NodeGenerator::engine

private

Reference to the engine instance.

Definition at line 354 of file Generator.h.

◆ indexTable

std::unordered_map<const ram::Node*, size_t> souffle::interpreter::NodeGenerator::indexTable

private

Environment encoding, store a mapping from ram::Node to its operation index id.

Definition at line 336 of file Generator.h.

◆ orderingContext

OrderingContext souffle::interpreter::NodeGenerator::orderingContext = OrderingContext(*this)

private

ordering context

Definition at line 352 of file Generator.h.

◆ parentQueryViewContext

std::shared_ptr<ViewContext> souffle::interpreter::NodeGenerator::parentQueryViewContext = nullptr

private

Points to the current viewContext during the generation.

It is used to passing viewContext between parent query and its nested parallel operation. As parallel operation requires its own view information.

Definition at line 340 of file Generator.h.

◆ relationMap

std::unordered_map<std::string, const ram::Relation*> souffle::interpreter::NodeGenerator::relationMap

private

name / relation mapping

Definition at line 350 of file Generator.h.

◆ relId

size_t souffle::interpreter::NodeGenerator::relId = 0

private

Next available location to encode a relation.

Definition at line 344 of file Generator.h.

◆ relTable

std::unordered_map<std::string, size_t> souffle::interpreter::NodeGenerator::relTable

private

Environment encoding, store a mapping from ram::Relation to its id.

Definition at line 348 of file Generator.h.

◆ viewId

size_t souffle::interpreter::NodeGenerator::viewId = 0

private

Next available location to encode View.

Definition at line 342 of file Generator.h.

◆ viewTable

std::unordered_map<const ram::Node*, size_t> souffle::interpreter::NodeGenerator::viewTable

private

Environment encoding, store a mapping from ram::Node to its View id.

Definition at line 346 of file Generator.h.

The documentation for this class was generated from the following files:

interpreter/Generator.h
interpreter/Generator.cpp

Data Structures

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ NodePtr

◆ NodePtrVec

◆ RelationHandle

Constructor & Destructor Documentation

◆ NodeGenerator()

Member Function Documentation

◆ encodeIndexPos()

◆ encodeRelation()

◆ encodeView()

◆ generateTree()

◆ getArity()

◆ getExistenceSuperInstInfo()

◆ getIndexSuperInstInfo()

◆ getNewRelId()

◆ getNextViewId()

◆ getProjectSuperInstInfo()

◆ getRelationHandle()

◆ getViewRelation()

◆ lookup()

◆ newQueryBlock()

◆ requireView()

◆ visitAggregate()

◆ visitAutoIncrement()

◆ visitBreak()

◆ visitCall()

◆ visitChoice()

◆ visitClear()

◆ visitConjunction()

◆ visitConstant()

◆ visitConstraint()

◆ visitDebugInfo()

◆ visitEmptinessCheck()

◆ visitExistenceCheck()

◆ visitExit()

◆ visitExtend()

◆ visitFalse()

◆ visitFilter()

◆ visitIndexAggregate()

◆ visitIndexChoice()

◆ visitIndexScan()

◆ visitIntrinsicOperator()

◆ visitIO()

◆ visitLogRelationTimer()

◆ visitLogSize()

◆ visitLogTimer()

◆ visitLoop()

◆ visitNegation()

◆ visitNestedIntrinsicOperator()

◆ visitNestedOperation()

◆ visitNode()

◆ visitPackRecord()

◆ visitParallel()

◆ visitParallelAggregate()

◆ visitParallelChoice()

◆ visitParallelIndexAggregate()

◆ visitParallelIndexChoice()

◆ visitParallelIndexScan()

◆ visitParallelScan()

◆ visitProject()

◆ visitProvenanceExistenceCheck()

◆ visitQuery()

◆ visitRelationSize()

◆ visitScan()

◆ visitSequence()

◆ visitSubroutineArgument()

◆ visitSubroutineReturn()

◆ visitSwap()

◆ visitTrue()

◆ visitTupleElement()

◆ visitTupleOperation()

◆ visitUndefValue()

◆ visitUnpackRecord()