| /********************************************************************** |
| // @@@ 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 STMTDDLCREATEVIEW_H |
| #define STMTDDLCREATEVIEW_H |
| /* -*-C++-*- |
| ***************************************************************************** |
| * |
| * File: StmtDDLCreateView.h |
| * Description: class for parse nodes representing Create View |
| * statements |
| * |
| * Also contains definitions of classes describing |
| * the view usages information. |
| * |
| * |
| * Created: 1/5/96 |
| * Language: C++ |
| * |
| * |
| * |
| * |
| ***************************************************************************** |
| */ |
| |
| #include "ComASSERT.h" |
| #include "ComOperators.h" |
| #include "ComSmallDefs.h" |
| #include "ElemDDLColViewDefArray.h" |
| #include "ElemDDLLocation.h" |
| #include "NABoolean.h" |
| #include "ObjectNames.h" |
| #include "ParNameLocList.h" |
| #include "ParTableUsageList.h" |
| #include "RelExpr.h" |
| #include "StmtDDLNode.h" |
| |
| // ----------------------------------------------------------------------- |
| // contents of this file |
| // ----------------------------------------------------------------------- |
| class StmtDDLCreateView; |
| class ParViewColTablesUsage; |
| class ParViewColTablesUsageList; |
| class ParViewColTableColsUsage; |
| class ParViewColTableColsUsageList; |
| class ParViewTableColsUsage; |
| class ParViewTableColsUsageList; |
| class ParViewUsages; |
| |
| extern NABoolean ParIsTracingViewUsages(); |
| |
| // ----------------------------------------------------------------------- |
| // forward references |
| // ----------------------------------------------------------------------- |
| // None |
| |
| // ----------------------------------------------------------------------- |
| // definition of class ParViewTableColsUsage |
| // ----------------------------------------------------------------------- |
| |
| class ParViewTableColsUsage : public NABasicObject |
| { |
| public: |
| |
| // default constructor |
| ParViewTableColsUsage(CollHeap * h=PARSERHEAP()); |
| |
| // initialize constructor |
| ParViewTableColsUsage(const ColRefName &colName, CollHeap * h=PARSERHEAP()); |
| |
| // copy ctor |
| ParViewTableColsUsage (const ParViewTableColsUsage & orig, |
| CollHeap * h=PARSERHEAP()) ; // not written |
| |
| // virtual destructor |
| virtual ~ParViewTableColsUsage(); |
| |
| // |
| // operator |
| // |
| |
| NABoolean operator==(const ParViewTableColsUsage &rhs) const; |
| |
| // |
| // accessors |
| // |
| |
| inline const NAString & getColumnName() const; |
| |
| // returns the referenced column name in internal format. |
| |
| inline const ExtendedQualName & getTableQualName() const; |
| |
| // returns the referenced table name in QualifedName format. |
| |
| // |
| // mutators |
| // |
| |
| inline void setColumnName(const NAString &colName); |
| inline void setTableName(const ExtendedQualName &tableQualName); |
| |
| private: |
| |
| ExtendedQualName tableName_; |
| NAString columnName_; |
| |
| }; // class ParViewTableColsUsage |
| |
| // ----------------------------------------------------------------------- |
| // definition of class ParViewTableColsUsageList |
| // ----------------------------------------------------------------------- |
| |
| class ParViewTableColsUsageList : private LIST(ParViewTableColsUsage *) |
| { |
| public: |
| |
| // constructor |
| ParViewTableColsUsageList(CollHeap *heap = PARSERHEAP()); |
| |
| // heap specifies the heap to allocate space for objects |
| // pointed by the elements in this list. |
| |
| // virtual destructor |
| virtual ~ParViewTableColsUsageList(); |
| |
| // operators |
| inline const ParViewTableColsUsage & operator[](CollIndex index) const; |
| inline ParViewTableColsUsage & operator[](CollIndex index); |
| |
| // |
| // accessors |
| // |
| |
| inline CollIndex entries() const; |
| |
| inline const ParViewTableColsUsage * const find(const ColRefName & |
| colName) const; |
| |
| ParViewTableColsUsage * const find(const ColRefName &colName); |
| |
| // returns the pointer pointing to the ParViewTableColsUsage |
| // element in the list containing the specified colName; |
| // returns the NULL pointer value if not found. |
| |
| // |
| // mutator |
| // |
| |
| NABoolean insert(const ColRefName &columnName); |
| |
| // 1. If columeName is not in the list, inserts it to the end of |
| // the list and return TRUE. |
| // 2. If the columnName is already in the list, returns FALSE. |
| |
| private: |
| |
| ParViewTableColsUsageList(const ParViewTableColsUsageList &); // DO NOT USE |
| ParViewTableColsUsageList & operator= |
| (const ParViewTableColsUsageList &); // DO NOT USE |
| |
| // |
| // heap to allocate space for objects pointed by elements in the list. |
| // |
| CollHeap * heap_; |
| |
| }; // class ParViewTableColsUsageList |
| |
| // ----------------------------------------------------------------------- |
| // View Column Tables Usage |
| // ----------------------------------------------------------------------- |
| class ParViewColTablesUsage : public NABasicObject |
| { |
| public: |
| |
| // |
| // constructors |
| // |
| |
| ParViewColTablesUsage(CollHeap * h=PARSERHEAP()); |
| ParViewColTablesUsage(const CollIndex usingViewColNum, |
| const ExtendedQualName &usedObjName, |
| CollHeap * h=PARSERHEAP()); |
| // copy ctor |
| ParViewColTablesUsage (const ParViewColTablesUsage & orig, CollHeap * h=PARSERHEAP()) ; |
| |
| // |
| // virtual destructor |
| // |
| |
| virtual ~ParViewColTablesUsage(); |
| |
| // |
| // operator |
| // |
| |
| NABoolean operator==(const ParViewColTablesUsage &rhs) const; |
| |
| // |
| // accessors |
| // |
| |
| inline const CollIndex getUsingViewColumnNumber() const; |
| inline const ExtendedQualName & getUsedObjectName() const; |
| |
| // |
| // mutators |
| // |
| |
| inline void setUsingViewColumnNumber(const CollIndex usingColNum); |
| inline void setUsedObjectName(const ExtendedQualName &usedObjName); |
| |
| private: |
| |
| CollIndex usingViewColumnNumber_; |
| ExtendedQualName usedObjectName_; |
| |
| }; // class ParViewColTablesUsage |
| |
| // ----------------------------------------------------------------------- |
| // View Column Table Columns Usage List |
| // ----------------------------------------------------------------------- |
| class ParViewColTablesUsageList : private LIST(ParViewColTablesUsage *) |
| { |
| public: |
| |
| // |
| // constructor |
| // |
| |
| ParViewColTablesUsageList(CollHeap *heap = PARSERHEAP()); |
| |
| // heap specifies the heap to allocate space for objects |
| // pointed by the elements in this list. |
| |
| // |
| // virtual destructor |
| // |
| |
| virtual ~ParViewColTablesUsageList(); |
| |
| // |
| // operators |
| // |
| |
| inline const ParViewColTablesUsage & operator[](CollIndex index) |
| const; |
| inline ParViewColTablesUsage & operator[](CollIndex index); |
| |
| // |
| // accessors |
| // |
| |
| inline CollIndex entries() const; |
| |
| const ParViewColTablesUsage * const find(const CollIndex usingViewColNum) |
| const; |
| ParViewColTablesUsage * const find(const CollIndex usingViewColNum); |
| |
| // returns the pointer pointing to the ParViewColTablesUsage |
| // element in the list containing the specified usingViewColNum. |
| // returns the NULL pointer value if not found. |
| |
| // |
| // mutator |
| // |
| |
| NABoolean insert(const CollIndex usingViewColumnNumber, |
| const ExtendedQualName &usedObjectName); |
| |
| // inserts to the list and returns TRUE if not in the list; |
| // otherwise, returns FALSE. |
| |
| private: |
| |
| ParViewColTablesUsageList(const ParViewColTablesUsageList &); // DO NOT USE |
| ParViewColTablesUsageList & operator= |
| (const ParViewColTablesUsageList &); // DO NOT USE |
| // |
| // heap to allocate space for objects pointed by elements in the list. |
| // |
| CollHeap * heap_; |
| |
| }; // class ParViewColTablesUsageList |
| |
| // ----------------------------------------------------------------------- |
| // View Column Table Columns Usage |
| // ----------------------------------------------------------------------- |
| class ParViewColTableColsUsage : public NABasicObject |
| { |
| public: |
| |
| // |
| // constructors |
| // |
| |
| ParViewColTableColsUsage(CollHeap * h=PARSERHEAP()); |
| ParViewColTableColsUsage(const CollIndex usingViewColumnNumber, |
| const ColRefName &usedObjectColumnName, |
| CollHeap * h=PARSERHEAP()); |
| // copy ctor |
| ParViewColTableColsUsage (const ParViewColTableColsUsage & orig, CollHeap * h=PARSERHEAP()) ; |
| |
| // |
| // virtual destructor |
| // |
| |
| virtual ~ParViewColTableColsUsage(); |
| |
| // |
| // operator |
| // |
| |
| NABoolean operator==(const ParViewColTableColsUsage &rhs) const; |
| |
| // |
| // accessors |
| // |
| |
| inline const CollIndex getUsingViewColumnNumber() const; |
| inline const ColRefName & getUsedObjectColumnName() const; |
| |
| // |
| // mutators |
| // |
| |
| inline void setUsingViewColumnNumber(const CollIndex colNum); |
| inline void setUsedObjectColumnName(const ColRefName &colRefName); |
| |
| private: |
| |
| CollIndex usingViewColumnNumber_; |
| ColRefName usedObjectColumnName_; |
| |
| }; // class ParViewColTableColsUsage |
| |
| // ----------------------------------------------------------------------- |
| // View Column Table Columns Usage List |
| // ----------------------------------------------------------------------- |
| class ParViewColTableColsUsageList : private LIST(ParViewColTableColsUsage *) |
| { |
| public: |
| |
| // |
| // constructor |
| // |
| |
| ParViewColTableColsUsageList(CollHeap *heap = PARSERHEAP()); |
| |
| // heap specifies the heap to allocate space for objects |
| // pointed by the elements in this list. |
| |
| // |
| // virtual destructor |
| // |
| |
| virtual ~ParViewColTableColsUsageList(); |
| |
| // |
| // operators |
| // |
| |
| inline const ParViewColTableColsUsage & operator[](CollIndex index) |
| const; |
| inline ParViewColTableColsUsage & operator[](CollIndex index); |
| |
| // |
| // accessors |
| // |
| |
| inline CollIndex entries() const; |
| |
| inline |
| const ParViewColTableColsUsage * const find(const CollIndex usingViewColNum) |
| const; |
| ParViewColTableColsUsage * const find(const CollIndex usingViewColNum); |
| |
| // returns the pointer pointing to the ParViewColTableColsUsage |
| // element in the list containing the specified usingViewColNum. |
| // Returns the NULL pointer value if not found. |
| |
| inline |
| const ParViewColTableColsUsage * const find(const CollIndex usingViewColNum, |
| const ColRefName &usedColRefName) |
| const; |
| ParViewColTableColsUsage * const find(const CollIndex usingViewColNum, |
| const ColRefName &usedColRefName); |
| |
| // returns the pointer pointing to the ParViewColTableColsUsage |
| // element in the list containing the specified usingViewColNum, |
| // the usedColRefName.getCorrNameObj().getQualifiedNameObj(), and |
| // the usedColRefName.getColName() values. Returns the NULL |
| // pointer value if not found. |
| |
| const CollIndex getIndex(const CollIndex usingViewColumnNumber) const; |
| |
| // returns the index to the first entry of the list of elements |
| // containing the usingViewColumnNumber; returns NULL_COLL_INDEX |
| // if not found. |
| |
| const CollIndex getIndexOfNextElem(const CollIndex |
| usingViewColumnNumber) const; |
| |
| // returns the index to the first entry of the list of elements |
| // containing the using-view-column-number that is greater than |
| // usingViewColumnNumber; returns NULL_COLL_INDEX if |
| // usingViewColumnNumber is the biggest value so far (or if the |
| // list is currently empty). |
| |
| // |
| // mutators |
| // |
| |
| void clear(); |
| |
| // destroys all elements in the list. |
| |
| NABoolean insert(const CollIndex usingViewColumnNumber, |
| const ColRefName &usedObjectColumnName); |
| |
| // inserts to the list and returns TRUE if not in the list; |
| // otherwise, returns FALSE. |
| |
| private: |
| |
| ParViewColTableColsUsageList |
| (const ParViewColTableColsUsageList &); // DO NOT USE |
| ParViewColTableColsUsageList & operator= |
| (const ParViewColTableColsUsageList &); // DO NOT USE |
| |
| // |
| // heap to allocate space for objects pointed by elements in the list. |
| // |
| CollHeap * heap_; |
| |
| }; // class ParViewColTableColsUsageList |
| |
| // ----------------------------------------------------------------------- |
| // View Usages |
| // ----------------------------------------------------------------------- |
| class ParViewUsages : public NABasicObject |
| { |
| public: |
| |
| ParViewUsages(CollHeap * heap = PARSERHEAP()); |
| |
| virtual ~ParViewUsages(); |
| |
| // |
| // accessors |
| // |
| |
| inline CollIndex getCurViewColNum() const; // for Binder use only |
| |
| inline const ExtendedQualName *getUsedTableNamePtr |
| (const ExtendedQualName &tableName) const; |
| |
| inline const ParViewTableColsUsageList & getViewTableColsUsageList() const; |
| inline ParViewTableColsUsageList & getViewTableColsUsageList(); |
| |
| inline const ParTableUsageList & getViewTableUsageList() const; |
| inline ParTableUsageList & getViewTableUsageList(); |
| |
| inline const ParViewColTablesUsageList & getViewColTablesUsageList() const; |
| inline ParViewColTablesUsageList & getViewColTablesUsageList(); |
| |
| // KSKSKS |
| |
| const ParViewColTableColsUsageList & getViewColTableColsUsageList() |
| const; |
| ParViewColTableColsUsageList & getViewColTableColsUsageList(); |
| |
| // KSKSKS |
| |
| inline NABoolean isItmColRefInColInRowVals() const; // Binder use only |
| |
| inline NABoolean isViewSurelyNotUpdatable() const; // Binder use only |
| |
| // Please note the we don't know whether view is updatable or not |
| // until we are done with the Normalization phase. This method, |
| // therefore, cannot provide accurrate information. Without knowing |
| // for sure if the view is not updatable, the binder has to collect |
| // the view-column-table-columns-usage information even though this |
| // information is not needed if the view is not updatable. Collecting |
| // this information is not an easy task because non-updatable view |
| // can be pretty complex. However, in certain cases, the binder can |
| // find out that a view is not updatable; for example, the query |
| // expression contains natural join operation. To make the binder's |
| // task simpler, the binder will stop collection the view-column- |
| // table-columns-usage information as soon as it knows. |
| |
| // |
| // mutators |
| // |
| |
| inline void setCurViewColNum(const CollIndex curVwColNum); // Binder |
| |
| inline void setItmColRefInColInRowValsFlag(const NABoolean // Binder |
| isItmColRef); // use only |
| |
| inline void setViewIsSurelyNotUpdatableFlag(); // for Binder use only |
| |
| // Please see comments for method isViewSurelyNotUpdatable() |
| |
| private: |
| |
| ParTableUsageList usedTableNameList_; |
| ParViewTableColsUsageList usedColRefList_; |
| ParViewColTablesUsageList viewColTablesUsageList_; |
| ParViewColTableColsUsageList viewColTableColsUsageList_; |
| |
| // |
| // information about the order number of the view column |
| // in the view column list (the order number of the leftmost |
| // column is 0). This field is set to NULL_COLL_INDEX if |
| // not processing view column list. This data member |
| // is used during the Binding phase only. |
| // |
| |
| CollIndex curViewColNum_; |
| |
| // |
| // The following data member is used in the Binding phase to |
| // find out whether the current column in the bindRowValues() |
| // is an ITM_REFERENCE (either a column reference or a star |
| // column reference) or not (e.g., a complex item expression). |
| // |
| |
| NABoolean isItmColRefInColInRowVals_; |
| |
| // |
| // see comments for method isViewSurelyNotUpdatable() |
| // |
| |
| NABoolean isViewSurelyNotUpdatable_; |
| |
| }; // class ParViewUsages |
| |
| // ----------------------------------------------------------------------- |
| // Create View statement |
| // ----------------------------------------------------------------------- |
| class StmtDDLCreateView : public StmtDDLNode |
| { |
| |
| public: |
| |
| // constructor |
| StmtDDLCreateView(const QualifiedName & viewName, |
| const ParNameLocList & nameLocList, |
| ElemDDLNode * optionalViewColumnList, |
| ElemDDLNode * optionalLocationClause, |
| RelExpr * queryExpression, |
| ElemDDLNode * optionalWithCheckOption, |
| ComCreateViewBehavior createViewBehavior, |
| ElemDDLNode *pOptionalOwner, |
| CollHeap * heap = PARSERHEAP()); |
| |
| // virtual destructor |
| virtual ~StmtDDLCreateView(); |
| |
| // cast |
| virtual StmtDDLCreateView * castToStmtDDLCreateView(); |
| |
| // pointers to child parse nodes (getChild and setChild methods) |
| enum { INDEX_VIEW_COLUMN_LIST = 0, |
| VIEW_COLUMN_LIST = INDEX_VIEW_COLUMN_LIST, |
| INDEX_LOCATION_CLAUSE, |
| LOCATION_CLAUSE = INDEX_LOCATION_CLAUSE, |
| INDEX_QUERY_EXPRESSION, |
| QUERY_EXPRESSION = INDEX_QUERY_EXPRESSION, |
| INDEX_WITH_CHECK_OPTION, |
| WITH_CHECK_OPTION = INDEX_WITH_CHECK_OPTION, |
| INDEX_VIEW_OWNER, |
| VIEW_OWNER = INDEX_VIEW_OWNER, |
| MAX_STMT_DDL_CREATE_VIEW_ARITY }; |
| |
| // |
| // accessors |
| // |
| |
| virtual Int32 getArity() const; |
| |
| inline NABoolean getIsUpdatable() const { return isUpdatable_; } |
| inline NABoolean getIsInsertable() const { return isInsertable_; } |
| |
| inline ComLevels getCheckOptionLevel() const; |
| |
| // returns the Check Option level when the With Check |
| // Option clause appears in the Create View statement |
| // (the default is COM_CASCADED_LEVEL); otherwise, |
| // returns COM_UNKNOWN_LEVEL. |
| |
| virtual ExprNode * getChild(Lng32 index); |
| |
| inline CollIndex getCurViewColNum() const; // for Binder use only |
| |
| inline const StringPos getEndPosition() const; |
| |
| // returns the ending position (the position of the |
| // last character) of the statement (within the input |
| // string) |
| |
| inline const NAString & getLocation() const; |
| |
| // returns the location name specified in the LOCATION |
| // clause/phrase associating with the view; returns an |
| // empty string if the LOCATION clause does not appear. |
| |
| inline ElemDDLLocation::locationNameTypeEnum getLocationNameType() const; |
| |
| // returns the type of the location name (e.g., an OSS |
| // path name, a Guardian device name, an OSS environment |
| // variable name, etc.) If LOCATION clause does not |
| // appear, the returned value has no meaning. |
| inline const NABoolean isCreateView() const; |
| inline const NABoolean isCreateSystemView() const; |
| inline const NABoolean isCreateOrReplaceView() const; |
| inline const NABoolean isCreateOrReplaceViewCascade() const; |
| inline const ComCreateViewBehavior getCreateViewBehavior() const; |
| inline const ParNameLocList & getNameLocList() const; |
| inline ParNameLocList & getNameLocList(); |
| |
| // returns a list of locations of names appearing in |
| // the statement input string. The list helps with |
| // the computing of the view text. |
| |
| inline const RelExpr * getQueryExpression() const; |
| inline RelExpr * getQueryExpression(); |
| |
| // returns the pointer pointing to the parse sub-tree |
| // representing the query expression in the view |
| // definition. |
| |
| inline const StringPos getStartPosition() const; |
| |
| // returns the starting position (the position of the |
| // first character) of the statement (within the |
| // input string) |
| |
| inline const ElemDDLColViewDefArray & getViewColDefArray() const; |
| inline ElemDDLColViewDefArray & getViewColDefArray(); |
| |
| // returns an array of pointers pointing to the Column |
| // Name parse nodes. If the View Column List phrase |
| // is not specified in the Create View statement, |
| // returns an empty array. |
| |
| inline const NAString getViewName() const; |
| |
| // returns the name of the defined view. |
| |
| inline const QualifiedName & getViewNameAsQualifiedName() const; |
| inline QualifiedName & getViewNameAsQualifiedName(); |
| |
| // returns the name of the defined view in |
| // QualifiedName format |
| |
| inline const ParViewUsages & getViewUsages() const; |
| inline ParViewUsages & getViewUsages(); |
| |
| // returns the UDF usage list |
| inline const LIST(OptUDFInfo *) &getUDFList() const; |
| inline LIST(OptUDFInfo *) &getUDFList(); |
| |
| // returns the view usages information after the parse |
| // node is bound; returns an empty object otherwise. |
| |
| inline NABoolean isItmColRefInColInRowVals() const; // for Binder use only |
| |
| inline NABoolean isLocationSpecified() const; |
| |
| // returns TRUE if the location clause/phrase appears; |
| // returns FALSE otherwise. |
| |
| inline NABoolean isProcessingViewColList() const; |
| |
| // This method is used during the Binding phase to help |
| // with collecting view column usage information |
| |
| inline NABoolean isWithCheckOptionSpecified() const; |
| |
| // returns FALSE if the With ... Check Option clause |
| // is not specified in the Create View Statement; |
| // returns TRUE otherwise. |
| |
| inline NABoolean isOwnerSpecified() const; |
| |
| // returns TRUE if the BY <owner> phrase appears |
| // in the Create statement; returns FALSE otherwise. |
| |
| inline const ElemDDLGrantee *getOwner() const; |
| // returns pointer to the optional "by owner" |
| // (in the form of an ElemDDLGrantee). |
| |
| // |
| // mutators |
| // |
| |
| void incrCurViewColNum(); |
| |
| inline void resetCurViewColNum(); |
| |
| virtual void setChild(Lng32 index, ExprNode * pChildNode); |
| |
| inline void setCurViewColNum(const CollIndex curVwCol); // for Binder use |
| |
| inline void setItmColRefInColInRowValsFlag(const NABoolean // for Binder |
| isItmColRef); // use only |
| inline void setEndPosition(const StringPos endPos); |
| |
| // sets the ending position (the position of the |
| // last character) of the statement (within the |
| // input string) |
| |
| inline void setStartPosition(const StringPos startPos); |
| |
| // sets the starting position (the position of the |
| // first character) of the statement (within the |
| // input string) |
| |
| // |
| // method for binding |
| // |
| |
| ExprNode * bindNode(BindWA *bindWAPtr); |
| |
| // method for collecting information |
| void synthesize(); |
| |
| // collects information in the parse sub-tree and |
| // copy/move them to the current parse node. |
| |
| // |
| // methods for tracing |
| // |
| |
| virtual const NAString displayLabel1() const; |
| virtual const NAString displayLabel2() const; |
| virtual const NAString displayLabel3() const; |
| virtual NATraceList getDetailInfo() const; |
| virtual const NAString getText() const; |
| |
| |
| private: |
| |
| // --------------------------------------------------------------------- |
| // private methods |
| // --------------------------------------------------------------------- |
| |
| // |
| // default constructor |
| // |
| |
| StmtDDLCreateView(); // DO NOT USE |
| |
| // |
| // assignment operator |
| // |
| |
| StmtDDLCreateView & operator==(const StmtDDLCreateView &rhs); // DO NOT USE |
| |
| // --------------------------------------------------------------------- |
| // private data members |
| // --------------------------------------------------------------------- |
| |
| QualifiedName viewQualName_; |
| |
| // |
| // information extracted from View Column List parse sub-tree |
| // |
| |
| ElemDDLColViewDefArray columnDefArray_; |
| |
| // |
| // information extracted from the optional LOCATION clause |
| // |
| |
| NABoolean isLocationClauseSpec_; |
| NAString locationName_; |
| ElemDDLLocation::locationNameTypeEnum locationNameType_; |
| |
| ComCreateViewBehavior createViewBehavior_; |
| |
| // |
| // information derived from With Check Option (child) parse node |
| // |
| |
| ComLevels checkOptionLevel_; |
| |
| // |
| // information about the position of the name within the input |
| // string (to help with computing the view text) |
| // |
| |
| ParNameLocList nameLocList_; |
| StringPos startPos_; |
| StringPos endPos_; |
| |
| // |
| // Updatable/insertable flags, set by Bind/Transform step |
| // |
| |
| NABoolean isUpdatable_; |
| NABoolean isInsertable_; |
| |
| // |
| // view usages information |
| // |
| |
| ParViewUsages viewUsages_; |
| |
| // |
| // pointers to child parse nodes |
| // |
| |
| ElemDDLNode * pViewColumnList_; |
| ElemDDLNode * pLocationClause_; |
| RelExpr * pQueryExpression_; |
| ElemDDLNode * pWithCheckOption_; |
| |
| ElemDDLGrantee * pOwner_; |
| // All UDF's referenced in a statement |
| // -------------------------------------------------------------------- |
| LIST(OptUDFInfo *) udfList_; |
| |
| }; // class StmtDDLCreateView |
| |
| |
| // ----------------------------------------------------------------------- |
| // definitions of inline methods for class ParViewTableColsUsage |
| // ----------------------------------------------------------------------- |
| |
| // |
| // accessors |
| // |
| |
| inline const NAString & |
| ParViewTableColsUsage::getColumnName() const |
| { |
| return columnName_; |
| } |
| |
| inline const ExtendedQualName & |
| ParViewTableColsUsage::getTableQualName() const |
| { |
| return tableName_; |
| } |
| |
| // |
| // mutators |
| // |
| |
| inline void |
| ParViewTableColsUsage::setColumnName(const NAString &colName) |
| { |
| columnName_ = colName; |
| } |
| |
| inline void |
| ParViewTableColsUsage::setTableName(const ExtendedQualName &tableQualName) |
| { |
| tableName_ = tableQualName; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // definitions of inline methods for class ParViewTableColsUsageList |
| // ----------------------------------------------------------------------- |
| |
| // |
| // operators |
| // |
| |
| inline const ParViewTableColsUsage & |
| ParViewTableColsUsageList::operator[](CollIndex index) const |
| { |
| return *(LIST(ParViewTableColsUsage *)::operator[](index)); |
| } |
| |
| inline ParViewTableColsUsage & |
| ParViewTableColsUsageList::operator[](CollIndex index) |
| { |
| return *(LIST(ParViewTableColsUsage *)::operator[](index)); |
| } |
| |
| // |
| // accessors |
| // |
| |
| inline CollIndex |
| ParViewTableColsUsageList::entries() const |
| { |
| return LIST(ParViewTableColsUsage *)::entries(); |
| } |
| |
| inline const ParViewTableColsUsage * const |
| ParViewTableColsUsageList::find(const ColRefName &colName) const |
| { |
| return ((ParViewTableColsUsageList *)this)->find(colName); |
| } |
| |
| // ----------------------------------------------------------------------- |
| // definitions of inline methods for class ViewColTablesUsage |
| // ----------------------------------------------------------------------- |
| |
| // |
| // accessors |
| // |
| |
| inline const CollIndex |
| ParViewColTablesUsage::getUsingViewColumnNumber() const |
| { |
| return usingViewColumnNumber_; |
| } |
| |
| inline const ExtendedQualName & |
| ParViewColTablesUsage::getUsedObjectName() const |
| { |
| return usedObjectName_; |
| } |
| |
| // |
| // mutators |
| // |
| |
| inline void |
| ParViewColTablesUsage::setUsingViewColumnNumber(const CollIndex usingColNum) |
| { |
| usingViewColumnNumber_ = usingColNum; |
| } |
| |
| inline void |
| ParViewColTablesUsage::setUsedObjectName(const ExtendedQualName &usedObjName) |
| { |
| usedObjectName_ = usedObjName; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // definitions of inline methods for class ParViewColTablesUsageList |
| // ----------------------------------------------------------------------- |
| |
| inline CollIndex |
| ParViewColTablesUsageList::entries() const |
| { |
| return LIST(ParViewColTablesUsage *)::entries(); |
| } |
| |
| inline const ParViewColTablesUsage & |
| ParViewColTablesUsageList::operator[](CollIndex index) const |
| { |
| return *(LIST(ParViewColTablesUsage *)::operator[](index)); |
| } |
| |
| inline ParViewColTablesUsage & |
| ParViewColTablesUsageList::operator[](CollIndex index) |
| { |
| return *(LIST(ParViewColTablesUsage *)::operator[](index)); |
| } |
| |
| // ----------------------------------------------------------------------- |
| // definitions of inline methods for class ViewColTableColsUsage |
| // ----------------------------------------------------------------------- |
| |
| // |
| // accessors |
| // |
| |
| inline const CollIndex |
| ParViewColTableColsUsage::getUsingViewColumnNumber() const |
| { |
| return usingViewColumnNumber_; |
| } |
| |
| inline const ColRefName & |
| ParViewColTableColsUsage::getUsedObjectColumnName() const |
| { |
| return usedObjectColumnName_; |
| } |
| |
| // |
| // mutators |
| // |
| |
| inline void |
| ParViewColTableColsUsage::setUsingViewColumnNumber(const CollIndex colNum) |
| { |
| usingViewColumnNumber_ = colNum; |
| } |
| |
| inline void |
| ParViewColTableColsUsage::setUsedObjectColumnName(const ColRefName &colRefName) |
| { |
| usedObjectColumnName_ = colRefName; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // definitions of inline methods for class ParViewColTableColsUsageList |
| // ----------------------------------------------------------------------- |
| |
| // |
| // operators |
| // |
| |
| inline const ParViewColTableColsUsage & |
| ParViewColTableColsUsageList::operator[](CollIndex index) const |
| { |
| return *(LIST(ParViewColTableColsUsage *)::operator[](index)); |
| } |
| |
| inline ParViewColTableColsUsage & |
| ParViewColTableColsUsageList::operator[](CollIndex index) |
| { |
| return *(LIST(ParViewColTableColsUsage *)::operator[](index)); |
| } |
| |
| // |
| // accessors |
| // |
| |
| inline CollIndex |
| ParViewColTableColsUsageList::entries() const |
| { |
| return LIST(ParViewColTableColsUsage *)::entries(); |
| } |
| |
| inline const ParViewColTableColsUsage * const |
| ParViewColTableColsUsageList::find(const CollIndex usingViewColNum) const |
| { |
| return ((ParViewColTableColsUsageList *)this)->find(usingViewColNum); |
| } |
| |
| inline const ParViewColTableColsUsage * const |
| ParViewColTableColsUsageList::find(const CollIndex usingViewColNum, |
| const ColRefName &usedColRefName) const |
| { |
| return ((ParViewColTableColsUsageList *)this)->find(usingViewColNum, |
| usedColRefName); |
| } |
| |
| // ----------------------------------------------------------------------- |
| // definitions of inline methods for class ParViewUsages |
| // ----------------------------------------------------------------------- |
| |
| // |
| // accessors |
| // |
| |
| inline CollIndex |
| ParViewUsages::getCurViewColNum() const |
| { |
| return curViewColNum_; |
| } |
| |
| inline const ExtendedQualName * |
| ParViewUsages::getUsedTableNamePtr(const ExtendedQualName &tableName) const |
| { |
| return usedTableNameList_.find(tableName); |
| } |
| |
| inline const ParViewTableColsUsageList & |
| ParViewUsages::getViewTableColsUsageList() const |
| { |
| return usedColRefList_; |
| } |
| |
| inline ParViewTableColsUsageList & |
| ParViewUsages::getViewTableColsUsageList() |
| { |
| return usedColRefList_; |
| } |
| |
| inline const ParTableUsageList & |
| ParViewUsages::getViewTableUsageList() const |
| { |
| return usedTableNameList_; |
| } |
| |
| inline ParTableUsageList & |
| ParViewUsages::getViewTableUsageList() |
| { |
| return usedTableNameList_; |
| } |
| |
| inline const ParViewColTablesUsageList & |
| ParViewUsages::getViewColTablesUsageList() const |
| { |
| return viewColTablesUsageList_; |
| } |
| |
| inline ParViewColTablesUsageList & |
| ParViewUsages::getViewColTablesUsageList() |
| { |
| return viewColTablesUsageList_; |
| } |
| |
| |
| #if 0 // KSKSKS |
| |
| inline const ParViewColTableColsUsageList & |
| ParViewUsages::getViewColTableColsUsageList() const |
| { |
| return viewColTableColsUsageList_; |
| } |
| |
| inline ParViewColTableColsUsageList & |
| ParViewUsages::getViewColTableColsUsageList() |
| { |
| return viewColTableColsUsageList_; |
| } |
| |
| #endif // KSKSKS |
| |
| |
| inline NABoolean |
| ParViewUsages::isItmColRefInColInRowVals() const |
| { |
| return isItmColRefInColInRowVals_; |
| } |
| |
| inline NABoolean |
| ParViewUsages::isViewSurelyNotUpdatable() const |
| { |
| return isViewSurelyNotUpdatable_; |
| } |
| |
| // |
| // mutators |
| // |
| |
| inline void |
| ParViewUsages::setCurViewColNum(const CollIndex curVwCol) |
| { |
| curViewColNum_ = curVwCol; |
| } |
| |
| inline void |
| ParViewUsages::setItmColRefInColInRowValsFlag(const NABoolean isItmColRef) |
| { |
| isItmColRefInColInRowVals_ = isItmColRef; |
| } |
| |
| inline void |
| ParViewUsages::setViewIsSurelyNotUpdatableFlag() |
| { |
| isViewSurelyNotUpdatable_ = TRUE; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // definitions of inline methods for class StmtDDLCreateView |
| // ----------------------------------------------------------------------- |
| |
| // |
| // accessors |
| // |
| |
| inline QualifiedName & |
| StmtDDLCreateView::getViewNameAsQualifiedName() |
| { |
| return viewQualName_; |
| } |
| |
| inline const QualifiedName & |
| StmtDDLCreateView::getViewNameAsQualifiedName() const |
| { |
| return viewQualName_; |
| } |
| |
| inline ComLevels |
| StmtDDLCreateView::getCheckOptionLevel() const |
| { |
| return checkOptionLevel_; |
| } |
| |
| inline CollIndex |
| StmtDDLCreateView::getCurViewColNum() const |
| { |
| return getViewUsages().getCurViewColNum(); |
| } |
| |
| inline const StringPos |
| StmtDDLCreateView::getEndPosition() const |
| { |
| return endPos_; |
| } |
| |
| inline const NAString & |
| StmtDDLCreateView::getLocation() const |
| { |
| return locationName_; |
| } |
| |
| inline ElemDDLLocation::locationNameTypeEnum |
| StmtDDLCreateView::getLocationNameType() const |
| { |
| return locationNameType_; |
| } |
| |
| inline const ParNameLocList & |
| StmtDDLCreateView::getNameLocList() const |
| { |
| return nameLocList_; |
| } |
| |
| inline ParNameLocList & |
| StmtDDLCreateView::getNameLocList() |
| { |
| return nameLocList_; |
| } |
| |
| inline const NABoolean |
| StmtDDLCreateView::isCreateView() const |
| { |
| if(createViewBehavior_ == COM_CREATE_VIEW_BEHAVIOR) |
| return TRUE; |
| else |
| return FALSE; |
| } |
| |
| inline const NABoolean |
| StmtDDLCreateView::isCreateSystemView() const |
| { |
| if(createViewBehavior_ == COM_CREATE_SYSTEM_VIEW_BEHAVIOR) |
| return TRUE; |
| else |
| return FALSE; |
| |
| } |
| |
| inline const NABoolean |
| StmtDDLCreateView::isCreateOrReplaceView() const |
| { |
| if(createViewBehavior_ == COM_CREATE_OR_REPLACE_VIEW_BEHAVIOR) |
| return TRUE; |
| else |
| return FALSE; |
| |
| } |
| |
| inline const NABoolean |
| StmtDDLCreateView::isCreateOrReplaceViewCascade() const |
| { |
| if(createViewBehavior_ == COM_CREATE_OR_REPLACE_VIEW_CASCADE_BEHAVIOR) |
| return TRUE; |
| else |
| return FALSE; |
| |
| } |
| |
| inline const ComCreateViewBehavior |
| StmtDDLCreateView::getCreateViewBehavior() const |
| { |
| return createViewBehavior_; |
| } |
| |
| inline const RelExpr * |
| StmtDDLCreateView::getQueryExpression() const |
| { |
| return pQueryExpression_; |
| } |
| |
| inline RelExpr * |
| StmtDDLCreateView::getQueryExpression() |
| { |
| return pQueryExpression_; |
| } |
| |
| inline const StringPos |
| StmtDDLCreateView::getStartPosition() const |
| { |
| return startPos_; |
| } |
| |
| inline const ElemDDLColViewDefArray & |
| StmtDDLCreateView::getViewColDefArray() const |
| { |
| return columnDefArray_; |
| } |
| |
| inline ElemDDLColViewDefArray & |
| StmtDDLCreateView::getViewColDefArray() |
| { |
| return columnDefArray_; |
| } |
| |
| inline const NAString |
| StmtDDLCreateView::getViewName() const |
| { |
| return viewQualName_.getQualifiedNameAsAnsiString(); |
| } |
| |
| inline const ParViewUsages & |
| StmtDDLCreateView::getViewUsages() const |
| { |
| return viewUsages_; |
| } |
| |
| inline ParViewUsages & |
| StmtDDLCreateView::getViewUsages() |
| { |
| return viewUsages_; |
| } |
| |
| inline const LIST(OptUDFInfo *) & |
| StmtDDLCreateView::getUDFList() const |
| { |
| return udfList_; |
| } |
| |
| inline LIST(OptUDFInfo *) & |
| StmtDDLCreateView::getUDFList() |
| { |
| return udfList_; |
| } |
| |
| inline NABoolean |
| StmtDDLCreateView::isItmColRefInColInRowVals() const |
| { |
| return getViewUsages().isItmColRefInColInRowVals(); |
| } |
| |
| // is location clause/phrase specified? |
| inline NABoolean |
| StmtDDLCreateView::isLocationSpecified() const |
| { |
| return isLocationClauseSpec_; |
| } |
| |
| inline NABoolean |
| StmtDDLCreateView::isProcessingViewColList() const |
| { |
| return getCurViewColNum() NEQ NULL_COLL_INDEX; |
| } |
| |
| inline NABoolean |
| StmtDDLCreateView::isWithCheckOptionSpecified() const |
| { |
| if (pWithCheckOption_ NEQ NULL) |
| { |
| return TRUE; |
| } |
| else |
| { |
| return FALSE; |
| } |
| } |
| |
| inline NABoolean |
| StmtDDLCreateView::isOwnerSpecified() const |
| { |
| return pOwner_ ? TRUE : FALSE; |
| } |
| |
| inline const ElemDDLGrantee * |
| StmtDDLCreateView::getOwner() const |
| { |
| return pOwner_; |
| } |
| |
| // |
| // mutators |
| // |
| |
| inline void |
| StmtDDLCreateView::resetCurViewColNum() |
| { |
| getViewUsages().setCurViewColNum(NULL_COLL_INDEX); |
| } |
| |
| inline void |
| StmtDDLCreateView::setCurViewColNum(const CollIndex curVwCol) |
| { |
| getViewUsages().setCurViewColNum(curVwCol); |
| } |
| |
| inline void |
| StmtDDLCreateView::setEndPosition(const StringPos endPos) |
| { |
| endPos_ = endPos; |
| } |
| |
| inline void |
| StmtDDLCreateView::setItmColRefInColInRowValsFlag(const NABoolean isItmColRef) |
| { |
| getViewUsages().setItmColRefInColInRowValsFlag(isItmColRef); |
| } |
| |
| inline void |
| StmtDDLCreateView::setStartPosition(const StringPos startPos) |
| { |
| startPos_ = startPos; |
| } |
| |
| #endif // STMTDDLCREATEVIEW_H |