core/sql/parser/StmtDDLCreateMV.h

/**********************************************************************
// @@@ 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 STMTDDLCREATEMV_H
#define STMTDDLCREATEMV_H
/* -*-C++-*-
 *****************************************************************************
 *
 * File:         StmtDDLCreateMV.h
 * Description:  class for parse nodes representing Create Materialized View
 *               statements
 *
 * Created:      6/11/99
 * Language:     C++
 *
 *
 *
 *
 *****************************************************************************
 */

#include "ComASSERT.h"
#include "ComOperators.h"
#include "ComSmallDefs.h"
#include "NABoolean.h"
#include "ObjectNames.h"
#include "ElemDDLColViewDefArray.h"
#include "ElemDDLDivisionClause.h"
#include "ParNameLocList.h"
#include "ParTableUsageList.h"
#include "RelExpr.h"
#include "StmtDDLNode.h"
#include "MVInfo.h"
#include "StmtDDLCreateView.h" // for ParViewUsages
#include "ElemDDLCreateMVOneAttributeTableList.h"
//#include "..\catman\CatExecCreateMV.h"

// MV Initialization types
enum MvInitializationType {
  MVINIT_EMPTY = 0,
  MVINIT_ON_CREATE,
  MVINIT_ON_REFRESH,
  MVINIT_NO_INIT,
  MVINIT_BY_USER
};

// -----------------------------------------------------------------------
// contents of this file
// -----------------------------------------------------------------------
class StmtDDLCreateMV;

// -----------------------------------------------------------------------
// forward declerations
// -----------------------------------------------------------------------
class CatExecCreateMV;
// -----------------------------------------------------------------------
// Create Materialized View statement
// -----------------------------------------------------------------------
class StmtDDLCreateMV : public StmtDDLNode
{

public:

  // constructor
  StmtDDLCreateMV(const QualifiedName  & MVQualName,
		  const ParNameLocList & nameLocList,
		  ElemDDLNode          * optionalMVColumnList,
		  ComMVRefreshType     refreshType,
		  ElemDDLNode		   * pAttributeTableLists, 
//		  ComMVStatus          mvStatus,
                  MvInitializationType initType,
		  ComBoolean           isRewriteEnabled,
		  ElemDDLNode          * optionalFileOptionsClause,
		  RelExpr              * queryExpression,
                  ElemDDLNode          * pOptionalOwner,
		  CollHeap             * heap = PARSERHEAP());

  // virtual destructor
  virtual ~StmtDDLCreateMV();

  // cast
  virtual StmtDDLCreateMV * castToStmtDDLCreateMV();

  // pointers to child parse nodes (getChild and setChild methods)
  enum { INDEX_MV_COLUMN_LIST = 0,
	     MV_COLUMN_LIST = INDEX_MV_COLUMN_LIST,
         INDEX_FILE_OPTIONS_CLAUSE,
	     FILE_OPTIONS_CLAUSE = INDEX_FILE_OPTIONS_CLAUSE,
         INDEX_QUERY_EXPRESSION,
	     QUERY_EXPRESSION = INDEX_QUERY_EXPRESSION,
         MAX_STMT_DDL_CREATE_MV_ARITY };

	friend class CatExecCreateMV;

  //
  // accessors
  //

  // Return the internal MVInfo object
  inline  MVInfoForDDL * getMVInfo() { return theMVInfo_ ; }

  virtual Int32 getArity() const;

  virtual ExprNode * getChild(Lng32 index);

  inline CollIndex getCurViewColNum() const;  // for Binder use only

  inline const ParNameLocList & getNameLocList() const;   // XXX
  inline       ParNameLocList & getNameLocList();         // XXX

  // returns the UDF usage list
  inline const LIST(OptUDFInfo *) &getUDFList() const;
  inline       LIST(OptUDFInfo *) &getUDFList();

  // returns a list of locations of names appearing in
  // the statement input string.  The list helps with
  // the computing of the MV text.

  inline ElemDDLNode	  * getOptionalColumnNames();
  inline ElemDDLNode	  * getFileOptions();
  inline ElemDDLStoreOptKeyColumnList  * getStoreByOption() const;

  // returns the pointer pointing to the (optional) sub-tree
  // for the file options

  inline const RelExpr * getQueryExpression() const;
  inline       RelExpr * getQueryExpression();

  // returns the pointer pointing to the parse sub-tree
  // representing the query expression in the MV definition.
  
  // ------------------------------------------------------------------
  // Get (internally stored) various positions within the input string
  // ------------------------------------------------------------------
  inline const StringPos getEndPosition() const;

        // returns the ending position (the position of the
        // last character) of the statement (within the input
        // string)
  
  inline const StringPos getStartPosition() const;

