/* -*-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 @@@
**********************************************************************/
/* -*-C++-*-
 *****************************************************************************
 *
 * File:         ElemDDLNode.C
 * Description:  definitions of methods for classes representing
 *               elements in DDL statements, excluding methods
 *               for classes representing lists (left-skewed
 *               binary trees), file attributes, constraints,
 *               like options, partitions, elements in like
 *               clauses, load options, privilege actions, etc.
 *
 *
 * Created:      3/9/95
 * Language:     C++
 *
 *
 *
 *
 *****************************************************************************
 */


#define   SQLPARSERGLOBALS_FLAGS        // must precede all #include's
#include "BaseTypes.h"
#include "ComASSERT.h"
#include "ComDiags.h"
#include "ComOperators.h"
#include "ComLocationNames.h"
#include "ElemDDLAlterTableMove.h"
#include "ElemDDLAuthSchema.h"
#include "ElemDDLLibClientFilename.h"
#include "ElemDDLLibClientName.h"
#include "ElemDDLLibPathName.h"
#include "ElemDDLColNameList.h"
#include "ElemDDLGrantee.h"
#include "ElemDDLGranteeArray.h"
#include "ElemDDLKeyValue.h"
#include "ElemDDLLocation.h"
#include "ElemDDLParallelExec.h"
#include "ElemDDLReferences.h"
#include "ElemDDLSchemaName.h"
#include "ElemDDLPrivActions.h"
#include "ElemDDLPrivileges.h"
#include "ElemDDLWithCheckOption.h"
#include "ElemDDLWithGrantOption.h"
#include "ElemDDLIndexPopulateOption.h"
#include "ElemDDLQualName.h" // MV - RG
#include "ElemDDLLoggable.h"
#include "ElemDDLLobAttrs.h"
#include "ElemDDLDivisionClause.h"
#include "ElemDDLSaltOptions.h"
#include "ElemDDLTableFeature.h"
#include "ElemDDLHbaseOptions.h"
#include "ItemExpr.h"
#include "ItemColRef.h"
#ifndef   SQLPARSERGLOBALS_CONTEXT_AND_DIAGS
#define   SQLPARSERGLOBALS_CONTEXT_AND_DIAGS
#endif
#include "SqlParserGlobals.h"

#include "OptimizerSimulator.h"

// -----------------------------------------------------------------------
// methods for class ElemDDLNode
// -----------------------------------------------------------------------

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

// cast virtual functions

ElemDDLNode *
ElemDDLNode::castToElemDDLNode()
{
  return this;
}

const ElemDDLNode *
ElemDDLNode::castToElemDDLNode() const
{
  return this;
}

ElemDDLQualName *
ElemDDLNode::castToElemDDLQualName() // MV - RG
{
  return NULL;
}


ElemDDLIndexPopulateOption *
ElemDDLNode::castToElemDDLIndexPopulateOption()
{
  return NULL;
}

ElemDDLAlterTableMove *
ElemDDLNode::castToElemDDLAlterTableMove()
{
  return NULL;
}

ElemDDLAuthSchema *
ElemDDLNode::castToElemDDLAuthSchema()
{
  return NULL;
}

ElemDDLColDef *
ElemDDLNode::castToElemDDLColDef()
{
  return NULL;
}

ElemProxyColDef *
ElemDDLNode::castToElemProxyColDef()
{
  return NULL;
}

ElemDDLColDefault *
ElemDDLNode::castToElemDDLColDefault()
{
  return NULL;
}

ElemDDLColHeading *
ElemDDLNode::castToElemDDLColHeading()
{
  return NULL;
}

ElemDDLColName *
ElemDDLNode::castToElemDDLColName()
{
  return NULL;
}

ElemDDLColNameList *
ElemDDLNode::castToElemDDLColNameList()
{
  return NULL;
}

ElemDDLColNameListNode *
ElemDDLNode::castToElemDDLColNameListNode()
{
  return NULL;
}

ElemDDLColRef *
ElemDDLNode::castToElemDDLColRef()
{
  return NULL;
}

ElemDDLColRefList *
ElemDDLNode::castToElemDDLColRefList()
{
  return NULL;
}

ElemDDLColViewDef *
ElemDDLNode::castToElemDDLColViewDef()
{
  return NULL;
}

ElemDDLConstraint *
ElemDDLNode::castToElemDDLConstraint()
{
  return NULL;
}

ElemDDLConstraintAttr *
ElemDDLNode::castToElemDDLConstraintAttr()
{
  return NULL;
}

ElemDDLConstraintAttrDroppable *
ElemDDLNode::castToElemDDLConstraintAttrDroppable()
{
  return NULL;
}

ElemDDLConstraintAttrEnforced *
ElemDDLNode::castToElemDDLConstraintAttrEnforced()
{
  return NULL;
}

ElemDDLConstraintCheck *
ElemDDLNode::castToElemDDLConstraintCheck()
{
  return NULL;
}

ElemDDLConstraintName *
ElemDDLNode::castToElemDDLConstraintName()
{
  return NULL;
}

ElemDDLConstraintNameList *
ElemDDLNode::castToElemDDLConstraintNameList()
{
  return NULL;
}

ElemDDLConstraintNotNull *
ElemDDLNode::castToElemDDLConstraintNotNull()
{
  return NULL;
}

ElemDDLLoggable *
ElemDDLNode::castToElemDDLLoggable()
{
	return NULL;
}

ElemDDLLobAttrs *
ElemDDLNode::castToElemDDLLobAttrs()
{
	return NULL;
}

ElemDDLSeabaseSerialized *
ElemDDLNode::castToElemDDLSeabaseSerialized()
{
	return NULL;
}


ElemDDLConstraintPK *
ElemDDLNode::castToElemDDLConstraintPK()
{
  return NULL;
}

ElemDDLConstraintPKColumn *
ElemDDLNode::castToElemDDLConstraintPKColumn()
{
  return NULL;
}

ElemDDLConstraintRI *
ElemDDLNode::castToElemDDLConstraintRI()
{
  return NULL;
}

ElemDDLConstraintUnique *
ElemDDLNode::castToElemDDLConstraintUnique()
{
  return NULL;
}


ElemDDLCreateMVOneAttributeTableList  *
ElemDDLNode::castToElemDDLCreateMVOneAttributeTableList() // MV OZ
{
	return NULL;
}

ElemDDLDivisionClause *
ElemDDLNode::castToElemDDLDivisionClause()
{
  return NULL;
}

ElemDDLFileAttr *
ElemDDLNode::castToElemDDLFileAttr()
{
  return NULL;
}


ElemDDLFileAttrAllocate *
ElemDDLNode::castToElemDDLFileAttrAllocate()
{
  return NULL;
}

ElemDDLFileAttrAudit *
ElemDDLNode::castToElemDDLFileAttrAudit()
{
  return NULL;
}

ElemDDLFileAttrAuditCompress *
ElemDDLNode::castToElemDDLFileAttrAuditCompress()
{
  return NULL;
}

ElemDDLFileAttrBlockSize *
ElemDDLNode::castToElemDDLFileAttrBlockSize()
{
  return NULL;
}

ElemDDLFileAttrBuffered *
ElemDDLNode::castToElemDDLFileAttrBuffered()
{
  return NULL;
}

ElemDDLFileAttrClause *
ElemDDLNode::castToElemDDLFileAttrClause()
{
  return NULL;
}

ElemDDLFileAttrClearOnPurge *
ElemDDLNode::castToElemDDLFileAttrClearOnPurge()
{
  return NULL;
}

ElemDDLFileAttrCompression *
ElemDDLNode::castToElemDDLFileAttrCompression()
{
  return NULL;
}

ElemDDLFileAttrDCompress *
ElemDDLNode::castToElemDDLFileAttrDCompress()
{
  return NULL;
}

ElemDDLFileAttrDeallocate *
ElemDDLNode::castToElemDDLFileAttrDeallocate()
{
  return NULL;
}

ElemDDLFileAttrICompress *
ElemDDLNode::castToElemDDLFileAttrICompress()
{
  return NULL;
}

ElemDDLFileAttrList *
ElemDDLNode::castToElemDDLFileAttrList()
{
  return NULL;
}

ElemDDLPartnAttrList *
ElemDDLNode::castToElemDDLPartnAttrList()
{
  return NULL;
}

ElemDDLFileAttrMaxSize *
ElemDDLNode::castToElemDDLFileAttrMaxSize()
{
  return NULL;
}

ElemDDLFileAttrExtents *
ElemDDLNode::castToElemDDLFileAttrExtents()
{
  return NULL;
}

ElemDDLFileAttrMaxExtents *
ElemDDLNode::castToElemDDLFileAttrMaxExtents()
{
  return NULL;
}

ElemDDLFileAttrNoLabelUpdate *
ElemDDLNode::castToElemDDLFileAttrNoLabelUpdate()
{
  return NULL;
}

ElemDDLFileAttrOwner *
ElemDDLNode::castToElemDDLFileAttrOwner()
{
  return NULL;
}

ElemDDLFileAttrUID *
ElemDDLNode::castToElemDDLFileAttrUID()
{
  return NULL;
}

