/* -*-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 @@@
 *****************************************************************************
 *
 * File:         StmtDDLNode.C
 * Description:  member functions for classes StmtDDLNode, StmtDDLGrant,
 *               StmtDDLGrantArray, StmtDDLInitializeSQL, StmtDDLRevoke,
 *		 StmtDDLSchRevoke
 *
 * Created:      3/9/95
 * Language:     C++
 *
 *
 *
 *
 *****************************************************************************
 */

#include "BaseTypes.h"
#include "ComOperators.h"
#include "ElemDDLPrivileges.h"
#include "ElemDDLGrantee.h"
#include "StmtDDLNode.h"
#include "StmtDDLGrant.h"
#include "StmtDDLGrantComponentPrivilege.h"
#include "StmtDDLGrantArray.h"
#include "StmtDDLSchGrant.h"
#include "StmtDDLSchGrantArray.h"
#include "StmtDDLInitializeSQL.h"
#include "StmtDDLRevoke.h"
#include "StmtDDLSchRevoke.h"
#include "StmtDDLReInitializeSQL.h"

void
StmtDDLInitializeSQL_visitRegisterUserElement(ElemDDLNode * pInitSQLNode,
                                              CollIndex /* index */,
                                              ElemDDLNode * pElement);

// -----------------------------------------------------------------------
// member functions for class StmtDDLNode
// -----------------------------------------------------------------------

StmtDDLNode::StmtDDLNode(OperatorTypeEnum otype)
     : ElemDDLNode(otype),
       tableType_(COM_REGULAR_TABLE),
       objectClass_(COM_CLASS_USER_TABLE),
       isVolatile_(FALSE),
       exeUtil_(FALSE),
       isGhostObject_(FALSE),
       inMemoryObjectDefn_(FALSE),
       isExternal_(FALSE),
       isImplicitExternal_(FALSE),
       ddlXns_(FALSE)
{ 
  ddlXns_ = (CmpCommon::getDefault(DDL_TRANSACTIONS) == DF_ON);
}

// virtual destructor
// To improve performance, do not use inline with virtual destructor
StmtDDLNode::~StmtDDLNode()
{
}

//
// cast virtual functions
//

StmtDDLNode *
StmtDDLNode::castToStmtDDLNode()
{
  return this;
}

const StmtDDLNode *
StmtDDLNode::castToStmtDDLNode() const
{
  return this;
}

//
// methods for tracing
//

const NAString
StmtDDLNode::getText() const
{
  NAAbort("StmtDDLNode.C", __LINE__, "internal logic error");
  return "StmtDDLNode";
}

void
StmtDDLNode::unparse(NAString &result,
		     PhaseEnum /*phase*/,
                     UnparseFormatEnum /*form*/,
		     TableDesc * tabId) const
{
  result += "a DDL statement";
}

NABoolean StmtDDLNode::performParallelOp(Lng32 numPartitions)
{
  // PerformParallelOp
  NABoolean ppo = FALSE; 

  // The CQD USE_PARALLEL_FOR_NUM_PARTITIONS specifies the number of 
  // partitions that must exist before
  // performing the create in parallel.
  Lng32 numParts = CmpCommon::getDefaultLong(USE_PARALLEL_FOR_NUM_PARTITIONS);
  NAString pos;
  CmpCommon::getDefault(POS, pos, 0);
  
  // Parallel Create logic should be executed only if POS and 
  // ATTEMPT_ESP_PARALLELISM are not turned OFF and table involved has 
  // multiple partitions.
  if ((CmpCommon::getDefault(POS) != DF_OFF) && (!IsNAStringSpaceOrEmpty(pos))
      && (CmpCommon::getDefault(ATTEMPT_ESP_PARALLELISM) != DF_OFF) 
      && (numPartitions >= numParts) 
      && (numPartitions > 1))
    {
      // Check to see if parallel creation of labels is required
      // Parallel creations should not happen if POS_NUM_OF_PARTNS is set 
      // to 1 ( single partition table).
      
      if (CmpCommon::getDefault(POS_NUM_OF_PARTNS,0) == DF_SYSTEM ) 
	ppo = TRUE;
      else
	{  // Not DF_SYSTEM - get numeric POS_NUM_OF_PARTNS
	  Lng32 posnumpartns = CmpCommon::getDefaultLong(POS_NUM_OF_PARTNS);
	  if (posnumpartns > 1)
	    ppo = TRUE;
	}
    }  

  return ppo;
}

// -----------------------------------------------------------------------
// member functions for class StmtDDLGrant
// -----------------------------------------------------------------------

//
// constructor
//

StmtDDLGrant::StmtDDLGrant(ElemDDLNode * pPrivileges,
                           const QualifiedName & objectName,
                           ElemDDLNode * pGranteeList,
                           ElemDDLNode * pWithGrantOption,
                           ElemDDLNode * pByGrantorOption,
                           QualifiedName * actionName,
                           CollHeap    * heap)
