| /* -*-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: StmtDDLAlter.C |
| * Description: contains definitions of non-inline methods for classes |
| * representing DDL Alter Statements |
| * |
| * Also contains definitions of non-inline methods for classes |
| * relating to check constraint usages |
| * |
| * |
| * Created: 3/9/95 |
| * Language: C++ |
| * |
| * |
| * |
| * |
| ***************************************************************************** |
| */ |
| |
| |
| #include "AllStmtDDLAlterTable.h" |
| #include "StmtDDLAlterTableToggleConstraint.h" |
| #include "BaseTypes.h" |
| #include "ComASSERT.h" |
| #include "ComOperators.h" |
| #include "ElemDDLConstraint.h" |
| #include "ElemDDLConstraintCheck.h" |
| #include "ElemDDLFileAttrClause.h" |
| #include "ElemDDLLibClientFilename.h" |
| #include "ElemDDLLibClientName.h" |
| #include "StmtDDLAlterIndexAttribute.h" |
| #include "ElemDDLConstraintPK.h" |
| #include "AllStmtDDLAlter.h" // MV - RG |
| #include "ElemDDLQualName.h" // MV - RG |
| #include "StmtDDLAlterTrigger.h" |
| #include "AllElemDDLFileAttr.h" |
| #include "StmtDDLAlterAuditConfig.h" |
| #include "StmtDDLAlterCatalog.h" |
| #include "StmtDDLAlterSchema.h" |
| #include "StmtDDLAlterLibrary.h" |
| #include "StmtDDLAlterSynonym.h" |
| #include "StmtDDLAlterTableDisableIndex.h" |
| #include "StmtDDLAlterTableEnableIndex.h" |
| #include "StmtDDLAlterTableAlterColumn.h" |
| |
| // ----------------------------------------------------------------------- |
| // definitions of non-inline methods for class ParCheckConstraintColUsage |
| // ----------------------------------------------------------------------- |
| |
| // |
| // default constructor |
| // |
| |
| ParCheckConstraintColUsage::ParCheckConstraintColUsage(CollHeap * h) |
| : isInSelectList_(FALSE), |
| tableName_(h), columnName_(h) |
| { |
| } |
| |
| // |
| // initialize constructor |
| // |
| |
| ParCheckConstraintColUsage::ParCheckConstraintColUsage |
| ( const ColRefName &colName, |
| const NABoolean isInSelectList, |
| CollHeap * h) |
| : tableName_(colName.getCorrNameObj().getQualifiedNameObj(), h), |
| columnName_(colName.getColName(), h), |
| isInSelectList_(isInSelectList) |
| { |
| } |
| |
| |
| // |
| // virtual destructor |
| // |
| |
| ParCheckConstraintColUsage::~ParCheckConstraintColUsage() |
| { |
| } |
| |
| // |
| // operator |
| // |
| |
| NABoolean |
| ParCheckConstraintColUsage::operator==(const ParCheckConstraintColUsage &rhs) |
| const |
| { |
| if (this EQU &rhs) |
| { |
| return TRUE; |
| } |
| return (getColumnName() EQU rhs.getColumnName() AND |
| getTableQualName() EQU rhs.getTableQualName() AND |
| isInSelectList() EQU rhs.isInSelectList()); |
| } |
| |
| // ----------------------------------------------------------------------- |
| // definitions of non-inline methods for class ParCheckConstraintColUsageList |
| // ----------------------------------------------------------------------- |
| |
| // |
| // constructor |
| // |
| |
| ParCheckConstraintColUsageList::ParCheckConstraintColUsageList |
| (const ParCheckConstraintColUsageList &other, |
| CollHeap *heap) |
| : LIST(ParCheckConstraintColUsage *)(other, heap), |
| heap_(heap) |
| { |
| } |
| |
| // |
| // virtual destructor |
| // |
| |
| ParCheckConstraintColUsageList::~ParCheckConstraintColUsageList() |
| { |
| for (CollIndex i = 0; i < entries(); i++) |
| { |
| //KSKSKS |
| delete &operator[](i); |
| // NADELETE(&operator[](i), ParCheckConstraintColUsage, heap_); |
| //KSKSKS |
| } |
| } |
| |
| // |
| // operator |
| // |
| |
| ParCheckConstraintColUsageList & |
| ParCheckConstraintColUsageList::operator= |
| (const ParCheckConstraintColUsageList &rhs) |
| { |
| if (this EQU &rhs) return *this; |
| clear(); |
| copy(rhs); |
| return *this; |
| } |
| |
| // |
| // accessor |
| // |
| |
| ParCheckConstraintColUsage * const |
| ParCheckConstraintColUsageList::find(const ColRefName &colName) |
| { |
| for (CollIndex i = 0; i < entries(); i++) |
| { |
| if (operator[](i).getColumnName() EQU colName.getColName() AND |
| operator[](i).getTableQualName() EQU colName.getCorrNameObj(). |
| getQualifiedNameObj()) |
| { |
| return &operator[](i); |
| } |
| } |
| return NULL; |
| } |
| |
| // |
| // mutators |
| // |
| |
| void |
| ParCheckConstraintColUsageList::clear() |
| { |
| for (CollIndex i = 0; i < entries(); i++) |
| { |
| //KSKSKS |
| delete &operator[](i); |
| // NADELETE(&operator[](i), ParCheckConstraintColUsage, heap_); |
| //KSKSKS |
| } |
| LIST(ParCheckConstraintColUsage *)::clear(); |
| // leave data member heap_ alone (it's only set once, by the constructor). |
| } |
| |
| void |
| ParCheckConstraintColUsageList::copy(const ParCheckConstraintColUsageList &rhs) |
| { |
| // DO NOT set the heap_ field. |
| // It's already been set by the constructor |
| // heap_ = rhs.heap_; |
| |
| for (CollIndex i = 0; i < rhs.entries(); i++) |
| { |
| CorrName corrName(rhs[i].getTableQualName()); |
| ColRefName colRefName(rhs[i].getColumnName(), corrName); |
| insert(colRefName, rhs[i].isInSelectList()); |
| } |
| } |
| |
| void |
| ParCheckConstraintColUsageList::insert(const ColRefName &colName, |
| const NABoolean isInSelectList) |
| { |
| ParCheckConstraintColUsage * const pCu = find(colName); |
| if (pCu EQU NULL) // not found |
| { |
| // ok to insert |
| ParCheckConstraintColUsage *cu = new(heap_) |
| ParCheckConstraintColUsage(colName, isInSelectList, heap_); |
| LIST(ParCheckConstraintColUsage *)::insert(cu); |
| } |
| else // found |
| { |
| if (NOT pCu->isInSelectList()) |
| { |
| pCu->setIsInSelectList(isInSelectList); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| // definitions of non-inline methods for class ParCheckConstraintUsages |
| // ----------------------------------------------------------------------- |
| |
| // |
| // virtual destructor |
| // |
| |
| ParCheckConstraintUsages::~ParCheckConstraintUsages() |
| { |
| } |
| |
| |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLAlterAuditConfig |
| // ----------------------------------------------------------------------- |
| |
| // |
| // constructor |
| // |
| // constructor used for ALTER AUDIT CONFIG |
| StmtDDLAlterAuditConfig::StmtDDLAlterAuditConfig( |
| const NAString & logName, |
| const NAString & columns, |
| const NAString & values) |
| : StmtDDLNode(DDL_ALTER_AUDIT_CONFIG), |
| logName_(logName), |
| columns_(columns), |
| values_(values) |
| |
| { |
| |
| } |
| |
| // virtual destructor |
| StmtDDLAlterAuditConfig::~StmtDDLAlterAuditConfig() |
| { |
| } |
| |
| // virtual cast |
| StmtDDLAlterAuditConfig * |
| StmtDDLAlterAuditConfig::castToStmtDDLAlterAuditConfig() |
| { |
| return this; |
| } |
| |
| |
| // |
| // methods for tracing |
| // |
| |
| const NAString |
| StmtDDLAlterAuditConfig::displayLabel1() const |
| { |
| return NAString("Log name: ") + getLogName(); |
| } |
| |
| const NAString |
| StmtDDLAlterAuditConfig::displayLabel2() const |
| { |
| |
| return NAString("Columns: ") + getColumns() + |
| NAString("Values: ") + getValues(); |
| |
| } |
| |
| |
| const NAString |
| StmtDDLAlterAuditConfig::getText() const |
| { |
| return "StmtDDLAlterAuditConfig"; |
| } |
| |
| |
| |
| |
| |
| // ----------------------------------------------------------------------- |
| // Methods for class StmtDDLAlterCatalog |
| // ----------------------------------------------------------------------- |
| |
| // This constructor is used by: |
| // ALTER CATALOG <cat> <enable/disable> SCHEMA <schema name> |
| StmtDDLAlterCatalog::StmtDDLAlterCatalog(const NAString & catalogName, |
| NABoolean isEnable, |
| const ElemDDLSchemaName & aSchemaNameParseNode, |
| CollHeap * heap) |
| |
| : StmtDDLNode(DDL_ALTER_CATALOG), |
| catalogName_(catalogName, heap), |
| schemaName_(heap), |
| schemaQualName_(aSchemaNameParseNode.getSchemaName(), heap), |
| enableStatus_(isEnable), |
| disableEnableCreates_(FALSE), |
| disableEnableAllCreates_(FALSE), |
| isAllSchemaPrivileges_(FALSE) |
| { |
| } |
| |
| // This constructor is used by: |
| // ALTER CATALOG <cat> <enable/disable> ALL SCHEMA and |
| // ALTER CATALOG <cat> <enable/disable> CREATE |
| StmtDDLAlterCatalog::StmtDDLAlterCatalog(const NAString & catalogName, |
| NABoolean isEnable, |
| NABoolean disableEnableCreates) |
| : StmtDDLNode(DDL_ALTER_CATALOG), |
| catalogName_(catalogName, PARSERHEAP()), |
| schemaName_(PARSERHEAP()), |
| schemaQualName_(PARSERHEAP()), |
| enableStatus_(isEnable) |
| { |
| if (disableEnableCreates) |
| { |
| isAllSchemaPrivileges_ = FALSE; |
| disableEnableCreates_ = TRUE; |
| disableEnableAllCreates_ = FALSE; |
| } |
| else |
| { |
| isAllSchemaPrivileges_ = TRUE; |
| disableEnableCreates_ = FALSE; |
| disableEnableAllCreates_ = FALSE; |
| } |
| } |
| |
| // This constructure is used by: |
| // ALTER ALL CATALOG <enable/disable> CREATE and |
| // ALTER ALL CATALOGS <enable/disable> CREATE |
| StmtDDLAlterCatalog::StmtDDLAlterCatalog(NABoolean isEnable) |
| : StmtDDLNode(DDL_ALTER_CATALOG), |
| catalogName_(PARSERHEAP()), |
| schemaName_(PARSERHEAP()), |
| schemaQualName_(PARSERHEAP()), |
| enableStatus_(isEnable), |
| isAllSchemaPrivileges_(FALSE), |
| disableEnableCreates_(FALSE), |
| disableEnableAllCreates_(TRUE) |
| { |
| } |
| |
| // This constructor is used by: |
| // ALTER CATALOG <cat> <enable/disable> CREATE IN SCHEMA <schema name> |
| StmtDDLAlterCatalog::StmtDDLAlterCatalog(const NAString & catalogName, |
| NABoolean isEnable, |
| NABoolean disableEnableCreates, |
| const ElemDDLSchemaName & aSchemaNameParseNode, |
| CollHeap * heap) |
| |
| : StmtDDLNode(DDL_ALTER_CATALOG), |
| catalogName_(catalogName, heap), |
| schemaName_(heap), |
| schemaQualName_(aSchemaNameParseNode.getSchemaName(), heap), |
| enableStatus_(isEnable), |
| disableEnableCreates_(disableEnableCreates), |
| disableEnableAllCreates_(FALSE), |
| isAllSchemaPrivileges_(FALSE) |
| { |
| } |
| |
| StmtDDLAlterCatalog::~StmtDDLAlterCatalog() |
| {} |
| |
| // cast |
| |
| StmtDDLAlterCatalog * |
| StmtDDLAlterCatalog::castToStmtDDLAlterCatalog() |
| { |
| return this; |
| } |
| |
| // for tracing |
| const NAString |
| StmtDDLAlterCatalog::displayLabel1() const |
| { |
| return NAString("Catalog name: " ) + getCatalogName(); |
| } |
| |
| Int32 |
| StmtDDLAlterCatalog::getArity() const |
| { |
| return MAX_STMT_DDL_ALTER_CATALOG_ARITY; |
| } |
| |
| const NAString |
| StmtDDLAlterCatalog::getText() const |
| { |
| return "StmtDDLAlterCatalog"; |
| } |
| |
| void |
| StmtDDLAlterCatalog::setSchemaName(const ElemDDLSchemaName & aSchemaName) |
| { |
| schemaQualName_ = aSchemaName.getSchemaName(); |
| } |
| void |
| StmtDDLAlterCatalog::setAllPrivileges(NABoolean isAll) |
| { |
| isAllSchemaPrivileges_ = isAll; |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| // Methods for class StmtDDLAlterSchema |
| // ----------------------------------------------------------------------- |
| |
| void StmtDDLAlterSchema::initChecks() |
| { |
| if (schemaQualName_.getCatalogName().isNull()) |
| { |
| schemaName_ = ToAnsiIdentifier(schemaQualName_.getSchemaName()); |
| } |
| else |
| { |
| schemaName_ = ToAnsiIdentifier(schemaQualName_.getCatalogName()) + "." + |
| ToAnsiIdentifier(schemaQualName_.getSchemaName()); |
| } |
| |
| // If the schema name specified is reserved name, users cannot drop them. |
| // They can only be dropped internally. |
| if ((! Get_SqlParser_Flags(INTERNAL_QUERY_FROM_EXEUTIL)) && |
| (ComIsTrafodionReservedSchemaName(schemaQualName_.getSchemaName())) && |
| (!ComIsTrafodionExternalSchemaName(schemaQualName_.getSchemaName()))) |
| { |
| // error. |
| *SqlParser_Diags << DgSqlCode(-1430) |
| << DgSchemaName(schemaName_); |
| } |
| } |
| |
| StmtDDLAlterSchema::StmtDDLAlterSchema(const ElemDDLSchemaName & aSchemaNameParseNode, |
| CollHeap * heap) |
| : StmtDDLNode(DDL_ALTER_SCHEMA), |
| schemaQualName_(aSchemaNameParseNode.getSchemaName(), heap), |
| dropAllTables_(TRUE), |
| renameSchema_(FALSE), |
| alterStoredDesc_(FALSE) |
| { |
| initChecks(); |
| } |
| |
| StmtDDLAlterSchema::StmtDDLAlterSchema(const ElemDDLSchemaName & aSchemaNameParseNode, |
| NAString &renamedSchName, |
| CollHeap * heap) |
| : StmtDDLNode(DDL_ALTER_SCHEMA), |
| schemaQualName_(aSchemaNameParseNode.getSchemaName(), heap), |
| dropAllTables_(FALSE), |
| renameSchema_(TRUE), |
| renamedSchName_(renamedSchName), |
| alterStoredDesc_(FALSE) |
| { |
| initChecks(); |
| } |
| |
| StmtDDLAlterSchema::StmtDDLAlterSchema(const ElemDDLSchemaName & aSchemaNameParseNode, |
| const StmtDDLAlterTableStoredDesc::AlterStoredDescType oper, |
| CollHeap * heap) |
| |
| : StmtDDLNode(DDL_ALTER_SCHEMA), |
| schemaQualName_(aSchemaNameParseNode.getSchemaName(), heap), |
| dropAllTables_(FALSE), |
| renameSchema_(FALSE), |
| alterStoredDesc_(TRUE), |
| storedDescOper_(oper) |
| { |
| initChecks(); |
| } |
| |
| StmtDDLAlterSchema::~StmtDDLAlterSchema() |
| {} |
| |
| // cast |
| |
| StmtDDLAlterSchema * |
| StmtDDLAlterSchema::castToStmtDDLAlterSchema() |
| { |
| return this; |
| } |
| |
| // for tracing |
| const NAString |
| StmtDDLAlterSchema::displayLabel1() const |
| { |
| return NAString("Schema name: " ) + getSchemaName(); |
| } |
| |
| const NAString |
| StmtDDLAlterSchema::getText() const |
| { |
| return "StmtDDLAlterSchema"; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // Methods for class StmtDDLAlterSynonym |
| // ----------------------------------------------------------------------- |
| |
| // |
| // Constructor |
| // |
| |
| StmtDDLAlterSynonym::StmtDDLAlterSynonym(const QualifiedName & synonymName, |
| const QualifiedName & objectReference) |
| : StmtDDLNode(DDL_ALTER_SYNONYM), |
| synonymName_(synonymName, PARSERHEAP()), |
| objectReference_(objectReference, PARSERHEAP()) |
| { |
| } |
| |
| // |
| // Virtual Destructor |
| // garbage collection is being done automatically by the NAString Class |
| // |
| |
| StmtDDLAlterSynonym::~StmtDDLAlterSynonym() |
| {} |
| |
| // cast |
| |
| StmtDDLAlterSynonym * |
| StmtDDLAlterSynonym::castToStmtDDLAlterSynonym() |
| { |
| return this; |
| } |
| |
| // for tracing |
| |
| const NAString |
| StmtDDLAlterSynonym::displayLabel1() const |
| { |
| return NAString("Synonym name: " ) + getSynonymName(); |
| } |
| |
| |
| const NAString |
| StmtDDLAlterSynonym::displayLabel2() const |
| { |
| return NAString("Object reference: ") + getObjectReference(); |
| } |
| |
| const NAString |
| StmtDDLAlterSynonym::getText() const |
| { |
| return "StmtDDLAlterSynonym"; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLAlterIndex |
| // ----------------------------------------------------------------------- |
| |
| StmtDDLAlterIndex::StmtDDLAlterIndex() |
| : StmtDDLNode(DDL_ANY_ALTER_INDEX_STMT), |
| alterIndexAction_(NULL), |
| indexName_(PARSERHEAP()), |
| indexQualName_(PARSERHEAP()) |
| { |
| } |
| |
| StmtDDLAlterIndex::StmtDDLAlterIndex(OperatorTypeEnum operatorType) |
| : StmtDDLNode(operatorType), |
| alterIndexAction_(NULL), |
| indexName_(PARSERHEAP()), |
| indexQualName_(PARSERHEAP()) |
| { |
| } |
| |
| StmtDDLAlterIndex::StmtDDLAlterIndex(OperatorTypeEnum operatorType, |
| ElemDDLNode * pAlterIndexAction) |
| : StmtDDLNode(operatorType), |
| alterIndexAction_(pAlterIndexAction), |
| indexName_(PARSERHEAP()), |
| indexQualName_(PARSERHEAP()) |
| { |
| } |
| |
| StmtDDLAlterIndex::StmtDDLAlterIndex(OperatorTypeEnum operatorType, |
| const QualifiedName & indexName, |
| ElemDDLNode * pAlterIndexAction) |
| : StmtDDLNode(operatorType), |
| indexName_(PARSERHEAP()), |
| indexQualName_(indexName, PARSERHEAP()), |
| alterIndexAction_(pAlterIndexAction) |
| { |
| indexName_ = indexQualName_.getQualifiedNameAsAnsiString(); |
| } |
| |
| |
| // virtual destructor |
| StmtDDLAlterIndex::~StmtDDLAlterIndex() |
| { |
| // delete all child parse nodes |
| |
| for (Int32 i = 0; i < getArity(); i++) |
| { |
| delete getChild(i); |
| } |
| } |
| |
| // cast virtual function |
| StmtDDLAlterIndex * |
| StmtDDLAlterIndex::castToStmtDDLAlterIndex() |
| { |
| return this; |
| } |
| |
| // |
| // accessors |
| // |
| |
| Int32 |
| StmtDDLAlterIndex::getArity() const |
| { |
| return MAX_STMT_DDL_ALTER_INDEX_ARITY; |
| } |
| |
| ExprNode * |
| StmtDDLAlterIndex::getChild(Lng32 index) |
| { |
| ComASSERT(index EQU INDEX_ALTER_INDEX_ACTION); |
| return alterIndexAction_; |
| } |
| |
| // |
| // mutators |
| // |
| |
| void |
| StmtDDLAlterIndex::setChild(Lng32 index, ExprNode * pChildNode) |
| { |
| ComASSERT(index EQU INDEX_ALTER_INDEX_ACTION); |
| if (pChildNode NEQ NULL) |
| { |
| ComASSERT(pChildNode->castToElemDDLNode() NEQ NULL); |
| alterIndexAction_ = pChildNode->castToElemDDLNode(); |
| } |
| else |
| alterIndexAction_ = NULL; |
| } |
| |
| void |
| StmtDDLAlterIndex::setIndexName(const QualifiedName &indexName) |
| { |
| indexQualName_ = indexName; |
| } |
| |
| // |
| // methods for tracing |
| // |
| |
| const NAString |
| StmtDDLAlterIndex::getText() const |
| { |
| return "StmtDDLAlterIndex"; |
| } |
| |
| const NAString |
| StmtDDLAlterIndex::displayLabel1() const |
| { |
| return NAString("Index name: ") + getIndexName(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLAlterIndexAttribute |
| // ----------------------------------------------------------------------- |
| |
| // |
| // constructor |
| // |
| StmtDDLAlterIndexAttribute::StmtDDLAlterIndexAttribute( |
| ElemDDLNode * pFileAttrNode) |
| : StmtDDLAlterIndex(DDL_ALTER_INDEX_ATTRIBUTE, |
| pFileAttrNode) |
| { |
| |
| // Traverse the File Attribute List parse sub-tree to extract the |
| // information about the specified file attributes. Store this |
| // information in data member fileAttributes_. |
| |
| ComASSERT(getAlterIndexAction() NEQ NULL); |
| ElemDDLFileAttrClause * pFileAttrClause = getAlterIndexAction()-> |
| castToElemDDLFileAttrClause(); |
| ComASSERT(pFileAttrClause NEQ NULL); |
| ElemDDLNode * pFileAttrList = pFileAttrClause->getFileAttrDefBody(); |
| ComASSERT(pFileAttrList NEQ NULL); |
| for (CollIndex i = 0; i < pFileAttrList->entries(); i++) |
| { |
| fileAttributes_.setFileAttr((*pFileAttrList)[i]->castToElemDDLFileAttr()); |
| } |
| } |
| |
| // virtual destructor |
| StmtDDLAlterIndexAttribute::~StmtDDLAlterIndexAttribute() |
| { |
| } |
| |
| // cast virtual function |
| StmtDDLAlterIndexAttribute * |
| StmtDDLAlterIndexAttribute::castToStmtDDLAlterIndexAttribute() |
| { |
| return this; |
| } |
| |
| // |
| // methods for tracing |
| // |
| |
| NATraceList |
| StmtDDLAlterIndexAttribute::getDetailInfo() const |
| { |
| NAString detailText; |
| NATraceList detailTextList; |
| |
| // |
| // index name |
| // |
| |
| detailTextList.append(displayLabel1()); |
| |
| // |
| // file attributes |
| // |
| |
| detailTextList.append("File attributes: "); |
| |
| const ParDDLFileAttrsAlterIndex fileAttribs = getFileAttributes(); |
| detailTextList.append(" ", fileAttribs.getDetailInfo()); |
| |
| return detailTextList; |
| } |
| |
| const NAString |
| StmtDDLAlterIndexAttribute::getText() const |
| { |
| return "StmtDDLAlterIndexAttribute"; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLAlterIndexHBaseOptions |
| // ----------------------------------------------------------------------- |
| |
| StmtDDLAlterIndexHBaseOptions::StmtDDLAlterIndexHBaseOptions(ElemDDLHbaseOptions *pHBaseOptions) |
| : StmtDDLAlterIndex(DDL_ALTER_INDEX_ALTER_HBASE_OPTIONS), |
| pHBaseOptions_(pHBaseOptions) |
| { |
| // nothing else to do |
| } |
| |
| // virtual destructor |
| StmtDDLAlterIndexHBaseOptions::~StmtDDLAlterIndexHBaseOptions() |
| { |
| // delete the things I own |
| delete pHBaseOptions_; |
| } |
| |
| |
| // cast |
| StmtDDLAlterIndexHBaseOptions * |
| StmtDDLAlterIndexHBaseOptions::castToStmtDDLAlterIndexHBaseOptions() |
| { |
| return this; |
| } |
| |
| // method for tracing |
| NATraceList |
| StmtDDLAlterIndexHBaseOptions::getDetailInfo() const |
| { |
| NAString detailText; |
| NATraceList detailTextList; |
| |
| ComASSERT(pHBaseOptions_ NEQ NULL); |
| // detailTextList.append(pHBaseOptions_); figure out what to do here later |
| |
| return detailTextList; |
| } |
| |
| const NAString |
| StmtDDLAlterIndexHBaseOptions::getText() const |
| { |
| return "StmtDDLAlterIndexHBaseOptions"; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLAlterTable |
| // ----------------------------------------------------------------------- |
| |
| // |
| // constructors |
| // |
| |
| StmtDDLAlterTable::StmtDDLAlterTable() |
| : StmtDDLNode(DDL_ANY_ALTER_TABLE_STMT), |
| tableQualName_(PARSERHEAP()), |
| alterTableAction_(NULL), |
| isParseSubTreeDestroyedByDestructor_(TRUE), |
| isDroppable_(TRUE), |
| isOnline_(TRUE), |
| forPurgedata_(FALSE) |
| {} |
| |
| StmtDDLAlterTable::StmtDDLAlterTable(OperatorTypeEnum operatorType) |
| : StmtDDLNode(operatorType), |
| tableQualName_(PARSERHEAP()), |
| alterTableAction_(NULL), |
| isParseSubTreeDestroyedByDestructor_(TRUE), |
| isDroppable_(TRUE), |
| isOnline_(TRUE), |
| forPurgedata_(FALSE) |
| {} |
| |
| StmtDDLAlterTable::StmtDDLAlterTable(OperatorTypeEnum operatorType, |
| ElemDDLNode * pAlterTableAction) |
| : StmtDDLNode(operatorType), |
| tableQualName_(PARSERHEAP()), |
| alterTableAction_(pAlterTableAction), |
| isParseSubTreeDestroyedByDestructor_(TRUE), |
| isDroppable_(TRUE), |
| isOnline_(TRUE), |
| forPurgedata_(FALSE) |
| {} |
| |
| StmtDDLAlterTable::StmtDDLAlterTable(OperatorTypeEnum operatorType, |
| const QualifiedName & tableQualName, |
| ElemDDLNode * pAlterTableAction) |
| : StmtDDLNode(operatorType), |
| tableQualName_(tableQualName, PARSERHEAP()), |
| alterTableAction_(pAlterTableAction), |
| isParseSubTreeDestroyedByDestructor_(TRUE), |
| isDroppable_(TRUE), |
| isOnline_(TRUE), |
| forPurgedata_(FALSE) |
| {} |
| |
| |
| // virtual destructor |
| StmtDDLAlterTable::~StmtDDLAlterTable() |
| { |
| // |
| // delete all children if the flag isParseSubTreeDestroyedByDestructor_ |
| // is set. For more detail information about this flag, please read |
| // the comments about this flag in the header file StmtDDLAlterTable.h. |
| // |
| if (isParseSubTreeDestroyedByDestructor_) |
| { |
| for (Int32 i = 0; i < getArity(); i++) |
| { |
| delete getChild(i); |
| } |
| } |
| } |
| |
| // cast virtual function |
| StmtDDLAlterTable * |
| StmtDDLAlterTable::castToStmtDDLAlterTable() |
| { |
| return this; |
| } |
| |
| // |
| // accessors |
| // |
| |
| Int32 |
| StmtDDLAlterTable::getArity() const |
| { |
| return MAX_STMT_DDL_ALTER_TABLE_ARITY; |
| } |
| |
| ExprNode * |
| StmtDDLAlterTable::getChild(Lng32 index) |
| { |
| ComASSERT(index EQU INDEX_ALTER_TABLE_ACTION); |
| return alterTableAction_; |
| } |
| |
| // |
| // mutators |
| // |
| |
| void |
| StmtDDLAlterTable::setChild(Lng32 index, ExprNode * pChildNode) |
| { |
| ComASSERT(index EQU INDEX_ALTER_TABLE_ACTION); |
| if (pChildNode NEQ NULL) |
| { |
| ComASSERT(pChildNode->castToElemDDLNode() NEQ NULL); |
| alterTableAction_ = pChildNode->castToElemDDLNode(); |
| } |
| else |
| alterTableAction_ = NULL; |
| } |
| |
| void |
| StmtDDLAlterTable::setTableName(const QualifiedName &tableQualName) |
| { |
| tableQualName_ = tableQualName; |
| } |
| |
| // |
| // methods for tracing |
| // |
| |
| const NAString |
| StmtDDLAlterTable::getText() const |
| { |
| return "StmtDDLAlterTable"; |
| } |
| |
| const NAString |
| StmtDDLAlterTable::displayLabel1() const |
| { |
| return NAString("Table name: ") + getTableName(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLAddConstraint |
| // ----------------------------------------------------------------------- |
| |
| // virtual destructor |
| StmtDDLAddConstraint::~StmtDDLAddConstraint() |
| { |
| } |
| |
| // cast virtual function |
| StmtDDLAddConstraint * |
| StmtDDLAddConstraint::castToStmtDDLAddConstraint() |
| { |
| return this; |
| } |
| |
| // |
| // accessors |
| // |
| |
| const NAString |
| StmtDDLAddConstraint::getConstraintName() const |
| { |
| ComASSERT(getAlterTableAction() NEQ NULL); |
| ElemDDLConstraint * pConstraint |
| = getAlterTableAction()->castToElemDDLConstraint(); |
| ComASSERT(pConstraint NEQ NULL); |
| |
| return pConstraint->getConstraintName(); |
| } |
| |
| const QualifiedName & |
| StmtDDLAddConstraint::getConstraintNameAsQualifiedName() const |
| { |
| return ((StmtDDLAddConstraint *)this)->getConstraintNameAsQualifiedName(); |
| } |
| |
| QualifiedName & |
| StmtDDLAddConstraint::getConstraintNameAsQualifiedName() |
| { |
| ComASSERT(getAlterTableAction() NEQ NULL); |
| ElemDDLConstraint * pConstraint |
| = getAlterTableAction()->castToElemDDLConstraint(); |
| ComASSERT(pConstraint NEQ NULL); |
| |
| return pConstraint->getConstraintNameAsQualifiedName(); |
| } |
| |
| NABoolean |
| StmtDDLAddConstraint::isDeferrable() const |
| { |
| ComASSERT(getAlterTableAction() NEQ NULL); |
| ElemDDLConstraint * pConstraint |
| = getAlterTableAction()->castToElemDDLConstraint(); |
| ComASSERT(pConstraint NEQ NULL); |
| |
| return pConstraint->isDeferrable(); |
| } |
| |
| NABoolean |
| StmtDDLAddConstraint::isDroppable() const |
| { |
| ComASSERT(getAlterTableAction() NEQ NULL); |
| ElemDDLConstraint * pConstraint |
| = getAlterTableAction()->castToElemDDLConstraint(); |
| ComASSERT(pConstraint NEQ NULL); |
| |
| StmtDDLAddConstraint *ncThis = (StmtDDLAddConstraint *)this; |
| StmtDDLAddConstraintPK *pk = ncThis->castToStmtDDLAddConstraintPK(); |
| if (pk NEQ NULL AND pk->isAlwaysDroppable()) |
| { |
| // Primary Key constrainst created in the ALTER TABLE <table-name> |
| // ADD CONSTRAINT statement specified by the user is always droppable. |
| return TRUE; |
| } |
| else |
| { |
| return pConstraint->isDroppable(); |
| } |
| } |
| |
| NABoolean |
| StmtDDLAddConstraint::isDroppableSpecifiedExplicitly() const |
| { |
| ComASSERT(getAlterTableAction() NEQ NULL); |
| ElemDDLConstraint * pConstraint |
| = getAlterTableAction()->castToElemDDLConstraint(); |
| ComASSERT(pConstraint NEQ NULL); |
| |
| return pConstraint->isDroppableSpecifiedExplicitly(); |
| } |
| |
| NABoolean |
| StmtDDLAddConstraint::isNotDroppableSpecifiedExplicitly() const |
| { |
| ComASSERT(getAlterTableAction() NEQ NULL); |
| ElemDDLConstraint * pConstraint |
| = getAlterTableAction()->castToElemDDLConstraint(); |
| ComASSERT(pConstraint NEQ NULL); |
| |
| return pConstraint->isNotDroppableSpecifiedExplicitly(); |
| } |
| |
| // |
| // mutators |
| // |
| |
| void |
| StmtDDLAddConstraint::setDroppableFlag(const NABoolean setting) |
| { |
| ComASSERT(getAlterTableAction() NEQ NULL); |
| ElemDDLConstraint * pConstraint |
| = getAlterTableAction()->castToElemDDLConstraint(); |
| ComASSERT(pConstraint NEQ NULL); |
| |
| pConstraint->setDroppableFlag(setting); |
| } |
| |
| // |
| // methods for tracing |
| // |
| |
| NATraceList |
| StmtDDLAddConstraint::getDetailInfo() const |
| { |
| NAString detailText; |
| NATraceList detailTextList; |
| |
| ElemDDLConstraint * pConstraint = getConstraint(); |
| ComASSERT(pConstraint NEQ NULL); |
| detailTextList.append(pConstraint->getDetailInfo()); |
| |
| return detailTextList; |
| |
| } // StmtDDLAddConstraint::getDetailInfo() |
| |
| const NAString |
| StmtDDLAddConstraint::getText() const |
| { |
| return "StmtDDLAddConstraint"; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLAddConstraintArray |
| // ----------------------------------------------------------------------- |
| |
| // virtual destructor |
| StmtDDLAddConstraintArray::~StmtDDLAddConstraintArray() |
| { |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLAddConstraintCheck |
| // ----------------------------------------------------------------------- |
| |
| // |
| // constructors |
| // |
| |
| StmtDDLAddConstraintCheck::StmtDDLAddConstraintCheck( |
| ElemDDLNode * pElemDDLConstraintCheck) |
| : StmtDDLAddConstraint(DDL_ALTER_TABLE_ADD_CONSTRAINT_CHECK, |
| pElemDDLConstraintCheck) |
| { |
| init(pElemDDLConstraintCheck); |
| } |
| |
| StmtDDLAddConstraintCheck::StmtDDLAddConstraintCheck( |
| const QualifiedName & tableQualName, |
| ElemDDLNode * pElemDDLConstraintCheck) |
| : StmtDDLAddConstraint(DDL_ALTER_TABLE_ADD_CONSTRAINT_CHECK, |
| tableQualName, |
| pElemDDLConstraintCheck) |
| { |
| init(pElemDDLConstraintCheck); |
| } |
| |
| void |
| StmtDDLAddConstraintCheck::init(ElemDDLNode * pElemDDLConstraintCheck) |
| { |
| ComASSERT(pElemDDLConstraintCheck NEQ NULL AND |
| pElemDDLConstraintCheck->castToElemDDLConstraintCheck() NEQ NULL); |
| ElemDDLConstraintCheck *pCkCnstrnt = |
| pElemDDLConstraintCheck->castToElemDDLConstraintCheck(); |
| endPos_ = pCkCnstrnt->getEndPosition(); |
| startPos_ = pCkCnstrnt->getStartPosition(); |
| nameLocList_ = pCkCnstrnt->getNameLocList(); |
| } |
| |
| // virtual destructor |
| StmtDDLAddConstraintCheck::~StmtDDLAddConstraintCheck() |
| { |
| } |
| |
| // cast virtual function |
| StmtDDLAddConstraintCheck * |
| StmtDDLAddConstraintCheck::castToStmtDDLAddConstraintCheck() |
| { |
| return this; |
| } |
| |
| // |
| // accessors |
| // |
| |
| ItemExpr * |
| StmtDDLAddConstraintCheck::getSearchCondition() const |
| { |
| ElemDDLConstraintCheck *pCkCnstrnt = |
| getAlterTableAction()->castToElemDDLConstraintCheck(); |
| ComASSERT(pCkCnstrnt NEQ NULL); |
| return pCkCnstrnt->getSearchCondition(); |
| } |
| |
| // |
| // methods for tracing |
| // |
| |
| const NAString |
| StmtDDLAddConstraintCheck::getText() const |
| { |
| return "StmtDDLAddConstraintCheck"; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLAddConstraintCheckArray |
| // ----------------------------------------------------------------------- |
| |
| // virtual destructor |
| StmtDDLAddConstraintCheckArray::~StmtDDLAddConstraintCheckArray() |
| { |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLAddConstraintPK |
| // ----------------------------------------------------------------------- |
| |
| // constructors |
| StmtDDLAddConstraintPK::StmtDDLAddConstraintPK( |
| ElemDDLNode * pElemDDLConstraintPK, |
| const NABoolean isAlwaysDroppable) |
| : StmtDDLAddConstraintUnique(DDL_ALTER_TABLE_ADD_CONSTRAINT_PRIMARY_KEY, |
| pElemDDLConstraintPK), |
| isAlwaysDroppable_(isAlwaysDroppable) |
| { |
| if (isAlwaysDroppable AND isNotDroppableSpecifiedExplicitly()) |
| { |
| // Primary key constraint defined in ALTER TABLE statement is always |
| // droppable. Please remove the NOT DROPPABLE clause. |
| // Note that for the ALTER TABLE ADD COLUMN statement, this check |
| // cannot be made in the constructor, since this statement uses |
| // the code for CREATE TABLE to parse its column definition. |
| // The test for this error was therefore put into function |
| // CatAlterTableAddColumn. |
| *SqlParser_Diags << DgSqlCode(-3067); |
| } |
| } |
| StmtDDLAddConstraintPK::StmtDDLAddConstraintPK( |
| const QualifiedName & tableQualName, |
| ElemDDLNode * pElemDDLConstraintPK, |
| const NABoolean isAlwaysDroppable) |
| : StmtDDLAddConstraintUnique(DDL_ALTER_TABLE_ADD_CONSTRAINT_PRIMARY_KEY, |
| tableQualName, |
| pElemDDLConstraintPK), |
| isAlwaysDroppable_(isAlwaysDroppable) |
| { |
| if (isAlwaysDroppable AND isNotDroppableSpecifiedExplicitly()) |
| { |
| // Primary key constraint defined in ALTER TABLE statement is always |
| // droppable. Please remove the NOT DROPPABLE clause. |
| // Note that for the ALTER TABLE ADD COLUMN statement, this check |
| // cannot be made in the constructor, since this statement uses |
| // the code for CREATE TABLE to parse its column definition. |
| // The test for this error was therefore put into function |
| // CatAlterTableAddColumn. |
| *SqlParser_Diags << DgSqlCode(-3067); |
| } |
| } |
| |
| // virtual destructor |
| StmtDDLAddConstraintPK::~StmtDDLAddConstraintPK() |
| { |
| } |
| |
| // cast virtual function |
| StmtDDLAddConstraintPK * |
| StmtDDLAddConstraintPK::castToStmtDDLAddConstraintPK() |
| { |
| return this; |
| } |
| |
| // methods for tracing |
| |
| const NAString |
| StmtDDLAddConstraintPK::getText() const |
| { |
| return "StmtDDLAddConstraintPK"; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLAddConstraintRI |
| // ----------------------------------------------------------------------- |
| |
| // virtual destructor |
| StmtDDLAddConstraintRI::~StmtDDLAddConstraintRI() |
| { |
| } |
| |
| // cast virtual function |
| StmtDDLAddConstraintRI * |
| StmtDDLAddConstraintRI::castToStmtDDLAddConstraintRI() |
| { |
| return this; |
| } |
| |
| // |
| // accessors |
| // |
| |
| ComRCDeleteRule |
| StmtDDLAddConstraintRI::getDeleteRule() const |
| { |
| return getConstraint()->castToElemDDLConstraintRI()->getDeleteRule(); |
| } |
| |
| ComRCMatchOption |
| StmtDDLAddConstraintRI::getMatchType() const |
| { |
| return getConstraint()->castToElemDDLConstraintRI()->getMatchType(); |
| } |
| |
| ElemDDLColNameArray & |
| StmtDDLAddConstraintRI::getReferencedColumns() |
| { |
| return getConstraint()->castToElemDDLConstraintRI()-> |
| getReferencedColumns(); |
| } |
| |
| const ElemDDLColNameArray & |
| StmtDDLAddConstraintRI::getReferencedColumns() const |
| { |
| return getConstraint()->castToElemDDLConstraintRI()-> |
| getReferencedColumns(); |
| } |
| |
| NAString |
| StmtDDLAddConstraintRI::getReferencedTableName() const |
| { |
| return getConstraint()->castToElemDDLConstraintRI()-> |
| getReferencedTableName(); |
| } |
| |
| const ElemDDLColNameArray & |
| StmtDDLAddConstraintRI::getReferencingColumns() const |
| { |
| return getConstraint()->castToElemDDLConstraintRI()-> |
| getReferencingColumns(); |
| } |
| |
| ElemDDLColNameArray & |
| StmtDDLAddConstraintRI::getReferencingColumns() |
| { |
| return getConstraint()->castToElemDDLConstraintRI()-> |
| getReferencingColumns(); |
| } |
| |
| ComRCUpdateRule |
| StmtDDLAddConstraintRI::getUpdateRule() const |
| { |
| return getConstraint()->castToElemDDLConstraintRI()->getUpdateRule(); |
| } |
| |
| NABoolean |
| StmtDDLAddConstraintRI::isDeleteRuleSpecified() const |
| { |
| return getConstraint()->castToElemDDLConstraintRI()-> |
| isDeleteRuleSpecified(); |
| } |
| |
| NABoolean |
| StmtDDLAddConstraintRI::isUpdateRuleSpecified() const |
| { |
| return getConstraint()->castToElemDDLConstraintRI()-> |
| isUpdateRuleSpecified(); |
| } |
| |
| // methods for tracing |
| |
| const NAString |
| StmtDDLAddConstraintRI::getText() const |
| { |
| return "StmtDDLAddConstraintRI"; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLAddConstraintRIArray |
| // ----------------------------------------------------------------------- |
| |
| // virtual destructor |
| StmtDDLAddConstraintRIArray::~StmtDDLAddConstraintRIArray() |
| { |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLAddConstraintUnique |
| // ----------------------------------------------------------------------- |
| |
| // virtual destructor |
| StmtDDLAddConstraintUnique::~StmtDDLAddConstraintUnique() |
| { |
| } |
| |
| // cast virtual function |
| StmtDDLAddConstraintUnique * |
| StmtDDLAddConstraintUnique::castToStmtDDLAddConstraintUnique() |
| { |
| return this; |
| } |
| |
| // methods for tracing |
| |
| const NAString |
| StmtDDLAddConstraintUnique::getText() const |
| { |
| return "StmtDDLAddConstraintUnique"; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLAddConstraintUniqueArray |
| // ----------------------------------------------------------------------- |
| |
| // virtual destructor |
| StmtDDLAddConstraintUniqueArray::~StmtDDLAddConstraintUniqueArray() |
| { |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLAlterTableAttribute |
| // ----------------------------------------------------------------------- |
| |
| // |
| // constructor |
| // |
| StmtDDLAlterTableAttribute::StmtDDLAlterTableAttribute( |
| ElemDDLNode * pFileAttrNode) |
| : StmtDDLAlterTable(DDL_ALTER_TABLE_ATTRIBUTE, |
| pFileAttrNode) |
| { |
| |
| // Traverse the File Attribute List parse sub-tree to extract the |
| // information about the specified file attributes. Store this |
| // information in data member fileAttributes_. |
| |
| ComASSERT(getAlterTableAction() NEQ NULL); |
| ElemDDLFileAttrClause * pFileAttrClause = getAlterTableAction()-> |
| castToElemDDLFileAttrClause(); |
| ComASSERT(pFileAttrClause NEQ NULL); |
| ElemDDLNode * pFileAttrList = pFileAttrClause->getFileAttrDefBody(); |
| ComASSERT(pFileAttrList NEQ NULL); |
| for (CollIndex i = 0; i < pFileAttrList->entries(); i++) |
| { |
| fileAttributes_.setFileAttr((*pFileAttrList)[i]->castToElemDDLFileAttr()); |
| } |
| } |
| |
| // virtual destructor |
| StmtDDLAlterTableAttribute::~StmtDDLAlterTableAttribute() |
| { |
| } |
| |
| // cast virtual function |
| StmtDDLAlterTableAttribute * |
| StmtDDLAlterTableAttribute::castToStmtDDLAlterTableAttribute() |
| { |
| return this; |
| } |
| |
| // |
| // methods for tracing |
| // |
| |
| NATraceList |
| StmtDDLAlterTableAttribute::getDetailInfo() const |
| { |
| NAString detailText; |
| NATraceList detailTextList; |
| |
| // |
| // table name |
| // |
| |
| detailTextList.append(displayLabel1()); |
| |
| // |
| // file attributes |
| // |
| |
| detailTextList.append("File attributes: "); |
| |
| const ParDDLFileAttrsAlterTable fileAttribs = getFileAttributes(); |
| detailTextList.append(" ", fileAttribs.getDetailInfo()); |
| |
| return detailTextList; |
| } |
| |
| const NAString |
| StmtDDLAlterTableAttribute::getText() const |
| { |
| return "StmtDDLAlterTableAttribute"; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLAlterTableColumn |
| // ----------------------------------------------------------------------- |
| |
| // virtual destructor |
| StmtDDLAlterTableColumn::~StmtDDLAlterTableColumn() |
| { |
| } |
| |
| // cast virtual function |
| StmtDDLAlterTableColumn * |
| StmtDDLAlterTableColumn::castToStmtDDLAlterTableColumn() |
| { |
| return this; |
| } |
| |
| // |
| // methods for tracing |
| // |
| |
| const NAString |
| StmtDDLAlterTableColumn::getText() const |
| { |
| return "StmtDDLAlterTableColumn"; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLAlterTableMove |
| // ----------------------------------------------------------------------- |
| |
| // virtual destructor |
| StmtDDLAlterTableMove::~StmtDDLAlterTableMove() |
| { |
| } |
| |
| // cast virtual function |
| StmtDDLAlterTableMove * |
| StmtDDLAlterTableMove::castToStmtDDLAlterTableMove() |
| { |
| return this; |
| } |
| |
| // |
| // methods for tracing |
| // |
| |
| const NAString |
| StmtDDLAlterTableMove::getText() const |
| { |
| return "StmtDDLAlterTableMove"; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLAlterTablePartition |
| // ----------------------------------------------------------------------- |
| |
| // virtual destructor |
| StmtDDLAlterTablePartition::~StmtDDLAlterTablePartition() |
| { |
| } |
| |
| // cast virtual function |
| StmtDDLAlterTablePartition * |
| StmtDDLAlterTablePartition::castToStmtDDLAlterTablePartition() |
| { |
| return this; |
| } |
| |
| // |
| // methods for tracing |
| // |
| |
| const NAString |
| StmtDDLAlterTablePartition::getText() const |
| { |
| return "StmtDDLAlterTablePartition"; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLAlterTableRename |
| // ----------------------------------------------------------------------- |
| |
| // virtual destructor |
| StmtDDLAlterTableRename::~StmtDDLAlterTableRename() |
| { |
| } |
| |
| // cast virtual function |
| StmtDDLAlterTableRename * |
| StmtDDLAlterTableRename::castToStmtDDLAlterTableRename() |
| { |
| return this; |
| } |
| |
| // |
| // methods for tracing |
| // |
| |
| const NAString |
| StmtDDLAlterTableRename::getText() const |
| { |
| return "StmtDDLAlterTableRename"; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLAlterTableNamespace |
| // ----------------------------------------------------------------------- |
| |
| // virtual destructor |
| StmtDDLAlterTableNamespace::~StmtDDLAlterTableNamespace() |
| { |
| } |
| |
| // cast virtual function |
| StmtDDLAlterTableNamespace * |
| StmtDDLAlterTableNamespace::castToStmtDDLAlterTableNamespace() |
| { |
| return this; |
| } |
| |
| // |
| // methods for tracing |
| // |
| |
| const NAString |
| StmtDDLAlterTableNamespace::getText() const |
| { |
| return "StmtDDLAlterTableNamespace"; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLAlterTableSetConstraint |
| // ----------------------------------------------------------------------- |
| |
| // virtual destructor |
| StmtDDLAlterTableSetConstraint::~StmtDDLAlterTableSetConstraint() |
| { |
| } |
| |
| // cast virtual function |
| StmtDDLAlterTableSetConstraint * |
| StmtDDLAlterTableSetConstraint::castToStmtDDLAlterTableSetConstraint() |
| { |
| return this; |
| } |
| |
| // |
| // methods for tracing |
| // |
| |
| const NAString |
| StmtDDLAlterTableSetConstraint::getText() const |
| { |
| return "StmtDDLAlterTableSetConstraint"; |
| } |
| |
| // -------------------------------------------------------------------- |
| // methods for class StmtDDLAlterTableDisableIndex |
| // -------------------------------------------------------------------- |
| |
| // |
| // constructor |
| // |
| |
| StmtDDLAlterTableDisableIndex::StmtDDLAlterTableDisableIndex |
| (NAString & indexName, NABoolean allIndexes, NABoolean allUniqueIndexes) |
| : StmtDDLAlterTable(DDL_ALTER_TABLE_DISABLE_INDEX), |
| indexName_(indexName, PARSERHEAP()), |
| allIndexes_(allIndexes), |
| allUniqueIndexes_(allUniqueIndexes) |
| { |
| } |
| |
| // |
| // Virtual destructor |
| // |
| |
| StmtDDLAlterTableDisableIndex::~StmtDDLAlterTableDisableIndex() |
| { |
| } |
| |
| // |
| // Cast function: to provide the safe castdown to the current object |
| // |
| |
| StmtDDLAlterTableDisableIndex * |
| StmtDDLAlterTableDisableIndex::castToStmtDDLAlterTableDisableIndex() |
| { |
| return this; |
| } |
| |
| // |
| // accessors |
| // |
| |
| // |
| // for tracing |
| // |
| |
| const NAString |
| StmtDDLAlterTableDisableIndex::displayLabel2() const |
| { |
| return NAString ("Index name: ") + getIndexName(); |
| } |
| |
| const NAString |
| StmtDDLAlterTableDisableIndex::getText() const |
| { |
| return "StmtAlterTableDisableIndex" ; |
| } |
| |
| // -------------------------------------------------------------------- |
| // methods for class StmtDDLAlterTableEnableIndex |
| // -------------------------------------------------------------------- |
| |
| // |
| // constructor |
| // |
| |
| StmtDDLAlterTableEnableIndex::StmtDDLAlterTableEnableIndex |
| (NAString & indexName, NABoolean allIndexes, NABoolean allUniqueIndexes) |
| : StmtDDLAlterTable(DDL_ALTER_TABLE_ENABLE_INDEX), |
| indexName_(indexName, PARSERHEAP()), |
| allIndexes_(allIndexes), |
| allUniqueIndexes_(allUniqueIndexes) |
| { |
| } |
| |
| // |
| // Virtual destructor |
| // |
| |
| StmtDDLAlterTableEnableIndex::~StmtDDLAlterTableEnableIndex() |
| { |
| } |
| |
| // |
| // Cast function: to provide the safe castdown to the current object |
| // |
| |
| StmtDDLAlterTableEnableIndex * |
| StmtDDLAlterTableEnableIndex::castToStmtDDLAlterTableEnableIndex() |
| { |
| return this; |
| } |
| |
| // |
| // accessors |
| // |
| |
| // |
| // for tracing |
| // |
| |
| const NAString |
| StmtDDLAlterTableEnableIndex::displayLabel2() const |
| { |
| return NAString ("Index name: ") + getIndexName(); |
| } |
| |
| const NAString |
| StmtDDLAlterTableEnableIndex::getText() const |
| { |
| return "StmtAlterTableEnableIndex" ; |
| } |
| |
| // -------------------------------------------------------------------- |
| // methods for class StmtDDLAlterTableToggleConstraint |
| // -------------------------------------------------------------------- |
| |
| // |
| // constructor |
| // |
| |
| StmtDDLAlterTableToggleConstraint::StmtDDLAlterTableToggleConstraint |
| (const QualifiedName & constraintQualifiedName |
| , NABoolean allConstraints |
| , NABoolean setDisabled |
| , NABoolean validateConstraint) |
| : StmtDDLAlterTable(DDL_ALTER_TABLE_TOGGLE_CONSTRAINT), |
| constraintQualName_(constraintQualifiedName, PARSERHEAP()), |
| allConstraints_(allConstraints), |
| setDisabled_(setDisabled), |
| validateConstraint_(validateConstraint) |
| { |
| } |
| |
| |
| // |
| // Virtual destructor |
| // |
| |
| StmtDDLAlterTableToggleConstraint::~StmtDDLAlterTableToggleConstraint() |
| { |
| } |
| |
| // |
| // Cast function: to provide the safe castdown to the current object |
| // |
| |
| StmtDDLAlterTableToggleConstraint * |
| StmtDDLAlterTableToggleConstraint::castToStmtDDLAlterTableToggleConstraint() |
| { |
| return this; |
| } |
| |
| // |
| // accessors |
| // |
| const NAString |
| StmtDDLAlterTableToggleConstraint::getConstraintName() const |
| { |
| return constraintQualName_.getQualifiedNameAsAnsiString(); |
| } |
| |
| // |
| // for tracing |
| // |
| |
| const NAString |
| StmtDDLAlterTableToggleConstraint::displayLabel2() const |
| { |
| return NAString ("Constraint name: ") + getConstraintName(); |
| } |
| |
| const NAString |
| StmtDDLAlterTableToggleConstraint::getText() const |
| { |
| return "StmtAlterTableToggleConstraint" ; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLDropConstraint |
| // ----------------------------------------------------------------------- |
| |
| // |
| // constructor |
| // |
| |
| StmtDDLDropConstraint::StmtDDLDropConstraint(const QualifiedName & |
| constraintQualifiedName, |
| ComDropBehavior dropbehavior) |
| |
| : StmtDDLAlterTable(DDL_ALTER_TABLE_DROP_CONSTRAINT), |
| constraintQualName_(constraintQualifiedName, PARSERHEAP()), |
| dropBehavior_(dropbehavior) |
| { |
| } |
| |
| // |
| // Virtual destructor |
| // |
| |
| StmtDDLDropConstraint::~StmtDDLDropConstraint() |
| {} |
| |
| // |
| // Cast function: to provide the safe castdown to the current object |
| // |
| |
| StmtDDLDropConstraint * |
| StmtDDLDropConstraint::castToStmtDDLDropConstraint() |
| { |
| return this; |
| } |
| |
| // |
| // accessors |
| // |
| |
| const NAString |
| StmtDDLDropConstraint::getConstraintName() const |
| { |
| return constraintQualName_.getQualifiedNameAsAnsiString(); |
| } |
| |
| // |
| // for tracing |
| // |
| |
| const NAString |
| StmtDDLDropConstraint::displayLabel2() const |
| { |
| return NAString ("Constraint name: ") + getConstraintName(); |
| } |
| |
| const NAString |
| StmtDDLDropConstraint::getText() const |
| { |
| return "StmtAlterTableDropContraint" ; |
| } |
| |
| const NAString |
| StmtDDLDropConstraint::displayLabel3() const |
| { |
| NAString label2("Drop Behavior: "); |
| switch (getDropBehavior()) |
| { |
| case COM_CASCADE_DROP_BEHAVIOR : |
| return label2 + "Cascade" ; |
| case COM_RESTRICT_DROP_BEHAVIOR : |
| return label2 + "Restrict" ; |
| default : |
| NAAbort("StmtDDLAlter.C", __LINE__ , "Internal logic error"); |
| return NAString(); |
| } |
| } |
| |
| //---------------------------------------------------------------------------- |
| // CLASS StmtDDLAlterTableAlterColumnLoggable |
| //---------------------------------------------------------------------------- |
| |
| StmtDDLAlterTableAlterColumnLoggable::StmtDDLAlterTableAlterColumnLoggable |
| (ElemDDLNode * pColumnDefinition, |
| NABoolean loggableVal |
| ,CollHeap * heap) |
| : StmtDDLAlterTable(DDL_ALTER_TABLE_ALTER_COLUMN_LOGGABLE, |
| QualifiedName(PARSERHEAP()) /*no table name*/, |
| pColumnDefinition), |
| columnName_(heap), |
| loggable_(loggableVal) |
| { |
| |
| } |
| |
| |
| StmtDDLAlterTableAlterColumnLoggable::StmtDDLAlterTableAlterColumnLoggable |
| (NAString columnName, |
| NABoolean loggableVal |
| ,CollHeap * heap) |
| : StmtDDLAlterTable(DDL_ALTER_TABLE_ALTER_COLUMN_LOGGABLE), |
| columnName_(columnName, heap), |
| loggable_(loggableVal) |
| { |
| |
| |
| } |
| |
| StmtDDLAlterTableAlterColumnLoggable::~StmtDDLAlterTableAlterColumnLoggable() |
| { |
| |
| |
| |
| } |
| |
| |
| StmtDDLAlterTableAlterColumnLoggable * |
| StmtDDLAlterTableAlterColumnLoggable:: |
| castToStmtDDLAlterTableAlterColumnLoggable() |
| { |
| return this; |
| |
| } |
| |
| //---------------------------------------------------------------------------- |
| // CLASS StmtDDLAlterTableAlterColumnSetSGOption |
| //---------------------------------------------------------------------------- |
| StmtDDLAlterTableAlterColumnSetSGOption::StmtDDLAlterTableAlterColumnSetSGOption( const NAString &columnName |
| , ElemDDLSGOptions *pSGOptions |
| , CollHeap *heap) |
| : StmtDDLAlterTable(DDL_ALTER_TABLE_ALTER_COLUMN_SET_SG_OPTION, |
| QualifiedName(PARSERHEAP()) /*no table name*/, |
| NULL), |
| columnName_(columnName, heap), |
| pSGOptions_(pSGOptions) |
| { |
| |
| |
| } |
| |
| // |
| // Virtual destructor |
| // |
| |
| StmtDDLAlterTableAlterColumnSetSGOption::~StmtDDLAlterTableAlterColumnSetSGOption() |
| { |
| if (pSGOptions_) |
| delete pSGOptions_; |
| |
| if (columnName_) |
| delete columnName_; |
| } |
| |
| // |
| // Cast function: to provide the safe castdown to the current object |
| // |
| |
| StmtDDLAlterTableAlterColumnSetSGOption * |
| StmtDDLAlterTableAlterColumnSetSGOption::castToStmtDDLAlterTableAlterColumnSetSGOption() |
| { |
| return this; |
| } |
| |
| const NAString |
| StmtDDLAlterTableAlterColumnSetSGOption::getText() const |
| { |
| return "StmtDDLAlterTableAlterColumnSetSGOption" ; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLAlterTableAddColumn |
| // ----------------------------------------------------------------------- |
| |
| // constructor |
| StmtDDLAlterTableAddColumn::StmtDDLAlterTableAddColumn( |
| ElemDDLNode * pColumnDefinition |
| ,CollHeap * heap ) |
| : StmtDDLAlterTable(DDL_ALTER_TABLE_ADD_COLUMN, |
| QualifiedName(PARSERHEAP()) /*no table name*/, |
| pColumnDefinition) |
| ,pColumnToAdd_(pColumnDefinition) |
| ,columnDefArray_(heap) |
| ,addConstraintCheckArray_(heap) |
| ,addConstraintRIArray_(heap) |
| ,addConstraintUniqueArray_(heap) |
| ,addConstraintArray_(heap) |
| ,pAddConstraintPK_(NULL) |
| ,addIfNotExists_(FALSE) |
| { |
| } |
| |
| // virtual destructor |
| StmtDDLAlterTableAddColumn::~StmtDDLAlterTableAddColumn() |
| { |
| // Delete the kludge parse nodes derived from class |
| // StmtDDLAddConstraint. For more information, please read |
| // the contents of the header file StmtDDLAlterTableAddColumn.h. |
| |
| StmtDDLAddConstraint * pAddConstraint; |
| while (addConstraintArray_.getFirst(pAddConstraint)) |
| { |
| delete pAddConstraint; |
| } |
| |
| // Delete all children |
| |
| for (Int32 i = 0; i < getArity(); i++) |
| { |
| delete getChild(i); |
| } |
| } |
| |
| // cast virtual function |
| StmtDDLAlterTableAddColumn * |
| StmtDDLAlterTableAddColumn::castToStmtDDLAlterTableAddColumn() |
| { |
| return this; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLAlterTableDropColumn |
| // ----------------------------------------------------------------------- |
| |
| // constructor |
| StmtDDLAlterTableDropColumn::StmtDDLAlterTableDropColumn( |
| NAString & colName |
| ,CollHeap * heap ) |
| : StmtDDLAlterTable(DDL_ALTER_TABLE_DROP_COLUMN, |
| QualifiedName(PARSERHEAP()) /*no table name*/, |
| NULL) |
| ,colName_(colName) |
| ,dropIfExists_(FALSE) |
| { |
| } |
| |
| // virtual destructor |
| StmtDDLAlterTableDropColumn::~StmtDDLAlterTableDropColumn() |
| { |
| } |
| |
| // cast virtual function |
| StmtDDLAlterTableDropColumn * |
| StmtDDLAlterTableDropColumn::castToStmtDDLAlterTableDropColumn() |
| { |
| return this; |
| } |
| |
| void |
| StmtDDLAlterTableAddColumn_visit(ElemDDLNode * pAltTabAddColNode, |
| CollIndex /* index */, |
| ElemDDLNode * pElement); |
| // |
| // Collect information in the parse sub-tree and copy it |
| // to the current parse node. |
| // |
| void |
| StmtDDLAlterTableAddColumn::synthesize() |
| { |
| ElemDDLNode *theColumn = getColToAdd(); |
| if (theColumn NEQ NULL) |
| { |
| // If pConstraint is not NULL, it points to a (left linear tree) list |
| // of column constraint definitions. Traverse this parse sub-tree. |
| // For each column constraint definition (except for Not Null |
| // constraint), add it to the contraint list corresponding to its |
| // constraint type (Check, RI, or Unique). |
| |
| theColumn->traverseList( |
| this, |
| StmtDDLAlterTableAddColumn_visit); |
| |
| ElemDDLColDefArray ColDefArray = getColDefArray(); |
| ElemDDLColDef *pColDef = ColDefArray[0]; |
| if (NOT pColDef->getColumnFamily().isNull()) |
| { |
| //TEMPTEMP |
| // Currently, DTM doesnt handle add columns with an explicit |
| // column family as a transactional operation. |
| // Do not use ddl xns until that bug is fixed. |
| setDdlXns(FALSE); |
| } |
| } |
| } //StmtDDLAlterTableAddColumn::synthesize() |
| |
| //------------------------------------------------------------------ |
| // StmtDDLAlterTableAddColumn_visit |
| // |
| // Parameter pAltTabAddColNode points to the Alter Table Add Column |
| // parse node. |
| // Parameter pElement points to a column constraint definition |
| // parse node in the left linear tree list. |
| // This tree is a sub-tree in the Alter Table Add Column parse node. |
| // Parameter index contains the index of the parse node |
| // pointed by pElement in the (left linear tree) list. |
| //------------------------------------------------------------------ |
| void |
| StmtDDLAlterTableAddColumn_visit(ElemDDLNode * pAltTabAddColNode, |
| CollIndex /* index */, |
| ElemDDLNode * pElement) |
| { |
| ComASSERT(pAltTabAddColNode NEQ NULL AND |
| pAltTabAddColNode->castToStmtDDLAlterTableAddColumn() NEQ NULL AND |
| pElement NEQ NULL); |
| |
| StmtDDLAlterTableAddColumn * pAltTabAddCol = |
| pAltTabAddColNode->castToStmtDDLAlterTableAddColumn(); |
| if (pElement->castToElemDDLColDef() NEQ NULL) |
| { |
| ElemDDLColDef *pColDef = pElement->castToElemDDLColDef(); |
| pAltTabAddCol->getColDefArray().insert(pColDef); |
| if(pColDef->getIsConstraintPKSpecified()) |
| { |
| pAltTabAddCol->setConstraint(pColDef->getConstraintPK()); |
| } |
| // |
| // For each column constraint definition (except for |
| // not null and primary key constraints), creates |
| // a corresponding table constraint definition and |
| // then insert the newly create parse node to the |
| // appropriate table constraint array. This arrangement |
| // helps the processing of constraint definitions in |
| // create table statement. |
| // |
| for (CollIndex i = 0; i < pColDef->getConstraintArray().entries(); i++) |
| { |
| pAltTabAddCol->setConstraint(pColDef->getConstraintArray()[i]); |
| } |
| } |
| else |
| *SqlParser_Diags << DgSqlCode(-1001); |
| |
| } // StmtDDLAlterTableAddColumn_visit() |
| |
| void |
| StmtDDLAlterTableAddColumn::setConstraint(ElemDDLNode * pElement) |
| { |
| switch (pElement->getOperatorType()) |
| { |
| case ELM_CONSTRAINT_CHECK_ELEM : |
| { |
| ComASSERT(pElement->castToElemDDLConstraintCheck() NEQ NULL); |
| |
| StmtDDLAddConstraintCheck * pAddConstraintCheck = |
| new(PARSERHEAP()) |
| StmtDDLAddConstraintCheck(getTableNameAsQualifiedName(), pElement); |
| |
| pAddConstraintCheck->setIsParseSubTreeDestroyedByDestructor(FALSE); |
| addConstraintArray_.insert(pAddConstraintCheck); |
| |
| addConstraintCheckArray_.insert(pAddConstraintCheck); |
| } |
| break; |
| |
| case ELM_CONSTRAINT_REFERENTIAL_INTEGRITY_ELEM : |
| { |
| ComASSERT(pElement->castToElemDDLConstraintRI() NEQ NULL); |
| |
| StmtDDLAddConstraintRI * pAddConstraintRI = new(PARSERHEAP()) |
| StmtDDLAddConstraintRI(getTableNameAsQualifiedName(), pElement); |
| |
| pAddConstraintRI->setIsParseSubTreeDestroyedByDestructor(FALSE); |
| addConstraintArray_.insert(pAddConstraintRI); |
| |
| addConstraintRIArray_.insert(pAddConstraintRI); |
| } |
| break; |
| |
| case ELM_CONSTRAINT_UNIQUE_ELEM : |
| { |
| ComASSERT(pElement->castToElemDDLConstraintUnique() NEQ NULL); |
| |
| StmtDDLAddConstraintUnique * pAddConstraintUnique = |
| new(PARSERHEAP()) |
| StmtDDLAddConstraintUnique(getTableNameAsQualifiedName(), |
| pElement); |
| |
| pAddConstraintUnique->setIsParseSubTreeDestroyedByDestructor(FALSE); |
| addConstraintArray_.insert(pAddConstraintUnique); |
| |
| addConstraintUniqueArray_.insert(pAddConstraintUnique); |
| } |
| break; |
| |
| case ELM_CONSTRAINT_PRIMARY_KEY_ELEM : |
| case ELM_CONSTRAINT_PRIMARY_KEY_COLUMN_ELEM : |
| { |
| pAddConstraintPK_ = new(PARSERHEAP()) |
| StmtDDLAddConstraintPK(getTableNameAsQualifiedName(), pElement); |
| |
| pAddConstraintPK_->setIsParseSubTreeDestroyedByDestructor(FALSE); |
| addConstraintArray_.insert(pAddConstraintPK_); |
| } |
| break; |
| |
| default : |
| NAAbort("StmtDDLAlter.C", __LINE__, "internal logic error"); |
| break; |
| } |
| } // StmtDDLAlterTableAddColumn::setConstraint() |
| |
| // |
| // methods for tracing |
| // |
| |
| const NAString |
| StmtDDLAlterTableAddColumn::getText() const |
| { |
| return "StmtDDLAlterTableAddColumn"; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLAlterTableHBaseOptions |
| // ----------------------------------------------------------------------- |
| |
| StmtDDLAlterTableHBaseOptions::StmtDDLAlterTableHBaseOptions(ElemDDLHbaseOptions *pHBaseOptions) |
| : StmtDDLAlterTable(DDL_ALTER_TABLE_ALTER_HBASE_OPTIONS), |
| pHBaseOptions_(pHBaseOptions) |
| { |
| // nothing else to do |
| } |
| |
| // virtual destructor |
| StmtDDLAlterTableHBaseOptions::~StmtDDLAlterTableHBaseOptions() |
| { |
| // delete the things I own |
| delete pHBaseOptions_; |
| } |
| |
| |
| // cast |
| StmtDDLAlterTableHBaseOptions * |
| StmtDDLAlterTableHBaseOptions::castToStmtDDLAlterTableHBaseOptions() |
| { |
| return this; |
| } |
| |
| // method for tracing |
| NATraceList |
| StmtDDLAlterTableHBaseOptions::getDetailInfo() const |
| { |
| NAString detailText; |
| NATraceList detailTextList; |
| |
| ComASSERT(pHBaseOptions_ NEQ NULL); |
| // detailTextList.append(pHBaseOptions_); figure out what to do here later |
| |
| return detailTextList; |
| } |
| |
| const NAString |
| StmtDDLAlterTableHBaseOptions::getText() const |
| { |
| return "StmtDDLAlterTableHBaseOptions"; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLAlterLibrary |
| // ----------------------------------------------------------------------- |
| |
| // |
| // constructor |
| // |
| // constructor used for ALTER LIBRARY |
| StmtDDLAlterLibrary::StmtDDLAlterLibrary( |
| const QualifiedName & libraryName, |
| const NAString & fileName, |
| ElemDDLNode * clientName, |
| ElemDDLNode * clientFilename, |
| CollHeap * heap) |
| : StmtDDLNode(DDL_ALTER_LIBRARY), |
| libraryName_(libraryName,heap), |
| fileName_(fileName), |
| clientName_("",heap), |
| clientFilename_("",heap) |
| |
| { |
| |
| ElemDDLLibClientName *clientNameNode = NULL; |
| ElemDDLLibClientFilename *clientFilenameNode = NULL; |
| |
| if (clientName != NULL) |
| { |
| clientNameNode = clientName->castToElemDDLLibClientName(); |
| |
| if (clientNameNode != NULL) |
| clientName_ = clientNameNode->getClientName(); |
| } |
| |
| if (clientFilename != NULL) |
| { |
| clientFilenameNode = clientFilename->castToElemDDLLibClientFilename(); |
| |
| |
| if (clientFilenameNode != NULL) |
| clientFilename_ = clientFilenameNode->getFilename(); |
| } |
| |
| } |
| |
| // virtual destructor |
| StmtDDLAlterLibrary::~StmtDDLAlterLibrary() |
| { |
| } |
| |
| // virtual cast |
| StmtDDLAlterLibrary * |
| StmtDDLAlterLibrary::castToStmtDDLAlterLibrary() |
| { |
| return this; |
| } |
| |
| |
| // |
| // methods for tracing |
| // |
| |
| const NAString |
| StmtDDLAlterLibrary::displayLabel1() const |
| { |
| return NAString("Library name: ") + getLibraryName(); |
| } |
| |
| const NAString |
| StmtDDLAlterLibrary::displayLabel2() const |
| { |
| |
| return NAString("Filename: ") + getFilename(); |
| |
| } |
| |
| |
| const NAString |
| StmtDDLAlterLibrary::getText() const |
| { |
| return "StmtDDLAlterLibrary"; |
| } |
| |
| |
| |
| |
| |
| //---------------------------------------------------------------------------- |
| //++ MVS |
| |
| |
| StmtDDLAlterMV::StmtDDLAlterMV(QualifiedName & mvName, |
| ComBoolean rewriteEnableStatus) : |
| StmtDDLNode(DDL_ALTER_MV), |
| alterType_(REWRITE), |
| MVQualName_(mvName, PARSERHEAP()), |
| newName_("", PARSERHEAP()), |
| isCascade_(FALSE), |
| pFileAttrClause_(NULL), |
| pMVFileAttrClause_(NULL), |
| rewriteEnableStatus_(rewriteEnableStatus), |
| pAuditCompress_(NULL), |
| pClearOnPurge_(NULL), |
| pCompressionType_(NULL), |
| pMaxExtents_(NULL), |
| pMvAudit_(NULL), |
| pCommitEach_(NULL), |
| pLockOnRefresh_(NULL), |
| pMvsAllowed_(NULL), |
| numOfAttributes_(0), |
| isFirstAttribute_(FALSE), |
| attributesListString_("", PARSERHEAP()), |
| pIgnoreChangesList_(NULL) |
| { |
| |
| |
| |
| } |
| StmtDDLAlterMV::StmtDDLAlterMV(QualifiedName & mvName, |
| ElemDDLNode * fileAttributeClause) : |
| StmtDDLNode(DDL_ALTER_MV), |
| alterType_(BT_ATTRIBUTES), |
| MVQualName_(mvName, PARSERHEAP()), |
| newName_("", PARSERHEAP()), |
| isCascade_(FALSE), |
| rewriteEnableStatus_(FALSE), |
| pAuditCompress_(NULL), |
| pClearOnPurge_(NULL), |
| pCompressionType_(NULL), |
| pMaxExtents_(NULL), |
| pMvAudit_(NULL), |
| pCommitEach_(NULL), |
| pLockOnRefresh_(NULL), |
| pMvsAllowed_(NULL), |
| numOfAttributes_(0), |
| isFirstAttribute_(TRUE), |
| attributesListString_("", PARSERHEAP()), |
| pIgnoreChangesList_(NULL) |
| { |
| pFileAttrClause_ = fileAttributeClause->castToElemDDLFileAttrClause(); |
| |
| pMVFileAttrClause_ = fileAttributeClause->castToElemDDLMVFileAttrClause(); |
| |
| if ((NULL == pFileAttrClause_ && NULL == pMVFileAttrClause_) || |
| (NULL != pFileAttrClause_ && NULL != pMVFileAttrClause_)) |
| { |
| ComASSERT(FALSE); |
| } |
| |
| if(NULL != pFileAttrClause_) |
| { |
| alterType_ = BT_ATTRIBUTES; |
| } |
| else // pMVFileAttrClause_ |
| { |
| alterType_ = MV_ATTRIBUTES; |
| } |
| |
| } |
| |
| |
| |
| StmtDDLAlterMV::StmtDDLAlterMV(QualifiedName & mvName, |
| const NAString & newName, |
| ComBoolean isCascade) : |
| StmtDDLNode(DDL_ALTER_MV), |
| alterType_(RENAME), |
| MVQualName_(mvName, PARSERHEAP()), |
| newName_(newName, PARSERHEAP()), |
| isCascade_(isCascade), |
| pFileAttrClause_(NULL), |
| pMVFileAttrClause_(NULL), |
| rewriteEnableStatus_(FALSE), |
| pAuditCompress_(NULL), |
| pClearOnPurge_(NULL), |
| pCompressionType_(NULL), |
| pMvAudit_(NULL), |
| pCommitEach_(NULL), |
| pLockOnRefresh_(NULL), |
| pMvsAllowed_(NULL), |
| numOfAttributes_(0), |
| isFirstAttribute_(FALSE), |
| attributesListString_("", PARSERHEAP()), |
| pIgnoreChangesList_(NULL) |
| { |
| |
| } |
| |
| StmtDDLAlterMV::StmtDDLAlterMV(QualifiedName & mvName, |
| ElemDDLNode *ignoreChangesList, |
| AlterType alterType) : |
| StmtDDLNode(DDL_ALTER_MV), |
| alterType_(alterType), |
| MVQualName_(mvName, PARSERHEAP()), |
| newName_("", PARSERHEAP()), |
| isCascade_(FALSE), |
| pFileAttrClause_(NULL), |
| pMVFileAttrClause_(NULL), |
| rewriteEnableStatus_(FALSE), |
| pAuditCompress_(NULL), |
| pClearOnPurge_(NULL), |
| pCompressionType_(NULL), |
| pMvAudit_(NULL), |
| pCommitEach_(NULL), |
| pLockOnRefresh_(NULL), |
| pMvsAllowed_(NULL), |
| numOfAttributes_(0), |
| isFirstAttribute_(FALSE), |
| attributesListString_("", PARSERHEAP()), |
| pIgnoreChangesList_(NULL) |
| { |
| pIgnoreChangesList_ = ignoreChangesList |
| ->castToElemDDLCreateMVOneAttributeTableList(); |
| } |
| |
| |
| void StmtDDLAlterMV::synthesize() |
| { |
| if (NULL != pFileAttrClause_) |
| { |
| processFileAttributeClause(BT_ATTRIBUTES); |
| } |
| |
| if (NULL != pMVFileAttrClause_) |
| { |
| processFileAttributeClause(MV_ATTRIBUTES); |
| } |
| } |
| |
| |
| |
| //---------------------------------------------------------------------------- |
| void |
| StmtDDLAlterMV::processFileAttributeClause(AlterType type) |
| { |
| ElemDDLNode * pFileAttrs = NULL; |
| |
| switch(type) |
| { |
| case BT_ATTRIBUTES: |
| pFileAttrs = pFileAttrClause_->getFileAttrDefBody(); |
| break; |
| case MV_ATTRIBUTES: |
| pFileAttrs = pMVFileAttrClause_->getFileAttrDefBody(); |
| break; |
| } |
| |
| ComASSERT(pFileAttrs NEQ NULL); |
| |
| for (CollIndex i = 0; i < pFileAttrs->entries(); i++) |
| { |
| checkFileAttribute((*pFileAttrs)[i]->castToElemDDLFileAttr()); |
| } |
| |
| attributesListString_ += getAuditCompressString(); |
| attributesListString_ += getClearOnPurgeString(); |
| attributesListString_ += getCompressionTypeString(); |
| attributesListString_ += getMaxExtentsString(); |
| attributesListString_ += getLockOnRefreshString(); |
| attributesListString_ += getMvsAllowedString(); |
| |
| } |
| |
| |
| |
| |
| |
| |
| //---------------------------------------------------------------------------- |
| void |
| StmtDDLAlterMV::checkFileAttribute(ElemDDLFileAttr * pFileAttr) |
| { |
| ULng32 maxext = 0; |
| |
| switch (pFileAttr->getOperatorType()) |
| { |
| |
| // ALLOWED |
| case ELM_FILE_ATTR_AUDIT_COMPRESS_ELEM : |
| if(NULL != pAuditCompress_) |
| { |
| *SqlParser_Diags << DgSqlCode(-12053); |
| } |
| |
| pAuditCompress_ = pFileAttr->castToElemDDLFileAttrAuditCompress(); |
| ComASSERT(NULL != pAuditCompress_); |
| |
| numOfAttributes_++; |
| break; |
| |
| case ELM_FILE_ATTR_CLEAR_ON_PURGE_ELEM : |
| if(NULL != pClearOnPurge_) |
| { |
| *SqlParser_Diags << DgSqlCode(-12053); |
| } |
| |
| pClearOnPurge_ = pFileAttr->castToElemDDLFileAttrClearOnPurge(); |
| numOfAttributes_++; |
| ComASSERT(NULL != pClearOnPurge_); |
| break; |
| |
| case ELM_FILE_ATTR_COMPRESSION_ELEM : |
| *SqlParser_Diags << DgSqlCode(-12049); |
| break; |
| |
| case ELM_FILE_ATTR_MAXEXTENTS_ELEM : |
| if(NULL != pMaxExtents_) |
| { |
| *SqlParser_Diags << DgSqlCode(-12053); |
| } |
| pMaxExtents_ = pFileAttr->castToElemDDLFileAttrMaxExtents(); |
| numOfAttributes_++; |
| ComASSERT(NULL != pMaxExtents_); |
| |
| maxext = pMaxExtents_->getMaxExtents(); |
| if ((maxext <= 0) || (maxext > COM_MAX_MAXEXTENTS)) |
| { |
| *SqlParser_Diags << DgSqlCode(-3191); |
| } |
| break; |
| |
| |
| |
| case ELM_FILE_ATTR_MV_COMMIT_EACH_ELEM : |
| if(NULL != pCommitEach_) |
| { |
| *SqlParser_Diags << DgSqlCode(-12059); |
| } |
| |
| pCommitEach_ = pFileAttr->castToElemDDLFileAttrMVCommitEach(); |
| numOfAttributes_++; |
| ComASSERT(NULL != pCommitEach_); |
| break; |
| |
| |
| case ELM_FILE_ATTR_MVAUDIT_ELEM : |
| if(NULL != pMvAudit_) |
| { |
| *SqlParser_Diags << DgSqlCode(-3082); |
| } |
| |
| pMvAudit_ = pFileAttr->castToElemDDLFileAttrMvAudit(); |
| numOfAttributes_++; |
| ComASSERT(NULL != pMvAudit_); |
| break; |
| |
| |
| case ELM_FILE_ATTR_LOCK_ON_REFRESH_ELEM: |
| if (NULL != pLockOnRefresh_) |
| { |
| // Duplicate [NO]LOCKONREFRESH phrases. |
| *SqlParser_Diags << DgSqlCode(-12055); |
| } |
| pLockOnRefresh_ = pFileAttr->castToElemDDLFileAttrLockOnRefresh(); |
| ComASSERT(NULL != pLockOnRefresh_ ); |
| break; |
| |
| |
| case ELM_FILE_ATTR_MVS_ALLOWED_ELEM: |
| if (NULL != pMvsAllowed_) |
| { |
| // Duplicate MVS ALLOWED phrases. |
| *SqlParser_Diags << DgSqlCode(-12058); |
| } |
| pMvsAllowed_ = pFileAttr->castToElemDDLFileAttrMvsAllowed(); |
| ComASSERT(NULL != pMvsAllowed_); |
| break; |
| |
| |
| |
| // NOT ALLOWED |
| case ELM_FILE_ATTR_BLOCK_SIZE_ELEM : |
| case ELM_FILE_ATTR_BUFFERED_ELEM : |
| case ELM_FILE_ATTR_D_COMPRESS_ELEM : |
| case ELM_FILE_ATTR_I_COMPRESS_ELEM : |
| case ELM_FILE_ATTR_MAX_SIZE_ELEM : |
| case ELM_FILE_ATTR_ALLOCATE_ELEM : |
| case ELM_FILE_ATTR_AUDIT_ELEM : |
| case ELM_FILE_ATTR_DEALLOCATE_ELEM : |
| case ELM_FILE_ATTR_RANGE_LOG_ELEM : |
| case ELM_FILE_ATTR_INSERT_LOG_ELEM : |
| |
| |
| *SqlParser_Diags << DgSqlCode(-12052); |
| break; |
| |
| default : |
| NAAbort("StmtDDLAlter.CPP", __LINE__, "internal logic error"); |
| break; |
| } |
| |
| |
| |
| } // StmtDDLAlterMV::checkFileAttribute |
| |
| const NAString StmtDDLAlterMV::getAuditCompressString() |
| { |
| NAString text; |
| |
| if (NULL != pAuditCompress_) |
| { |
| if (FALSE == isFirstAttribute_) |
| { |
| text += ", "; |
| } |
| else |
| { |
| isFirstAttribute_ = FALSE; // for the next one |
| } |
| |
| if ( FALSE == pAuditCompress_->getIsAuditCompress()) |
| { |
| text = "NO "; |
| } |
| |
| text += "AUDITCOMPRESS "; |
| } |
| |
| return text; |
| } |
| |
| const NAString StmtDDLAlterMV::getClearOnPurgeString() |
| { |
| NAString text; |
| |
| if (NULL != pClearOnPurge_) // no attribute |
| { |
| |
| if (FALSE == isFirstAttribute_) |
| { |
| text += ", "; |
| } |
| else |
| { |
| isFirstAttribute_ = FALSE; // for the next one |
| } |
| |
| if ( FALSE == pClearOnPurge_->getIsClearOnPurge()) |
| { |
| text = "NO "; |
| } |
| |
| text += "CLEARONPURGE "; |
| } |
| |
| return text; |
| } |
| |
| const NAString StmtDDLAlterMV::getCompressionTypeString() |
| { |
| NAString text; |
| |
| if (NULL != pCompressionType_) // no attribute |
| { |
| |
| if (FALSE == isFirstAttribute_) |
| { |
| text += ", "; |
| } |
| else |
| { |
| isFirstAttribute_ = FALSE; // for the next one |
| } |
| |
| switch (pCompressionType_->getCompressionType()) |
| { |
| case COM_HARDWARE_COMPRESSION: |
| text = "COMPRESSION TYPE HARDWARE "; |
| break; |
| |
| case COM_SOFTWARE_COMPRESSION: |
| text = "COMPRESSION TYPE SOFTWARE "; |
| break; |
| |
| default: |
| text = "COMPRESSION TYPE NONE "; |
| break; |
| } |
| } |
| |
| return text; |
| } |
| |
| const NAString StmtDDLAlterMV::getMaxExtentsString() |
| { |
| NAString text; |
| |
| if (NULL != pMaxExtents_) // no attribute |
| { |
| |
| if (FALSE == isFirstAttribute_) |
| { |
| text += ", "; |
| } |
| else |
| { |
| isFirstAttribute_ = FALSE; // for the next one |
| } |
| |
| text = "MAXEXTENTS "; |
| text += LongToNAString(pMaxExtents_->getMaxExtents()); |
| } |
| |
| return text; |
| } |
| |
| const NAString StmtDDLAlterMV::getLockOnRefreshString() |
| { |
| NAString text; |
| |
| if (NULL != pLockOnRefresh_) // no attribute |
| { |
| |
| if (FALSE == isFirstAttribute_) |
| { |
| text += ", "; |
| } |
| else |
| { |
| isFirstAttribute_ = FALSE; // for the next one |
| } |
| |
| if ( FALSE == pLockOnRefresh_->isLockOnRefresh()) |
| { |
| text = "NO "; |
| } |
| |
| text += "LOCKONREFRESH "; |
| } |
| |
| return text; |
| |
| } |
| |
| const NAString StmtDDLAlterMV::getMvsAllowedString() |
| { |
| NAString text; |
| |
| if (NULL != pMvsAllowed_) // no attribute |
| { |
| |
| if (FALSE == isFirstAttribute_) |
| { |
| text += ", "; |
| } |
| else |
| { |
| isFirstAttribute_ = FALSE; // for the next one |
| } |
| |
| text += ElemDDLFileAttrMvsAllowed::getMvsAllowedTypeAsNAString( |
| pMvsAllowed_->getMvsAllowedType()); |
| |
| text += " MVS ALLOWED "; |
| } |
| |
| return text; |
| } |
| |
| |
| |
| |
| //---------------------------------------------------------------------------- |
| // MV - RG |
| |
| StmtDDLAlterMvRGroup::StmtDDLAlterMvRGroup(const QualifiedName & mvRGroupName, |
| alterMvGroupType action, |
| ElemDDLNode * pMVList) |
| :StmtDDLNode(DDL_ALTER_MV_REFRESH_GROUP), |
| mvRGroupQualName_(mvRGroupName, PARSERHEAP()), |
| pMVList_(pMVList), |
| action_(action), |
| listIndex_(0) |
| { |
| |
| |
| |
| } |
| |
| StmtDDLAlterMvRGroup::~StmtDDLAlterMvRGroup() |
| { |
| |
| // should i release anything? probably |
| |
| } |
| StmtDDLAlterMvRGroup * |
| StmtDDLAlterMvRGroup::castToStmtDDLAlterMvRGroup() |
| { |
| return this; |
| |
| |
| } |
| |
| QualifiedName & |
| StmtDDLAlterMvRGroup::getFirstMvInList() |
| { |
| listIndex_ = 0; |
| return getNextMvInList(); |
| } |
| ComBoolean |
| StmtDDLAlterMvRGroup::listHasMoreMVs() const |
| { |
| return (listIndex_ < pMVList_->entries()) ? TRUE : FALSE ; |
| } |
| |
| QualifiedName & |
| StmtDDLAlterMvRGroup::getNextMvInList() |
| { |
| ComASSERT(TRUE == listHasMoreMVs()); |
| |
| return ((*pMVList_)[listIndex_++]-> |
| castToElemDDLQualName())->getQualifiedName(); |
| } |
| |
| StmtDDLAlterMvRGroup::alterMvGroupType |
| StmtDDLAlterMvRGroup::getAction() const |
| { |
| |
| return action_; |
| |
| } |
| |
| const NAString |
| StmtDDLAlterMvRGroup::displayLabel1() const |
| { |
| |
| return NAString("MV name: ") + getMvRGroupName(); |
| |
| |
| } |
| const NAString |
| StmtDDLAlterMvRGroup::getText() const |
| { |
| return "StmtDDLAlterMvRGroup"; |
| } |
| |
| |
| //-- MVS |
| //---------------------------------------------------------------------------- |
| |
| |
| |
| |
| // |
| // Virtual destructor |
| // |
| |
| StmtDDLAlterTrigger::~StmtDDLAlterTrigger() {} |
| |
| // cast virtual function |
| StmtDDLAlterTrigger * |
| StmtDDLAlterTrigger::castToStmtDDLAlterTrigger() |
| { |
| return this; |
| } |
| |
| |
| // |
| // methods for tracing |
| // |
| |
| const NAString |
| StmtDDLAlterTrigger::getText() const |
| { |
| return "StmtDDLAlterTrigger"; |
| } |
| |
| const NAString |
| StmtDDLAlterTrigger::displayLabel1() const |
| { |
| return NAString("TriggerOrTable name: ") + getTriggerOrTableName(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLAlterView |
| // ----------------------------------------------------------------------- |
| |
| // constructor |
| StmtDDLAlterView::StmtDDLAlterView(QualifiedName & viewName, |
| const NAString & newName) : |
| StmtDDLNode(DDL_ALTER_VIEW), |
| alterType_(RENAME), |
| viewQualName_(viewName, PARSERHEAP()), |
| newName_(newName, PARSERHEAP()), |
| cascade_(FALSE) |
| { |
| |
| } |
| |
| // constructor |
| StmtDDLAlterView::StmtDDLAlterView(QualifiedName & viewName, |
| const NABoolean cascade) : |
| StmtDDLNode(DDL_ALTER_VIEW), |
| alterType_(COMPILE), |
| viewQualName_(viewName, PARSERHEAP()), |
| cascade_(cascade) |
| { |
| |
| } |
| |
| // virtual destructor |
| StmtDDLAlterView::~StmtDDLAlterView() {} |
| |
| // cast virtual function |
| StmtDDLAlterView * |
| StmtDDLAlterView::castToStmtDDLAlterView() |
| { |
| return this; |
| } |
| |
| // |
| // methods for tracing |
| // |
| |
| // virtual |
| const NAString |
| StmtDDLAlterView::displayLabel1() const |
| { |
| return NAString("View name: ") + getViewName(); |
| } |
| |
| // virtual |
| const NAString |
| StmtDDLAlterView::getText() const |
| { |
| return "StmtDDLAlterView"; |
| } |
| |
| // |
| // accessors |
| // |
| |
| QualifiedName & |
| StmtDDLAlterView::getViewNameAsQualifiedName() |
| { |
| return viewQualName_; |
| } |
| |
| const QualifiedName & |
| StmtDDLAlterView::getViewNameAsQualifiedName() const |
| { |
| return viewQualName_; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLAlterRoutine |
| // ----------------------------------------------------------------------- |
| |
| // constructor |
| StmtDDLAlterRoutine::StmtDDLAlterRoutine(ComAnsiNameSpace eNameSpace, |
| const QualifiedName & aRoutineName, |
| const QualifiedName & anActionName, |
| ComRoutineType eRoutineType, |
| ElemDDLNode * pAlterPassThroughParamParseTree, |
| ElemDDLNode * pAddPassThroughParamParseTree, |
| ElemDDLNode * pRoutineAttributesParseTree, |
| CollHeap * heap) |
| : StmtDDLCreateRoutine(aRoutineName, |
| anActionName, |
| NULL, // in - ElemDDLNode * pParamList |
| NULL, // in - ElemDDLNode * pReturnsList |
| pAddPassThroughParamParseTree, // in - ElemDDLNode * pPassThroughParamList |
| pRoutineAttributesParseTree, // in - ElemDDLNode * pOptionList |
| eRoutineType, // in - ComRoutinetype |
| heap), // in - CollHeap * heap); |
| nameSpace_(eNameSpace), |
| alterPassThroughInputsParseTree_(pAlterPassThroughParamParseTree) |
| { |
| setOperatorType(DDL_ALTER_ROUTINE); // overwrite the setting done by StmtDDLCreateRoutine() call |
| } |
| |
| // virtual destructor |
| StmtDDLAlterRoutine::~StmtDDLAlterRoutine() |
| { |
| } |
| |
| // virtual cast |
| StmtDDLAlterRoutine * |
| StmtDDLAlterRoutine::castToStmtDDLAlterRoutine() |
| { |
| return this; |
| } |
| |
| // |
| // helper |
| // |
| |
| void StmtDDLAlterRoutine::synthesize() |
| { |
| ElemDDLNode *pPassThroughList = getAlterPassThroughInputsParseTree(); |
| if (pPassThroughList NEQ NULL) |
| { |
| CollIndex i4 = 0; |
| CollIndex nbrPassThroughList = pPassThroughList->entries(); |
| ElemDDLPassThroughParamDef * passThroughDef = NULL; |
| for (i4 = 0; i4 < nbrPassThroughList; i4++) |
| { |
| passThroughDef = (*pPassThroughList)[i4]->castToElemDDLPassThroughParamDef(); |
| ComASSERT(passThroughDef NEQ NULL); |
| alterPassThroughParamArray_.insert(passThroughDef); // ALTER PASS THROUGH INPUTS |
| } // for (i4 = 0; i4 < nbrPassThroughList; i4++) |
| } |
| |
| StmtDDLCreateRoutine::synthesize(); |
| |
| } // StmtDDLAlterRoutine::synthesize() |
| |
| // |
| // virtual tracing functions |
| // |
| |
| const NAString StmtDDLAlterRoutine::displayLabel1(void) const |
| { |
| return NAString("Routine name: ") + getRoutineName(); |
| } |
| |
| const NAString StmtDDLAlterRoutine::displayLabel2(void) const |
| { |
| NAString actionName(getActionNameAsAnsiString()); |
| if (NOT actionName.isNull()) |
| return "Routine action name: " + actionName; |
| else |
| return "No routine action name"; |
| } |
| |
| NATraceList StmtDDLAlterRoutine::getDetailInfo(void) const |
| { |
| NAString detailText; |
| NATraceList detailTextList; |
| |
| // |
| // routine name and routine action name |
| // |
| |
| detailTextList.append(displayLabel1()); |
| detailTextList.append(displayLabel2()); |
| |
| return detailTextList; |
| } |
| |
| const NAString StmtDDLAlterRoutine::getText(void) const |
| { |
| return "StmtDDLAlterKRoutine"; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLAlterUser |
| // ----------------------------------------------------------------------- |
| |
| // |
| // constructor |
| // |
| // constructor used for ALTER USER |
| StmtDDLAlterUser::StmtDDLAlterUser( |
| const NAString & databaseUsername, |
| AlterUserCmdSubType cmdSubType, |
| const NAString * pExternalName, |
| NABoolean isValidUser, |
| CollHeap * heap) |
| : StmtDDLNode(DDL_ALTER_USER), |
| databaseUserName_(databaseUsername,heap), |
| alterUserCmdSubType_(cmdSubType), |
| isValidUser_(isValidUser) |
| |
| { |
| |
| if (pExternalName == NULL) |
| externalUserName_ = ComString("",heap); |
| else |
| { |
| NAString userName(*pExternalName,heap); |
| externalUserName_ = userName; |
| } |
| |
| } |
| |
| // virtual destructor |
| StmtDDLAlterUser::~StmtDDLAlterUser() |
| { |
| } |
| |
| // virtual cast |
| StmtDDLAlterUser * |
| StmtDDLAlterUser::castToStmtDDLAlterUser() |
| { |
| return this; |
| } |
| |
| |
| // |
| // methods for tracing |
| // |
| |
| const NAString |
| StmtDDLAlterUser::displayLabel1() const |
| { |
| return NAString("Database username: ") + getDatabaseUsername(); |
| } |
| |
| const NAString |
| StmtDDLAlterUser::displayLabel2() const |
| { |
| |
| if (NOT getExternalUsername().isNull()) |
| return NAString("External username: ") + getExternalUsername(); |
| |
| return NAString("External username not specified."); |
| |
| } |
| |
| |
| const NAString |
| StmtDDLAlterUser::getText() const |
| { |
| return "StmtDDLAlterUser"; |
| } |
| |
| |
| |
| // |
| // End of File |
| // |