ElemDDLFileAttrRowFormat *
ElemDDLNode::castToElemDDLFileAttrRowFormat()
{
  return NULL;
}

ElemDDLFileAttrColFam *
ElemDDLNode::castToElemDDLFileAttrColFam()
{
  return NULL;
}

//++ MV
ElemDDLFileAttrRangeLog *
ElemDDLNode::castToElemDDLFileAttrRangeLog()
{
  return NULL;
}

ElemDDLFileAttrLockOnRefresh  *
ElemDDLNode::castToElemDDLFileAttrLockOnRefresh()
{
	return NULL;
}

ElemDDLFileAttrInsertLog *
ElemDDLNode::castToElemDDLFileAttrInsertLog()
{
	return NULL;
}

ElemDDLFileAttrMvsAllowed *
ElemDDLNode::castToElemDDLFileAttrMvsAllowed()
{
	return NULL;
}

ElemDDLMVFileAttrClause *
ElemDDLNode::castToElemDDLMVFileAttrClause()
{
	return NULL;
}

ElemDDLFileAttrMVCommitEach	*
ElemDDLNode::castToElemDDLFileAttrMVCommitEach()
{
	return NULL;
}

ElemDDLFileAttrMvAudit *
ElemDDLNode::castToElemDDLFileAttrMvAudit()
{
	return NULL;
}

//-- MV


ElemDDLGrantee *
ElemDDLNode::castToElemDDLGrantee()
{
  return NULL;
}

ElemDDLKeyValue *
ElemDDLNode::castToElemDDLKeyValue()
{
  return NULL;
}

ElemDDLKeyValueList *
ElemDDLNode::castToElemDDLKeyValueList()
{
  return NULL;
}

ElemDDLLibrary *
ElemDDLNode::castToElemDDLLibrary()
{
  return NULL;
}

ElemDDLLibClientFilename *
ElemDDLNode::castToElemDDLLibClientFilename()
{
  return NULL;
}

ElemDDLLibClientName *
ElemDDLNode::castToElemDDLLibClientName()
{
  return NULL;
}

ElemDDLLibPathName *
ElemDDLNode::castToElemDDLLibPathName()
{
  return NULL;
}

ElemDDLLike *
ElemDDLNode::castToElemDDLLike()
{
  return NULL;
}

ElemDDLLikeCreateTable *
ElemDDLNode::castToElemDDLLikeCreateTable()
{
  return NULL;
}

ElemDDLLikeOpt *
ElemDDLNode::castToElemDDLLikeOpt()
{
  return NULL;
}

ElemDDLLikeOptWithoutConstraints *
ElemDDLNode::castToElemDDLLikeOptWithoutConstraints()
{
  return NULL;
}

ElemDDLLikeOptWithHeadings *
ElemDDLNode::castToElemDDLLikeOptWithHeadings()
{
  return NULL;
}

ElemDDLLikeOptWithHorizontalPartitions *
ElemDDLNode::castToElemDDLLikeOptWithHorizontalPartitions()
{
  return NULL;
}

ElemDDLLikeOptWithoutSalt * ElemDDLNode::castToElemDDLLikeOptWithoutSalt()
{
  return NULL;
}

ElemDDLLikeSaltClause * ElemDDLNode::castToElemDDLLikeSaltClause()
{
  return NULL;
}

ElemDDLLikeOptWithoutDivision * ElemDDLNode::castToElemDDLLikeOptWithoutDivision()
{
  return NULL;
}

ElemDDLLikeLimitColumnLength * ElemDDLNode::castToElemDDLLikeLimitColumnLength()
{
  return NULL;
}

ElemDDLLikeOptWithoutRowFormat * ElemDDLNode::castToElemDDLLikeOptWithoutRowFormat()
{
  return NULL;
}

ElemDDLLikeOptWithoutLobColumns * ElemDDLNode::castToElemDDLLikeOptWithoutLobColumns()
{
  return NULL;
}

ElemDDLList *
ElemDDLNode::castToElemDDLList()
{
  return NULL;
}

ElemDDLLocation *
ElemDDLNode::castToElemDDLLocation()
{
  return NULL;
}

ElemDDLOptionList *
ElemDDLNode::castToElemDDLOptionList()
{
  return NULL;
}

ElemDDLParallelExec *
ElemDDLNode::castToElemDDLParallelExec()
{
  return NULL;
}

ElemDDLParamDef *
ElemDDLNode::castToElemDDLParamDef()
{
  return NULL;
}

ElemDDLPartition *
ElemDDLNode::castToElemDDLPartition()
{
  return NULL;
}

ElemDDLPartitionByOpt *
ElemDDLNode::castToElemDDLPartitionByOpt()
{
  return NULL;
}

ElemDDLPartitionByColumnList *
ElemDDLNode::castToElemDDLPartitionByColumnList()
{
  return NULL;
}

ElemDDLPartitionClause *
ElemDDLNode::castToElemDDLPartitionClause()
{
  return NULL;
}

ElemDDLPartitionList *
ElemDDLNode::castToElemDDLPartitionList()
{
  return NULL;
}

ElemDDLPartitionRange *
ElemDDLNode::castToElemDDLPartitionRange()
{
  return NULL;
}

ElemDDLPartitionSingle *
ElemDDLNode::castToElemDDLPartitionSingle()
{
  return NULL;
}

ElemDDLPartitionSystem *
ElemDDLNode::castToElemDDLPartitionSystem()
{
  return NULL;
}

ElemDDLPassThroughParamDef *
ElemDDLNode::castToElemDDLPassThroughParamDef()
{
  return NULL;
}

ElemDDLPrivAct *
ElemDDLNode::castToElemDDLPrivAct()
{
  return NULL;
}

ElemDDLPrivActAlter *
ElemDDLNode::castToElemDDLPrivActAlter()
{
  return NULL;
}

ElemDDLPrivActAlterLibrary *
ElemDDLNode::castToElemDDLPrivActAlterLibrary()
{
  return NULL;
}

ElemDDLPrivActAlterMV *
ElemDDLNode::castToElemDDLPrivActAlterMV()
{
  return NULL;
}

ElemDDLPrivActAlterMVGroup *
ElemDDLNode::castToElemDDLPrivActAlterMVGroup()
{
  return NULL;
}

ElemDDLPrivActAlterRoutine *
ElemDDLNode::castToElemDDLPrivActAlterRoutine()
{
  return NULL;
}

ElemDDLPrivActAlterRoutineAction *
ElemDDLNode::castToElemDDLPrivActAlterRoutineAction()
{
  return NULL;
}

ElemDDLPrivActAlterSynonym *
ElemDDLNode::castToElemDDLPrivActAlterSynonym()
{
  return NULL;
}

ElemDDLPrivActAlterTable *
ElemDDLNode::castToElemDDLPrivActAlterTable()
{
  return NULL;
}

ElemDDLPrivActAlterTrigger *
ElemDDLNode::castToElemDDLPrivActAlterTrigger()
{
  return NULL;
}

ElemDDLPrivActAlterView *
ElemDDLNode::castToElemDDLPrivActAlterView()
{
  return NULL;
}

ElemDDLPrivActCreate *
ElemDDLNode::castToElemDDLPrivActCreate()
{
  return NULL;
}

ElemDDLPrivActCreateLibrary *
ElemDDLNode::castToElemDDLPrivActCreateLibrary()
{
  return NULL;
}

ElemDDLPrivActCreateMV *
ElemDDLNode::castToElemDDLPrivActCreateMV()
{
  return NULL;
}

ElemDDLPrivActCreateMVGroup *
ElemDDLNode::castToElemDDLPrivActCreateMVGroup()
{
  return NULL;
}

ElemDDLPrivActCreateProcedure *
ElemDDLNode::castToElemDDLPrivActCreateProcedure()
{
  return NULL;
}

ElemDDLPrivActCreateRoutine *
ElemDDLNode::castToElemDDLPrivActCreateRoutine()
{
  return NULL;
}

ElemDDLPrivActCreateRoutineAction *
ElemDDLNode::castToElemDDLPrivActCreateRoutineAction()
{
  return NULL;
}

ElemDDLPrivActCreateSynonym *
ElemDDLNode::castToElemDDLPrivActCreateSynonym()
{
  return NULL;
}

ElemDDLPrivActCreateTable *
ElemDDLNode::castToElemDDLPrivActCreateTable()
{
  return NULL;
}

ElemDDLPrivActCreateTrigger *
ElemDDLNode::castToElemDDLPrivActCreateTrigger()
{
  return NULL;
}

ElemDDLPrivActCreateView *
ElemDDLNode::castToElemDDLPrivActCreateView()
{
  return NULL;
}

ElemDDLPrivActDBA *
ElemDDLNode::castToElemDDLPrivActDBA()
{
  return NULL;
}

ElemDDLPrivActDelete *
ElemDDLNode::castToElemDDLPrivActDelete()
{
  return NULL;
}

ElemDDLPrivActDrop *
ElemDDLNode::castToElemDDLPrivActDrop()
{
  return NULL;
}

ElemDDLPrivActDropLibrary *
ElemDDLNode::castToElemDDLPrivActDropLibrary()
{
  return NULL;
}