: StmtDDLNode(DDL_GRANT),
  objectName_(heap),
  objectQualName_(objectName, heap),
  isAllPrivileges_(FALSE),
  isWithGrantOptionSpec_(FALSE),
  privActArray_(heap),
  actionQualName_(actionName),
  granteeArray_(heap),
  isByGrantorOptionSpec_(FALSE),
  byGrantor_(NULL)
{
  setChild(INDEX_PRIVILEGES, pPrivileges);
  setChild(INDEX_GRANTEE_LIST, pGranteeList);
  setChild(INDEX_WITH_GRANT_OPTION, pWithGrantOption);
  setChild(INDEX_BY_GRANTOR_OPTION, pByGrantorOption);
  origObjectName_ = objectQualName_.getQualifiedNameAsAnsiString();
  objectName_ = objectQualName_.getQualifiedNameAsAnsiString();
  //
  // inserts pointers to parse nodes representing privilege
  // actions to privActArray_ so the user can access the
  // information about privilege actions easier.
  //

  ComASSERT(pPrivileges NEQ NULL);
  ElemDDLPrivileges * pPrivsNode = pPrivileges->castToElemDDLPrivileges();
  ComASSERT(pPrivsNode NEQ NULL);
  if (pPrivsNode->isAllPrivileges())
  {
    isAllPrivileges_ = TRUE;
  }
  else
  {
    ElemDDLNode * pPrivActs = pPrivsNode->getPrivilegeActionList();
    for (CollIndex i = 0; i < pPrivActs->entries(); i++)
    {
      ElemDDLPrivAct *pPrivAct = (*pPrivActs)[i]->castToElemDDLPrivAct();
      privActArray_.insert(pPrivAct);
      if (pPrivAct->isDDLPriv())
         privActArray_.setHasDDLPriv(TRUE);
    }
  }

  //
  // copies pointers to parse nodes representing grantee
  // to granteeArray_ so the user can access the information
  // easier.
  //

  ComASSERT(pGranteeList NEQ NULL);
  for (CollIndex i = 0; i < pGranteeList->entries(); i++)
  {
    granteeArray_.insert((*pGranteeList)[i]->castToElemDDLGrantee());
  }

  //
  // looks for With Grant option phrase
  //
  
  if (pWithGrantOption NEQ NULL)
  {
    isWithGrantOptionSpec_ = TRUE;
  }
  
  if ( pByGrantorOption NEQ NULL )
  {
    isByGrantorOptionSpec_ = TRUE;
    byGrantor_ = pByGrantorOption->castToElemDDLGrantee();
  }


} // StmtDDLGrant::StmtDDLGrant()

// virtual destructor
StmtDDLGrant::~StmtDDLGrant()
{
  // delete all children
  for (Int32 i = 0; i < getArity(); i++)
  {
    delete getChild(i);
  }
}

// cast
StmtDDLGrant *
StmtDDLGrant::castToStmtDDLGrant()
{
  return this;
}

//
// accessors
//

Int32
StmtDDLGrant::getArity() const
{
  return MAX_STMT_DDL_GRANT_ARITY;
}

ExprNode *
StmtDDLGrant::getChild(Lng32 index) 
{
  ComASSERT(index >= 0 AND index < getArity());
  return children_[index];
}

//
// mutators
//

void
StmtDDLGrant::setChild(Lng32 index, ExprNode * pChildNode)
{
  ComASSERT(index >= 0 AND index < getArity());
  if (pChildNode NEQ NULL)
  {
    ComASSERT(pChildNode->castToElemDDLNode() NEQ NULL);
    children_[index] = pChildNode->castToElemDDLNode(); 
  }
  else
  {
    children_[index] = NULL;
  }
}

//
// methods for tracing
//

const NAString
StmtDDLGrant::displayLabel1() const
{
  return NAString("Object name: ") + getObjectName();
}

NATraceList
StmtDDLGrant::getDetailInfo() const
{
  NAString        detailText;
  NATraceList detailTextList;

  //
  // object name
  //

  detailTextList.append(displayLabel1());   // object name

  //
  // privileges
  //

  StmtDDLGrant * localThis = (StmtDDLGrant *)this;

  detailTextList.append(localThis->getChild(INDEX_PRIVILEGES)
                                 ->castToElemDDLNode()
                                 ->castToElemDDLPrivileges()
                                 ->getDetailInfo());

  //
  // grantee list
  //

  const ElemDDLGranteeArray & granteeArray = getGranteeArray();

  detailText = "Grantee list [";
  detailText += LongToNAString((Lng32)granteeArray.entries());
  detailText += " element(s)]";
  detailTextList.append(detailText);

  for (CollIndex i = 0; i < granteeArray.entries(); i++)
  {
    detailText = "[grantee ";
    detailText += LongToNAString((Lng32)i);
    detailText += "]";
    detailTextList.append(detailText);
  
    ComASSERT(granteeArray[i] NEQ NULL AND
              granteeArray[i]->castToElemDDLGrantee() NEQ NULL);
    detailTextList.append("    ", granteeArray[i]->castToElemDDLGrantee()
                                                 ->getDetailInfo());
  }

  //
  // with grant option
  //

  detailText = "is with grant option? ";
  detailText += YesNo(localThis->getChild(INDEX_WITH_GRANT_OPTION) NEQ NULL);
  detailTextList.append(detailText);

  return detailTextList;

} // StmtDDLGrant::getDetailInfo

const NAString
StmtDDLGrant::getText() const
{
  return "StmtDDLGrant";
}

// -----------------------------------------------------------------------
// methods for class StmtDDLGrantArray
// -----------------------------------------------------------------------

// virtual destructor
StmtDDLGrantArray::~StmtDDLGrantArray()
{
}


// -----------------------------------------------------------------------
// member functions for class StmtDDLSchGrant
// -----------------------------------------------------------------------
StmtDDLSchGrant::StmtDDLSchGrant(ElemDDLNode * pPrivileges,
                           const ElemDDLSchemaName & aSchemaNameParseNode,
                           ElemDDLNode * pGranteeList,
                           ElemDDLNode * pWithGrantOption,
			   ElemDDLNode * pByGrantorOption,
                           CollHeap    * heap)
