| /********************************************************************** |
| // @@@ 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 TRANSRULE_H |
| #define TRANSRULE_H |
| /* -*-C++-*- |
| ****************************************************************************** |
| * |
| * File: TransRule.h |
| * Description: Transformation rules |
| * |
| * |
| * Created: 9/14/94 |
| * Language: C++ |
| * |
| * |
| * |
| * |
| ****************************************************************************** |
| */ |
| |
| |
| #include "Rule.h" |
| #include "Analyzer.h" |
| |
| //------------------------------------------------------------------------ |
| //forward declaration |
| //------------------------------------------------------------------------ |
| |
| class MultiJoin; |
| class LSRConfidence; |
| |
| // ----------------------------------------------------------------------- |
| // classes defined in this file |
| // ----------------------------------------------------------------------- |
| |
| class JoinCommutativityRule; |
| class JoinLeftShiftRule; |
| class IndexJoinRule1; |
| class IndexJoinRule2; |
| class OrOptimizationRule; |
| class TSJRule; |
| class RoutineJoinToTSJRule; |
| class JoinToTSJRule; |
| class TSJFlowRule; |
| class TSJUDRRule; |
| |
| class FilterRule; |
| class FilterRule0; |
| class FilterRule1; |
| class FilterRule2; |
| |
| class GroupByEliminationRule; |
| class GroupByOnJoinRule; |
| class PartialGroupByOnTSJRule; |
| class GroupBySplitRule; |
| class AggrDistinctEliminationRule; |
| class GroupByTernarySplitRule; |
| class ShortCutGroupByRule; |
| class CommonSubExprRule; |
| |
| class SampleScanRule; |
| class JoinToBushyTreeRule; |
| |
| class OnceGuidance; |
| class StopGuidance; |
| class FilterGuidance; |
| |
| // LSRs declared in this file |
| class MJStarJoinIRule; |
| class MJStarJoinIIRule; |
| |
| // Workareas for MJ Rules |
| class MJRulesWA; |
| class MJStarJoinIRuleWA; |
| |
| // Non-LSR MJ rules |
| class MJExpandRule; |
| class MJEnumRule; |
| class MVQRRule; |
| class MVQRScanRule; |
| class GroupByMVQRRule; |
| |
| class HbaseScanRule; |
| |
| |
| // ----------------------------------------------------------------------- |
| // forward references |
| // ----------------------------------------------------------------------- |
| |
| class ScanIndexInfo; |
| class Scan; |
| |
| // ----------------------------------------------------------------------- |
| // Function to add transformation rules to the rule set |
| // ----------------------------------------------------------------------- |
| void CreateTransformationRules(RuleSet*); |
| |
| // ----------------------------------------------------------------------- |
| // transformation rule subclasses |
| // ----------------------------------------------------------------------- |
| |
| class MJExpandRule : public Rule |
| { |
| public: |
| MJExpandRule (const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| MJExpandRule (const MJExpandRule &) ; // not written |
| |
| virtual ~MJExpandRule() {} |
| |
| virtual NABoolean topMatch (RelExpr * expr, |
| Context * context); |
| |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context *context, |
| RuleSubstituteMemory * & memory); |
| |
| virtual Int32 promiseForOptimization(RelExpr * relExpr, |
| Guidance * guidance, |
| Context * context); |
| |
| virtual NABoolean isImplementationRule () const { return FALSE; } |
| |
| }; |
| |
| // ----------------------------------------------------------------------- |
| // use for MV query rewrite |
| // ----------------------------------------------------------------------- |
| class MVQRRule : public Rule |
| { |
| public: |
| MVQRRule (const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| MVQRRule (const MVQRRule &) ; |
| |
| virtual ~MVQRRule() {} |
| |
| virtual NABoolean topMatch (RelExpr * expr, |
| Context * context); |
| |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context *context, |
| RuleSubstituteMemory * & memory); |
| |
| virtual NABoolean isImplementationRule () const { return FALSE; } |
| }; |
| |
| class MVQRScanRule : public Rule |
| { |
| public: |
| MVQRScanRule (const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| MVQRScanRule (const MVQRScanRule &) ; |
| |
| virtual ~MVQRScanRule() {} |
| |
| virtual NABoolean topMatch (RelExpr * expr, |
| Context * context); |
| |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context *context, |
| RuleSubstituteMemory * & memory); |
| |
| virtual NABoolean isImplementationRule () const { return FALSE; } |
| }; |
| |
| class GroupByMVQRRule : public Rule |
| { |
| public: |
| GroupByMVQRRule (const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| GroupByMVQRRule (const GroupByMVQRRule &) ; |
| |
| virtual ~GroupByMVQRRule() {} |
| |
| virtual NABoolean topMatch (RelExpr * expr, |
| Context * context); |
| |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context *context, |
| RuleSubstituteMemory * & memory); |
| |
| virtual NABoolean isImplementationRule () const { return FALSE; } |
| }; |
| |
| class MJEnumRule : public Rule |
| { |
| public: |
| MJEnumRule (const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| MJEnumRule (const MJEnumRule &) ; // not written |
| |
| virtual ~MJEnumRule() {} |
| |
| virtual NABoolean topMatch (RelExpr * expr, |
| Context * context); |
| |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context *context, |
| RuleSubstituteMemory * & memory); |
| |
| virtual NABoolean isImplementationRule () const { return FALSE; } |
| |
| }; |
| |
| enum StarJoinType { TYPE_I, TYPE_II }; |
| |
| class MJStarJoinIRuleWA : public NABasicObject |
| { |
| friend class MJStarJoinIRule; |
| |
| public: |
| // listOfEdges_ is allocated from the statement heap. It is safe to |
| // ignore this dstr is not code coveraged. |
| ~MJStarJoinIRuleWA() |
| { |
| if(listOfEdges_) |
| delete listOfEdges_; |
| } |
| |
| private: |
| |
| // construct is private since only the MJStarJoinRule should be able to |
| // instantiate an object of this class |
| MJStarJoinIRuleWA(CollHeap *outHeap = CmpCommon::statementHeap()): |
| factTable_(NULL_CA_ID), |
| listOfEdges_(NULL), |
| matchedStarSchema_(FALSE), |
| optimalFTLocation_(-1), |
| heap_(outHeap) |
| { |
| } |
| |
| // the fact table |
| CANodeId factTable_; |
| |
| // This is the set of tables are are joined before |
| // the fact table is joined. Generally this should |
| // be a union of the tables in the lists of sets below. |
| CANodeIdSet nodesJoinedBeforeFactTable_; |
| |
| // list of fringes that are joined to the fact table via clustering |
| // key prefix predicates |
| NAList<CANodeIdSet> * listOfEdges_; |
| |
| // optimal position of FactTable in list of edges |
| Int32 optimalFTLocation_; |
| |
| // Nodes that are not part of the fringes |
| CANodeIdSet availableNodes_; |
| |
| // flag indicating if the Star Schema was matched |
| // in the MJStarJoinRule topMatch |
| NABoolean matchedStarSchema_; |
| |
| CollHeap *heap_; |
| }; |
| |
| // ------------------------------------------------------------------------ |
| // Base class for the two star join LSRs |
| // 1. Star Join Type I |
| // * This produces a plan with a nested join into the fact table |
| // 2. Star Join Type II |
| // * This produces a plan with the fact table as the outer most |
| // in a series of hash joins |
| // ------------------------------------------------------------------------ |
| |
| class MJStarJoinRules : public Rule |
| { |
| public: |
| MJStarJoinRules(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| MJStarJoinRules (const MJExpandRule &) ; // not written |
| |
| virtual ~MJStarJoinRules() {} |
| |
| /*virtual NABoolean topMatch (RelExpr * expr, |
| Context * context); |
| |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context *context, |
| RuleSubstituteMemory * & memory); |
| |
| virtual NABoolean isImplementationRule ();*/ |
| |
| virtual NABoolean isAStarJoinRule() const = 0; |
| |
| protected: |
| //extends an edge of the star |
| CANodeIdSet extendEdge(CANodeId connectedTable,//in |
| CANodeIdSet& availableNodes,//in |
| UInt32 lookAhead);//in |
| }; |
| |
| // ------------------------------------------------------------------------ |
| // The MultiJoin StarJoin Type I Rule |
| // This is a Large-Scope Rule |
| // It tries to match the pattern for a classic star schema |
| // and if the shape matches it produces a plan with a nested |
| // join into the fact table |
| // If nested join into the fact table does not make sense |
| // the topMatch returns false and schedules the MJStarBDRule |
| // ------------------------------------------------------------------------ |
| |
| class MJStarJoinIRule : public MJStarJoinRules |
| { |
| public: |
| MJStarJoinIRule (const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| MJStarJoinRules(name,pattern,substitute) {} |
| |
| // copy ctor |
| MJStarJoinIRule (const MJStarJoinIRule &) ; // not written |
| |
| virtual ~MJStarJoinIRule() {} |
| |
| virtual NABoolean topMatch (RelExpr * expr, |
| Context * context); |
| |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context *context, |
| RuleSubstituteMemory * & memory); |
| |
| virtual NABoolean isImplementationRule () const { return FALSE; } |
| virtual NABoolean isAStarJoinRule() const {return TRUE; } |
| |
| private: |
| NABoolean topMatch_Old(RelExpr * expr, |
| Context * context); |
| |
| RelExpr * nextSubstitute_Old(RelExpr * before, |
| Context *context, |
| RuleSubstituteMemory * & memory); |
| //helper methods |
| //Sort JBBCs of the MultiJoin on which this rule is firing. |
| //The sorting order is based on the cardinality of the JBBC after application |
| //of local predicates on the prefix of the clustering key. |
| void sortMJJBBCsByCardAfterLocalKeyPrefixPred(NAList<CANodeId> &sortedJBBCs,//out |
| const MultiJoin * const mjoin);//in |
| |
| // return the fact table if one is found otherwise return a CANodeId of |
| // NULL_CA_ID |
| CANodeId findFactTable(const MultiJoin * const mjoin, //in |
| CostScalar & factTableCKPrefixCardinality, //out |
| CANodeId & biggestNode); //out |
| |
| // does the given multijoin resemble a star shape |
| // e.g. |
| // t1 |
| // | |
| // | |
| // | |
| // t2---------t3-----------t4 |
| // | |
| // | |
| // | |
| // t5 |
| // |
| // The method will return the center of the star, in this case |
| // it should be t3. |
| // Note this does not necessarily mean it is a star schema |
| // since t3 might be a small table. |
| // For the above schema to be a star schema the center should be |
| // a large fact table |
| // This method just looks and table connectivities and returns the |
| // center of the shape, otherwise it returns NULL_CA_ID |
| CANodeId isAStarShape(MultiJoin * mjoin); |
| |
| // This method give a fact table, matches a multi-join to a star pattern |
| NABoolean isAStarPattern(MultiJoin * mjoin,//in |
| CANodeId factTable,//in |
| CostScalar factTableCKPrefixCardinality);//in |
| |
| // get a rough estimate of cost for doing a nested join on the fact table |
| // number of probes = dataFlowFromEdge |
| // Rows of fact table that will be scanned = factTableRowsToScan |
| CostScalar computeCostForFactTable(CostScalar probes, |
| CostScalar factTableRowsToScan, |
| CANodeId factTable, |
| MultiJoin *mjoin); |
| |
| // sort the JBBCs based on cardinality after local predicates |
| // the sorting order is descending i.e. largest -> smallest |
| void sortMJJBBCs(NAList<CANodeId> &sortedJBBCs, |
| const MultiJoin * const mjoin); |
| |
| }; |
| |
| // ------------------------------------------------------------------------ |
| // The MultiJoin StarJoin Rule |
| // This is a Large-Scope Rule |
| // ------------------------------------------------------------------------ |
| |
| class MJStarJoinIIRule : public MJStarJoinRules |
| { |
| public: |
| MJStarJoinIIRule (const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| MJStarJoinRules(name,pattern,substitute) {} |
| |
| // copy ctor |
| MJStarJoinIIRule (const MJExpandRule &) ; // not written |
| |
| virtual ~MJStarJoinIIRule() {} |
| |
| virtual NABoolean topMatch (RelExpr * expr, |
| Context * context); |
| |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context *context, |
| RuleSubstituteMemory * & memory); |
| |
| virtual NABoolean isImplementationRule () const { return FALSE; } |
| virtual NABoolean isAStarJoinRule() const {return TRUE; } |
| |
| private: |
| RelExpr * nextSubstitute_Old (RelExpr * before, |
| Context *context, |
| RuleSubstituteMemory * & memory); |
| }; |
| |
| class JoinCommutativityRule : public Rule |
| { |
| public: |
| JoinCommutativityRule (const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| JoinCommutativityRule (const JoinCommutativityRule &) ; // not written |
| |
| virtual ~JoinCommutativityRule() {} |
| |
| virtual NABoolean topMatch (RelExpr * expr, |
| Context * context); |
| |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context *context, |
| RuleSubstituteMemory * & memory); |
| |
| }; |
| |
| class JoinLeftShiftRule : public Rule |
| { |
| public: |
| JoinLeftShiftRule (const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| JoinLeftShiftRule (const JoinLeftShiftRule &) ; // not written |
| |
| virtual ~JoinLeftShiftRule() {} |
| |
| virtual NABoolean topMatch (RelExpr * expr, |
| Context * context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context *context, |
| RuleSubstituteMemory * & memory); |
| |
| virtual Guidance * guidanceForExploringChild(Guidance *, Context *, Lng32); |
| |
| virtual Guidance * guidanceForExploringSubstitute(Guidance * guidance); |
| |
| virtual Guidance * guidanceForOptimizingSubstitute(Guidance * guidance, |
| Context * context); |
| |
| }; |
| |
| class IndexJoinRule1 : public Rule |
| { |
| public: |
| IndexJoinRule1 (const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| IndexJoinRule1 (const IndexJoinRule1 &) ; // not written |
| |
| virtual ~IndexJoinRule1() {} |
| virtual NABoolean topMatch (RelExpr * expr, |
| Context * context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context *context, |
| RuleSubstituteMemory * & memory); |
| |
| // non-virtual methods to do the work for both pass 1 and pass 2 |
| RelExpr * nextSubstituteForPass(RelExpr * before, |
| RuleSubstituteMemory * & memory, |
| Lng32 pass); |
| RelExpr * makeSubstituteFromIndexInfo(Scan *bef, |
| ScanIndexInfo *ixi); |
| }; |
| |
| class IndexJoinRule2 : public IndexJoinRule1 |
| { |
| public: |
| IndexJoinRule2 (const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| IndexJoinRule1(name,pattern,substitute) {} |
| |
| // copy ctor |
| IndexJoinRule2 (const IndexJoinRule2 &) ; // not written |
| |
| virtual ~IndexJoinRule2() {} |
| virtual NABoolean topMatch (RelExpr * expr, |
| Context * context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context *context, |
| RuleSubstituteMemory * & memory); |
| }; |
| |
| class OrOptimizationRule : public Rule |
| { |
| public: |
| OrOptimizationRule (const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| OrOptimizationRule (const OrOptimizationRule &) ; // not written |
| |
| virtual ~OrOptimizationRule() {} |
| virtual NABoolean topMatch (RelExpr * expr, |
| Context * context); |
| |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context *context, |
| RuleSubstituteMemory * & memory); |
| |
| private: |
| |
| CostScalar rateIndexForColumn(Int32 colNumInIndex, |
| Scan *s, |
| IndexDesc *ixDesc, |
| NABoolean indexOnly); |
| RelExpr * makeSubstituteScan(Scan *s, |
| const ValueIdSet &disjuncts, |
| RelExpr *partialResult, |
| const ValueIdSet disjunctsProcessedSoFar, |
| const ValueIdList &origCharOutputList, |
| ValueIdList &resultCharOutputs); |
| |
| }; |
| |
| class TSJRule : public Rule |
| { |
| public: |
| TSJRule (const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| TSJRule (const TSJRule &) ; // not written |
| |
| virtual ~TSJRule() {} |
| |
| virtual NABoolean topMatch (RelExpr * expr, |
| Context * context); |
| |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context *context, |
| RuleSubstituteMemory * & memory); |
| }; |
| |
| class RoutineJoinToTSJRule : public Rule |
| { |
| public: |
| RoutineJoinToTSJRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| RoutineJoinToTSJRule (const RoutineJoinToTSJRule &) ; // not written |
| |
| virtual ~RoutineJoinToTSJRule(); |
| virtual NABoolean topMatch (RelExpr * relExpr, |
| Context * context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| virtual Int32 promiseForOptimization(RelExpr * relExpr, |
| Guidance * guidance, |
| Context * context); |
| |
| virtual NABoolean canBePruned(RelExpr * expr) const; |
| |
| }; |
| |
| class JoinToTSJRule : public Rule |
| { |
| public: |
| JoinToTSJRule (const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| JoinToTSJRule (const JoinToTSJRule &) ; // not written |
| |
| virtual ~JoinToTSJRule() {} |
| |
| virtual NABoolean topMatch (RelExpr * expr, |
| Context * context); |
| |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context *context, |
| RuleSubstituteMemory * & memory); |
| virtual Int32 promiseForOptimization(RelExpr * relExpr, |
| Guidance * guidance, |
| Context * context); |
| virtual NABoolean canBePruned(RelExpr * expr) const; |
| }; |
| |
| class TSJFlowRule : public Rule |
| { |
| public: |
| TSJFlowRule (const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| TSJFlowRule (const TSJFlowRule &) ; // not written |
| |
| virtual ~TSJFlowRule() {} |
| |
| virtual NABoolean topMatch (RelExpr * expr, |
| Context * context); |
| |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context *context, |
| RuleSubstituteMemory * & memory); |
| }; |
| |
| // Raj P - 10/2000 |
| // Rule to support CALL <stored-proc> |
| class TSJUDRRule : public Rule |
| { |
| public: |
| TSJUDRRule (const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| virtual ~TSJUDRRule() {} |
| |
| virtual NABoolean topMatch (RelExpr * expr, |
| Context * context); |
| |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context *context, |
| RuleSubstituteMemory * & memory); |
| |
| virtual NABoolean isContextSensitive() const; |
| |
| private: |
| // default constructor, not written |
| TSJUDRRule (); |
| |
| // copy ctor |
| TSJUDRRule (const TSJUDRRule &) ; // not written |
| |
| }; |
| |
| class FilterRule : public Rule |
| { |
| public: |
| FilterRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| FilterRule (const FilterRule &) ; // not written |
| |
| virtual ~FilterRule() {} |
| virtual Guidance * guidanceForExploringChild(Guidance * guidance, |
| Context * context, |
| Lng32 childIndex); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context *context, |
| RuleSubstituteMemory * & memory)=0; |
| virtual Int32 promiseForOptimization(RelExpr * relExpr, |
| Guidance * guidance, |
| Context * context); |
| }; |
| |
| class FilterRule0 : public FilterRule |
| { |
| public: |
| FilterRule0(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| FilterRule(name,pattern,substitute) {} |
| |
| // copy ctor |
| FilterRule0 (const FilterRule0 &) ; // not written |
| |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context *context, |
| RuleSubstituteMemory * & memory); |
| |
| }; |
| |
| class FilterRule1 : public FilterRule |
| { |
| public: |
| FilterRule1(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| FilterRule(name,pattern,substitute) {} |
| |
| // copy ctor |
| FilterRule1 (const FilterRule1 &) ; // not written |
| |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context *context, |
| RuleSubstituteMemory * & memory); |
| |
| }; |
| |
| class FilterRule2 : public FilterRule |
| { |
| public: |
| FilterRule2(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| FilterRule(name,pattern,substitute) {} |
| |
| // copy ctor |
| FilterRule2 (const FilterRule2 &) ; // not written |
| |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context *context, |
| RuleSubstituteMemory * & memory); |
| |
| }; |
| |
| class GroupByEliminationRule : public Rule |
| { |
| public: |
| GroupByEliminationRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| GroupByEliminationRule (const GroupByEliminationRule &) ; // not written |
| |
| virtual ~GroupByEliminationRule(); |
| virtual NABoolean topMatch (RelExpr * expr, |
| Context * context); |
| virtual Int32 promiseForOptimization(RelExpr * relExpr, |
| Guidance * guidance, |
| Context * context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context *context, |
| RuleSubstituteMemory * & memory); |
| }; |
| |
| class GroupByOnJoinRule : public Rule |
| { |
| public: |
| GroupByOnJoinRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| GroupByOnJoinRule (const GroupByOnJoinRule &) ; // not written |
| |
| virtual ~GroupByOnJoinRule(); |
| |
| virtual NABoolean topMatch (RelExpr * expr, |
| Context * context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| }; |
| |
| class PartialGroupByOnTSJRule : public Rule |
| { |
| public: |
| PartialGroupByOnTSJRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| PartialGroupByOnTSJRule (const PartialGroupByOnTSJRule &) ; // not written |
| |
| virtual ~PartialGroupByOnTSJRule(); |
| |
| virtual NABoolean topMatch (RelExpr * expr, |
| Context * context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| }; |
| |
| class GroupBySplitRule : public Rule |
| { |
| public: |
| GroupBySplitRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| GroupBySplitRule (const GroupBySplitRule &) ; // not written |
| |
| virtual ~GroupBySplitRule(); |
| |
| virtual NABoolean topMatch (RelExpr * expr, |
| Context * context); |
| virtual Int32 promiseForOptimization(RelExpr * relExpr, |
| Guidance * guidance, |
| Context * context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| virtual NABoolean canMatchPattern (const RelExpr * pattern) const; |
| }; |
| |
| class AggrDistinctEliminationRule : public Rule |
| { |
| public: |
| AggrDistinctEliminationRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| AggrDistinctEliminationRule (const AggrDistinctEliminationRule &) ; // not written |
| |
| virtual ~AggrDistinctEliminationRule(); |
| virtual NABoolean topMatch (RelExpr * expr, |
| Context * context); |
| virtual RelExpr * nextSubstitute (RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| virtual NABoolean canMatchPattern (const RelExpr * pattern) const; |
| }; |
| |
| class GroupByTernarySplitRule : public GroupBySplitRule |
| { |
| public: |
| GroupByTernarySplitRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| GroupBySplitRule(name,pattern,substitute) {} |
| |
| // copy ctor |
| GroupByTernarySplitRule (const GroupByTernarySplitRule &) ; // not written |
| |
| virtual ~GroupByTernarySplitRule(); |
| virtual NABoolean isContextSensitive() const; |
| virtual NABoolean topMatch (RelExpr * expr, |
| Context * context); |
| virtual NABoolean canMatchPattern (const RelExpr * pattern) const; |
| }; |
| |
| class ShortCutGroupByRule : public Rule |
| { |
| public: |
| ShortCutGroupByRule (const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| ShortCutGroupByRule (const ShortCutGroupByRule &) ; // not written |
| |
| virtual ~ShortCutGroupByRule(); |
| virtual NABoolean topMatch (RelExpr * relExpr, |
| Context *context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| virtual NABoolean canMatchPattern (const RelExpr * pattern) const; |
| }; |
| |
| class CommonSubExprRule : public Rule |
| { |
| public: |
| CommonSubExprRule (const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| CommonSubExprRule (const CommonSubExprRule &) ; // not written |
| |
| virtual ~CommonSubExprRule(); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| virtual NABoolean canMatchPattern (const RelExpr * pattern) const; |
| }; |
| |
| class SampleScanRule : public Rule |
| { |
| public: |
| SampleScanRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| SampleScanRule (const SampleScanRule &) ; // not written |
| |
| virtual ~SampleScanRule() {} |
| virtual NABoolean topMatch (RelExpr * expr, |
| Context * context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context *context, |
| RuleSubstituteMemory * & memory); |
| |
| virtual Int32 promiseForOptimization(RelExpr * relExpr, |
| Guidance * guidance, |
| Context * context); |
| }; |
| |
| |
| //++MV, |
| class JoinToBushyTreeRule : public Rule |
| { |
| public: |
| JoinToBushyTreeRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| virtual ~JoinToBushyTreeRule() {} |
| |
| virtual NABoolean topMatch (RelExpr * expr, |
| Context * context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context *context, |
| RuleSubstituteMemory * & memory); |
| |
| }; |
| |
| //--MV |
| |
| /* |
| class HbaseScanRule : public Rule |
| { |
| public: |
| HbaseScanRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| HbaseScanRule (const HbaseScanRule &) ; // not written |
| |
| virtual ~HbaseScanRule(); |
| virtual NABoolean topMatch (RelExpr * relExpr, |
| Context *context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| }; |
| */ |
| |
| |
| // ----------------------------------------------------------------------- |
| // Work areas to share work done between MJ Rules (i.e. LSRs) and also |
| // between topMatch and nextSubstitute of an MJ Rule |
| // ----------------------------------------------------------------------- |
| |
| // Work area used by MJ Rules (i.e. LSRs), to store common information shared |
| // between the various LSRs. This helps avoids recomputation of this information |
| // for each seperate LSR |
| class MJRulesWA : public NABasicObject |
| { |
| friend class MJStarJoinRule; |
| friend class MJStarJoinIRule; |
| friend class MJStarJoinIIRule; |
| friend class MJStarBDRule; |
| |
| public: |
| ~MJRulesWA(){}; |
| MJRulesWA(JBBSubsetAnalysis * analysis); |
| CANodeId computeCenterTable(); |
| |
| private: |
| |
| // information set by method MJRulesWA::getCenterTable() |
| // begin |
| // the center table in the connectivity graph |
| NABoolean centerTableComputed_; |
| CANodeId centerTable_; |
| CostScalar centerTableRowsScanned_; |
| CostScalar centerTableDataScanned_; |
| CostScalar centerTableDataPerPartition_; |
| CostScalar centerTablePartitions_; |
| // number of tables connected to the center table |
| UInt32 centerTableConnectivity_; |
| // max number of tables connected to other tables, |
| // i.e. table apart from the center table |
| UInt32 maxDimensionConnectivity_; |
| // end |
| |
| // information set by the MJRulesWA::findFactTable |
| // begin |
| // fact table used in the star join I and star join II rules |
| // a fact table significantly larger (e.g. 5x) than all other |
| // tables in the JBBSubset. But if the largest table in the |
| // JBBSubset is not significantly larger then this is set to |
| // NULL_CA_ID |
| CANodeId factTable_; |
| // this is the largest table in the JBBSubset. |
| CANodeId largestTable_; |
| // this is the largest node in the JBBSubset, it is not necessarily |
| // a table, could be a subquery, e.g. group by. |
| CANodeId largestNode_; |
| // end |
| |
| // pointer to the JBBSubsetAnalysis to which this guy belongs |
| JBBSubsetAnalysis * analysis_; |
| }; |
| |
| // ----------------------------------------------------------------------- |
| // OnceGuidance: instruct not to apply a rule on an expression |
| // (usually used on rules like the commutativity rule that produce |
| // the original expression when applied twice) |
| // ----------------------------------------------------------------------- |
| class OnceGuidance : public Guidance |
| { |
| public: |
| |
| // ctor |
| OnceGuidance(NAUnsigned exceptRule, NAMemory * h); |
| |
| // copy ctor |
| OnceGuidance (const OnceGuidance &) ; // not written |
| |
| virtual ~OnceGuidance(); |
| |
| virtual const RuleSubset * applicableRules(); |
| |
| private: |
| |
| RuleSubset allButOne_; // all applicable rules minus "exceptRule" |
| }; |
| |
| // ----------------------------------------------------------------------- |
| // StopGuidance: stop doing anything (don't apply any more rules) |
| // ----------------------------------------------------------------------- |
| class StopGuidance : public Guidance |
| { |
| public: |
| |
| StopGuidance(NAMemory * h); |
| |
| // copy ctor |
| StopGuidance (const StopGuidance &) ; // not written |
| |
| virtual ~StopGuidance(); |
| |
| virtual const RuleSubset * applicableRules(); |
| |
| private: |
| |
| RuleSubset emptySet_; // an empty rule subset |
| }; |
| |
| // ----------------------------------------------------------------------- |
| // FilterGuidance: |
| // Only allow the filter rules to be applied - i.e. |
| // FilterRule0, FilterRule1, and FilterRule2. Used when exploring |
| // the child of a filter so that double filter nodes - i.e. a |
| // filter that is a child of a filter - are processed correctly. |
| // |
| // This is necessary because FilterRule1, which is the rule that |
| // would process a filter over a filter (since a filter is a unary |
| // non-leaf operator), will refuse to do anything if it's child is |
| // a filter. It assumes that the filter child will be merged with |
| // it's child when exploring. But the filter rule used to issue |
| // "StopGuidance", above, so this would never happen during exploring. |
| // It also never happens during optimization, because there is no |
| // implementation rule for a filter, and rules are only issued |
| // for the immediate child of an operator during optimization if the |
| // parent was actually implemented. Prior to adding this guidance |
| // class, once one filter ended up on top of another filter, |
| // the "double filter" could never be eliminated. One solution |
| // would be to issue no guidance at all, so all rules could fire. |
| // This was not done because it was assumed that the reason |
| // "StopGuidance" was issued was because applying all the rules to |
| // the child of a filter was causing a performance problem, |
| // since all the rules would have to be applied on the child |
| // again after the filter was merged with the child. By |
| // issuing a guidance that only allows the filter rules to fire, |
| // additional work will only be performed if we are indeed processing |
| // a "double filter". These were never being processed before, so |
| // it is not possible that this will result in any new unnecessary work. |
| // ----------------------------------------------------------------------- |
| class FilterGuidance : public Guidance |
| { |
| public: |
| |
| FilterGuidance(NAMemory * h); |
| |
| // copy ctor |
| FilterGuidance (const StopGuidance &) ; // not written |
| |
| virtual ~FilterGuidance(); |
| |
| virtual const RuleSubset * applicableRules(); |
| |
| private: |
| |
| RuleSubset filterRules_; // FilterRule0, FilterRule1, FilterRule2 |
| }; |
| |
| #endif // TRANSRULE_H |