ElemDDLPrivActDropMV *
ElemDDLNode::castToElemDDLPrivActDropMV()
{
  return NULL;
}

ElemDDLPrivActDropMVGroup *
ElemDDLNode::castToElemDDLPrivActDropMVGroup()
{
  return NULL;
}

ElemDDLPrivActDropProcedure *
ElemDDLNode::castToElemDDLPrivActDropProcedure()
{
  return NULL;
}
ElemDDLPrivActDropRoutine *
ElemDDLNode::castToElemDDLPrivActDropRoutine()
{
  return NULL;
}

ElemDDLPrivActDropRoutineAction *
ElemDDLNode::castToElemDDLPrivActDropRoutineAction()
{
  return NULL;
}

ElemDDLPrivActDropSynonym *
ElemDDLNode::castToElemDDLPrivActDropSynonym()
{
  return NULL;
}

ElemDDLPrivActDropTable *
ElemDDLNode::castToElemDDLPrivActDropTable()
{
  return NULL;
}

ElemDDLPrivActDropTrigger *
ElemDDLNode::castToElemDDLPrivActDropTrigger()
{
  return NULL;
}

ElemDDLPrivActDropView *
ElemDDLNode::castToElemDDLPrivActDropView()
{
  return NULL;
}

ElemDDLPrivActInsert *
ElemDDLNode::castToElemDDLPrivActInsert()
{
  return NULL;
}

ElemDDLPrivActMaintain *
ElemDDLNode::castToElemDDLPrivActMaintain()
{
  return NULL;
}

ElemDDLPrivActReferences *
ElemDDLNode::castToElemDDLPrivActReferences()
{
  return NULL;
}

ElemDDLPrivActRefresh *
ElemDDLNode::castToElemDDLPrivActRefresh()
{
  return NULL;
}

ElemDDLPrivActReorg *
ElemDDLNode::castToElemDDLPrivActReorg()
{
  return NULL;
}

ElemDDLPrivActSelect *
ElemDDLNode::castToElemDDLPrivActSelect()
{
  return NULL;
}

ElemDDLPrivActTransform *
ElemDDLNode::castToElemDDLPrivActTransform()
{
  return NULL;
}

ElemDDLPrivActUpdate *
ElemDDLNode::castToElemDDLPrivActUpdate()
{
  return NULL;
}

ElemDDLPrivActUpdateStats *
ElemDDLNode::castToElemDDLPrivActUpdateStats()
{
  return NULL;
}

ElemDDLPrivActAllDDL *
ElemDDLNode::castToElemDDLPrivActAllDDL()
{
  return NULL;
}

ElemDDLPrivActAllDML *
ElemDDLNode::castToElemDDLPrivActAllDML()
{
  return NULL;
}

ElemDDLPrivActAllOther *
ElemDDLNode::castToElemDDLPrivActAllOther()
{
  return NULL;
}

ElemDDLPrivActUsage *
ElemDDLNode::castToElemDDLPrivActUsage()
{
  return NULL;
}

ElemDDLPrivActWithColumns *
ElemDDLNode::castToElemDDLPrivActWithColumns()
{
  return NULL;
}

ElemDDLPrivileges *
ElemDDLNode::castToElemDDLPrivileges()
{
  return NULL;
}

ElemDDLRefAct *
ElemDDLNode::castToElemDDLRefAct()
{
  return NULL;
}

ElemDDLRefActCascade *
ElemDDLNode::castToElemDDLRefActCascade()
{
  return NULL;
}

ElemDDLRefActNoAction *
ElemDDLNode::castToElemDDLRefActNoAction()
{
  return NULL;
}

ElemDDLRefActRestrict *
ElemDDLNode::castToElemDDLRefActRestrict()
{
  return NULL;
}

ElemDDLRefActSetDefault *
ElemDDLNode::castToElemDDLRefActSetDefault()
{
  return NULL;
}

ElemDDLRefActSetNull *
ElemDDLNode::castToElemDDLRefActSetNull()
{
  return NULL;
}

ElemDDLRefTrigAct *
ElemDDLNode::castToElemDDLRefTrigAct()
{
  return NULL;
}

ElemDDLRefTrigActDeleteRule *
ElemDDLNode::castToElemDDLRefTrigActDeleteRule()
{
  return NULL;
}

ElemDDLRefTrigActUpdateRule *
ElemDDLNode::castToElemDDLRefTrigActUpdateRule()
{
  return NULL;
}

ElemDDLReferences *
ElemDDLNode::castToElemDDLReferences()
{
  return NULL;
}

ElemDDLSaltOptionsClause * 
ElemDDLNode::castToElemDDLSaltOptionsClause()
{
  return NULL;
}

ElemDDLTableFeature *
ElemDDLNode::castToElemDDLTableFeature()
{
  return NULL;
}

ElemDDLHbaseOptions *
ElemDDLNode::castToElemDDLHbaseOptions()
{
  return NULL;
}

ElemDDLSchemaName *
ElemDDLNode::castToElemDDLSchemaName()
{
  return NULL;
}

ElemDDLSGOptions *
ElemDDLNode::castToElemDDLSGOptions()
{
  return NULL;
}

ElemDDLSGOption *
ElemDDLNode::castToElemDDLSGOption()
{
  return NULL;
}
 
ElemDDLSGOptionStartValue *
ElemDDLNode::castToElemDDLSGOptionStartValue()
{
  return NULL;
}
 
ElemDDLSGOptionMinValue *
ElemDDLNode::castToElemDDLSGOptionMinValue()
{
  return NULL;
}

ElemDDLSGOptionMaxValue *
ElemDDLNode::castToElemDDLSGOptionMaxValue()
{
  return NULL;
}

ElemDDLSGOptionIncrement *
ElemDDLNode::castToElemDDLSGOptionIncrement()
{
  return NULL;
}

ElemDDLSGOptionCycleOption *
ElemDDLNode::castToElemDDLSGOptionCycleOption()
{
  return NULL;
}
 
ElemDDLSGOptionCacheOption *
ElemDDLNode::castToElemDDLSGOptionCacheOption()
{
  return NULL;
}
 
ElemDDLSGOptionDatatype *
ElemDDLNode::castToElemDDLSGOptionDatatype()
{
  return NULL;
}
 
ElemDDLStoreOpt *
ElemDDLNode::castToElemDDLStoreOpt()
{
  return NULL;
}

ElemDDLStoreOptDefault *
ElemDDLNode::castToElemDDLStoreOptDefault()
{
  return NULL;
}

ElemDDLStoreOptEntryOrder *
ElemDDLNode::castToElemDDLStoreOptEntryOrder()
{
  return NULL;
}

ElemDDLStoreOptKeyColumnList *
ElemDDLNode::castToElemDDLStoreOptKeyColumnList()
{
  return NULL;
}

ElemDDLStoreOptNondroppablePK *
ElemDDLNode::castToElemDDLStoreOptNondroppablePK()
{
  return NULL;
}

ElemDDLUdfExecutionMode *
ElemDDLNode::castToElemDDLUdfExecutionMode(void)
{
  return NULL;
}

ElemDDLUdfFinalCall *
ElemDDLNode::castToElemDDLUdfFinalCall()
{
  return NULL;
}

ElemDDLUdfOptimizationHint *
ElemDDLNode::castToElemDDLUdfOptimizationHint()
{
  return NULL;
}

ElemDDLUdfParallelism *
ElemDDLNode::castToElemDDLUdfParallelism()
{
  return NULL;
}

ElemDDLUdfSpecialAttributes *
ElemDDLNode::castToElemDDLUdfSpecialAttributes(void)
{
  return NULL;
}

ElemDDLUdfStateAreaSize *
ElemDDLNode::castToElemDDLUdfStateAreaSize()
{
  return NULL;
}

ElemDDLUdfVersionTag *
ElemDDLNode::castToElemDDLUdfVersionTag()
{
  return NULL;
}
ElemDDLUdrDeterministic *
ElemDDLNode::castToElemDDLUdrDeterministic()
{
  return NULL;
}

ElemDDLUdrExternalName *
ElemDDLNode::castToElemDDLUdrExternalName()
{
  return NULL;
}

ElemDDLUdrExternalPath *
ElemDDLNode::castToElemDDLUdrExternalPath()
{
  return NULL;
}

ElemDDLUdrIsolate *
ElemDDLNode::castToElemDDLUdrIsolate()
{
  return NULL;
}

ElemDDLUdrLanguage *
ElemDDLNode::castToElemDDLUdrLanguage()
{
  return NULL;
}

ElemDDLUdrLibrary *
ElemDDLNode::castToElemDDLUdrLibrary()
{
  return NULL;
}

ElemDDLUdrMaxResults *
ElemDDLNode::castToElemDDLUdrMaxResults()
{
  return NULL;
}

ElemDDLUdrParamStyle *
ElemDDLNode::castToElemDDLUdrParamStyle()
{
  return NULL;
}

ElemDDLUdrExternalSecurity *
ElemDDLNode::castToElemDDLUdrExternalSecurity()
{
  return NULL;
}

ElemDDLUdrSqlAccess *
ElemDDLNode::castToElemDDLUdrSqlAccess()
{
  return NULL;
}