: StmtDDLNode(DDL_GRANT_SCHEMA),
  schemaName_(heap),
  schemaQualName_(aSchemaNameParseNode.getSchemaName(), heap),
  isAllDMLPrivileges_(FALSE),
  isAllDDLPrivileges_(FALSE),
  isAllOtherPrivileges_(FALSE),
  isWithGrantOptionSpec_(FALSE),
  privActArray_(heap),
  granteeArray_(heap),
  isByGrantorOptionSpec_(FALSE),
  byGrantor_(NULL)
{
  if (schemaQualName_.getSchemaName().isNull())
  {
    schemaQualName_ = ActiveSchemaDB()->getDefaultSchema();
  }
  setChild(INDEX_PRIVILEGES, pPrivileges);
  setChild(INDEX_GRANTEE_LIST, pGranteeList);
  setChild(INDEX_WITH_GRANT_OPTION, pWithGrantOption);
  setChild(INDEX_BY_GRANTOR_OPTION, pByGrantorOption);
  //objectName_ = objectQualName_.getQualifiedNameAsAnsiString();
  //
  // inserts pointers to parse nodes representing privilege
  // actions to privActArray_ so the user can access the
  // information about privilege actions easier.
  //

  ComASSERT(pPrivileges NEQ NULL);
  ElemDDLPrivileges * pPrivsNode = pPrivileges->castToElemDDLPrivileges();
  ComASSERT(pPrivsNode NEQ NULL);
  if (pPrivsNode->isAllPrivileges())
  {
    isAllDMLPrivileges_ = TRUE;
    isAllDDLPrivileges_ = TRUE;
    isAllOtherPrivileges_ = TRUE;
  }
  if (pPrivsNode->isAllDMLPrivileges())
  {
    isAllDMLPrivileges_ = TRUE;
  }
  if (pPrivsNode->isAllDDLPrivileges())
  {
    isAllDDLPrivileges_ = TRUE;
  }
  if (pPrivsNode->isAllOtherPrivileges())
  {
    isAllOtherPrivileges_ = TRUE;
  }

  ElemDDLNode * pPrivActs = pPrivsNode->getPrivilegeActionList();
  if (pPrivActs)
  {
    for (CollIndex i = 0; i < pPrivActs->entries(); i++)
    {
      privActArray_.insert((*pPrivActs)[i]->castToElemDDLPrivAct());
    }
  }

  //
  // copies pointers to parse nodes representing grantee
  // to granteeArray_ so the user can access the information
  // easier.
  //

  ComASSERT(pGranteeList NEQ NULL);
  for (CollIndex i = 0; i < pGranteeList->entries(); i++)
  {
    granteeArray_.insert((*pGranteeList)[i]->castToElemDDLGrantee());
  }

  //
  // looks for With Grant option phrase
  //
  
  if (pWithGrantOption NEQ NULL)
  {
    isWithGrantOptionSpec_ = TRUE;
  }

  if ( pByGrantorOption NEQ NULL )
  {
    isByGrantorOptionSpec_ = TRUE;
    byGrantor_ = pByGrantorOption->castToElemDDLGrantee();
  }

} // StmtDDLSchGrant::StmtDDLSchGrant()

// virtual destructor
StmtDDLSchGrant::~StmtDDLSchGrant()
{
  // delete all children
  for (Int32 i = 0; i < getArity(); i++)
  {
    delete getChild(i);
  }
}

// cast
StmtDDLSchGrant *
StmtDDLSchGrant::castToStmtDDLSchGrant()
{
  return this;
}

//
// accessors
//

Int32
StmtDDLSchGrant::getArity() const
{
  return MAX_STMT_DDL_GRANT_ARITY;
}

ExprNode *
StmtDDLSchGrant::getChild(Lng32 index) 
{
  ComASSERT(index >= 0 AND index < getArity());
  return children_[index];
}

//
// mutators
//

void
StmtDDLSchGrant::setChild(Lng32 index, ExprNode * pChildNode)
{
  ComASSERT(index >= 0 AND index < getArity());
  if (pChildNode NEQ NULL)
  {
    ComASSERT(pChildNode->castToElemDDLNode() NEQ NULL);
    children_[index] = pChildNode->castToElemDDLNode(); 
  }
  else
  {
    children_[index] = NULL;
  }
}

//
// methods for tracing
//

const NAString
StmtDDLSchGrant::displayLabel1() const
{
  return NAString("Schema Name ") + getSchemaName();
}

NATraceList
StmtDDLSchGrant::getDetailInfo() const
{
  NAString        detailText;
  NATraceList detailTextList;

  //
  // object name
  //

  detailTextList.append(displayLabel1());   // object name

  //
  // privileges
  //

  StmtDDLSchGrant * localThis = (StmtDDLSchGrant *)this;

  detailTextList.append(localThis->getChild(INDEX_PRIVILEGES)
                                 ->castToElemDDLNode()
                                 ->castToElemDDLPrivileges()
                                 ->getDetailInfo());

  //
  // grantee list
  //

  const ElemDDLGranteeArray & granteeArray = getGranteeArray();

  detailText = "Grantee list [";
  detailText += LongToNAString((Lng32)granteeArray.entries());
  detailText += " element(s)]";
  detailTextList.append(detailText);

  for (CollIndex i = 0; i < granteeArray.entries(); i++)
  {
    detailText = "[grantee ";
    detailText += LongToNAString((Lng32)i);
    detailText += "]";
    detailTextList.append(detailText);
  
    ComASSERT(granteeArray[i] NEQ NULL AND
              granteeArray[i]->castToElemDDLGrantee() NEQ NULL);
    detailTextList.append("    ", granteeArray[i]->castToElemDDLGrantee()
                                                 ->getDetailInfo());
  }

  //
  // with grant option
  //

  detailText = "is with grant option? ";
  detailText += YesNo(localThis->getChild(INDEX_WITH_GRANT_OPTION) NEQ NULL);
  detailTextList.append(detailText);

  return detailTextList;

} // StmtDDLGrant::getDetailInfo