        // returns the starting position (the position of the
        // first character) of the statement (within the
        // input string)
  
  inline const StringPos getEndOfOptionalColumnListPosition() const;

        // returns the end position (the position of the "after the last"
        // character) of the "optional MV column list" clause (within the
        // input string)

  inline const StringPos getStartOfFileOptionsPosition() const;
  inline const StringPos getEndOfFileOptionsPosition() const;

        // returns the start/end positions of the "optional file options" 
        // clause (within the input string)

  inline const StringPos getEndOfSelectColumnListPosition() const;

        // returns the end position (the position of the "after the last"
        // character) of the "select column list" of the MV stmt (within
        // the input string)

  inline const StringPos getStartOfMVQueryPosition() const;

        // returns the start position of the MV query (just before SELECT)
        // (within the input string)

  // ------------------------------------------------------------------

  inline const ElemDDLColViewDefArray & getMVColDefArray() const; // XXX
  inline       ElemDDLColViewDefArray & getMVColDefArray();       // XXX

        // returns an array of pointers pointing to the Column Name parse
        // nodes.  If the Optional MV Column Name List phrase is not
        // specified in the Create View statement, returns an empty array.

  inline const NAString getMVName() const;

        // returns the name of the defined MV.

  inline const QualifiedName & getMVNameAsQualifiedName() const;
  inline       QualifiedName & getMVNameAsQualifiedName();

        // returns the name of the defined MV in QualifiedName format

  inline const ParViewUsages & getViewUsages() const;
  inline       ParViewUsages & getViewUsages();

        // returns the view usages information after the parse
        // node is bound; returns an empty object otherwise.

  ElemDDLCreateMVOneAttributeTableList * getIgnoreChangesList() 
										{ return pIgnoreChangesList_; }

  
  inline NABoolean isItmColRefInColInRowVals() const;  // for Binder use only

  inline NABoolean isProcessingViewColList() const;

        // This method is used during the Binding phase to help
        // with collecting view column usage information

  ComMvAuditType getMvAuditType() {return mvAuditType_;}
  ULng32 getCommitEachNRows() {return commitEachNRows_;}

  ComBoolean getIsStoreByOptionSpecified() {return isStoreByClauseSpecified_;}

  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).

  inline NABoolean isDivisionClauseSpecified() const;

        // returns TRUE if the DIVISION BY clause appears;
        // returns FALSE otherwise.

  inline ElemDDLDivisionClause::divisionTypeEnum getDivisionType() const;
  inline ItemExprList * getDivisionExprList();
  inline ElemDDLDivisionClause * getDivisionClause();

  //
  // 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)

  inline void setEndOptionalColumnListPosition(const StringPos endPos);

        // sets the end position (the position of the "after the last"
        // character) of the "optional view column list" clause (within the
        // input string)

  inline void setFileOptionsPositions(const StringPos startPos,
				      const StringPos endPos);

        // sets the start + end positions of the "optional file options" 
        // clause (within the input string)

  inline void setEndSelectColumnListPosition(const StringPos endPos);

        // sets the end position (the position of the "after the last"
        // character) of the "select column list" clause (within the
        // input string)

  inline void setStartOfMVQueryPosition(const StringPos startPos);

        // sets the start position of the MV query (within the input string)

  inline const ElemDDLColRefArray & getPartitionKeyColRefArray() const;
  inline       ElemDDLColRefArray & getPartitionKeyColRefArray();
        // get the MV partition columns specified by the user

  //
  // 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.

	// CHANGES CLAUSE
	void processAttributeTableLists();
	NABoolean statementHasAttributeTableLists();

	NABoolean hasIgnoreChangesList() {return !!pIgnoreChangesList_;}

	NABoolean isPartitionByClauseSpecified () { return isPartitionByClauseSpecified_; }
        NABoolean isPartitionDefinitionSpecified () { return isPartitionDefinitionSpecified_; }

	// check FILE OPTIONS sub tree. 
	void ensureCorrectMVFileOptions();
	void checkFileOption(ElemDDLNode * pTableOption);
	void checkStoreByClause(ElemDDLStoreOpt*);
	void checkFileAttributeClause(ElemDDLFileAttrClause*);
	void checkFileAttribute(ElemDDLFileAttr*);
	void checkLocationClause(ElemDDLLocation*);
	void checkDivisionByClause(ElemDDLDivisionClause *);

	void checkPartitionDefinitionclause(ElemDDLPartitionClause*);
	void checkMVFileAttributeClause(ElemDDLMVFileAttrClause *);

	void extractMvAttributesFromFileOptions();

  //
  // methods for tracing
  //
  
  virtual const NAString displayLabel1() const;
  virtual NATraceList getDetailInfo() const;
  virtual const NAString getText() const;

  virtual NABoolean explainSupported() { return TRUE; }