ElemDDLUdrTransaction *
ElemDDLNode::castToElemDDLUdrTransaction()
{
  return NULL;
}

ElemDDLUudfParamDef *
ElemDDLNode::castToElemDDLUudfParamDef()
{
  return NULL;
}

ElemDDLWithCheckOption *
ElemDDLNode::castToElemDDLWithCheckOption()
{
  return NULL;
}

ElemDDLWithGrantOption *
ElemDDLNode::castToElemDDLWithGrantOption()
{
  return NULL;
}

StmtDDLAddConstraint *
ElemDDLNode::castToStmtDDLAddConstraint()
{
  return NULL;
}

StmtDDLAddConstraintCheck *
ElemDDLNode::castToStmtDDLAddConstraintCheck()
{
  return NULL;
}

StmtDDLAddConstraintPK *
ElemDDLNode::castToStmtDDLAddConstraintPK()
{
  return NULL;
}

StmtDDLAddConstraintRI *
ElemDDLNode::castToStmtDDLAddConstraintRI()
{
  return NULL;
}

StmtDDLAddConstraintUnique *
ElemDDLNode::castToStmtDDLAddConstraintUnique()
{
  return NULL;
}

StmtDDLAlterAuditConfig *
ElemDDLNode::castToStmtDDLAlterAuditConfig()
{
  return NULL;
}

StmtDDLAlterCatalog *
ElemDDLNode::castToStmtDDLAlterCatalog()
{
  return NULL;
}

StmtDDLAlterSchema *
ElemDDLNode::castToStmtDDLAlterSchema()
{
  return NULL;
}

StmtDDLAlterSynonym *
ElemDDLNode::castToStmtDDLAlterSynonym()
{
  return NULL;
}

StmtDDLAlterIndex *
ElemDDLNode::castToStmtDDLAlterIndex()
{
  return NULL;
}

StmtDDLAlterIndexAttribute *
ElemDDLNode::castToStmtDDLAlterIndexAttribute()
{
  return NULL;
}

StmtDDLAlterIndexHBaseOptions *
ElemDDLNode::castToStmtDDLAlterIndexHBaseOptions()
{
  return NULL;
}

StmtDDLAlterLibrary *
ElemDDLNode::castToStmtDDLAlterLibrary()
{
  return NULL;
}

StmtDDLAlterRoutine *
ElemDDLNode::castToStmtDDLAlterRoutine()
{
  return NULL;
}

StmtDDLAlterTable *
ElemDDLNode::castToStmtDDLAlterTable()
{
  return NULL;
}

StmtDDLAlterTableAttribute *
ElemDDLNode::castToStmtDDLAlterTableAttribute()
{
  return NULL;
}

StmtDDLAlterTableColumn *
ElemDDLNode::castToStmtDDLAlterTableColumn()
{
  return NULL;
}

StmtDDLAlterTableAddColumn *
ElemDDLNode::castToStmtDDLAlterTableAddColumn()
{
  return NULL;
}

StmtDDLAlterTableDropColumn *
ElemDDLNode::castToStmtDDLAlterTableDropColumn()
{
  return NULL;
}


StmtDDLAlterTableAlterColumnLoggable *
ElemDDLNode::castToStmtDDLAlterTableAlterColumnLoggable()
{
	return NULL;
}

StmtDDLAlterTableDisableIndex *
ElemDDLNode::castToStmtDDLAlterTableDisableIndex()
{
        return NULL;
}

StmtDDLAlterTableEnableIndex *
ElemDDLNode::castToStmtDDLAlterTableEnableIndex()
{
        return NULL;
}


StmtDDLAlterTableMove *
ElemDDLNode::castToStmtDDLAlterTableMove()
{
  return NULL;
}

StmtDDLAlterTablePartition *
ElemDDLNode::castToStmtDDLAlterTablePartition()
{
  return NULL;
}

StmtDDLAlterTableRename *
ElemDDLNode::castToStmtDDLAlterTableRename()
{
  return NULL;
}

StmtDDLAlterTableStoredDesc *
ElemDDLNode::castToStmtDDLAlterTableStoredDesc()
{
  return NULL;
}

StmtDDLAlterTableNamespace *
ElemDDLNode::castToStmtDDLAlterTableNamespace()
{
  return NULL;
}

StmtDDLAlterTableAlterColumnDefaultValue *
ElemDDLNode::castToStmtDDLAlterTableAlterColumnDefaultValue()
{
  return NULL;
}

StmtDDLAlterTableAlterColumnDatatype *
ElemDDLNode::castToStmtDDLAlterTableAlterColumnDatatype()
{
  return NULL;
}

StmtDDLAlterTableAlterColumnRename *
ElemDDLNode::castToStmtDDLAlterTableAlterColumnRename()
{
  return NULL;
}

StmtDDLAlterTableAlterColumnSetSGOption *
ElemDDLNode::castToStmtDDLAlterTableAlterColumnSetSGOption()
{
  return NULL;
}

StmtDDLAlterTableSetConstraint *
ElemDDLNode::castToStmtDDLAlterTableSetConstraint()
{
  return NULL;
}

StmtDDLAlterTableToggleConstraint *
ElemDDLNode::castToStmtDDLAlterTableToggleConstraint()
{
        return NULL;
}

StmtDDLAlterTableHBaseOptions *
ElemDDLNode::castToStmtDDLAlterTableHBaseOptions()
{
        return NULL;
}

StmtDDLAlterMvRGroup *
ElemDDLNode::castToStmtDDLAlterMvRGroup() // OZ
{
  return NULL;
}

StmtDDLAlterTrigger *
ElemDDLNode::castToStmtDDLAlterTrigger()
{
  return NULL;
}

StmtDDLAlterMV *
ElemDDLNode::castToStmtDDLAlterMV()
{
  return NULL;
}

StmtDDLAlterUser *
ElemDDLNode::castToStmtDDLAlterUser()
{
  return NULL;
}

StmtDDLAlterView *
ElemDDLNode::castToStmtDDLAlterView()
{
  return NULL;
}

StmtDDLAlterDatabase *
ElemDDLNode::castToStmtDDLAlterDatabase()
{
  return NULL;
}

StmtDDLCreateSynonym *
ElemDDLNode::castToStmtDDLCreateSynonym()
{
  return NULL;
}

StmtDDLCreateExceptionTable *
ElemDDLNode::castToStmtDDLCreateExceptionTable()
{
  return NULL;
}

StmtDDLCreateComponentPrivilege *
ElemDDLNode::castToStmtDDLCreateComponentPrivilege()
{
  return NULL;
}

StmtDDLCreateCatalog *
ElemDDLNode::castToStmtDDLCreateCatalog()
{
  return NULL;
}

StmtDDLCreateIndex *
ElemDDLNode::castToStmtDDLCreateIndex()
{
  return NULL;
}

StmtDDLPopulateIndex *
ElemDDLNode::castToStmtDDLPopulateIndex()
{
  return NULL;
}

StmtDDLCreateLibrary *
ElemDDLNode::castToStmtDDLCreateLibrary()
{
  return NULL;
}

StmtDDLCommentOn *
ElemDDLNode::castToStmtDDLCommentOn()
{
  return NULL;
}


StmtDDLCreateRoutine *
ElemDDLNode::castToStmtDDLCreateRoutine()
{
  return NULL;
}

StmtDDLCreateSchema *
ElemDDLNode::castToStmtDDLCreateSchema()
{
  return NULL;
}

StmtDDLCreateSequence *
ElemDDLNode::castToStmtDDLCreateSequence()
{
  return NULL;
}

StmtDDLCreateTable *
ElemDDLNode::castToStmtDDLCreateTable()
{
  return NULL;
}

StmtDDLCreateHbaseTable *
ElemDDLNode::castToStmtDDLCreateHbaseTable()
{
  return NULL;
}

StmtDDLCreateMvRGroup *
ElemDDLNode::castToStmtDDLCreateMvRGroup()
{

	return NULL;  // OZ

}

StmtDDLCreateTrigger *
ElemDDLNode::castToStmtDDLCreateTrigger()
{
  return NULL;
}

StmtDDLCreateMV *
ElemDDLNode::castToStmtDDLCreateMV()
{
  return NULL;
}


StmtDDLCreateView *
ElemDDLNode::castToStmtDDLCreateView()
{
  return NULL;
}

StmtDDLDropSynonym *
ElemDDLNode::castToStmtDDLDropSynonym()
{
  return NULL;
}

StmtDDLDropCatalog *
ElemDDLNode::castToStmtDDLDropCatalog()
{
  return NULL;
}

StmtDDLDropComponentPrivilege *
ElemDDLNode::castToStmtDDLDropComponentPrivilege()
{
  return NULL;
}

StmtDDLDropIndex *
ElemDDLNode::castToStmtDDLDropIndex()
{
  return NULL;
}

StmtDDLDropLibrary *
ElemDDLNode::castToStmtDDLDropLibrary()  
{
  return NULL;
}

StmtDDLDropModule *
ElemDDLNode::castToStmtDDLDropModule()
{
  return NULL;
}

StmtDDLDropRoutine *
ElemDDLNode::castToStmtDDLDropRoutine()
{
  return NULL;
}

StmtDDLDropSchema *
ElemDDLNode::castToStmtDDLDropSchema()
{
  return NULL;
}