const NAString
StmtDDLSchGrant::getText() const
{
  return "StmtDDLSchGrant";
}

// -----------------------------------------------------------------------
// methods for class StmtDDLSchGrantArray
// -----------------------------------------------------------------------

// virtual destructor
StmtDDLSchGrantArray::~StmtDDLSchGrantArray()
{
}

// -----------------------------------------------------------------------
// methods for class StmtDDLGrantComponentPrivilege
// -----------------------------------------------------------------------

//
// constructor
//

StmtDDLGrantComponentPrivilege::StmtDDLGrantComponentPrivilege (const ConstStringList * pComponentPrivilegeNameList,
                                                                const NAString & componentName,
                                                                const NAString & userRoleName,
                                                                const NABoolean isWithGrantOptionClauseSpecified,
                                                                ElemDDLNode * pOptionalGrantedBy,
                                                                CollHeap * heap) // default is PARSERHEAP()
  : StmtDDLNode(DDL_GRANT_COMPONENT_PRIVILEGE),
    pComponentPrivilegeNameList_(pComponentPrivilegeNameList),
    componentName_(componentName, heap),
    userRoleName_(userRoleName, heap),
    isWithGrantOptionSpec_(isWithGrantOptionClauseSpecified),
    grantedBy_(NULL)
{
  if ( pOptionalGrantedBy NEQ NULL )
  {
    grantedBy_ = pOptionalGrantedBy->castToElemDDLGrantee();
  }
}

//
// virtual destructor
//

StmtDDLGrantComponentPrivilege::~StmtDDLGrantComponentPrivilege()
{
  if (pComponentPrivilegeNameList_ NEQ NULL)
    delete pComponentPrivilegeNameList_;
}

// virtual safe cast-down function
StmtDDLGrantComponentPrivilege *
StmtDDLGrantComponentPrivilege::castToStmtDDLGrantComponentPrivilege()
{
  return this;
}


//
// methods for tracing
//


const NAString StmtDDLGrantComponentPrivilege::displayLabel1() const
{
  NAString aLabel("Component name: ");
  aLabel += getComponentName();
  return aLabel;
}

const NAString StmtDDLGrantComponentPrivilege::displayLabel2() const
{
  NAString aLabel("User role name: ");
  aLabel += getUserRoleName();
  return aLabel;
}

NATraceList StmtDDLGrantComponentPrivilege::getDetailInfo() const
{
  NAString        detailText;
  NATraceList detailTextList;

  //
  // component name
  //

  detailTextList.append(displayLabel1());   // component name

  //
  // user role name
  //

  detailTextList.append(displayLabel2());   // user role name

  //
  // component privilege name list
  //

  const ConstStringList & privs = getComponentPrivilegeNameList();

  detailText = "Component Privilege Name List [";
  detailText += LongToNAString((Lng32)privs.entries());
  detailText += " element(s)]";
  detailTextList.append(detailText);

  for (CollIndex i = 0; i < privs.entries(); i++)
  {
    detailText = "[";
    detailText += LongToNAString((Lng32)i);
    detailText += "] ";
    detailText += *privs[i];
    detailTextList.append(detailText);
  }

  //
  // with grant option
  //

  detailText = "is with grant option? ";
  detailText += YesNo(isWithGrantOptionSpecified());
  detailTextList.append(detailText);

  return detailTextList;

} // StmtDDLGrantComponentPrivilege::getDetailInfo

const NAString StmtDDLGrantComponentPrivilege::getText()
{
  return "StmtDDLGrantComponentPrivilege";
}


// -----------------------------------------------------------------------
// methods for class StmtDDLRevokeComponentPrivilege
// -----------------------------------------------------------------------

//
// constructor
//

StmtDDLRevokeComponentPrivilege::StmtDDLRevokeComponentPrivilege (const ConstStringList * pComponentPrivilegeNameList,
                                                                  const NAString & componentName,
                                                                  const NAString & userRoleName,
                                                                  const NABoolean isGrantOptionForClauseSpecified,
                                                                  ElemDDLNode * pOptionalGrantedBy,
                                                                  CollHeap * heap) // default is PARSERHEAP()
  : StmtDDLNode(DDL_REVOKE_COMPONENT_PRIVILEGE),
    pComponentPrivilegeNameList_(pComponentPrivilegeNameList), // shallow copy
    componentName_(componentName, heap),                       // deep copy
    userRoleName_(userRoleName, heap),                         // deep copy
    isGrantOptionForSpec_(isGrantOptionForClauseSpecified),
    grantedBy_(NULL)
{
  if ( pOptionalGrantedBy NEQ NULL )
  {
    grantedBy_ = pOptionalGrantedBy->castToElemDDLGrantee();
  }
}

//
// virtual destructor
//

StmtDDLRevokeComponentPrivilege::~StmtDDLRevokeComponentPrivilege()
{
  if (pComponentPrivilegeNameList_ NEQ NULL)
    delete pComponentPrivilegeNameList_;
}

// virtual safe cast-down function
StmtDDLRevokeComponentPrivilege *
StmtDDLRevokeComponentPrivilege::castToStmtDDLRevokeComponentPrivilege()
{
  return this;
}

//
// methods for tracing
//


const NAString StmtDDLRevokeComponentPrivilege::displayLabel1() const
{
  NAString aLabel("Component name: ");
  aLabel += getComponentName();
  return aLabel;
}

const NAString StmtDDLRevokeComponentPrivilege::displayLabel2() const
{
  NAString aLabel("User rol name: ");
  aLabel += getUserRoleName();
  return aLabel;
}

