| /********************************************************************** |
| // @@@ 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: StmtDDLDrop.C |
| * Description: definitions of methods associating with DDL Drop |
| * statements |
| * |
| * |
| * Created: 11/11/95 |
| * Language: C++ |
| * |
| * |
| * |
| * |
| ***************************************************************************** |
| */ |
| |
| #include "AllStmtDDLDrop.h" |
| |
| #ifndef SQLPARSERGLOBALS_CONTEXT_AND_DIAGS |
| #define SQLPARSERGLOBALS_CONTEXT_AND_DIAGS |
| #endif |
| #include "SqlParserGlobals.h" |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLDropCatalog |
| // ----------------------------------------------------------------------- |
| |
| // |
| // constructor |
| // |
| StmtDDLDropCatalog::StmtDDLDropCatalog(const NAString & catalogName, ComDropBehavior dropBehavior) |
| : StmtDDLNode(DDL_DROP_CATALOG), |
| catalogName_(catalogName, PARSERHEAP()), |
| dropBehavior_(dropBehavior) |
| { |
| } |
| |
| // |
| // virtual destructor |
| // |
| StmtDDLDropCatalog::~StmtDDLDropCatalog() |
| { |
| } |
| |
| // |
| // cast |
| // |
| StmtDDLDropCatalog * |
| StmtDDLDropCatalog::castToStmtDDLDropCatalog() |
| { |
| return this; |
| } |
| |
| // |
| // methods for tracing |
| // |
| |
| const NAString |
| StmtDDLDropCatalog::displayLabel1() const |
| { |
| return NAString("Catalog name: ") + getCatalogName(); |
| } |
| |
| const NAString |
| StmtDDLDropCatalog::getText() const |
| { |
| return "StmtDDLDropCatalog"; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLDropComponentPrivilege |
| // ----------------------------------------------------------------------- |
| |
| // |
| // constructor |
| // |
| |
| StmtDDLDropComponentPrivilege::StmtDDLDropComponentPrivilege( |
| const NAString & aComponentPrivilegeName, |
| const NAString & aComponentName, |
| ComDropBehavior dropBehavior, |
| CollHeap * heap) // default is PARSERHEAP() |
| : StmtDDLNode(DDL_DROP_COMPONENT_PRIVILEGE), |
| componentPrivilegeName_(aComponentPrivilegeName, heap), |
| dropBehavior_(dropBehavior), |
| componentName_(aComponentName, heap) |
| { |
| } |
| |
| // |
| // virtual destructor |
| // |
| |
| StmtDDLDropComponentPrivilege::~StmtDDLDropComponentPrivilege() |
| { |
| } |
| |
| // |
| // virtual safe cast-down function |
| // |
| |
| StmtDDLDropComponentPrivilege * |
| StmtDDLDropComponentPrivilege::castToStmtDDLDropComponentPrivilege() |
| { |
| return this; |
| } |
| |
| // |
| // methods for tracing |
| // |
| |
| |
| const NAString |
| StmtDDLDropComponentPrivilege::displayLabel1() const |
| { |
| NAString aLabel("Component privilege name: "); |
| aLabel += getComponentPrivilegeName(); |
| return aLabel; |
| } |
| |
| const NAString |
| StmtDDLDropComponentPrivilege::displayLabel2() const |
| { |
| NAString aLabel("Component name: "); |
| aLabel += getComponentName(); |
| aLabel += " Drop behavior: "; |
| if (dropBehavior_ == COM_CASCADE_DROP_BEHAVIOR) |
| aLabel += "CASCADE"; |
| else |
| aLabel += "RESTRICT"; |
| |
| return aLabel; |
| } |
| |
| const NAString |
| StmtDDLDropComponentPrivilege::getText() const |
| { |
| return "StmtDDLDropComponentPrivilege"; |
| } |
| |
| |
| //---------------------------------------------------------------------------- |
| // MV - RG |
| |
| // methods for class StmtDDLDropMvRGroup - refresh groups |
| // --------------------------------------------------------------------------- |
| |
| |
| |
| // initialize constructor |
| StmtDDLDropMvRGroup::StmtDDLDropMvRGroup(const QualifiedName & mvGroupName) |
| :StmtDDLNode(DDL_DROP_MV_REFRESH_GROUP), |
| mvRGroupQualName_(mvGroupName, PARSERHEAP()) |
| { |
| // XXXXXXXXXMVSXXXXXXXXXXXXXXX |
| } |
| |
| StmtDDLDropMvRGroup::~StmtDDLDropMvRGroup() |
| { |
| |
| |
| |
| } |
| |
| StmtDDLDropMvRGroup * |
| StmtDDLDropMvRGroup::castToStmtDDLDropMvRGroup() |
| { |
| return this; |
| |
| |
| } |
| |
| |
| const NAString |
| StmtDDLDropMvRGroup::displayLabel1() const |
| { |
| |
| return NAString("MV name: ") + getMvRGroupName(); |
| } |
| |
| const NAString |
| StmtDDLDropMvRGroup::getText() const |
| { |
| |
| return "StmtDDLDropMvRGroup"; |
| |
| |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLDropTrigger |
| // ----------------------------------------------------------------------- |
| |
| // |
| // constructor |
| // |
| StmtDDLDropTrigger::StmtDDLDropTrigger(const QualifiedName & triggerQualName, |
| NABoolean cleanupSpec, |
| NABoolean validateSpec, |
| NAString * pLogFile) |
| : StmtDDLNode(DDL_DROP_TRIGGER), |
| triggerQualName_(triggerQualName, PARSERHEAP()), |
| isCleanupSpec_(cleanupSpec), |
| isValidateSpec_(validateSpec), |
| pLogFile_(pLogFile) |
| {} |
| |
| // |
| // virtual destructor |
| // |
| StmtDDLDropTrigger::~StmtDDLDropTrigger() |
| { |
| if (pLogFile_) |
| delete pLogFile_; |
| } |
| |
| // |
| // cast |
| // |
| StmtDDLDropTrigger * |
| StmtDDLDropTrigger::castToStmtDDLDropTrigger() |
| { |
| return this; |
| } |
| |
| // |
| // methods for tracing |
| // |
| |
| const NAString |
| StmtDDLDropTrigger::displayLabel1() const |
| { |
| return NAString("Trigger name: ") + getTriggerName(); |
| } |
| |
| const NAString |
| StmtDDLDropTrigger::getText() const |
| { |
| return "StmtDDLDropTrigger"; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLDropIndex |
| // ----------------------------------------------------------------------- |
| |
| // |
| // constructor |
| // |
| StmtDDLDropIndex::StmtDDLDropIndex(const QualifiedName & indexName, |
| ComDropBehavior dropBehavior, |
| NABoolean cleanupSpec, |
| NABoolean validateSpec, |
| NAString * pLogFile) |
| : StmtDDLNode(DDL_DROP_INDEX), |
| origIndexQualName_(PARSERHEAP()), |
| indexQualName_(indexName, PARSERHEAP()), |
| dropBehavior_(dropBehavior), |
| isCleanupSpec_(cleanupSpec), |
| isValidateSpec_(validateSpec), |
| pLogFile_(pLogFile) |
| {} |
| |
| // |
| // virtual destructor |
| // |
| StmtDDLDropIndex::~StmtDDLDropIndex() |
| { |
| if (pLogFile_) |
| delete pLogFile_; |
| } |
| |
| void |
| StmtDDLDropIndex::synthesize() |
| { |
| } |
| |
| // |
| // cast |
| // |
| StmtDDLDropIndex * |
| StmtDDLDropIndex::castToStmtDDLDropIndex() |
| { |
| return this; |
| } |
| |
| // |
| // methods for tracing |
| // |
| |
| const NAString |
| StmtDDLDropIndex::displayLabel1() const |
| { |
| return NAString("Index name: ") + getIndexName(); |
| } |
| |
| const NAString |
| StmtDDLDropIndex::displayLabel2() const |
| { |
| NAString label2("Drop behavior: "); |
| switch (getDropBehavior()) |
| { |
| case COM_CASCADE_DROP_BEHAVIOR : |
| return label2 + "Cascade"; |
| |
| case COM_RESTRICT_DROP_BEHAVIOR : |
| return label2 + "Restrict"; |
| |
| default : |
| NAAbort("StmtDDLDrop.C", __LINE__, "internal logic error"); |
| return NAString(); |
| } |
| } |
| |
| const NAString |
| StmtDDLDropIndex::getText() const |
| { |
| return "StmtDDLDropIndex"; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLDropLibrary |
| // ----------------------------------------------------------------------- |
| |
| // |
| // constructor |
| // |
| |
| StmtDDLDropLibrary::StmtDDLDropLibrary( |
| const QualifiedName & libraryName, |
| ComDropBehavior dropBehavior) |
| : StmtDDLNode(DDL_DROP_LIBRARY), |
| libraryName_(libraryName, PARSERHEAP()), |
| dropBehavior_(dropBehavior) |
| { |
| |
| } |
| |
| // |
| // virtual destructor |
| // |
| |
| StmtDDLDropLibrary::~StmtDDLDropLibrary() |
| {} |
| |
| // |
| // safe cast |
| // |
| |
| StmtDDLDropLibrary * |
| StmtDDLDropLibrary::castToStmtDDLDropLibrary() |
| { |
| return this; |
| } |
| |
| // |
| // methods for tracing |
| // |
| |
| const NAString |
| StmtDDLDropLibrary::displayLabel1() const |
| { |
| return NAString("Library name: ") + getLibraryName(); |
| } |
| |
| const NAString |
| StmtDDLDropLibrary::getText() const |
| { |
| return "StmtDDLDropLibrary"; |
| } |
| |
| |
| |
| |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLDropModule |
| // ----------------------------------------------------------------------- |
| |
| // |
| // constructor |
| // |
| |
| StmtDDLDropModule::StmtDDLDropModule(const QualifiedName & modulename) |
| : StmtDDLNode(DDL_DROP_MODULE), |
| moduleName_(PARSERHEAP()), |
| moduleQualName_(modulename, PARSERHEAP()) |
| { |
| moduleName_ = moduleQualName_.getQualifiedNameAsAnsiString(); |
| } |
| |
| // |
| // virtual destructor |
| // |
| |
| StmtDDLDropModule::~StmtDDLDropModule() |
| {} |
| |
| // |
| // safe cast |
| // |
| |
| StmtDDLDropModule * |
| StmtDDLDropModule::castToStmtDDLDropModule() |
| { |
| return this; |
| } |
| |
| // |
| // methods for tracing |
| // |
| |
| const NAString |
| StmtDDLDropModule::displayLabel1() const |
| { |
| return NAString("Module name: ") + getModuleName(); |
| } |
| |
| const NAString |
| StmtDDLDropModule::getText() const |
| { |
| return "StmtDDLDropModule"; |
| } |
| |
| |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLDropRoutine |
| // ----------------------------------------------------------------------- |
| |
| // |
| // constructor |
| // |
| StmtDDLDropRoutine::StmtDDLDropRoutine(ComRoutineType routineType, |
| const QualifiedName & routineName, |
| const QualifiedName & routineActionName, |
| ComDropBehavior dropBehavior, |
| NABoolean cleanupSpec, |
| NABoolean validateSpec, |
| NAString * pLogFile, |
| CollHeap * heap) |
| : StmtDDLNode(DDL_DROP_ROUTINE), |
| routineType_(routineType), |
| routineQualName_(routineName, heap), |
| routineActionQualName_(routineActionName, heap), |
| dropBehavior_(dropBehavior), |
| isCleanupSpec_(cleanupSpec), |
| isValidateSpec_(validateSpec), |
| pLogFile_(pLogFile) |
| { |
| } |
| |
| |
| // |
| // virtual destructor |
| // |
| StmtDDLDropRoutine::~StmtDDLDropRoutine() |
| { |
| if (pLogFile_) |
| delete pLogFile_; |
| } |
| |
| // |
| // cast |
| // |
| StmtDDLDropRoutine * |
| StmtDDLDropRoutine::castToStmtDDLDropRoutine() |
| { |
| return this; |
| } |
| |
| // |
| // methods for tracing |
| // |
| |
| const NAString |
| StmtDDLDropRoutine::displayLabel1() const |
| { |
| return NAString("Routine name: ") + getRoutineName(); |
| } |
| |
| const NAString |
| StmtDDLDropRoutine::displayLabel2() const |
| { |
| NAString label2("Drop behavior: "); |
| switch (getDropBehavior()) |
| { |
| case COM_CASCADE_DROP_BEHAVIOR : |
| return label2 + "Cascade"; |
| |
| case COM_RESTRICT_DROP_BEHAVIOR : |
| return label2 + "Restrict"; |
| |
| default : |
| NAAbort("StmtDDLDrop.C", __LINE__, "internal logic error"); |
| return NAString(); |
| } |
| } |
| |
| const NAString |
| StmtDDLDropRoutine::getText() const |
| { |
| return "StmtDDLDropRoutine"; |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLDropSchema |
| // ----------------------------------------------------------------------- |
| |
| // |
| // constructor |
| // |
| StmtDDLDropSchema::StmtDDLDropSchema(//const SchemaName & schemaName, |
| const ElemDDLSchemaName & aSchemaNameParseNode, |
| ComDropBehavior dropBehavior, |
| ComBoolean cleanupMode, |
| ComBoolean dropObjectsOnly) |
| : StmtDDLNode(DDL_DROP_SCHEMA), |
| schemaQualName_(aSchemaNameParseNode.getSchemaName(), PARSERHEAP()), |
| dropBehavior_(dropBehavior), |
| cleanupMode_(cleanupMode), |
| dropObjectsOnly_(dropObjectsOnly), |
| dropIfExists_(FALSE), |
| schemaName_(PARSERHEAP()) |
| { |
| 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_); |
| |
| } |
| |
| } |
| |
| // |
| // virtual destructor |
| // |
| StmtDDLDropSchema::~StmtDDLDropSchema() |
| { |
| } |
| |
| // |
| // cast |
| // |
| StmtDDLDropSchema * |
| StmtDDLDropSchema::castToStmtDDLDropSchema() |
| { |
| return this; |
| } |
| |
| // |
| // methods for tracing |
| // |
| |
| const NAString |
| StmtDDLDropSchema::displayLabel1() const |
| { |
| return NAString("Schema name: ") + getSchemaName(); |
| } |
| |
| const NAString |
| StmtDDLDropSchema::displayLabel2() const |
| { |
| NAString label2("Drop behavior: "); |
| switch (getDropBehavior()) |
| { |
| case COM_CASCADE_DROP_BEHAVIOR : |
| return label2 + "Cascade"; |
| |
| case COM_RESTRICT_DROP_BEHAVIOR : |
| return label2 + "Restrict"; |
| |
| default : |
| NAAbort("StmtDDLDrop.C", __LINE__, "internal logic error"); |
| return NAString(); |
| } |
| } |
| |
| const NAString |
| StmtDDLDropSchema::getText() const |
| { |
| return "StmtDDLDropSchema"; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLDropSequence |
| // ----------------------------------------------------------------------- |
| |
| // |
| // constructor |
| // |
| StmtDDLDropSequence::StmtDDLDropSequence(const QualifiedName & seqQualName, |
| ElemDDLNode * pSequenceOptionList, |
| CollHeap * heap) |
| : StmtDDLNode(DDL_DROP_SEQUENCE), |
| seqQualName_(seqQualName, heap) |
| { |
| |
| } |
| |
| StmtDDLDropSequence::~StmtDDLDropSequence() |
| { |
| } |
| |
| // |
| // cast virtual function |
| // |
| StmtDDLDropSequence * |
| StmtDDLDropSequence::castToStmtDDLDropSequence() |
| { |
| return this; |
| } |
| |
| // |
| // accessors |
| // |
| |
| Int32 |
| StmtDDLDropSequence::getArity() const |
| { |
| return 0; |
| } |
| |
| ExprNode * |
| StmtDDLDropSequence::getChild(Lng32 index) |
| { |
| return NULL; |
| } |
| |
| // |
| // methods for tracing |
| // |
| |
| const NAString |
| StmtDDLDropSequence::displayLabel1() const |
| { |
| return NAString("Sequence name: ") + seqQualName_.getQualifiedNameAsAnsiString(); |
| } |
| |
| NATraceList |
| StmtDDLDropSequence::getDetailInfo() const |
| { |
| NAString detailText; |
| NATraceList detailTextList; |
| |
| // |
| // table name |
| // |
| |
| detailTextList.append(displayLabel1()); |
| |
| return detailTextList; |
| } |
| |
| const NAString |
| StmtDDLDropSequence::getText() const |
| { |
| return "StmtDDLDropSequence"; |
| } |
| |
| // method for collecting information |
| void StmtDDLDropSequence::synthesize() |
| { |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLDropSQL |
| // ----------------------------------------------------------------------- |
| |
| // |
| // constructor |
| // |
| |
| StmtDDLDropSQL::StmtDDLDropSQL(ComDropBehavior dropBehavior) |
| : StmtDDLNode(DDL_DROP_SQL), |
| dropBehavior_(dropBehavior) |
| {} |
| |
| // |
| // virtual destructor |
| // |
| |
| StmtDDLDropSQL::~StmtDDLDropSQL() |
| {} |
| |
| StmtDDLDropSQL * |
| StmtDDLDropSQL::castToStmtDDLDropSQL() |
| { |
| return this; |
| } |
| |
| // |
| // for tracing |
| // |
| const NAString |
| StmtDDLDropSQL::getText() const |
| { |
| return "StmtDDLDropSQL"; |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLDropTable |
| // ----------------------------------------------------------------------- |
| |
| // |
| // constructor |
| // |
| StmtDDLDropTable::StmtDDLDropTable(const QualifiedName & tableQualName, |
| ComDropBehavior dropBehavior) |
| : StmtDDLNode(DDL_DROP_TABLE), |
| origTableQualName_(PARSERHEAP()), |
| tableQualName_(tableQualName, PARSERHEAP()), |
| dropBehavior_(dropBehavior), |
| tableType_(ExtendedQualName::NORMAL_TABLE), //++ MV |
| isSpecialTypeSpecified_(FALSE), //++ MV |
| isCleanupSpec_(FALSE), |
| isValidateSpec_(FALSE), |
| pLogFile_(NULL), |
| dropIfExists_(FALSE) |
| { |
| } |
| |
| // |
| // constructor for CLEANUP |
| // |
| StmtDDLDropTable::StmtDDLDropTable(const QualifiedName & tableQualName, |
| ComDropBehavior dropBehavior, |
| NABoolean cleanupSpec, |
| NABoolean validateSpec, |
| NAString *pLogFile) |
| : StmtDDLNode(DDL_DROP_TABLE), |
| origTableQualName_(PARSERHEAP()), |
| tableQualName_(tableQualName, PARSERHEAP()), |
| dropBehavior_(dropBehavior), |
| tableType_(ExtendedQualName::NORMAL_TABLE), //++ MV |
| isSpecialTypeSpecified_(FALSE), //++ MV |
| isCleanupSpec_(cleanupSpec), |
| isValidateSpec_(validateSpec), |
| pLogFile_(pLogFile), |
| dropIfExists_(FALSE) |
| { |
| } |
| |
| // |
| // virtual destructor |
| // |
| StmtDDLDropTable::~StmtDDLDropTable() |
| { |
| if (pLogFile_) |
| delete pLogFile_; |
| } |
| |
| void |
| StmtDDLDropTable::synthesize() |
| { |
| } |
| |
| // |
| // cast |
| // |
| StmtDDLDropTable * |
| StmtDDLDropTable::castToStmtDDLDropTable() |
| { |
| return this; |
| } |
| |
| // |
| // methods for tracing |
| // |
| |
| const NAString |
| StmtDDLDropTable::displayLabel1() const |
| { |
| return NAString("Table name: ") + getTableName(); |
| } |
| |
| const NAString |
| StmtDDLDropTable::displayLabel2() const |
| { |
| NAString label2("Drop behavior: "); |
| switch (getDropBehavior()) |
| { |
| case COM_CASCADE_DROP_BEHAVIOR : |
| return label2 + "Cascade"; |
| |
| case COM_RESTRICT_DROP_BEHAVIOR : |
| return label2 + "Restrict"; |
| |
| default : |
| NAAbort("StmtDDLDrop.C", __LINE__, "internal logic error"); |
| return NAString(); |
| } |
| } |
| |
| const NAString |
| StmtDDLDropTable::getText() const |
| { |
| return "StmtDDLDropTable"; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLDropHbaseTable |
| // ----------------------------------------------------------------------- |
| |
| // |
| // constructor |
| // |
| StmtDDLDropHbaseTable::StmtDDLDropHbaseTable(const QualifiedName & tableQualName) |
| : StmtDDLNode(DDL_DROP_HBASE_TABLE), |
| origTableQualName_(PARSERHEAP()), |
| tableQualName_(tableQualName, PARSERHEAP()) |
| { |
| } |
| |
| // |
| // virtual destructor |
| // |
| StmtDDLDropHbaseTable::~StmtDDLDropHbaseTable() |
| { |
| } |
| |
| // |
| // cast |
| // |
| StmtDDLDropHbaseTable * |
| StmtDDLDropHbaseTable::castToStmtDDLDropHbaseTable() |
| { |
| return this; |
| } |
| |
| // |
| // methods for tracing |
| // |
| |
| const NAString |
| StmtDDLDropHbaseTable::displayLabel1() const |
| { |
| return NAString("Table name: ") + getTableName(); |
| } |
| |
| const NAString |
| StmtDDLDropHbaseTable::displayLabel2() const |
| { |
| return NAString(); |
| } |
| |
| const NAString |
| StmtDDLDropHbaseTable::getText() const |
| { |
| return "StmtDDLDropHbaseTable"; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLDropView |
| // ----------------------------------------------------------------------- |
| |
| // |
| // constructor |
| // |
| StmtDDLDropView::StmtDDLDropView(const QualifiedName & viewQualName, |
| ComDropBehavior dropBehavior, |
| NABoolean cleanupSpec, |
| NABoolean validateSpec, |
| NAString * pLogFile) |
| : StmtDDLNode(DDL_DROP_VIEW), |
| viewQualName_(viewQualName, PARSERHEAP()), |
| dropBehavior_(dropBehavior), |
| isCleanupSpec_(cleanupSpec), |
| isValidateSpec_(validateSpec), |
| pLogFile_(pLogFile) |
| { |
| } |
| |
| // |
| // virtual destructor |
| // |
| StmtDDLDropView::~StmtDDLDropView() |
| { |
| if (pLogFile_) |
| delete pLogFile_; |
| } |
| |
| // |
| // cast |
| // |
| StmtDDLDropView * |
| StmtDDLDropView::castToStmtDDLDropView() |
| { |
| return this; |
| } |
| |
| // |
| // methods for tracing |
| // |
| |
| const NAString |
| StmtDDLDropView::displayLabel1() const |
| { |
| return NAString("View name: ") + getViewName(); |
| } |
| |
| const NAString |
| StmtDDLDropView::displayLabel2() const |
| { |
| NAString label2("Drop behavior: "); |
| switch (getDropBehavior()) |
| { |
| case COM_CASCADE_DROP_BEHAVIOR : |
| return label2 + "Cascade"; |
| |
| case COM_RESTRICT_DROP_BEHAVIOR : |
| return label2 + "Restrict"; |
| |
| default : |
| NAAbort("StmtDDLDrop.C", __LINE__, "internal logic error"); |
| return NAString(); |
| } |
| } |
| |
| const NAString |
| StmtDDLDropView::getText() const |
| { |
| return "StmtDDLDropView"; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for class StmtDDLDropMV |
| // ----------------------------------------------------------------------- |
| |
| // |
| // constructor |
| // |
| StmtDDLDropMV::StmtDDLDropMV(const QualifiedName & MVQualName, |
| ComDropBehavior dropBehavior, |
| NABoolean cleanupSpec, |
| NABoolean validateSpec, |
| NAString * pLogFile) |
| : StmtDDLNode(DDL_DROP_MV), |
| MVQualName_(MVQualName, PARSERHEAP()), |
| dropBehavior_(dropBehavior), |
| isCleanupSpec_(cleanupSpec), |
| isValidateSpec_(validateSpec), |
| pLogFile_(pLogFile) |
| { |
| } |
| |
| // |
| // virtual destructor |
| // |
| StmtDDLDropMV::~StmtDDLDropMV() |
| { |
| if (pLogFile_) |
| delete pLogFile_; |
| } |
| |
| // |
| // cast |
| // |
| StmtDDLDropMV * |
| StmtDDLDropMV::castToStmtDDLDropMV() |
| { |
| return this; |
| } |
| |
| // |
| // methods for tracing |
| // |
| |
| const NAString |
| StmtDDLDropMV::displayLabel1() const |
| { |
| return NAString("Materialized View name: ") + getMVName(); |
| } |
| |
| const NAString |
| StmtDDLDropMV::displayLabel2() const |
| { |
| NAString label2("Drop behavior: "); |
| switch (getDropBehavior()) |
| { |
| case COM_CASCADE_DROP_BEHAVIOR : |
| return label2 + "Cascade"; |
| |
| case COM_RESTRICT_DROP_BEHAVIOR : |
| return label2 + "Restrict"; |
| |
| default : |
| NAAbort("StmtDDLDrop.C", __LINE__, "internal logic error"); |
| return NAString(); |
| } |
| } |
| |
| const NAString |
| StmtDDLDropMV::getText() const |
| { |
| return "StmtDDLDropMV"; |
| } |
| |
| //----------------------------------------------------------------------- |
| // methods for class StmtDDLDropSynonym |
| //----------------------------------------------------------------------- |
| |
| // |
| // constructor |
| // |
| |
| StmtDDLDropSynonym::StmtDDLDropSynonym(const QualifiedName & synonymName) |
| : StmtDDLNode (DDL_DROP_SYNONYM), |
| synonymName_(synonymName, PARSERHEAP()) |
| { |
| } |
| |
| // |
| // Virtual destructor |
| // |
| |
| StmtDDLDropSynonym::~StmtDDLDropSynonym() |
| {} |
| |
| // |
| // cast |
| // |
| |
| StmtDDLDropSynonym * |
| StmtDDLDropSynonym::castToStmtDDLDropSynonym() |
| { |
| return this; |
| } |
| |
| // |
| // for tracing |
| // |
| |
| const NAString |
| StmtDDLDropSynonym::displayLabel1() const |
| { |
| return NAString ("Synonym name: ") + getSynonymName(); |
| } |
| |
| const NAString |
| StmtDDLDropSynonym::getText() const |
| { |
| return "StmtDropSynonym"; |
| } |
| |
| //----------------------------------------------------------------------- |
| // methods for class StmtDDLDropExceptionTable |
| //----------------------------------------------------------------------- |
| |
| // |
| // constructor |
| // |
| |
| StmtDDLDropExceptionTable::StmtDDLDropExceptionTable(const QualifiedName & exceptionName, |
| const QualifiedName & objectReference, |
| ComDropBehavior dropBehavior, |
| NABoolean cleanupSpec, |
| NAString * pLogFile) |
| : StmtDDLNode (DDL_DROP_EXCEPTION_TABLE), |
| exceptionName_(exceptionName, PARSERHEAP()), |
| objectReference_(objectReference, PARSERHEAP()), |
| dropBehavior_(dropBehavior), |
| isCleanupSpec_(cleanupSpec), |
| dropType_(COM_DROP_SINGLE), |
| pLogFile_(pLogFile) |
| { |
| } |
| |
| |
| StmtDDLDropExceptionTable::StmtDDLDropExceptionTable(const QualifiedName & objectReference, |
| ComDropBehavior dropBehavior, |
| NABoolean cleanupSpec, |
| NAString * pLogFile) |
| : StmtDDLNode (DDL_DROP_EXCEPTION_TABLE), |
| exceptionName_(NULL), |
| objectReference_(objectReference, PARSERHEAP()), |
| dropBehavior_(dropBehavior), |
| isCleanupSpec_(cleanupSpec), |
| dropType_(COM_DROP_ALL), |
| pLogFile_(pLogFile) |
| { |
| } |
| |
| |
| // |
| // Virtual destructor |
| // |
| |
| StmtDDLDropExceptionTable::~StmtDDLDropExceptionTable() |
| {} |
| |
| // |
| // cast |
| // |
| |
| StmtDDLDropExceptionTable * |
| StmtDDLDropExceptionTable::castToStmtDDLDropExceptionTable() |
| { |
| return this; |
| } |
| |
| // |
| // for tracing |
| // |
| |
| const NAString |
| StmtDDLDropExceptionTable::displayLabel1() const |
| { |
| return NAString ("Exception table name: ") + getExceptionName(); |
| } |
| |
| const NAString |
| StmtDDLDropExceptionTable::displayLabel2() const |
| { |
| return NAString ("Table name: ") + getObjectReference(); |
| } |
| |
| const NAString |
| StmtDDLDropExceptionTable::getText() const |
| { |
| return "StmtDropExceptionTable"; |
| } |
| |
| // |
| // End of File |
| // |
