| #ifndef IMPLRULE_H |
| #define IMPLRULE_H |
| /* -*-C++-*- |
| ****************************************************************************** |
| * |
| * File: ImplRule.h |
| * Description: Implementation rules |
| * |
| * |
| * Created: 9/14/94 |
| * Language: C++ |
| * |
| * |
| // @@@ 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 @@@ |
| * |
| * |
| ****************************************************************************** |
| */ |
| |
| // ----------------------------------------------------------------------- |
| |
| #include "Rule.h" |
| |
| // It is found that DP2 goes into infinite loop if we have rowsize |
| // of approximately > 30000. Internally the executor has a max buffer |
| // size of 31000 for nodes with remotepartition and 56000 for local |
| // partitions.30000 bytes limit is experimentally found to be safe after |
| // taking into consideration the additional bytes that will be added for |
| // header information and control information in executor. |
| #define ROWSIZE_TO_EXECUTE_IN_DP2 30000 |
| // increasing this limit for the DB limits project (see .cpp file) |
| #define ROWSIZE_TO_EXECUTE_IN_DP2_DBL 55000 |
| // ----------------------------------------------------------------------- |
| // classes defined in this file |
| // ----------------------------------------------------------------------- |
| class HbaseDeleteRule; |
| class HbaseUpdateRule; |
| class HiveInsertRule; |
| class HbaseInsertRule; |
| class ExchangeEnforcerRule; |
| class HbaseScanRule; |
| class FileScanRule; |
| class GenericUpdateRule; |
| class HashGroupByRule; |
| class HashJoinRule; |
| class MergeJoinRule; |
| class NestedJoinRule; |
| class PhysCompoundStmtRule; |
| class PhysicalExplainRule; |
| class PhysicalHiveMDRule; |
| class PhysicalMapValueIdsRule; |
| class PhysicalPackRule; |
| class PhysicalSequenceRule; |
| class PhysicalTransposeRule; |
| class PhysicalTupleRule; |
| class PhysicalTupleListRule; |
| class PhysicalUnPackRowsRule; |
| class PhysicalTMUDFRule; |
| class PhysicalFastExtractRule; |
| class SortEnforcerRule; |
| class SortGroupByRule; |
| class AggregateRule; |
| class PhysShortCutGroupByRule; |
| class UnionRule; |
| |
| // ----------------------------------------------------------------------- |
| // forward references |
| // ----------------------------------------------------------------------- |
| |
| // ----------------------------------------------------------------------- |
| // Function to add transformation rules to the rule set |
| // ----------------------------------------------------------------------- |
| void CreateImplementationRules(RuleSet*); |
| |
| class HbaseDeleteRule : public Rule |
| { |
| public: |
| HbaseDeleteRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| HbaseDeleteRule (const HbaseDeleteRule &) ; // not written |
| |
| virtual ~HbaseDeleteRule(); |
| virtual NABoolean topMatch (RelExpr * relExpr, |
| Context *context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| }; |
| |
| class HbaseDeleteCursorRule : public HbaseDeleteRule |
| { |
| public: |
| HbaseDeleteCursorRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| HbaseDeleteRule(name,pattern,substitute) {} |
| |
| // copy ctor |
| HbaseDeleteCursorRule (const HbaseDeleteCursorRule &) ; // not written |
| |
| virtual ~HbaseDeleteCursorRule(); |
| virtual NABoolean topMatch (RelExpr * relExpr, |
| Context *context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| }; |
| |
| class HbaseUpdateRule : public Rule |
| { |
| public: |
| HbaseUpdateRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| HbaseUpdateRule (const HbaseUpdateRule &) ; // not written |
| |
| virtual ~HbaseUpdateRule(); |
| virtual NABoolean topMatch (RelExpr * relExpr, |
| Context *context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| }; |
| |
| class HbaseUpdateCursorRule : public HbaseUpdateRule |
| { |
| public: |
| HbaseUpdateCursorRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| HbaseUpdateRule(name,pattern,substitute) {} |
| |
| // copy ctor |
| HbaseUpdateCursorRule (const HbaseUpdateCursorRule &) ; // not written |
| |
| virtual ~HbaseUpdateCursorRule(); |
| virtual NABoolean topMatch (RelExpr * relExpr, |
| Context *context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| }; |
| |
| class HiveInsertRule : public Rule |
| { |
| public: |
| HiveInsertRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| HiveInsertRule (const HiveInsertRule &) ; // not written |
| |
| virtual ~HiveInsertRule(); |
| virtual NABoolean topMatch (RelExpr * relExpr, |
| Context *context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| }; |
| |
| 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); |
| }; |
| |
| |
| class HbaseInsertRule : public Rule |
| { |
| public: |
| HbaseInsertRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| HbaseInsertRule (const HbaseInsertRule &) ; // not written |
| |
| virtual ~HbaseInsertRule(); |
| virtual NABoolean topMatch (RelExpr * relExpr, |
| Context *context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| }; |
| |
| class ExchangeEnforcerRule : public Rule |
| { |
| public: |
| ExchangeEnforcerRule (const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| ExchangeEnforcerRule (const ExchangeEnforcerRule &) ; // not written |
| |
| virtual ~ExchangeEnforcerRule(); |
| 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); |
| }; |
| |
| class FileScanRule : public Rule |
| { |
| public: |
| FileScanRule (const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| FileScanRule (const FileScanRule &) ; // not written |
| |
| virtual ~FileScanRule(); |
| virtual NABoolean topMatch (RelExpr * relExpr, |
| Context *context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| }; |
| |
| class HashGroupByRule : public Rule |
| { |
| public: |
| HashGroupByRule (const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| HashGroupByRule (const HashGroupByRule &) ; // not written |
| |
| virtual ~HashGroupByRule(); |
| virtual NABoolean topMatch(RelExpr * relExpr, |
| Context *context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| }; |
| |
| |
| class HashJoinRule : public Rule |
| { |
| public: |
| HashJoinRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| HashJoinRule (const HashJoinRule &) ; // not written |
| |
| virtual ~HashJoinRule(); |
| virtual NABoolean topMatch(RelExpr * relExpr, |
| Context *context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| }; |
| |
| class MergeJoinRule : public Rule |
| { |
| public: |
| MergeJoinRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| MergeJoinRule (const MergeJoinRule &) ; // not written |
| |
| virtual ~MergeJoinRule(); |
| virtual NABoolean topMatch (RelExpr * relExpr, |
| Context * context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| virtual NABoolean canBePruned(RelExpr * expr) const; |
| }; |
| |
| class NestedJoinRule : public Rule |
| { |
| public: |
| NestedJoinRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| NestedJoinRule (const NestedJoinRule &) ; // not written |
| |
| virtual ~NestedJoinRule(); |
| virtual NABoolean topMatch(RelExpr * relExpr, |
| Context *context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| virtual NABoolean canBePruned(RelExpr * expr) const; |
| }; |
| |
| class NestedJoinFlowRule : public Rule |
| { |
| public: |
| NestedJoinFlowRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| NestedJoinFlowRule (const NestedJoinFlowRule &) ; // not written |
| |
| virtual ~NestedJoinFlowRule(); |
| virtual NABoolean topMatch (RelExpr * relExpr, |
| Context *context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| }; |
| |
| class PhysCompoundStmtRule : public Rule |
| { |
| public: |
| PhysCompoundStmtRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| PhysCompoundStmtRule (const PhysCompoundStmtRule &) ; // not written |
| |
| virtual ~PhysCompoundStmtRule() {} |
| virtual NABoolean topMatch(RelExpr * expr, |
| Context * context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| }; |
| |
| class PhysicalMapValueIdsRule : public Rule |
| { |
| public: |
| PhysicalMapValueIdsRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| PhysicalMapValueIdsRule (const PhysicalMapValueIdsRule &) ; // not written |
| |
| virtual ~PhysicalMapValueIdsRule(); |
| virtual NABoolean topMatch (RelExpr * relExpr, |
| Context *context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| virtual NABoolean canMatchPattern (const RelExpr * pattern) const; |
| |
| // This implementation rule is not context sensitive |
| virtual NABoolean isContextSensitive() const; |
| }; |
| |
| class PhysicalRelRootRule : public Rule |
| { |
| public: |
| PhysicalRelRootRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| PhysicalRelRootRule (const PhysicalRelRootRule &) ; // not written |
| |
| virtual ~PhysicalRelRootRule(); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| }; |
| |
| class PhysicalSequenceRule : public Rule |
| { |
| public: |
| PhysicalSequenceRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| PhysicalSequenceRule (const PhysicalSequenceRule &) ; // not written |
| |
| virtual ~PhysicalSequenceRule(); |
| virtual NABoolean topMatch(RelExpr * relExpr, |
| Context *context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| }; |
| |
| class PhysicalTupleRule : public Rule |
| { |
| public: |
| PhysicalTupleRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| PhysicalTupleRule (const PhysicalTupleRule &) ; // not written |
| |
| virtual ~PhysicalTupleRule(); |
| virtual NABoolean topMatch(RelExpr * relExpr, |
| Context *context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| }; |
| |
| class PhysicalTupleListRule : public Rule |
| { |
| public: |
| PhysicalTupleListRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| PhysicalTupleListRule (const PhysicalTupleListRule &) ; // not written |
| |
| virtual ~PhysicalTupleListRule(); |
| virtual NABoolean topMatch(RelExpr * relExpr, |
| Context *context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| }; |
| |
| class PhysicalExplainRule : public Rule |
| { |
| public: |
| PhysicalExplainRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| PhysicalExplainRule (const PhysicalExplainRule &) ; // not written |
| |
| virtual ~PhysicalExplainRule(); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| }; |
| |
| class PhysicalHiveMDRule : public Rule |
| { |
| public: |
| PhysicalHiveMDRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| PhysicalHiveMDRule (const PhysicalHiveMDRule &) ; // not written |
| |
| virtual ~PhysicalHiveMDRule(); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| }; |
| |
| class PhysicalPackRule : public Rule |
| { |
| public: |
| PhysicalPackRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| PhysicalPackRule (const PhysicalPackRule &) ; // not written |
| |
| virtual ~PhysicalPackRule(); |
| virtual NABoolean topMatch(RelExpr * relExpr, |
| Context *context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| virtual NABoolean canMatchPattern (const RelExpr * pattern) const; |
| }; |
| |
| class PhysicalTransposeRule : public Rule |
| { |
| public: |
| PhysicalTransposeRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| PhysicalTransposeRule (const PhysicalTransposeRule &) ; // not written |
| |
| virtual ~PhysicalTransposeRule(); |
| virtual NABoolean topMatch(RelExpr * relExpr, |
| Context *context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| }; |
| |
| |
| class PhysicalUnPackRowsRule : public Rule |
| { |
| public: |
| PhysicalUnPackRowsRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| PhysicalUnPackRowsRule (const PhysicalUnPackRowsRule &) ; // not written |
| |
| virtual ~PhysicalUnPackRowsRule(); |
| virtual NABoolean topMatch(RelExpr * relExpr, |
| Context *context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| virtual NABoolean canMatchPattern (const RelExpr * pattern) const; |
| }; |
| |
| |
| class SortEnforcerRule : public Rule |
| { |
| public: |
| SortEnforcerRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| SortEnforcerRule (const SortEnforcerRule &) ; // not written |
| |
| virtual ~SortEnforcerRule(); |
| 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); |
| }; |
| |
| class SortGroupByRule : public Rule |
| { |
| public: |
| SortGroupByRule (const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| SortGroupByRule (const SortGroupByRule &) ; // not written |
| |
| virtual ~SortGroupByRule(); |
| virtual NABoolean topMatch (RelExpr * relExpr, |
| Context *context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| }; |
| |
| class AggregateRule : public SortGroupByRule |
| { |
| public: |
| AggregateRule (const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| SortGroupByRule(name,pattern,substitute) {} |
| |
| // copy ctor |
| AggregateRule (const AggregateRule &) ; // not written |
| |
| virtual ~AggregateRule(); |
| virtual NABoolean topMatch (RelExpr * relExpr, |
| Context * context); |
| }; |
| |
| class PhysShortCutGroupByRule : public Rule |
| { |
| public: |
| PhysShortCutGroupByRule (const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| PhysShortCutGroupByRule (const PhysShortCutGroupByRule &) ; // not written |
| |
| virtual ~PhysShortCutGroupByRule(); |
| virtual NABoolean topMatch (RelExpr * relExpr, |
| Context *context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| }; |
| |
| class UnionRule : public Rule |
| { |
| public: |
| UnionRule (const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| UnionRule (const UnionRule &) ; // not written |
| |
| virtual ~UnionRule(); |
| virtual NABoolean topMatch (RelExpr * relExpr, |
| Context * context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| }; |
| |
| |
| class PhysicalSampleRule : public Rule |
| { |
| public: |
| PhysicalSampleRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy ctor |
| PhysicalSampleRule (const PhysicalSampleRule &) ; // not written |
| |
| virtual ~PhysicalSampleRule(); |
| virtual NABoolean topMatch(RelExpr * relExpr, |
| Context *context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| }; |
| |
| class PhysicalInterpretAsRowRule : public Rule |
| { |
| public: |
| PhysicalInterpretAsRowRule(const char *name, |
| RelExpr *pattern, |
| RelExpr *substitute) : |
| Rule(name,pattern,substitute) {}; |
| |
| PhysicalInterpretAsRowRule(const PhysicalInterpretAsRowRule &); // not written |
| |
| virtual ~PhysicalInterpretAsRowRule(); |
| virtual NABoolean topMatch(RelExpr *relExpr, |
| Context *context); |
| virtual RelExpr * nextSubstitute(RelExpr *before, |
| Context *context, |
| RuleSubstituteMemory * & memory); |
| }; |
| |
| class PhysicalSPProxyFuncRule : public Rule |
| { |
| public: |
| |
| PhysicalSPProxyFuncRule(const char *name, RelExpr *pattern, RelExpr *substitute) |
| : Rule(name,pattern,substitute) |
| {} |
| |
| // copy ctor |
| PhysicalSPProxyFuncRule(const PhysicalSPProxyFuncRule &); // not written |
| |
| virtual ~PhysicalSPProxyFuncRule(); |
| virtual NABoolean topMatch(RelExpr *relExpr, |
| Context *context); |
| |
| virtual RelExpr *nextSubstitute(RelExpr *before, |
| Context *context, |
| RuleSubstituteMemory *&memory); |
| }; |
| |
| class PhysicalExtractSourceRule : public Rule |
| { |
| public: |
| |
| PhysicalExtractSourceRule(const char *name, RelExpr *pattern, RelExpr *substitute) |
| : Rule(name,pattern,substitute) |
| {} |
| |
| // copy ctor |
| PhysicalExtractSourceRule(const PhysicalExtractSourceRule &); // not written |
| |
| virtual ~PhysicalExtractSourceRule(); |
| virtual NABoolean topMatch(RelExpr *relExpr, |
| Context *context); |
| |
| virtual RelExpr *nextSubstitute(RelExpr *before, |
| Context *context, |
| RuleSubstituteMemory *&memory); |
| }; |
| |
| class PhysicalIsolatedScalarUDFRule : public Rule |
| { |
| public: |
| PhysicalIsolatedScalarUDFRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy-ctor, not implemented |
| PhysicalIsolatedScalarUDFRule (const PhysicalIsolatedScalarUDFRule &); |
| |
| virtual ~PhysicalIsolatedScalarUDFRule(); |
| virtual NABoolean topMatch(RelExpr * relExpr, |
| Context *context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| }; |
| |
| class PhysicalTMUDFRule : public Rule |
| { |
| public: |
| PhysicalTMUDFRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy-ctor, not implemented |
| PhysicalTMUDFRule (const PhysicalTMUDFRule &); |
| |
| virtual ~PhysicalTMUDFRule(); |
| virtual NABoolean topMatch(RelExpr * relExpr, |
| Context *context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| |
| virtual NABoolean isImplementationRule () const { return TRUE; } |
| virtual NABoolean canMatchPattern (const RelExpr * pattern) const; |
| }; |
| |
| class PhysicalFastExtractRule : public Rule |
| { |
| public: |
| PhysicalFastExtractRule(const char * name, |
| RelExpr * pattern, |
| RelExpr * substitute) : |
| Rule(name,pattern,substitute) {} |
| |
| // copy-ctor, not implemented |
| PhysicalFastExtractRule (const PhysicalFastExtractRule &); |
| |
| virtual ~PhysicalFastExtractRule(); |
| virtual NABoolean topMatch(RelExpr * relExpr, |
| Context *context); |
| virtual RelExpr * nextSubstitute(RelExpr * before, |
| Context * context, |
| RuleSubstituteMemory * & memory); |
| |
| virtual NABoolean isImplementationRule () const { return TRUE; } |
| }; |
| #endif // IMPLRULE_H |