NATraceList StmtDDLRevokeComponentPrivilege::getDetailInfo() const
{
  NAString        detailText;
  NATraceList detailTextList;

  //
  // component name
  //

  detailTextList.append(displayLabel1());   // component name

  //
  // user role name
  //

  detailTextList.append(displayLabel2());   // user role name

  //
  // component privilege name list
  //

  const ConstStringList & privs = getComponentPrivilegeNameList();

  detailText = "Component Privilege Name List [";
  detailText += LongToNAString((Lng32)privs.entries());
  detailText += " element(s)]";
  detailTextList.append(detailText);

  for (CollIndex i = 0; i < privs.entries(); i++)
  {
    detailText = "[";
    detailText += LongToNAString((Lng32)i);
    detailText += "] ";
    detailText += *privs[i];
    detailTextList.append(detailText);
  }

  //
  // with revoke option
  //

  detailText = "is Grant Option For clause specified? ";
  detailText += YesNo(isGrantOptionForSpecified());
  detailTextList.append(detailText);

  return detailTextList;

} // StmtDDLRevokeComponentPrivilege::getDetailInfo

const NAString StmtDDLRevokeComponentPrivilege::getText()
{
  return "StmtDDLRevokeComponentPrivilege";
}


// -----------------------------------------------------------------------
// methodsn for class StmtDDLReInitializeSQL
// -----------------------------------------------------------------------

//
// constructor 
//

StmtDDLReInitializeSQL::StmtDDLReInitializeSQL()
  : StmtDDLNode(DDL_REINITIALIZE_SQL)

{}

StmtDDLReInitializeSQL::~StmtDDLReInitializeSQL()
{}

const NAString
StmtDDLReInitializeSQL::getText() const
{
  return "StmtDDLReInitializeSQL";
}

//
// cast 
//

StmtDDLReInitializeSQL *
StmtDDLReInitializeSQL::castToStmtDDLReInitializeSQL()
{
  return this;
}


// -----------------------------------------------------------------------
// member functions for class StmtDDLInitializeSQL
// -----------------------------------------------------------------------

//
// constructor
//
StmtDDLInitializeSQL::StmtDDLInitializeSQL( ElemDDLNode *pCreateRoleList,
                                            ElemDDLNode *pRegisterUserList,
                                            CollHeap    *heap)
  : StmtDDLNode(DDL_INITIALIZE_SQL)
  , registerUserArray_(heap)
  , createRoleArray_(heap)
{
  setChild(INDEX_REGISTER_USER_LIST, pRegisterUserList);
  setChild(INDEX_CREATE_ROLE_LIST, pCreateRoleList);
}

//
// virtual destructor
//
StmtDDLInitializeSQL::~StmtDDLInitializeSQL()
{
  // delete all children
  for (Int32 i = 0; i < getArity(); i++)
  {
    delete getChild(i);
  }
}

//
// cast
//
StmtDDLInitializeSQL *
StmtDDLInitializeSQL::castToStmtDDLInitializeSQL()
{
  return this;
}

Int32
StmtDDLInitializeSQL::getArity() const
{
  return MAX_STMT_DDL_INITIALIZE_SQL_ARITY;
}

ExprNode *
StmtDDLInitializeSQL::getChild(Lng32 index)
{
  ComASSERT ((index >= 0) && index < getArity());
  return children_[index];
}

//
// mutators
//

void
StmtDDLInitializeSQL::setChild(Lng32 index, ExprNode * pChildNode)
{
  ComASSERT ((index >= 0) && index < getArity());
  if (pChildNode NEQ NULL)
    children_[index] = pChildNode->castToElemDDLNode();
  else
    children_[index] = NULL;
}

void
StmtDDLInitializeSQL_visitRegisterUserElement(ElemDDLNode * pInitSQLNode,
                                              CollIndex /* index */,
                                              ElemDDLNode * pElement)
{
  ComASSERT(pInitSQLNode NEQ NULL AND
            pInitSQLNode->castToStmtDDLInitializeSQL() NEQ NULL AND
            pElement NEQ NULL AND
            pElement->getOperatorType() == DDL_REGISTER_USER);

  StmtDDLInitializeSQL * pInitializeSQL =
                        pInitSQLNode->castToStmtDDLInitializeSQL();

  StmtDDLRegisterUser *pRegisterUser = pElement->castToStmtDDLRegisterUser();
  ComASSERT(pRegisterUser NEQ NULL);
  pInitializeSQL->registerUserArray_.insert(pRegisterUser);
}

void
StmtDDLInitializeSQL_visitCreateRoleElement(ElemDDLNode * pInitSQLNode,
                                            CollIndex /* index */,
                                            ElemDDLNode * pElement)
{ 
  ComASSERT(pInitSQLNode NEQ NULL AND
            pInitSQLNode->castToStmtDDLInitializeSQL() NEQ NULL AND
            pElement NEQ NULL AND
            pElement->getOperatorType() == DDL_CREATE_ROLE);

  StmtDDLInitializeSQL * pInitializeSQL =
                        pInitSQLNode->castToStmtDDLInitializeSQL();

  StmtDDLCreateRole *pCreateRole = pElement->castToStmtDDLCreateRole();
  ComASSERT(pCreateRole NEQ NULL);
  pInitializeSQL->createRoleArray_.insert(pCreateRole);
}