StmtDDLDropSequence *
ElemDDLNode::castToStmtDDLDropSequence()
{
  return NULL;
}

StmtDDLDropSQL *
ElemDDLNode::castToStmtDDLDropSQL()
{
  return NULL;
}

StmtDDLDropTable *
ElemDDLNode::castToStmtDDLDropTable()
{
  return NULL;
}

StmtDDLDropHbaseTable *
ElemDDLNode::castToStmtDDLDropHbaseTable()
{
  return NULL;
}

StmtDDLDropMvRGroup *
ElemDDLNode::castToStmtDDLDropMvRGroup()
{
	return NULL; 
}

StmtDDLDropTrigger *
ElemDDLNode::castToStmtDDLDropTrigger()
{
  return NULL;
}

StmtDDLDropMV *
ElemDDLNode::castToStmtDDLDropMV()
{
  return NULL;
}

StmtDDLDropView *
ElemDDLNode::castToStmtDDLDropView()
{
  return NULL;
}

StmtDDLDropExceptionTable *
ElemDDLNode::castToStmtDDLDropExceptionTable()
{
  return NULL;
}

StmtDDLGrant *
ElemDDLNode::castToStmtDDLGrant()
{
  return NULL;
}

StmtDDLGrantComponentPrivilege *
ElemDDLNode::castToStmtDDLGrantComponentPrivilege()
{
  return NULL;
}

StmtDDLSchGrant *
ElemDDLNode::castToStmtDDLSchGrant()
{
  return NULL;
}

StmtDDLGiveAll *
ElemDDLNode::castToStmtDDLGiveAll()
{
  return NULL;
}

StmtDDLGiveCatalog *
ElemDDLNode::castToStmtDDLGiveCatalog()
{
  return NULL;
}

StmtDDLGiveObject *
ElemDDLNode::castToStmtDDLGiveObject()
{
  return NULL;
}

StmtDDLGiveSchema *
ElemDDLNode::castToStmtDDLGiveSchema()
{
  return NULL;
}

StmtDDLReInitializeSQL *
ElemDDLNode::castToStmtDDLReInitializeSQL()
{
  return NULL;
}


StmtDDLInitializeSQL *
ElemDDLNode::castToStmtDDLInitializeSQL()
{
  return NULL;
}

StmtDDLRevoke *
ElemDDLNode::castToStmtDDLRevoke()
{
  return NULL;
}


StmtDDLRevokeComponentPrivilege *
ElemDDLNode::castToStmtDDLRevokeComponentPrivilege()
{
  return NULL;
}

StmtDDLSchRevoke *
ElemDDLNode::castToStmtDDLSchRevoke()
{
  return NULL;
}

StmtDDLDropConstraint *
ElemDDLNode::castToStmtDDLDropConstraint()
{
  return NULL;
}

StmtDDLRegisterCatalog *
ElemDDLNode::castToStmtDDLRegisterCatalog()
{
  return NULL;
}

StmtDDLUnregisterCatalog *
ElemDDLNode::castToStmtDDLUnregisterCatalog()
{
  return NULL;
}

ElemDDLFileAttrPOSNumPartns * ElemDDLNode::castToElemDDLFileAttrPOSNumPartns()
{
  return NULL;
}

ElemDDLFileAttrPOSTableSize * ElemDDLNode::castToElemDDLFileAttrPOSTableSize()
{
  return NULL;
}

ElemDDLFileAttrPOSDiskPool * ElemDDLNode::castToElemDDLFileAttrPOSDiskPool()
{
  return NULL;
}

ElemDDLFileAttrPOSIgnore * ElemDDLNode::castToElemDDLFileAttrPOSIgnore()
{
  return NULL;
}

StmtDDLRegisterComponent *
ElemDDLNode::castToStmtDDLRegisterComponent()
{
  return NULL;
}

StmtDDLRegisterUser *
ElemDDLNode::castToStmtDDLRegisterUser()
{
  return NULL;
}

StmtDDLRegOrUnregObject *
ElemDDLNode::castToStmtDDLRegOrUnregObject()
{
  return NULL;
}

StmtDDLCreateRole *
ElemDDLNode::castToStmtDDLCreateRole()
{
  return NULL;
}

StmtDDLCleanupObjects *
ElemDDLNode::castToStmtDDLCleanupObjects()
{
  return NULL;
}

StmtDDLRoleGrant *
ElemDDLNode::castToStmtDDLRoleGrant()
{
  return NULL;
}

StmtDDLonHiveObjects *
ElemDDLNode::castToStmtDDLonHiveObjects()
{
  return NULL;
}

//
// accessors
//

Int32
ElemDDLNode::getArity() const
{
  return 0;
}

ExprNode *
ElemDDLNode::getChild(Lng32 /* index */ )
{
  return NULL;
}

// Treat this node as an array (of one element).
// The number of elements in this array is 1.
// For more information about this method,
// please read the description of the corresponding
// method in file ElemDDLList.h
CollIndex
ElemDDLNode::entries() const
{
  return 1;
}

// Treat this node as an array (of one element).
// The only legal index is 0.
// For more information about this method,
// please read the description of the corresponding
// method in file ElemDDLList.h
ElemDDLNode *
ElemDDLNode::operator[](CollIndex index)
{
  ComASSERT(index EQU 0);
  return this;
}

// Treat this node as a list (of one element)
// represented by a left linear tree.
// For more information about this method,
// please read the description of the corresponding
// method in file ElemDDLList.h
/*virtual*/ void
ElemDDLNode::traverseList(ElemDDLNode * pOtherNode,
                          void (*visitNode)(ElemDDLNode * pOtherNode,
                                            CollIndex indexOfLeafNode,
                                            ElemDDLNode * pLeafNode))
{
  // visit the first (and only) element in the list
  (*visitNode)(pOtherNode, 0, this);
}

//
// mutators
//

void
ElemDDLNode::setChild(Lng32        /* index */ ,
                      ExprNode *  /* pElemDDLNode */ )
{
  ABORT("virtual function ElemDDLNode::setChild() must be redefined");
}

//
// method for binding
//

ExprNode *
ElemDDLNode::bindNode(BindWA * /*pBindWA*/)
{
  markAsBound();
  return this;
}

ComBoolean ElemDDLNode::applyDefaultsAndValidateObject(BindWA * pBindWA,
						       QualifiedName *qn)
{
  qn->applyDefaults(pBindWA->getDefaultSchema());

  return FALSE;
}

//
// methods for tracing
//

const NAString
ElemDDLNode::displayLabel1() const
{
  return NAString();
}

const NAString
ElemDDLNode::displayLabel2() const
{
  return NAString();
}

const NAString
ElemDDLNode::displayLabel3() const
{
  return NAString();
}

NATraceList
ElemDDLNode::getDetailInfo() const
{
  NATraceList detailTextList;
  if (NOT displayLabel1().isNull())
  {
    detailTextList.append(displayLabel1());
  }
  if (NOT displayLabel2().isNull())
  {
    detailTextList.append(displayLabel2());
  }
  if (NOT displayLabel3().isNull())
  {
    detailTextList.append(displayLabel3());
  }
  return detailTextList;
}

const NAString
ElemDDLNode::getText() const
{
  ABORT("internal logic error");
  return "ElemDDLNode";
}

void
ElemDDLNode::print(FILE * f,
                   const char * prefix,
                   const char * suffix) const
{
#ifdef TRACING_ENABLED 
  fprintf(f,"%s%s(%s)\n", prefix, (const char *)getText(), suffix);
#endif
}

// -----------------------------------------------------------------------
// methods for class ElemDDLAlterTableMove
// -----------------------------------------------------------------------

// constructor
ElemDDLAlterTableMove::ElemDDLAlterTableMove(ElemDDLNode * sourceLocationList,
                                             ElemDDLNode * destLocationList)
: ElemDDLNode(ELM_ALTER_TABLE_MOVE_ELEM)
{
  setChild(INDEX_SOURCE_LOCATION_LIST, sourceLocationList);
  setChild(INDEX_DEST_LOCATION_LIST, destLocationList);
}

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

// cast virtual function
ElemDDLAlterTableMove *
ElemDDLAlterTableMove::castToElemDDLAlterTableMove()
{
  return this;
}

//
// accessors
//

// get the degree of this node
Int32
ElemDDLAlterTableMove::getArity() const
{
  return MAX_ELEM_DDL_ALTER_TABLE_MOVE_ARITY;
}

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

// mutator
void
ElemDDLAlterTableMove::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
ElemDDLAlterTableMove::getText() const
{
  return "ElemDDLAlterTableMove";
}

// -----------------------------------------------------------------------
// methods for class ElemDDLAuthSchema
// -----------------------------------------------------------------------

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

// cast virtual function
ElemDDLAuthSchema *
ElemDDLAuthSchema::castToElemDDLAuthSchema()
{
  return this;
}


// -----------------------------------------------------------------------
// methods for class ElemDDLGrantee
// -----------------------------------------------------------------------

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

// cast virtual function
ElemDDLGrantee *
ElemDDLGrantee::castToElemDDLGrantee()
{
  return this;
}

//
// methods for tracing
//