private:

  // ---------------------------------------------------------------------
  // private methods
  // ---------------------------------------------------------------------

  //
  // default constructor
  //
  
  StmtDDLCreateMV();  // DO NOT USE

  //
  // assignment operator
  //

  StmtDDLCreateMV & operator==(const StmtDDLCreateMV &rhs);  // DO NOT USE 
  
  // ---------------------------------------------------------------------
  // private data members
  // ---------------------------------------------------------------------

  QualifiedName MVQualName_;

  ComMVRefreshType refreshType_;
  ElemDDLNode * pAttributeTableLists_;
  ElemDDLCreateMVOneAttributeTableList * pIgnoreChangesList_;

  //
  // information extracted from View Column List parse sub-tree
  //

  ElemDDLColViewDefArray columnDefArray_;
  
  //
  // information about the position of the name within the input
  // string (to help with computing the view text)
  //

  ParNameLocList nameLocList_;
  StringPos startPos_;
  StringPos endPos_;

  StringPos endOfOptionalColumnList_;
  StringPos startOfFileOptions_;
  StringPos endOfFileOptions_;
  StringPos startOfMVQuery_;
  StringPos endOfSelectColumnList_;

  //
  //  The MVInfo internal object
  //
  MVInfoForDDL * theMVInfo_ ;

  //
  // view usages information
  //

  ParViewUsages viewUsages_;

  //
  // indicators for indicating a clause has already been specified
  //
  
  NABoolean isAttrClauseSpecified_;
  NABoolean isLocationClauseSpecified_; 
  NABoolean isDivisionByClauseSpecified_;
  ElemDDLDivisionClause * pDivisionByClauseParseNode_;
  NABoolean isPartitionDefinitionSpecified_;     // for any HASH(2) PARTITION clauses
  NABoolean isPartitionByClauseSpecified_;       // for HASH(2) PARTITION BY clause
  NABoolean isStoreByClauseSpecified_; 
  NABoolean	isMVAttributeClauseSpecified_;

  // MVATTRIBUTES
  ComMvAuditType mvAuditType_;
  ULng32 commitEachNRows_;
  
  //
  // pointers to child parse nodes
  //
 
  ElemDDLNode			*pMVColumnList_;
  ElemDDLNode			*pFileOptions_;
  ElemDDLStoreOptKeyColumnList	*pStoreByOption_;
  RelExpr			*pQueryExpression_;

  // PARTITION BY clause
  ElemDDLColRefArray             partitionKeyColRefArray_;

  ElemDDLGrantee * pOwner_;

  // --------------------------------------------------------------------
  // All UDF's referenced in a statement
  // --------------------------------------------------------------------
  LIST(OptUDFInfo *) udfList_;

}; // class StmtDDLCreateMV


// -----------------------------------------------------------------------
// definitions of inline methods for class StmtDDLCreateMV
// -----------------------------------------------------------------------

//
// accessors
//

inline QualifiedName &
StmtDDLCreateMV::getMVNameAsQualifiedName()
{
  return MVQualName_;
}

inline const QualifiedName & 
StmtDDLCreateMV::getMVNameAsQualifiedName() const 
{
  return MVQualName_;
}

inline CollIndex
StmtDDLCreateMV::getCurViewColNum() const
{
  return getViewUsages().getCurViewColNum();
}

inline const StringPos
StmtDDLCreateMV::getEndPosition() const
{
  return endPos_;
}

inline const ParNameLocList &
StmtDDLCreateMV::getNameLocList() const
{
  return nameLocList_;
}

inline ParNameLocList &
StmtDDLCreateMV::getNameLocList()
{
  return nameLocList_;
}


inline  ElemDDLNode * 
StmtDDLCreateMV::getOptionalColumnNames()
{
  return pMVColumnList_;
}

inline  ElemDDLNode * 
StmtDDLCreateMV::getFileOptions()
{
  return pFileOptions_;
}

inline ElemDDLStoreOptKeyColumnList * 
StmtDDLCreateMV::getStoreByOption() const
{
  return pStoreByOption_;
}


inline const RelExpr *
StmtDDLCreateMV::getQueryExpression() const
{
  return pQueryExpression_;
}

inline RelExpr *
StmtDDLCreateMV::getQueryExpression()
{
  return pQueryExpression_;
}

inline const StringPos
StmtDDLCreateMV::getStartPosition() const
{
  return startPos_;
}

inline const ElemDDLColViewDefArray &
StmtDDLCreateMV::getMVColDefArray() const
{
  return columnDefArray_;
}

inline ElemDDLColViewDefArray &
StmtDDLCreateMV::getMVColDefArray()
{
  return columnDefArray_;
}