void
StmtDDLInitializeSQL::synthesize(void)
{
  // Traverses the element list that contains parse nodes
  // representing register user commands.  Collects pointers to
  // these parse nodes and saves them in the corresponding array.

  if (getChild(INDEX_REGISTER_USER_LIST) NEQ NULL)
  {
    ElemDDLNode *pElemList =
      getChild(INDEX_REGISTER_USER_LIST)->castToElemDDLNode();
    ComASSERT(pElemList NEQ NULL);
    pElemList->traverseList(this,
                            StmtDDLInitializeSQL_visitRegisterUserElement);
  }

  if (getChild(INDEX_CREATE_ROLE_LIST) NEQ NULL)
  {
    ElemDDLNode *pElemList =
      getChild(INDEX_CREATE_ROLE_LIST)->castToElemDDLNode();
    ComASSERT(pElemList NEQ NULL);
    pElemList->traverseList(this,
                            StmtDDLInitializeSQL_visitCreateRoleElement);
  } 
}

//
// methods for tracing
//

NATraceList
StmtDDLInitializeSQL::getDetailInfo() const
{
  NATraceList detailTextList;

  return detailTextList;

} // StmtDDLInitializeSQL::getDetailInfo()

const NAString
StmtDDLInitializeSQL::getText() const
{
  return "StmtDDLInitializeSQL";
}

// -----------------------------------------------------------------------
// member functions for class StmtDDLRevoke
// -----------------------------------------------------------------------

//
// constructor
//

StmtDDLRevoke::StmtDDLRevoke(NABoolean isGrantOptionFor,
                             ElemDDLNode * pPrivileges,
                             const QualifiedName & objectName,
                             ElemDDLNode * pGranteeList,
                             ComDropBehavior dropBehavior,
                             ElemDDLNode * pByGrantorOption,
                             QualifiedName * actionName,
                             CollHeap    * heap)
: StmtDDLNode(DDL_REVOKE),
  objectName_(heap),
  objectQualName_(objectName, heap),
  isAllPrivileges_(FALSE),
  isGrantOptionForSpec_(isGrantOptionFor),
  dropBehavior_(dropBehavior),
  privActArray_(heap),
  actionQualName_(actionName),
  granteeArray_(heap),
  isByGrantorOptionSpec_(FALSE),
  byGrantor_(NULL)
{
  
  setChild(INDEX_PRIVILEGES, pPrivileges);
  setChild(INDEX_GRANTEE_LIST, pGranteeList);
  setChild(INDEX_BY_GRANTOR_OPTION, pByGrantorOption);
 
  //
  // Fully expand the name. 
  //
  origObjectName_ = objectQualName_.getQualifiedNameAsAnsiString();  
  objectName_ = objectQualName_.getQualifiedNameAsAnsiString();
 
  //
  // inserts pointers to parse nodes representing privilege
  // actions to privActArray_ so the user can access the
  // information about privilege actions easier.
  //

  ComASSERT(pPrivileges NEQ NULL);
  ElemDDLPrivileges * pPrivsNode = pPrivileges->castToElemDDLPrivileges();
  ComASSERT(pPrivsNode NEQ NULL);
  if (pPrivsNode->isAllPrivileges())
  {
    isAllPrivileges_ = TRUE;
  }
  else
  {
    ElemDDLNode * pPrivActs = pPrivsNode->getPrivilegeActionList();
    for (CollIndex i = 0; i < pPrivActs->entries(); i++)
    {
      ElemDDLPrivAct *pPrivAct = (*pPrivActs)[i]->castToElemDDLPrivAct();
      privActArray_.insert(pPrivAct);
      if (pPrivAct->isDDLPriv())
         privActArray_.setHasDDLPriv(TRUE);
    }
  }

  //
  // copies pointers to parse nodes representing grantee
  // to granteeArray_ so the user can access the information
  // easier.
  //

  ComASSERT(pGranteeList NEQ NULL);
  for (CollIndex i = 0; i < pGranteeList->entries(); i++)
  {
    granteeArray_.insert((*pGranteeList)[i]->castToElemDDLGrantee());
  }

  if ( pByGrantorOption NEQ NULL )
  {
    isByGrantorOptionSpec_ = TRUE;
    byGrantor_ = pByGrantorOption->castToElemDDLGrantee();
  }

} // StmtDDLRevoke::StmtDDLRevoke()

// virtual destructor
StmtDDLRevoke::~StmtDDLRevoke()
{
  // delete all children
  for (Int32 i = 0; i < getArity(); i++)
  {
    delete getChild(i);
  }
}

// cast
StmtDDLRevoke *
StmtDDLRevoke::castToStmtDDLRevoke()
{
  return this;
}

//
// accessors
//

Int32
StmtDDLRevoke::getArity() const
{
  return MAX_STMT_DDL_REVOKE_ARITY;
}

ExprNode *
StmtDDLRevoke::getChild(Lng32 index) 
{
  ComASSERT(index >= 0 AND index < getArity());
  return children_[index];
}

//
// mutators
//

void
StmtDDLRevoke::setChild(Lng32 index, ExprNode * pChildNode)
{
  ComASSERT(index >= 0 AND index < getArity());
  if (pChildNode NEQ NULL)
  {
    ComASSERT(pChildNode->castToElemDDLNode() NEQ NULL);
    children_[index] = pChildNode->castToElemDDLNode(); 
  }
  else
  {
    children_[index] = NULL;
  }
}

//
// methods for tracing
//

const NAString
StmtDDLRevoke::displayLabel1() const
{
  return NAString("Object name: ") + getObjectName();
}

const NAString
StmtDDLRevoke::displayLabel2() const
{
  NAString label2("Drop behavior: ");
  switch (getDropBehavior())
  {
  case COM_CASCADE_DROP_BEHAVIOR :
    return label2 + "Cascade";

  case COM_RESTRICT_DROP_BEHAVIOR :
    return label2 + "Restrict";

  default :
    ABORT("internal logic error");
    return NAString();
  }
}