const NAString
ElemDDLGrantee::displayLabel1() const
{
  if (isPublic())
  {
    return NAString("is public? ") + YesNo(isPublic());
  }
  else
  {
    return (NAString("Authorization identifier: ") +
            getAuthorizationIdentifier());
  }
}

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

// -----------------------------------------------------------------------
// methods for class ElemDDLGranteeArray
//
//   Note that class ElemDDLGranteeArray is not derived from class
//   ElemDDLGrantee.  The former represents an array of pointers
//   pointing to ElemDDLGrantee parse node.
// -----------------------------------------------------------------------

// constructor
ElemDDLGranteeArray::ElemDDLGranteeArray(CollHeap *heap)
  : LIST(ElemDDLGrantee *)(heap)
{
}

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

//----------------------------------------------------------------------------
// methods for class ElemDDLKeyValue
//----------------------------------------------------------------------------

// constructor
ElemDDLKeyValue::ElemDDLKeyValue(ItemExpr * pConstValue)
: ElemDDLNode(ELM_KEY_VALUE_ELEM)
{
  //
  // The parser currently does not handle negative
  // value well.  So we currently use castToConstValue
  // to return the nagation information of the constant.
  // This is a kludge, and it is temporary.
  //
  NABoolean isNegative;
  ComASSERT(pConstValue NEQ NULL AND
            pConstValue->castToConstValue(isNegative) NEQ NULL);
  keyValue_ = pConstValue->castToConstValue(isNegative);
}

// virtual destructor
ElemDDLKeyValue::~ElemDDLKeyValue()
{
  // delete all children
  for (Int32 i = 0; i < MAX_ELEM_DDL_KEY_VALUE_ARITY; i++)
  {
    if (getChild(i) NEQ NULL)
      delete getChild(i);
  }
}

// cast
ElemDDLKeyValue *
ElemDDLKeyValue::castToElemDDLKeyValue()
{
  return this;
}

// accessors

// get the degree of this node
Int32
ElemDDLKeyValue::getArity() const
{
  return MAX_ELEM_DDL_KEY_VALUE_ARITY;
}

ExprNode *
ElemDDLKeyValue::getChild(Lng32 index)
{
  ComASSERT(index EQU INDEX_KEY_VALUE);
  return keyValue_;
}

// mutator
void
ElemDDLKeyValue::setChild(Lng32 index, ExprNode * pChildNode)
{
  ComASSERT(index EQU INDEX_KEY_VALUE);
  if (pChildNode NEQ NULL)
  {
    //
    // The parser currently does not handle negative
    // value well.  So we currently use castToConstValue
    // to return the nagation information of the constant.
    // This is a kludge, and it is temporary.
    //
    NABoolean isNegative;
    ComASSERT(pChildNode->castToItemExpr() NEQ NULL AND
              pChildNode->castToItemExpr()
                        ->castToConstValue(isNegative) NEQ NULL);
    keyValue_ = pChildNode->castToItemExpr()->castToConstValue(isNegative);
  }
  else
    keyValue_ = NULL;
}

// methods for tracing

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


// method for building text
// virtual
NAString ElemDDLKeyValue::getSyntax() const
{
  return keyValue_->getConstStr(FALSE);


} // getSyntax()


// -----------------------------------------------------------------------
// methods for class ElemDDLLibClientName
// -----------------------------------------------------------------------

//
// contructor
//

ElemDDLLibClientName::ElemDDLLibClientName(const NAString &theName)
: ElemDDLNode(ELM_CLIENTNAME_ELEM),
  clientName_(theName)
  
{

  ComASSERT(!theName.isNull());
  
}

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

// casting
ElemDDLLibClientName *
ElemDDLLibClientName::castToElemDDLLibClientName()
{
  return this;
}

//
// methods for tracing
//

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

const NAString
ElemDDLLibClientName::displayLabel1() const
{
  return NAString("Client name: ") + getClientName();
}

// method for building text
//virtual
NAString ElemDDLLibClientName::getSyntax() const
{
  NAString syntax = "CLIENTNAME ";

  syntax += getClientName();

  return syntax;

} // getSyntax


// -----------------------------------------------------------------------
// methods for class ElemDDLLibClientFilename
// -----------------------------------------------------------------------

//
// contructor
//

ElemDDLLibClientFilename::ElemDDLLibClientFilename(const NAString &theName)
: ElemDDLNode(ELM_CLIENTFILE_ELEM),
  theFilename_(theName)
  
{

  ComASSERT(!theName.isNull());
  
}

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

// casting
ElemDDLLibClientFilename *
ElemDDLLibClientFilename::castToElemDDLLibClientFilename()
{
  return this;
}

//
// methods for tracing
//

const NAString
ElemDDLLibClientFilename::getText() const
{
  return "ElemDDLLibClientName";
}

const NAString
ElemDDLLibClientFilename::displayLabel1() const
{
  return NAString("Client file: ") + getFilename();
}

// method for building text
//virtual
NAString ElemDDLLibClientFilename::getSyntax() const
{
  NAString syntax = "CLIENTFILE ";

  syntax += getFilename();

  return syntax;

} // getSyntax


// -----------------------------------------------------------------------
// methods for class ElemDDLLibPathName
// -----------------------------------------------------------------------

//
// contructor
//

ElemDDLLibPathName::ElemDDLLibPathName(
      const NAString     &theName)
: ElemDDLNode(ELM_PATHNAME_ELEM),
  pathName_(theName)
  
{

  ComASSERT(!theName.isNull());
  
}

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

// casting
ElemDDLLibPathName *
ElemDDLLibPathName::castToElemDDLLibPathName()
{
  return this;
}

//
// methods for tracing
//

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

const NAString
ElemDDLLibPathName::displayLabel1() const
{
  return NAString("Path: ") + getPathName();
}

// method for building text
//virtual
NAString ElemDDLLibPathName::getSyntax() const
{

  return NAString("PATH ") + getPathName();

} // getSyntax


// -----------------------------------------------------------------------
// methods for class ElemDDLLocation
// -----------------------------------------------------------------------

//
// contructor
//

ElemDDLLocation::ElemDDLLocation(locationNameTypeEnum locationNameType,
                                 const NAString & aLocationName)
: ElemDDLNode(ELM_LOCATION_ELEM),
  locationNameInputFormat_(ComLocationName::UNKNOWN_INPUT_FORMAT),
  flags_(0),
  locationNameType_(locationNameType),
  locationName_(aLocationName, PARSERHEAP()),
  partitionName_(PARSERHEAP())
{
  //
  // checks the syntax of the input aLocationName
  //

  ComASSERT(NOT aLocationName.isNull());
  ComLocationName locName;

  switch(locationNameType)
  {
  case LOCATION_ENVIRONMENT_VARIABLE:
    //
    // This feature is currently not supported.
    // The parser has already issued error message(s).
    //
    // Does not check for valid syntax.
    //
    break;

  case LOCATION_GUARDIAN_NAME:
  case LOCATION_OSS_NAME:
    {
      if (locationNameType EQU LOCATION_GUARDIAN_NAME)
      {
        locName.copy(aLocationName,
                     ComLocationName::GUARDIAN_LOCATION_NAME_FORMAT);
      }
      else
      {
        locName.copy(aLocationName,
                     ComLocationName::OSS_LOCATION_NAME_FORMAT);
      }

      if (NOT locName.isValid())
      {
        // Illegal location name.
        *SqlParser_Diags << DgSqlCode(-3061) << DgString0(aLocationName);
      }
      locationNameInputFormat_ = locName.getInputFormat();

      //
      // check system name part
      //

      const ComNodeName & systemName = locName.getGuardianSystemNamePart();
      if (!systemName.isNull())
      {
        Lng32 systemNumber;
        if (systemName.getNodeNumber(systemNumber) &&
	   (CmpCommon::getDefault(CREATE_OBJECTS_IN_METADATA_ONLY,0) == DF_OFF))
           //|| !OSIM_runningSimulation()))
          // Currently system name is not defined
          *SqlParser_Diags << DgSqlCode(-3122) << DgString0(aLocationName);
      }

      //
      // check subvolume name part
      //

      const ComSubvolumeName & svNamePart = locName.getSubvolumeNamePart();
      if (!svNamePart.isNull())
      {
        size_t svMinLength = 4;
        if (!svNamePart.isMXSubvol (svMinLength))
        {
          flags_ |= INVALIDSUBVOLNAME;
          // Subvolume name part must be eight characters long and
          // contain the ZSD prefix
          *SqlParser_Diags << DgSqlCode(-3025) << DgString0(aLocationName);
        }
      }

      //
      // check file name part
      //

      const ComFileName & fileNamePart = locName.getFileNamePart();
      if (!fileNamePart.isNull())
      {
        if (NOT fileNamePart.isMXDataFork())
        {
          flags_ |= INVALIDFILENAME;
          // File name part must be eight characters long and
          // contain the two zero digit suffix
          *SqlParser_Diags << DgSqlCode(-3123) << DgString0(aLocationName);
        }
      }
    }
    break;

  default:
    ABORT("internal logic error");
    break;
  }
}

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

// casting
ElemDDLLocation *
ElemDDLLocation::castToElemDDLLocation()
{
  return this;
}