inline const NAString
StmtDDLCreateMV::getMVName() const
{
  return MVQualName_.getQualifiedNameAsAnsiString();
}

inline const ParViewUsages &
StmtDDLCreateMV::getViewUsages() const
{
  return viewUsages_;
}

inline ParViewUsages &
StmtDDLCreateMV::getViewUsages()
{
  return viewUsages_;
}

inline const LIST(OptUDFInfo *) &
StmtDDLCreateMV::getUDFList() const
{
  return udfList_;
}

inline LIST(OptUDFInfo *) &
StmtDDLCreateMV::getUDFList()
{
  return udfList_;
}

inline NABoolean
StmtDDLCreateMV::isItmColRefInColInRowVals() const
{
  return getViewUsages().isItmColRefInColInRowVals();
}

inline NABoolean
StmtDDLCreateMV::isProcessingViewColList() const
{
  return getCurViewColNum() NEQ NULL_COLL_INDEX;
}

//
// mutators
//

inline void
StmtDDLCreateMV::resetCurViewColNum()
{
  getViewUsages().setCurViewColNum(NULL_COLL_INDEX);
}

inline void
StmtDDLCreateMV::setCurViewColNum(const CollIndex curVwCol)
{
  getViewUsages().setCurViewColNum(curVwCol);
}

inline void
StmtDDLCreateMV::setEndPosition(const StringPos endPos)
{
  endPos_ = endPos;
}

inline void
StmtDDLCreateMV::setItmColRefInColInRowValsFlag(const NABoolean isItmColRef)
{
  getViewUsages().setItmColRefInColInRowValsFlag(isItmColRef);
}
inline void
StmtDDLCreateMV::setStartPosition(const StringPos startPos)
{
  startPos_ = startPos;
}
inline 
const StringPos StmtDDLCreateMV::getEndOfOptionalColumnListPosition() const
{
  return endOfOptionalColumnList_;
}
inline 
const StringPos StmtDDLCreateMV::getEndOfSelectColumnListPosition() const
{
  return endOfSelectColumnList_;
}
inline 
const StringPos StmtDDLCreateMV::getStartOfMVQueryPosition() const
{
  return startOfMVQuery_;
}
inline const StringPos StmtDDLCreateMV::getStartOfFileOptionsPosition() const
{
  return startOfFileOptions_;
}
inline const StringPos StmtDDLCreateMV::getEndOfFileOptionsPosition() const
{
  return endOfFileOptions_;
}


inline void 
StmtDDLCreateMV::setEndOptionalColumnListPosition(const StringPos endPos)
{
  endOfOptionalColumnList_ = endPos;
}

inline void 
StmtDDLCreateMV::setFileOptionsPositions(const StringPos startPos,
					 const StringPos endPos)
{
  startOfFileOptions_ = startPos;
  endOfFileOptions_ = endPos;
}

inline void 
StmtDDLCreateMV::setEndSelectColumnListPosition(const StringPos endPos)
{
  endOfSelectColumnList_ = endPos;
}
inline void 
StmtDDLCreateMV::setStartOfMVQueryPosition(const StringPos startPos)
{
  startOfMVQuery_ = startPos;
}

// get column name list in partition by clause
inline const ElemDDLColRefArray &
StmtDDLCreateMV::getPartitionKeyColRefArray() const
{
  return partitionKeyColRefArray_;
}

// get column name list in partition by clause
inline ElemDDLColRefArray &
StmtDDLCreateMV::getPartitionKeyColRefArray()
{
  return partitionKeyColRefArray_;
}

inline NABoolean
StmtDDLCreateMV::isOwnerSpecified() const
{
  return pOwner_ ? TRUE : FALSE;
}

inline const ElemDDLGrantee *
StmtDDLCreateMV::getOwner() const
{
  return pOwner_;
}

inline NABoolean StmtDDLCreateMV::isDivisionClauseSpecified() const
{
  return isDivisionByClauseSpecified_;
}

inline ElemDDLDivisionClause::divisionTypeEnum StmtDDLCreateMV::getDivisionType() const
{
  return ( pDivisionByClauseParseNode_ EQU NULL
           ? ElemDDLDivisionClause::UNKNOWN_DIVISION_TYPE
           : pDivisionByClauseParseNode_->getDivisionType() );
}

inline ElemDDLDivisionClause * StmtDDLCreateMV::getDivisionClause()
{
  return pDivisionByClauseParseNode_;
}

inline ItemExprList * StmtDDLCreateMV::getDivisionExprList()
{
  return ( pDivisionByClauseParseNode_ EQU NULL
           ? NULL
           : pDivisionByClauseParseNode_->getDivisionExprList() );
}

#endif // STMTDDLCREATEMV_H