| /********************************************************************** |
| // @@@ START COPYRIGHT @@@ |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| // |
| // @@@ END COPYRIGHT @@@ |
| **********************************************************************/ |
| #ifndef REL3GL_H |
| #define REL3GL_H |
| |
| /* -*-C++-*- |
| ****************************************************************************** |
| * |
| * File: Rel3GL.h |
| * Description: PSM/3GL operators. |
| * |
| * Created: 11/05/97 |
| * Language: C++ |
| * |
| * |
| ****************************************************************************** |
| */ |
| #include "RelExpr.h" |
| #include "Rule.h" |
| #include "RelMisc.h" |
| #include "RelSet.h" |
| |
| ////////////////////////////////////////////////////////////////////////// |
| // |
| // Contents. |
| // |
| ////////////////////////////////////////////////////////////////////////// |
| class CompoundStmt; |
| class Loop; |
| |
| ////////////////////////////////////////////////////////////////////////// |
| // |
| // Forward References. |
| // |
| ////////////////////////////////////////////////////////////////////////// |
| class BindWA; |
| class NormWA; |
| |
| ////////////////////////////////////////////////////////////////////////// |
| // |
| // CompoundStmt. |
| // |
| ////////////////////////////////////////////////////////////////////////// |
| class CompoundStmt : public RelExpr |
| { |
| |
| public: |
| // Standared constructor/destructor/accessor/mutators. |
| CompoundStmt(RelExpr *leftChild, |
| RelExpr *rightChild, |
| OperatorTypeEnum op = REL_COMPOUND_STMT, |
| CollHeap *heap = CmpCommon::statementHeap()) : |
| RelExpr(op, leftChild, rightChild, heap) { setNonCacheable(); } |
| |
| CompoundStmt(const CompoundStmt &other) : |
| RelExpr(other.getOperatorType(), other.child(0), other.child(1)) |
| { setNonCacheable(); } |
| |
| virtual ~CompoundStmt() {} |
| |
| virtual Int32 getArity() const { return 2; } |
| |
| // Binder methods. |
| virtual RelExpr *bindNode(BindWA*); |
| |
| // Transformation methods. |
| virtual void transformNode(NormWA&, ExprGroupId&); |
| virtual void recomputeOuterReferences(); |
| |
| // Normalizer methods. |
| virtual RelExpr *normalizeNode(NormWA&); |
| virtual void pullUpPreds(); |
| virtual void rewriteNode(NormWA&); |
| virtual void pushdownCoveredExpr |
| (const ValueIdSet & outputExprOnOperator, |
| const ValueIdSet & newExternalInputs, |
| ValueIdSet & predicatesOnParent, |
| const ValueIdSet * setOfValuesReqdByParent = NULL, |
| Lng32 childIndex = (-MAX_REL_ARITY)); |
| |
| // Optimizer methods. |
| virtual RelExpr *copyTopNode(RelExpr * = NULL, CollHeap* = NULL); |
| |
| // PreCodeGen methods |
| virtual RelExpr *preCodeGen(Generator * generator, |
| const ValueIdSet & externalInputs, |
| ValueIdSet &pulledNewInputs); |
| |
| // GUI methods. |
| virtual const NAString getText() const { return "CompoundStmt"; } |
| |
| Context* createContextForAChild(Context* myContext, |
| PlanWorkSpace* pws, |
| Lng32& childIndex); |
| |
| protected: |
| |
| // Internal support methods. |
| void enterVEGRegion(NormWA&, Int32 id, NABoolean create=FALSE); |
| void leaveVEGRegion(NormWA&, Int32 id); |
| |
| }; |
| |
| class PhysCompoundStmt : public CompoundStmt |
| { |
| public: |
| // Standard constructor/destructor/accessor/mutators. |
| PhysCompoundStmt(RelExpr *leftChild, |
| RelExpr *rightChild, |
| OperatorTypeEnum op = REL_COMPOUND_STMT, |
| CollHeap *heap = CmpCommon::statementHeap()) : |
| CompoundStmt(leftChild, rightChild, op, heap ) {} |
| |
| PhysCompoundStmt(const CompoundStmt &other) : |
| CompoundStmt(other) {} |
| |
| virtual ~PhysCompoundStmt() {} |
| |
| virtual NABoolean isPhysical() const { return TRUE; } |
| virtual NABoolean isLogical() const { return FALSE; } |
| |
| virtual CostMethod *costMethod() const; |
| // Optimizer methods. |
| virtual RelExpr *copyTopNode(RelExpr * = NULL, CollHeap * = NULL); |
| |
| virtual PhysicalProperty *synthPhysicalProperty(const Context*, |
| const Lng32, |
| PlanWorkSpace *pws); |
| |
| // Code generation methods. |
| virtual short codeGen(Generator *); |
| }; |
| |
| |
| // -------------------------------------------------------------------- |
| // This class is used by assignment statements in compound statements. |
| // A list of this type is kept in class AssignmentStArea (below) so that |
| // it is globally accessible at binding time. This class mantains a current and previous |
| // valueId, so that when we find SET <var> = <select statement>, we update |
| // the value id of <var> to that returned by the select statement. See |
| // assignment statements internal spec for details. |
| // -------------------------------------------------------------------- |
| |
| class AssignmentStHostVars: public NABasicObject |
| { |
| public: |
| // Constructor |
| AssignmentStHostVars(BindWA *bindWA, CollHeap * h = 0) |
| : bindWA_(bindWA), |
| var_(NULL), |
| next_(NULL) |
| {} |
| |
| // Copy constructor |
| AssignmentStHostVars(const AssignmentStHostVars &other, CollHeap * h = 0) |
| : bindWA_(other.bindWA_), |
| next_(other.next_), |
| var_(other.var_) |
| {} |
| |
| AssignmentStHostVars() |
| { AssignmentStHostVars(NULL); } |
| |
| ~AssignmentStHostVars() {} |
| |
| // Adds var to end of this list with new value id. The id value overwrites |
| // the current value id unless we are inside an IF statement and this |
| // is the first time we call this function, in which case the value id is |
| // appended, since we will need the old value id when we exit the IF statement |
| AssignmentStHostVars & addVar(HostVar *var, const ValueId &id); |
| |
| // Adds var to this list with new value id; if it is already there, it |
| // overwrites the value id |
| AssignmentStHostVars & addToListInIF(HostVar *var, const ValueId &id); |
| |
| // Adds all the hostvars and their associated value ids from the AssignmentStHostVars |
| // that is passed as an argument to this method to the AssignmentStHostVars pointed to |
| // this pointer. The implementation is by repeated calls to addToListInIF() . |
| void addAllToListInIF(AssignmentStHostVars * copyFromList) ; |
| |
| // Gets current value id |
| const ValueId currentValueId(); |
| |
| // Update the current value id of this host var |
| void setCurrentValueId(const ValueId &id); |
| |
| // Gets the variable |
| HostVar *& var(); |
| |
| // Finds the variable whose name is given |
| AssignmentStHostVars * findVar(const NAString & name); |
| |
| // Finds the variable whose valueId is given |
| AssignmentStHostVars * containsValueId(ValueId valueId); |
| |
| // Returns next element |
| inline AssignmentStHostVars * next() { return next_; } |
| |
| // When we reach a Root node that contains a list of host variables on the |
| // left hand side of an assignment statement, we update the value ids |
| // of such variables with the value ids returned from the subtree below |
| // the Root node. This function is called in RelRoot::bindNode |
| NABoolean updateValueIds(const ValueIdList &returnedList, ItemExpr *listInRootNode); |
| |
| // Remove the current value id of this variable |
| void removeLastValueId() |
| { |
| valueIds_.removeAt(valueIds_.entries() - 1); |
| } |
| |
| // To acces list of value ids |
| ValueIdList &valueIds() { return valueIds_; } |
| |
| // To know if there are rowsets in the given list |
| NABoolean containsRowsets(ItemExpr * list); |
| |
| // To perform necessary transformations in case we have rowsets in the SET statement |
| // on the left side. We must replace the Root node where the rowset variables appear |
| // with a RowsetInto node |
| RelExpr * processRowsets(ItemExpr * list, RelExpr * thisNode); |
| |
| // Given a list of Host variables with value ids, we enter them in our list |
| void enterHostVars(ItemExpr *listOfVars); |
| |
| private: |
| |
| // The variable |
| HostVar *var_; |
| |
| // A list of the value ids this variable gets. The last one in the list |
| // is the current one |
| ValueIdList valueIds_; |
| |
| // To have access to the rest of the structure |
| BindWA *bindWA_; |
| |
| // Next element |
| AssignmentStHostVars *next_; |
| |
| }; |
| |
| |
| class Union; |
| |
| // -------------------------------------------------------------------- |
| // This class is used by assignment statements in compound statements. |
| // A list of this type is kept in class BindWA so that it is globally |
| // accessible at binding time. This class mantains data needed by the |
| // aforementioned project. See assignment statements internal spec for |
| // details. |
| // -------------------------------------------------------------------- |
| |
| class AssignmentStArea : public NABasicObject |
| { |
| public: |
| |
| // Constructor |
| AssignmentStArea(BindWA *bindWA, CollHeap * h = 0) |
| : listOfVars_(NULL), |
| currentIF_(NULL), |
| bindWA_(bindWA) |
| {} |
| |
| // Copy constructor |
| AssignmentStArea(const AssignmentStArea &other, CollHeap * h = 0) |
| : listOfVars_(other.listOfVars_), |
| currentIF_(other.currentIF_), |
| bindWA_(other.bindWA_) |
| {} |
| |
| AssignmentStArea() |
| { AssignmentStArea(NULL); } |
| |
| ~AssignmentStArea() {} |
| |
| // Please see comments for currentIF_ below. |
| Union * getCurrentIF() { return currentIF_; } |
| void setCurrentIF(Union * node) { currentIF_ = node; } |
| |
| // Gets pointer to list of variables |
| AssignmentStHostVars *&getAssignmentStHostVars() { return listOfVars_; } |
| |
| // Updates listOfVars_ when we exit a Union node at binding time. For |
| // each host variable, it determines whether its value id is no longer |
| // valid outside the IF statement we are exiting, and removes it if so. |
| // In this way, the value id this variable had before entering the IF |
| // statement will be the current one |
| void updateValueIdsTable(Union * node); |
| |
| // Removes the last value ids assigned to the given node during |
| // binding of childNumber |
| void removeLastValueIds(AssignmentStHostVars * listInUnion, Union * node); |
| |
| private: |
| |
| // List of host variables in the statement |
| AssignmentStHostVars * listOfVars_; |
| |
| // To know which is the Union node that is the immediate ancestor of |
| // the node we are currently in. This gets used when we have SET statements |
| // within an IF statement. |
| Union *currentIF_; |
| |
| BindWA * bindWA_; |
| |
| }; |
| |
| #endif /* REL3GL_H */ |
| |