// accessor
NAString
ElemDDLLocation::getLocationNameTypeAsNAString() const
{
  switch (getLocationNameType())
  {
  case LOCATION_OSS_NAME :
    return NAString("OSS path name");
  case LOCATION_GUARDIAN_NAME :
    return NAString("Guardian device name");
  case LOCATION_ENVIRONMENT_VARIABLE :
    return NAString("OSS environment variable name");
  default :
    ABORT("internal logic error");
    return NAString();
  }
}

//
// methods for tracing
//

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

const NAString
ElemDDLLocation::displayLabel1() const
{
  return NAString("Location name: ") + getLocationName();
}

const NAString
ElemDDLLocation::displayLabel2() const
{
  return NAString("Location name type: ") + getLocationNameTypeAsNAString();
}

const NAString
ElemDDLLocation::displayLabel3() const
{
  return NAString("Partition name: ") + getPartitionName();
}


// method for building text
//virtual
NAString ElemDDLLocation::getSyntax() const
{
  NAString syntax = "LOCATION ";

  syntax += getLocation();

  if(getPartitionName() != "")
  {
	  syntax += "NAME ";
	  syntax += getPartitionName();
  }

  return syntax;

} // getSyntax

// -----------------------------------------------------------------------
// methods for class ElemDDLParallelExec
// -----------------------------------------------------------------------

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

// cast
ElemDDLParallelExec *
ElemDDLParallelExec::castToElemDDLParallelExec()
{
  return this;
}

//
// methods for tracing
//

const NAString
ElemDDLParallelExec::displayLabel1() const
{
  return (NAString("is parallel exec enabled? ") +
          YesNo(isParallelExecEnabled()));
}

const NAString
ElemDDLParallelExec::displayLabel2() const
{
  if (isParallelExecEnabled())
  {
    return NAString("config file name: ") + getConfigFileName();
  }
  else
  {
    return NAString();
  }
}

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

// -----------------------------------------------------------------------
// methods for class ElemDDLPrivileges
// -----------------------------------------------------------------------

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

// cast virtual function
ElemDDLPrivileges *
ElemDDLPrivileges::castToElemDDLPrivileges()
{
  return this;
}

//
// accessors
//

// get the degree of this node
Int32
ElemDDLPrivileges::getArity() const
{
  return MAX_ELEM_DDL_PRIVILEGES_ARITY;
}

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

//
// mutators
//

void
ElemDDLPrivileges::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;
  }
}

NABoolean ElemDDLPrivileges::containsPriv(OperatorTypeEnum whichPriv) const
{
  ElemDDLNode *pActionList = getPrivilegeActionList();
  if (!pActionList)
    return FALSE;

  ElemDDLList * pDDLList = pActionList->castToElemDDLList();
  if (!pDDLList)
  {
    ElemDDLPrivAct *pPrivAct = pActionList->castToElemDDLPrivAct();
    if ( pPrivAct->getOperatorType() == whichPriv )
      return TRUE;
  }
  else
  {
    for (CollIndex i = 0 ; i < pDDLList->entries() ; i++)
    {
      ElemDDLPrivAct *pPrivAct = (*pDDLList)[i]->castToElemDDLPrivAct();
      if ( pPrivAct->getOperatorType() == whichPriv )
        return TRUE;
    }
  }
  return FALSE;
} 

NABoolean ElemDDLPrivileges::containsColumnPrivs() const
{
  ElemDDLNode * privActs = getPrivilegeActionList();
  if (!privActs)
    return FALSE;

  ElemDDLList * privActsList = privActs->castToElemDDLList();
  if (!privActsList)
  {
    if (privActs->castToElemDDLPrivActWithColumns())
    {
      if(privActs->castToElemDDLPrivActWithColumns()
          ->getColumnNameArray().entries() > 0)
          return TRUE;
    }
  }
  else
  {
    for (CollIndex i = 0 ; i < privActsList->entries() ; i++)
    {
      if ((*privActsList)[i]->castToElemDDLPrivActWithColumns())
      {
        if((*privActsList)[i]->castToElemDDLPrivActWithColumns()
          ->getColumnNameArray().entries() > 0)
          return TRUE;
      }
    }
  }
  return FALSE;
}

//
// methods for tracing
//

const NAString
ElemDDLPrivileges::displayLabel1() const
{
  return NAString("is all privileges? ") + YesNo(isAllPrivileges());
}

NATraceList
ElemDDLPrivileges::getDetailInfo() const
{
  NAString        detailText;
  NATraceList detailTextList;
  ElemDDLNode   * pPrivActList = getPrivilegeActionList();

  if (isAllPrivileges())
  {
    ComASSERT(pPrivActList EQU NULL);
    detailTextList.append(displayLabel1());   // All Privileges
    return detailTextList;
  }

  ComASSERT(pPrivActList NEQ NULL);

  detailText = "Privilege Action List [";
  detailText += LongToNAString((Lng32)pPrivActList->entries());
  detailText += " element(s)]:";
  detailTextList.append(detailText);

  for (CollIndex i = 0; i < pPrivActList->entries(); i++)
  {
    detailText = "[privilege action ";
    detailText += LongToNAString((Lng32)i);
    detailText += "]";
    detailTextList.append(detailText);

    detailTextList.append("    ", (*pPrivActList)[i]->getDetailInfo());
  }

  return detailTextList;
}

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


// -----------------------------------------------------------------------
// methods for class ElemDDLReferences
// -----------------------------------------------------------------------

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

//cast
ElemDDLReferences *
ElemDDLReferences::castToElemDDLReferences()
{
  return this;
}

//
// accessors
//

Int32
ElemDDLReferences::getArity() const
{
  return MAX_ELEM_DDL_REFERENCES_ARITY;
}

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

NAString
ElemDDLReferences::getReferencedTableName() const
{
  return getReferencedNameAsQualifiedName().getQualifiedNameAsAnsiString();
}

//
// mutator
//

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

//
// methods for tracing
//

const NAString
ElemDDLReferences::displayLabel1() const
{
  return NAString("Referenced table name: ") + getReferencedTableName();
}

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

  //
  // referenced table name
  //

  detailTextList.append(displayLabel1());

  //
  // referenced columns
  //

  if (getReferencedColumns() EQU NULL)
  {
    detailTextList.append("Referenced column list not specified.");
  }
  else
  {
    CollIndex nbrCols = getReferencedColumns()->entries();
    ComASSERT(nbrCols > 0);

    detailText = "Referenced column list [";
    detailText += LongToNAString((Lng32)nbrCols);
    detailText += " element(s)]:";
    detailTextList.append(detailText);

    for (CollIndex i = 0; i < nbrCols; i++)
    {
      detailText = "[referenced column ";
      detailText += LongToNAString((Lng32)i);
      detailText += "]";
      detailTextList.append(detailText);

      NATraceList refColDetailTextList
        = (*getReferencedColumns())[i]->getDetailInfo();

      for (CollIndex j = 0; j < refColDetailTextList.entries(); j++)
      {
        detailTextList.append(NAString("    ") + refColDetailTextList[j]);
      }
    }
  } // else (getReferencedColumns() NEQ NULL)

  return detailTextList;

} // ElemDDLReferences::getDetailInfo()

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

// -----------------------------------------------------------------------
// methods for class ElemDDLSchemaName
// -----------------------------------------------------------------------

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

// cast virtual function
ElemDDLSchemaName *
ElemDDLSchemaName::castToElemDDLSchemaName()
{
  return this;
}

// -----------------------------------------------------------------------
// methods for class ElemDDLTableFeature
// -----------------------------------------------------------------------
//
// methods for tracing
//

const NAString
ElemDDLTableFeature::displayLabel1() const
{
  NAString tableAttr ("Table options: ");
  if (isDroppable())
    tableAttr += "DROPPABLE, ";
  else
    tableAttr += "NOT DROPPABLE, ";
  if (isInsertOnly())
    tableAttr += "INSERT_ONLY ";
  else
    tableAttr += "ALL DML ALLOWED";

  return tableAttr;
}

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

// -----------------------------------------------------------------------
// methods for class ElemDDLHbaseOptions
// -----------------------------------------------------------------------
//
// methods for tracing
//

const NAString
ElemDDLHbaseOptions::displayLabel1() const
{
  return "";
}

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

// -----------------------------------------------------------------------
// methods for class ElemDDLWithCheckOption
// -----------------------------------------------------------------------

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

// cast virtual function
ElemDDLWithCheckOption *
ElemDDLWithCheckOption::castToElemDDLWithCheckOption()
{
  return this;
}

//
// accessor
//

NAString
ElemDDLWithCheckOption::getLevelAsNAString() const
{
  switch (getLevel())
  {
  case COM_CASCADED_LEVEL :
    return "CASCADED";
  case COM_LOCAL_LEVEL :
    return "LOCAL";
  case COM_UNKNOWN_LEVEL :
    return "UNKNOWN";
  default :
    ABORT("internal logic error");
    return NAString();
  }
}

//
// methods for tracing
//

const NAString
ElemDDLWithCheckOption::displayLabel1() const
{
  return NAString("Level: ") + getLevelAsNAString();
}

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