NATraceList
StmtDDLRevoke::getDetailInfo() const
{
  NAString        detailText;
  NATraceList detailTextList;

  //
  // object name
  //

  detailTextList.append(displayLabel1());   // object name

  //
  // privileges
  //

  StmtDDLRevoke * localThis = (StmtDDLRevoke *)this;

  detailTextList.append(localThis->getChild(INDEX_PRIVILEGES)
                                 ->castToElemDDLNode()
                                 ->castToElemDDLPrivileges()
                                 ->getDetailInfo());

  //
  // grantee list
  //

  const ElemDDLGranteeArray & granteeArray = getGranteeArray();

  detailText = "Grantee list [";
  detailText += LongToNAString((Lng32)granteeArray.entries());
  detailText += " element(s)]";
  detailTextList.append(detailText);

  for (CollIndex i = 0; i < granteeArray.entries(); i++)
  {
    detailText = "[grantee ";
    detailText += LongToNAString((Lng32)i);
    detailText += "]";
    detailTextList.append(detailText);
  
    ComASSERT(granteeArray[i] NEQ NULL AND
              granteeArray[i]->castToElemDDLGrantee() NEQ NULL);
    detailTextList.append("    ", granteeArray[i]->castToElemDDLGrantee()
                                                 ->getDetailInfo());
  }

  //
  // grant option for
  //

  detailText = "is grant option for? ";
  detailText += YesNo(isGrantOptionForSpecified());
  detailTextList.append(detailText);

  //
  // drop behavior
  //

  detailTextList.append(displayLabel2());   // drop behavior


  return detailTextList;

} // StmtDDLRevoke::getDetailInfo

const NAString
StmtDDLRevoke::getText() const
{
  return "StmtDDLRevoke";
}


// -----------------------------------------------------------------------
// member functions for class StmtDDLSchRevoke
// -----------------------------------------------------------------------

//
// constructor
//

StmtDDLSchRevoke::StmtDDLSchRevoke(NABoolean isGrantOptionFor,
                             ElemDDLNode * pPrivileges,
                             const ElemDDLSchemaName & aSchemaNameParseNode,
                             ElemDDLNode * pGranteeList,
                             ComDropBehavior dropBehavior,
			     ElemDDLNode * pByGrantorOption,
                             CollHeap    * heap)
: StmtDDLNode(DDL_REVOKE_SCHEMA),
  schemaName_(heap),
  schemaQualName_(aSchemaNameParseNode.getSchemaName(), heap),
  isAllDDLPrivileges_(FALSE),
  isAllDMLPrivileges_(FALSE),
  isAllOtherPrivileges_(FALSE),
  isGrantOptionForSpec_(isGrantOptionFor),
  dropBehavior_(dropBehavior),
  privActArray_(heap),
  granteeArray_(heap),
  isByGrantorOptionSpec_(FALSE),
  byGrantor_(NULL)
{
  
  setChild(INDEX_PRIVILEGES, pPrivileges);
  setChild(INDEX_GRANTEE_LIST, pGranteeList);
  setChild(INDEX_BY_GRANTOR_OPTION, pByGrantorOption);
        
  //
  // inserts pointers to parse nodes representing privilege
  // actions to privActArray_ so the user can access the
  // information about privilege actions easier.
  //

  ComASSERT(pPrivileges NEQ NULL);
  ElemDDLPrivileges * pPrivsNode = pPrivileges->castToElemDDLPrivileges();
  ComASSERT(pPrivsNode NEQ NULL);
  if (pPrivsNode->isAllPrivileges())
  {
    isAllDDLPrivileges_ = TRUE;
    isAllDMLPrivileges_ = TRUE;
    isAllOtherPrivileges_ = TRUE;
  }
  if (pPrivsNode->isAllDDLPrivileges())
  {
    isAllDDLPrivileges_ = TRUE;
  }
  if (pPrivsNode->isAllDMLPrivileges())
  {
    isAllDMLPrivileges_ = TRUE;
  }
  if (pPrivsNode->isAllOtherPrivileges())
  {
    isAllOtherPrivileges_ = TRUE;
  }

  ElemDDLNode * pPrivActs = pPrivsNode->getPrivilegeActionList();
  if (pPrivActs)
  {
    for (CollIndex i = 0; i < pPrivActs->entries(); i++)
    {
      privActArray_.insert((*pPrivActs)[i]->castToElemDDLPrivAct());
    }
  }

  //
  // copies pointers to parse nodes representing grantee
  // to granteeArray_ so the user can access the information
  // easier.
  //

  ComASSERT(pGranteeList NEQ NULL);
  for (CollIndex i = 0; i < pGranteeList->entries(); i++)
  {
    granteeArray_.insert((*pGranteeList)[i]->castToElemDDLGrantee());
  } 

  if ( pByGrantorOption NEQ NULL )
  {
    isByGrantorOptionSpec_ = TRUE;
    byGrantor_ = pByGrantorOption->castToElemDDLGrantee();
  }

} // StmtDDLSchRevoke::StmtDDLSchRevoke()

// virtual destructor
StmtDDLSchRevoke::~StmtDDLSchRevoke()
{
  // delete all children
  for (Int32 i = 0; i < getArity(); i++)
  {
    delete getChild(i);
  }
}

// cast
StmtDDLSchRevoke *
StmtDDLSchRevoke::castToStmtDDLSchRevoke()
{
  return this;
}

//
// accessors
//

Int32
StmtDDLSchRevoke::getArity() const
{
  return MAX_STMT_DDL_REVOKE_ARITY;
}

ExprNode *
StmtDDLSchRevoke::getChild(Lng32 index) 
{
  ComASSERT(index >= 0 AND index < getArity());
  return children_[index];
}

//
// mutators
//