// -----------------------------------------------------------------------
// methods for class ElemDDLWithGrantOption
// -----------------------------------------------------------------------

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

// cast virtual function
ElemDDLWithGrantOption *
ElemDDLWithGrantOption::castToElemDDLWithGrantOption()
{
  return this;
}

// methods for tracing
const NAString
ElemDDLWithGrantOption::getText() const
{
  return "ElemDDLWithGrantOption";
}

// -----------------------------------------------------------------------
// methods for class ElemDDLColNameListNode
// -----------------------------------------------------------------------

// virtual destructor
ElemDDLColNameListNode :: ~ElemDDLColNameListNode()
{
    // delete the column name list

  delete columnNameList_;
}

// cast virtual function
ElemDDLColNameListNode *
ElemDDLColNameListNode::castToElemDDLColNameListNode()
{
  return this;
}

// methods for tracing
const NAString
ElemDDLColNameListNode ::getText() const
{
  return "ElemDDLColNameListNode";
}

// -----------------------------------------------------------------------
// methods for class ElemDDLDivisionClause
// -----------------------------------------------------------------------

ElemDDLDivisionClause::ElemDDLDivisionClause(ItemExpr * pDivisionExprTree)
  : ElemDDLNode(ELM_DIVISION_CLAUSE_ELEM),
    eDivisionType_(DIVISION_BY_EXPR_LIST),
    pDivisionExprTree_(pDivisionExprTree), // shallow copy - Assume *pDivisionExprTree parse tree allocated in PARSERHEAP()
    pDivisionExprList_(NULL),
    pColumnRefList_(NULL),
    columnRefArray_(PARSERHEAP()),
    startPos_(0),
    endPos_(0)
{
  pDivisionExprList_ = new(PARSERHEAP()) ItemExprList(pDivisionExprTree, PARSERHEAP());
}

ElemDDLDivisionClause::ElemDDLDivisionClause(divisionTypeEnum eDivisionType)
  : ElemDDLNode(ELM_DIVISION_CLAUSE_ELEM),
    eDivisionType_(eDivisionType),
    pDivisionExprTree_(NULL),
    pDivisionExprList_(NULL),
    pColumnRefList_(NULL),
    columnRefArray_(PARSERHEAP()),
    startPos_(0),
    endPos_(0)
{
  PARSERASSERT(eDivisionType EQU DIVISION_LIKE_TABLE); // valid in CREATE INDEX syntax only
}

// virtual destructor
ElemDDLDivisionClause::~ElemDDLDivisionClause()
{
  // Note that we do not destroy the parse tree pointed by data member
  // pDivisionExprTree_ (because the constructor did a shallow copy).
  // We assume that the parse tree is allocated in the PARSERHEAP().
  delete pDivisionExprList_;
}

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

// Gather the information from the child sub-tree and store it in this Parse node
void ElemDDLDivisionClause::synthesize(ElemDDLNode * pColRefTree)
{
  this->setColumnRefList(pColRefTree);

  size_t colRefEntries = 0;
  if (pColRefTree NEQ NULL)
    colRefEntries = pColRefTree->entries();
  if (colRefEntries EQU 1)
  {
    columnRefArray_.insert(pColRefTree->castToElemDDLColRef());
  }
  else if (colRefEntries > 1 AND pColRefTree NEQ NULL)
  {
    ElemDDLList * pElemDDLList = pColRefTree->castToElemDDLList();
    ElemDDLColRef * pElemDDLColRef = NULL;
    ItemExpr * pDivExpr = NULL;
    ComColumnOrdering eSortingOrder = COM_UNKNOWN_ORDER;
    Int32 iInverseNodeCount = 0;

    for (CollIndex i = 0; i < colRefEntries; i++)
    {
      pElemDDLColRef = ((*pElemDDLList)[i])->castToElemDDLColRef();
      columnRefArray_.insert(pElemDDLColRef); // shallow copy

      // Get the sorting order setting from the division expression parse tree;
      // then assign that value to the associating ElemDDLColRef parse node
      // to override the ElemDDLColRef default sorting order setting.
      pDivExpr = (*pDivisionExprList_)[i];
      eSortingOrder = COM_ASCENDING_ORDER;
      iInverseNodeCount = 0;
      while (pDivExpr NEQ NULL AND pDivExpr->getOperatorType() EQU ITM_INVERSE)
      {
        pDivExpr = pDivExpr->child(0);
        iInverseNodeCount++;
      }
      if ((iInverseNodeCount % 2) EQU 1) // odd count
        eSortingOrder = COM_DESCENDING_ORDER;
      pElemDDLColRef->setColumnOrdering(eSortingOrder);
    }
  }
}

// Check to make sure that the number of division expressions in the DIVISION BY ( ... ) clause
// matches the number of columns specified in the associating COLUMN NAME[S] ( ... ) clause
NABoolean ElemDDLDivisionClause::isNumOfDivExprsAndColsMatched() const
{
  if (pDivisionExprList_ NEQ NULL)
  {
    if (pDivisionExprList_->entries() NEQ columnRefArray_.entries())
      return FALSE;
  }
  else // pDivisionExprList_ EQU NULL
  {
    if (columnRefArray_.entries() > 0)
      return FALSE;
  }
  return TRUE;
}

// virtual method for tracing
const NAString ElemDDLDivisionClause::getText() const
{
  return "ElemDDLDivisionClause";
}

// method for building text
// virtual 
NAString ElemDDLDivisionClause::getSyntax() const
{
  ElemDDLDivisionClause * ncThis = const_cast<ElemDDLDivisionClause *>(this);
  ItemExprList * pItemExprList = ncThis->getDivisionExprList();
  ParNameLocList & nameLocList = ncThis->getNameLocList();
  const char * pInputStr = nameLocList.getInputStringPtr();
  StringPos startPos = this->getStartPosition();
  StringPos endPos = this->getEndPosition();

  // Temporary code to help with debugging
  // *SqlParser_Diags << DgSqlCode(-1110) 
  //                  << DgString0("Define LOOP_ON_ERROR=1110 in file ms.env before starting sqlci");

  NAString syntax;
  if (pItemExprList EQU NULL OR pItemExprList->entries() EQU 0 OR
      pInputStr EQU NULL OR strlen(pInputStr) EQU 0 OR startPos >= endPos)
    return syntax;

  const char * pDivExprListText = &pInputStr[startPos];
  size_t divExprListTextLenInBytes = (size_t)(endPos + 1 - startPos);

  syntax = " DIVISION BY ";
  if (*pDivExprListText NEQ '(')
    syntax += "(";
  syntax.append(pDivExprListText, divExprListTextLenInBytes);
  if (*pDivExprListText NEQ '(')
    syntax += ")";
  syntax += " ";

  return syntax;

} // getSyntax

// -----------------------------------------------------------------------
// methods for class ElemDDLSaltOptionsClause
// -----------------------------------------------------------------------

ElemDDLSaltOptionsClause::ElemDDLSaltOptionsClause(ElemDDLNode * pSaltExprTree,
                                                   Int32 numPartitions)
  : ElemDDLNode(ELM_SALT_OPTIONS_ELEM),
    numPartitions_(numPartitions),
    saltColumnArray_(PARSERHEAP()),
    likeTable_(FALSE)
{
  setChild(INDEX_SALT_COLUMN_LIST, pSaltExprTree);
  //
  // copies pointers to parse nodes representing
  // column names (appearing in a store option) to
  // keyColumnArray_ so the user can access this
  // information easier.
  //

  if (pSaltExprTree)
    for (CollIndex i = 0; i < pSaltExprTree->entries(); i++)
      {
        saltColumnArray_.insert((*pSaltExprTree)[i]->castToElemDDLColRef());
      }
}

ElemDDLSaltOptionsClause::ElemDDLSaltOptionsClause(NABoolean likeTable)
  : ElemDDLNode(ELM_SALT_OPTIONS_ELEM),
    numPartitions_(0),
    saltColumnArray_(PARSERHEAP()),
    likeTable_(likeTable)
{
}


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

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

// virtual method for tracing
const NAString ElemDDLSaltOptionsClause::getText() const
{
  return "ElemDDLSaltOptionsClause";
}

// get the degree of this node
Int32
ElemDDLSaltOptionsClause::getArity() const
{
  return MAX_ELEM_DDL_SALT_OPT_KEY_COLUMN_LIST_ARITY;
}

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

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


NABoolean
ElemDDLSaltOptionsClause::getLikeTable() const
{
  return likeTable_;
}

void
ElemDDLSaltOptionsClause::unparseIt(NAString & result) const
{
  if (likeTable_)
    result = "SALT LIKE TABLE";
  else
    {  
      char buf[40];
      sprintf(buf," SALT USING %d PARTITIONS",numPartitions_);
      result = buf;

      if (saltColumnArray_.entries() > 0)
        {
          result += " ON (";
          const ElemDDLColRef * colRef = saltColumnArray_[0];
          result += colRef->getColumnName();
          for (CollIndex i = 1; i < saltColumnArray_.entries(); i++)
            {
              result += ",";
              colRef = saltColumnArray_[i];
              result += colRef->getColumnName();
            }
          result += ")";
        }
    }
}

//
// End of File
//