void
StmtDDLSchRevoke::setChild(Lng32 index, ExprNode * pChildNode)
{
  ComASSERT(index >= 0 AND index < getArity());
  if (pChildNode NEQ NULL)
  {
    ComASSERT(pChildNode->castToElemDDLNode() NEQ NULL);
    children_[index] = pChildNode->castToElemDDLNode(); 
  }
  else
  {
    children_[index] = NULL;
  }
}

//
// methods for tracing
//


const NAString
StmtDDLSchRevoke::displayLabel1() const
{
  return NAString("Schema name: ") + getSchemaName();
}

const NAString
StmtDDLSchRevoke::displayLabel2() const
{
  NAString label2("Drop behavior: ");
  switch (getDropBehavior())
  {
  case COM_CASCADE_DROP_BEHAVIOR :
    return label2 + "Cascade";

  case COM_RESTRICT_DROP_BEHAVIOR :
    return label2 + "Restrict";

  default :
    ABORT("internal logic error");
    return NAString();
  }
}

NATraceList
StmtDDLSchRevoke::getDetailInfo() const
{
  NAString        detailText;
  NATraceList detailTextList;

  //
  // object name
  //

  detailTextList.append(displayLabel1());   // object name

  //
  // privileges
  //

  StmtDDLSchRevoke * localThis = (StmtDDLSchRevoke *)this;

  detailTextList.append(localThis->getChild(INDEX_PRIVILEGES)
                                 ->castToElemDDLNode()
                                 ->castToElemDDLPrivileges()
                                 ->getDetailInfo());

  //
  // grantee list
  //

  const ElemDDLGranteeArray & granteeArray = getGranteeArray();

  detailText = "Grantee list [";
  detailText += LongToNAString((Lng32)granteeArray.entries());
  detailText += " element(s)]";
  detailTextList.append(detailText);

  for (CollIndex i = 0; i < granteeArray.entries(); i++)
  {
    detailText = "[grantee ";
    detailText += LongToNAString((Lng32)i);
    detailText += "]";
    detailTextList.append(detailText);
  
    ComASSERT(granteeArray[i] NEQ NULL AND
              granteeArray[i]->castToElemDDLGrantee() NEQ NULL);
    detailTextList.append("    ", granteeArray[i]->castToElemDDLGrantee()
                                                 ->getDetailInfo());
  }

  //
  // grant option for
  //

  detailText = "is grant option for? ";
  detailText += YesNo(isGrantOptionForSpecified());
  detailTextList.append(detailText);

  //
  // drop behavior
  //

  detailTextList.append(displayLabel2());   // drop behavior


  return detailTextList;

} // StmtDDLSchRevoke::getDetailInfo

const NAString
StmtDDLSchRevoke::getText() const
{
  return "StmtDDLSchRevoke";
}


// -----------------------------------------------------------------------
// methods for class StmtDDLRegisterComponent
// -----------------------------------------------------------------------

//
// constructors used for (UN)REGISTER COMPONENT
//
StmtDDLRegisterComponent::StmtDDLRegisterComponent(StmtDDLRegisterComponent::RegisterComponentType eRegComponentParseNodeType,
                                                   const NAString & sComponentName,
                                                   const NABoolean isSystem,
                                                   const NAString & sDetailInfo,
                                                   CollHeap * heap)
  : StmtDDLNode(DDL_REGISTER_COMPONENT),
    registerComponentType_(eRegComponentParseNodeType),
    componentName_(sComponentName, heap),
    isSystem_(isSystem),
    componentDetailInfo_(sDetailInfo, heap)
{
} 
StmtDDLRegisterComponent::StmtDDLRegisterComponent(StmtDDLRegisterComponent::RegisterComponentType eRegComponentParseNodeType,
                                                   const NAString & sComponentName,
                                                   ComDropBehavior dropBehavior, 
                                                   CollHeap * heap)
  : StmtDDLNode(DDL_REGISTER_COMPONENT),
    registerComponentType_(eRegComponentParseNodeType),
    componentName_(sComponentName, heap),
    dropBehavior_(dropBehavior),
    componentDetailInfo_(heap)
{
} 

//
// virtual destructor
//
StmtDDLRegisterComponent::~StmtDDLRegisterComponent()
{
}

//
// cast
//
StmtDDLRegisterComponent *
StmtDDLRegisterComponent::castToStmtDDLRegisterComponent()
{
  return this;
}


//
// methods for tracing
//


const NAString
StmtDDLRegisterComponent::displayLabel1() const
{
  NAString aLabel("UNREGISTER COMPONENT");
  if (getRegisterComponentType() == StmtDDLRegisterComponent::REGISTER_COMPONENT)
  {
    aLabel = "REGISTER COMPONENT";
    if (isSystem())
      aLabel += " (SYSTEM)";
  }
  aLabel += " - External Component name: ";
  aLabel += getExternalComponentName();
  if (getRegisterComponentType() == StmtDDLRegisterComponent::UNREGISTER_COMPONENT)
  {
     aLabel += " Drop behavior: ";
     if (dropBehavior_ == COM_CASCADE_DROP_BEHAVIOR)
        aLabel += "CASCADE";
     else
        aLabel += "RESTRICT";
  }
  return aLabel;
}

const NAString
StmtDDLRegisterComponent::displayLabel2() const
{
  if (NOT getRegisterComponentDetailInfo().isNull())
  {
    return NAString("Detail Information: ") + getRegisterComponentDetailInfo();
  }
  else
  {
    return NAString("No Detail Information (i.e., an empty string).");
  }
}

const NAString
StmtDDLRegisterComponent::getText() const
{
  return "StmtDDLRegisterComponent";
}


//
// End of File
//