/**********************************************************************
// @@@ 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:         CmpSeabaseDDLupgrade.cpp
 * Description:  Implements upgrade of metadata.
 *
 *
 * Created:     6/30/2013
 * Language:     C++
 *
 *
 *****************************************************************************
 */

#include "CmpSeabaseDDLincludes.h"
#include "CmpDDLCatErrorCodes.h"
#include "CmpSeabaseDDLupgrade.h"
#include "CmpSeabaseDDLrepos.h"
#include "PrivMgrMD.h"

NABoolean CmpSeabaseMDupgrade::isOldMDtable(const NAString &objName)
{
  if (objName.contains(OLD_MD_EXTENSION))
    return TRUE;
  else
    return FALSE;
}

NABoolean CmpSeabaseMDupgrade::isMDUpgradeNeeded()
{
  for (Lng32 i = 0; i < sizeof(allMDupgradeInfo)/sizeof(MDUpgradeInfo); i++)
    {
      const MDUpgradeInfo &mdti = allMDupgradeInfo[i];
      if (mdti.upgradeNeeded)
        return TRUE;
    }

  return FALSE;
}

NABoolean CmpSeabaseMDupgrade::isViewsUpgradeNeeded()
{
  for (Lng32 i = 0; i < sizeof(allMDviewsInfo)/sizeof(MDViewInfo); i++)
    {
      const MDViewInfo &mdti = allMDviewsInfo[i];
      if (mdti.upgradeNeeded)
        return TRUE;
    }

  return FALSE;
}

NABoolean CmpSeabaseMDupgrade::isReposUpgradeNeeded()
{
  for (Lng32 i = 0; i < sizeof(allReposUpgradeInfo)/sizeof(MDUpgradeInfo); i++)
    {
      const MDUpgradeInfo &mdti = allReposUpgradeInfo[i];
      if (mdti.upgradeNeeded)
        return TRUE;
    }
  return FALSE;
}

// ----------------------------------------------------------------------------
// isPrivsUpgradeNeeded
//
// Checks to see PrivMgr metadata tables need to be upgraded
// returns:
//   TRUE - upgrade maybe needed
//   FALSE - upgrade not needed
// ----------------------------------------------------------------------------
NABoolean CmpSeabaseMDupgrade::isPrivsUpgradeNeeded()
{
  // If PrivMgr tables don't exist (0), then authorization is not enabled
  NABoolean checkAllTables = FALSE;
  if (isPrivMgrMetadataInitialized(&ActiveSchemaDB()->getDefaults(), checkAllTables) == 0)
  {
    // During a Trafodion upgrade, the customer can choose to enable security 
    // features through a new installation option.  When chosen, the installer 
    // sets the environment variable TRAFODION_ENABLE_AUTHENTICATION to YES.
    // Check to see if this envvar has been set:
    char * env = getenv("TRAFODION_ENABLE_AUTHENTICATION");
    if (env)
       return (strcmp(env, "YES") == 0) ? TRUE : FALSE;

    // authorization is not enabled -> no need to upgrade
    return FALSE;
  }

  // Otherwise assume upgrade is required
  return TRUE;
}

short CmpSeabaseMDupgrade::dropMDtables(ExpHbaseInterface *ehi, 
					NABoolean oldTbls,
					NABoolean useOldNameForNewTables)
{
  Lng32 retcode = 0;
  Lng32 errcode = 0;

  for (Lng32 i = 0; i < sizeof(allMDupgradeInfo)/sizeof(MDUpgradeInfo); i++)
    {
      const MDUpgradeInfo &mdti = allMDupgradeInfo[i];
      
      if ((NOT oldTbls) && (!mdti.newName))
	continue;
      
      if (mdti.mdOnly)
        continue;

      HbaseStr hbaseTable;
      NAString extNameForHbase;
      extNameForHbase = TRAFODION_SYSCAT_LIT;
      extNameForHbase += ".";
      extNameForHbase += SEABASE_MD_SCHEMA;
      extNameForHbase += ".";

      if (oldTbls)
	{
	  if (useOldNameForNewTables)
	    {
	      if (! mdti.newName)
		continue;

	      extNameForHbase += mdti.newName;
	      extNameForHbase += OLD_MD_EXTENSION;
	    }
	  else
	    {
	      if (!mdti.oldName)
		continue;
	      
	      extNameForHbase += mdti.oldName;
	    }
	}
      else
	extNameForHbase += mdti.newName;
	
      hbaseTable.val = (char*)extNameForHbase.data();
      hbaseTable.len = extNameForHbase.length();
      
      retcode = dropHbaseTable(ehi, &hbaseTable, FALSE, FALSE);
      if (retcode < 0)
	{
	  errcode = -1;
	}
      
    } // for
  
  return errcode;
}

short CmpSeabaseMDupgrade::restoreOldMDtables(ExpHbaseInterface *ehi)
{
  Lng32 retcode = 0;
  Lng32 errcode = 0;

  // drop all the new MD tables. Ignore errors.
  dropMDtables(ehi, FALSE);

  for (Lng32 i = 0; i < sizeof(allMDupgradeInfo)/sizeof(MDUpgradeInfo); i++)
    {
      const MDUpgradeInfo &mdti = allMDupgradeInfo[i];
      
      if ((!mdti.newName) || (!mdti.oldName) ||
	  (mdti.addedTable) || (mdti.mdOnly))
	continue;
      
      HbaseStr oldHbaseTable;
      NAString extNameForOldHbase;
      extNameForOldHbase = TRAFODION_SYSCAT_LIT;
      extNameForOldHbase += ".";
      extNameForOldHbase += SEABASE_MD_SCHEMA;
      extNameForOldHbase += ".";
      extNameForOldHbase += mdti.oldName;
      oldHbaseTable.val = (char*)extNameForOldHbase.data();
      oldHbaseTable.len = extNameForOldHbase.length();
      
      HbaseStr currHbaseTable;
      NAString extNameForCurrHbase;
      extNameForCurrHbase = TRAFODION_SYSCAT_LIT;
      extNameForCurrHbase += ".";
      extNameForCurrHbase += SEABASE_MD_SCHEMA;
      extNameForCurrHbase += ".";
      extNameForCurrHbase += mdti.newName;
      currHbaseTable.val = (char*)extNameForCurrHbase.data();
      currHbaseTable.len = extNameForCurrHbase.length();
      
      retcode = copyHbaseTable(ehi, &oldHbaseTable/*src*/, &currHbaseTable/*tgt*/);
      if (retcode < 0)
	{
	  dropMDtables(ehi, FALSE);
	  return -1;
	}
    } // for
  
  return 0;
}

NABoolean CmpSeabaseDDL::getOldMDInfo(const MDTableInfo  &mdti,
                                      const char* &oldName,
                                      const QString* &oldDDL, Lng32 &sizeOfoldDDL)
{
  if (! mdti.newName)
    return FALSE;

  Lng32 numEntries = sizeof(allMDupgradeInfo) / sizeof(MDUpgradeInfo);

  for (Lng32 i = 0; i < numEntries; i++)
    {
      const MDUpgradeInfo &mdui = allMDupgradeInfo[i];
      if (! mdui.newName)
        continue;

      if (strcmp(mdti.newName, mdui.newName) == 0)
        {
          oldName = mdui.oldName;
          oldDDL = mdui.oldDDL;
          sizeOfoldDDL = mdui.sizeOfoldDDL;
          return TRUE;
        }
    }

  return FALSE;
}

// Return value:
//   0: not all old metadata tables exist, metadata is not initialized
//   1: all old metadata tables exists, metadata is initialized
//  -ve: error code
short CmpSeabaseDDL::isOldMetadataInitialized(ExpHbaseInterface * ehi)
{
  short retcode ;

  Lng32 numTotal = 0;
  Lng32 numExists = 0;
  retcode = 0;
  for (Int32 i = 0; 
       (((retcode == 0) || (retcode == -1)) && (i < sizeof(allMDtablesInfo)/sizeof(MDTableInfo))); i++)
    {
      const MDUpgradeInfo &mdi = allMDupgradeInfo[i];
      
      if (! mdi.oldName)
        continue;

      if (mdi.addedTable)
        continue;

      NAString oldName(mdi.oldName);
      size_t pos = oldName.index(OLD_MD_EXTENSION);
      oldName = oldName.remove(pos, sizeof(OLD_MD_EXTENSION));

      numTotal++;
      HbaseStr hbaseTables;
      NAString hbaseTablesStr(getSystemCatalog());
      hbaseTablesStr += ".";
      hbaseTablesStr += SEABASE_MD_SCHEMA;
      hbaseTablesStr += ".";
      hbaseTablesStr += oldName;
      hbaseTables.val = (char*)hbaseTablesStr.data();
      hbaseTables.len = hbaseTablesStr.length();
      
      retcode = ehi->exists(hbaseTables);
      if (retcode == -1) // exists
        numExists++;
    }
  
  if ((retcode != 0) && (retcode != -1))
    return retcode; // error accessing metadata

  if (numExists < numTotal) 
    return 0; // corrupted or uninitialized old metadata

  if (numExists == numTotal)
    return 1; // metadata is initialized
  
  return -1;
}

short CmpSeabaseMDupgrade::executeSeabaseMDupgrade(CmpDDLwithStatusInfo *mdui,
                                                   NABoolean ddlXns,
						   NAString &currCatName, NAString &currSchName)
{
  Lng32 cliRC = 0;
  Lng32 retcode = 0;

  char msgBuf[1000];
  char buf[10000];

  // interfaces for upgrading subsystems; OK to create on stack for
  // now as they are stateless
  CmpSeabaseUpgradeRepository upgradeRepository;
  CmpSeabaseUpgradePrivMgr upgradePrivMgr;

  ExeCliInterface cliInterface(STMTHEAP, 0, NULL,
    CmpCommon::context()->sqlSession()->getParentQid());
  ExpHbaseInterface * ehi = NULL;

  while (1)
    {
      // The line below is useful when debugging upgrade; it shows the step progression
      // through the upgrade state machine.
      // cout << "mdui->step() is " << mdui->step() 
      //      << ", mdui->subStep() is " << mdui->subStep() << endl;

      switch (mdui->step())
	{
	case UPGRADE_START: 
	  {
	    if (xnInProgress(&cliInterface))
	      {
		*CmpCommon::diags() << DgSqlCode(-20123);
		return -1;
	      }

	    if (mdui->getMDVersion())
	      {
		mdui->setStep(GET_MD_VERSION);
		mdui->setSubstep(0);
		break;
	      }

	    if (mdui->getSWVersion())
	      {
		mdui->setStep(GET_SW_VERSION);
		mdui->setSubstep(0);
		break;
	      }

	    mdui->setMsg("Metadata Upgrade: started");
	    mdui->setStep(VERSION_CHECK);
	    mdui->setSubstep(0);
	    mdui->setEndStep(TRUE);
	    
            if (!ComUser::isRootUserID())
              {
                 mdui->setMsg("Metadata Upgrade: not authorized");
                 mdui->setStep(UPGRADE_FAILED);
                 mdui->setSubstep(0);
              }

	    if (sendAllControlsAndFlags())
	      {
		mdui->setStep(UPGRADE_FAILED);
		mdui->setSubstep(0);
	      }

	    return 0;
	  }
	  break;
	  
	case GET_MD_VERSION:
	  {
	    switch (mdui->subStep())
	      {
	      case 0:
		{
		  ehi = allocEHI(&ActiveSchemaDB()->getDefaults());
		  
		  Int64 mdCurrMajorVersion;
		  Int64 mdCurrMinorVersion;
                  Int64 mdCurrUpdateVersion;
		  retcode = validateVersions(&ActiveSchemaDB()->getDefaults(), ehi,
					     &mdCurrMajorVersion,
					     &mdCurrMinorVersion,
                                             &mdCurrUpdateVersion);
		  
		  deallocEHI(ehi);
		  
		  if (retcode == 0)
		    {
		      // no version mismatch detected.
		      // Metadata is uptodate.
		      mdui->setSubstep(1);
		    }
		  else if (retcode == -1395) // mismatch in MAJOR version. Need to upgrade
		    {
		      if ((mdCurrMajorVersion == METADATA_OLD_MAJOR_VERSION) &&
			  (mdCurrMinorVersion == METADATA_OLD_MINOR_VERSION) &&
			  (mdCurrUpdateVersion == METADATA_OLD_UPDATE_VERSION))
			{
			  mdui->setSubstep(2);
			}
		      else
			{
			  // metadata cannot be upgraded with the current release.
			  mdui->setSubstep(3);
			}
		    }
		  else if (retcode == -1394) // mismatch in MAJOR version. Need to upgrade
		    {
		      // metadata cannot be upgraded with the current release.
		      mdui->setSubstep(3);
		    }
		  else
		    {
		      *CmpCommon::diags() << DgSqlCode(retcode);
		      mdui->setStep(DONE_RETURN);
		      
		      mdui->setSubstep(0);
		      mdui->setEndStep(TRUE);
		      break;
		    }
		  
		  str_sprintf(msgBuf, "  Current Version %ld.%ld.%ld. Expected Version %d.%d.%d.",
			      mdCurrMajorVersion, 
                              mdCurrMinorVersion,
                              mdCurrUpdateVersion,
			      METADATA_MAJOR_VERSION, 
                              METADATA_MINOR_VERSION,
                              METADATA_UPDATE_VERSION);
		  mdui->setMsg(msgBuf);
		  mdui->setEndStep(FALSE);
		  
		  return 0;
		} // case 0
		break;
		
	      case 1:
		{
		  str_sprintf(msgBuf, "  Metadata is current.");
		  mdui->setMsg(msgBuf);
		  mdui->setEndStep(FALSE);
		  
		  mdui->setStep(DONE_RETURN);
		  mdui->setSubstep(0);
		  
		  return 0;
		}
		break;
		
	      case 2:
		{
		  str_sprintf(msgBuf, "  Metadata needs to be upgraded or reinitialized.");
		  mdui->setMsg(msgBuf);
		  mdui->setEndStep(FALSE);
		  
		  mdui->setStep(DONE_RETURN);
		  mdui->setSubstep(0);
		  
		  return 0;
		}
		break;
		
	      case 3:
		{
		  str_sprintf(msgBuf, "  Metadata cannot be upgraded with this version of software.");
		  mdui->setMsg(msgBuf);
		  mdui->setEndStep(FALSE);
		  
		  mdui->setSubstep(4);
		  
		  return 0;
		}
		break;

	      case 4:
		{
		  str_sprintf(msgBuf, "  Install previous version of software or reinitialize metadata.");
		  mdui->setMsg(msgBuf);
		  mdui->setEndStep(FALSE);
		  
		  mdui->setStep(DONE_RETURN);
		  mdui->setSubstep(0);
		  
		  return 0;
		}
		break;

	      } // switch
	  } // GET_MD_VERSION
	  break;
	  
	case GET_SW_VERSION:
	  {
	    switch (mdui->subStep())
	      {
	      case 0:
		{
		  ehi = allocEHI(&ActiveSchemaDB()->getDefaults());
		  
		  Int64 mdCurrMajorVersion;
		  Int64 mdCurrMinorVersion;
                  Int64 mdCurrUpdateVersion;
		  Int64 sysSWMajorVersion;
		  Int64 sysSWMinorVersion;
                  Int64 sysSWUpdVersion;
                  Int64 mdSWMajorVersion;
                  Int64 mdSWMinorVersion;
                  Int64 mdSWUpdateVersion;
		  retcode = validateVersions(&ActiveSchemaDB()->getDefaults(), ehi,
					     &mdCurrMajorVersion,
					     &mdCurrMinorVersion,
                                             &mdCurrUpdateVersion,
					     &sysSWMajorVersion,
					     &sysSWMinorVersion,
                                             &sysSWUpdVersion,
                                             &mdSWMajorVersion,
                                             &mdSWMinorVersion,
                                             &mdSWUpdateVersion);
		  
		  deallocEHI(ehi);
		  
		  if ((retcode == 0) ||
                      (retcode == -1393) ||
                      (retcode == -1395))
		    {
		      // no version mismatch detected between system and expected software.
                      if ((mdSWMajorVersion == sysSWMajorVersion) &&
                          (mdSWMinorVersion == sysSWMinorVersion) &&
                          (mdSWUpdateVersion == sysSWUpdVersion))
                        // software version stored in metadata is uptodate
                        mdui->setSubstep(1);
                      else
                        // Software version stored in metadata is not current.
                        // Initialize scripts need to be enhanced to store current software 
                        // version in metadata when trafodion is initialized or upgraded. 
                        // Until scripts are enhanced to do that, do not return an error.
                        mdui->setSubstep(1);
		    }
		  else if (retcode == -1397) // mismatch in software version
		    {
                      mdui->setSubstep(3);
		    }
                  else
                    {
                      if (retcode == -1395)
                        str_sprintf(msgBuf, "   Metadata needs to be upgraded or reinitialized (Current Version %ld.%ld.%ld, Expected Version %ld.%ld.%ld).",
                                    mdCurrMajorVersion, mdCurrMinorVersion, mdCurrUpdateVersion,
                                    (Int64)METADATA_MAJOR_VERSION, (Int64)METADATA_MINOR_VERSION, (Int64)METADATA_UPDATE_VERSION);   
                      else
                        str_sprintf(msgBuf, " Error %d returned while accessing metadata. Fix that error before running this command.",
                                    retcode);

                      mdui->setSubstep(4);

                      mdui->setMsg(msgBuf);
                      mdui->setEndStep(FALSE);
                  
                      return 0;
                    }

                  Int64 expSWMajorVersion = SOFTWARE_MAJOR_VERSION;
                  Int64 expSWMinorVersion = SOFTWARE_MINOR_VERSION;
                  Int64 expSWUpdVersion = SOFTWARE_UPDATE_VERSION;
		  str_sprintf(msgBuf, "  System Version %ld.%ld.%ld. Expected Version %ld.%ld.%ld.",
			      sysSWMajorVersion, sysSWMinorVersion, sysSWUpdVersion,
			      expSWMajorVersion, expSWMinorVersion, expSWUpdVersion);
		  mdui->setMsg(msgBuf);
		  mdui->setEndStep(FALSE);
		  
		  return 0;
		} // case 0
		break;
		
	      case 1:
		{
		  str_sprintf(msgBuf, "  Software is current.");
		  mdui->setMsg(msgBuf);
		  mdui->setEndStep(FALSE);
		  
		  mdui->setStep(DONE_RETURN);
		  mdui->setSubstep(0);
		  
		  return 0;
		}
		break;
		
	      case 2:
		{
		  str_sprintf(msgBuf, "  Metadata needs to be updated with current software version. Run 'initialize trafodion, update software version' to update it.");
		  mdui->setMsg(msgBuf);
		  mdui->setEndStep(FALSE);
		  
		  mdui->setStep(DONE_RETURN);
		  mdui->setSubstep(0);
		  
		  return 0;
		}
		break;

	      case 3:
		{
		  str_sprintf(msgBuf, "  Version of software being used is not compatible with version of software on the system.");
		  mdui->setMsg(msgBuf);
		  mdui->setEndStep(FALSE);
		  
		  mdui->setStep(DONE_RETURN);
		  mdui->setSubstep(0);
		  
		  return 0;
		}
		break;
		
              case 4:
                {
		  mdui->setEndStep(FALSE);
		  
		  mdui->setStep(DONE_RETURN);
		  mdui->setSubstep(0);
                }
                break;

	      } // switch
	  } // GET_SW_VERSION
	  break;
	  
	case VERSION_CHECK:
	  {
	    switch (mdui->subStep())
	      {
	      case 0:
		{
		  mdui->setMsg("Version Check: started");
		  mdui->subStep()++;
		  mdui->setEndStep(FALSE);

		  return 0;
		}
		break;

	      case 1:
		{
		  // check if upgrade has already been done.
		  ehi = allocEHI(&ActiveSchemaDB()->getDefaults());

		  Int64 mdCurrMajorVersion;
		  Int64 mdCurrMinorVersion;
		  retcode = validateVersions(&ActiveSchemaDB()->getDefaults(), ehi,
					     &mdCurrMajorVersion,
					     &mdCurrMinorVersion);

		  deallocEHI(ehi);

		  if (retcode == 0)
		    {
		      // no version mismatch detected.
		      // Metadata is uptodate.
		      str_sprintf(msgBuf, "  Metadata is already at Version %ld.%ld.",
				  mdCurrMajorVersion, mdCurrMinorVersion);
		      mdui->setMsg(msgBuf);
		      mdui->setEndStep(FALSE);

		      mdui->setSubstep(2);
		      
		      return 0;
		    }
		  else if (retcode == -1395) // mismatch in MAJOR version. Need to upgrade
		    {
		      if ((mdCurrMajorVersion == METADATA_OLD_MAJOR_VERSION) &&
			  (mdCurrMinorVersion == METADATA_OLD_MINOR_VERSION))
			{
                          NAString upgItems;
                          if (isUpgradeNeeded())
                            {
                              upgItems = "\n  Upgrade needed for";

                              if (isMDUpgradeNeeded())
                                {
                                  upgItems += " Catalogs,";
                                }
                              if (isViewsUpgradeNeeded())
                                {
                                  upgItems += " Views,";
                                }
                              if (upgradePrivMgr.needsUpgrade(this))
                                {
                                  upgItems += " Privileges,";
                                }
                              if (upgradeRepository.needsUpgrade(this))
                                {
                                  upgItems += " Repository,";
                                }
                              if (NOT upgItems.isNull())
                                {
                                  upgItems = upgItems.strip(NAString::trailing, ',');
                                  upgItems += ".";
                                }
                            }
			  str_sprintf(msgBuf, "  Metadata needs to be upgraded from Version %ld.%ld.%ld to %d.%d.%d.%s",
				      mdCurrMajorVersion, mdCurrMinorVersion/10, 
                                      (mdCurrMinorVersion - (mdCurrMinorVersion/10)*10),
				      METADATA_MAJOR_VERSION, METADATA_MINOR_VERSION,
                                      METADATA_UPDATE_VERSION,
                                      (upgItems.isNull() ? " " : upgItems.data()));
			  
			  mdui->setMsg(msgBuf);
			  
			  mdui->setSubstep(3);
			  
			  return 0;
			}
		      else
			{
			  // metadata cannot be upgraded with the current release.
			  str_sprintf(msgBuf, "  Metadata cannot to be upgraded from Version %ld.%ld to %d.%d with this software",
				      mdCurrMajorVersion, mdCurrMinorVersion,
				      METADATA_MAJOR_VERSION, METADATA_MINOR_VERSION);
			  
			  mdui->setMsg(msgBuf);
			  
			  mdui->setSubstep(4);
			  
			  return 0;
			}
		    }
		  else
		    {
		      *CmpCommon::diags() << DgSqlCode(retcode);
		      mdui->setStep(UPGRADE_DONE);

		      mdui->setSubstep(0);
		      mdui->setEndStep(TRUE);
		    }

		  return 0;
		}
		break;

	      case 2:
		{
		  mdui->setMsg("Version Check: done");
		  mdui->setSubstep(0);
		  mdui->setEndStep(TRUE);

		  mdui->setStep(UPGRADE_DONE);

		  return 0;
		}
		break;

	      case 3:
		{
		  mdui->setMsg("Version Check: done");
		  mdui->setSubstep(0);
		  mdui->setEndStep(TRUE);
                  mdui->setStep(OLD_MD_DROP_PRE);

		  return 0;
		}
		break;

	      case 4:
		{
		  mdui->setMsg("Version Check: done");
		  mdui->setSubstep(0);
		  mdui->setEndStep(TRUE);

		  mdui->setStep(UPGRADE_FAILED);

		  return 0;
		}
		break;

	      } // case
	  } // case VERSION_CHECK
	  break;

	case OLD_MD_DROP_PRE:
	  {
	    switch (mdui->subStep())
	      {
	      case 0:
		{
                  if ((NOT isMDUpgradeNeeded()) &&
                      (NOT isViewsUpgradeNeeded()))
                    {
                      mdui->setStep(UPDATE_MD_VIEWS);
                      mdui->setSubstep(0);
                      break;
                    }

		  mdui->setMsg("Drop Old Metadata: started");
		  mdui->subStep()++;
		  mdui->setEndStep(FALSE);

		  return 0;
		}
		break;
		
	      case 1:
		{
		  ehi = allocEHI();

		  //
		  // drop metadata tables using hbase drop command
		  //
		  if (dropMDtables(ehi, TRUE)) // drop old tables
		    {
		      deallocEHI(ehi); 

		      mdui->setStep(UPGRADE_FAILED);
		      mdui->setSubstep(0);

		      break;
		    }

		  deallocEHI(ehi); 

		  mdui->setMsg("Drop Old Metadata: done");
		  mdui->setStep(CURR_MD_BACKUP);
		  mdui->setSubstep(0);
		  mdui->setEndStep(TRUE);

		  return 0;
		}
		break;
	      } // case
	  }
	  break;

	case CURR_MD_BACKUP:
	  {
	    switch (mdui->subStep())
	      {
	      case 0:
		{
		  mdui->setMsg("Backup Current Metadata: started");
		  mdui->subStep()++;
		  mdui->setEndStep(FALSE);

		  return 0;
		}
		break;
		
	      case 1:
		{
		  //
		  // backup current metadata using hbase snapshot command
		  //
		  ehi = allocEHI();

		  for (Lng32 i = 0; i < sizeof(allMDupgradeInfo)/sizeof(MDUpgradeInfo); i++)
		    {
		      const MDUpgradeInfo &mdti = allMDupgradeInfo[i];

		      if ((mdti.addedTable) || (mdti.mdOnly))
			continue;

		      HbaseStr currHbaseTable;
		      NAString extNameForCurrHbase;
		      extNameForCurrHbase = TRAFODION_SYSCAT_LIT;
		      extNameForCurrHbase += ".";
		      extNameForCurrHbase += SEABASE_MD_SCHEMA;
		      extNameForCurrHbase += ".";
		      extNameForCurrHbase += mdti.newName;
		      currHbaseTable.val = (char*)extNameForCurrHbase.data();
		      currHbaseTable.len = extNameForCurrHbase.length();
		      
		      HbaseStr oldHbaseTable;
		      NAString extNameForOldHbase;
		      extNameForOldHbase = TRAFODION_SYSCAT_LIT;
		      extNameForOldHbase += ".";
		      extNameForOldHbase += SEABASE_MD_SCHEMA;
		      extNameForOldHbase += ".";
		      extNameForOldHbase += mdti.oldName;
		      oldHbaseTable.val = (char*)extNameForOldHbase.data();
		      oldHbaseTable.len = extNameForOldHbase.length();
		      
		      retcode = copyHbaseTable(ehi, &currHbaseTable, &oldHbaseTable);
		      if (retcode < 0)
			{
			  mdui->setStep(UPGRADE_FAILED_DROP_OLD_MD);
			  mdui->setSubstep(0);
			  break;
			}
		      
		    } // for

		  if (mdui->step() != CURR_MD_BACKUP)
		    break;

		  deallocEHI(ehi); 

		  mdui->setMsg("Backup Current Metadata: done");
		  mdui->setStep(CURR_MD_DROP);
		  mdui->setSubstep(0);
		  mdui->setEndStep(TRUE);

		  return 0;
		}
		break;
	      } // case
	    
	  }
	  break;

	case CURR_MD_DROP:
	  {
	    switch (mdui->subStep())
	      {
	      case 0:
		{
                 if (NOT isMDUpgradeNeeded())
                    {
                      mdui->setStep(UPDATE_MD_VIEWS);
                      mdui->setSubstep(0);
                      break;
                    }

		  mdui->setMsg("Drop Current Metadata: started");
		  mdui->subStep()++;
		  mdui->setEndStep(FALSE);

		  return 0;
		}
		break;
		
	      case 1:
		{
		  ehi = allocEHI();

		  //
		  // drop metadata tables using hbase drop command
		  //
		  if (dropMDtables(ehi, FALSE)) // drop curr/new MD tables
		    {
		      mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
		      mdui->setSubstep(0);
		      break;
		    }

		  deallocEHI(ehi); 

		  mdui->setMsg("Drop Current Metadata: done");
		  mdui->setStep(INITIALIZE_TRAF);
		  mdui->setSubstep(0);
		  mdui->setEndStep(TRUE);

		  return 0;
		}
		break;
	      } // case
	  }
	  break;

	case INITIALIZE_TRAF:
	  {
	    switch (mdui->subStep())
	      {
	      case 0:
		{
		  if (xnInProgress(&cliInterface))
		    {
		      *CmpCommon::diags() << DgSqlCode(-20123);

		      mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
		      mdui->setSubstep(0);
		      break;
		    }

		  mdui->setMsg("Initialize New Metadata: started");
		  mdui->subStep()++;
		  mdui->setEndStep(FALSE);

		  return 0;
		}
		break;
		
	      case 1:
		{
		  //
		  // initialize trafodion
		  CmpCommon::context()->setIsUninitializedSeabase(TRUE);
		  CmpCommon::context()->uninitializedSeabaseErrNum() = -1393; // MD doesn't exist

                  // Use "initialize trafodion, minimal" so we only create the metadata
                  // tables. The other tables (repository and privilege manager) already
                  // exist; we will upgrade them later in this method.
		  str_sprintf(buf, "initialize trafodion, minimal;");
		  
		  cliRC = cliInterface.executeImmediate(buf);
		  if (cliRC < 0)
		    {
		      cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
		      
		      mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
		      mdui->setSubstep(0);
		      break;
		    }

		  if (xnInProgress(&cliInterface))
		    {
		      *CmpCommon::diags() << DgSqlCode(-20123);

		      mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
		      mdui->setSubstep(0);
		      break;
		    }

                  CmpCommon::context()->setIsUninitializedSeabase(FALSE);
                  CmpCommon::context()->uninitializedSeabaseErrNum() = 0;

		  // After initialize, VERSIONS table contain the new metadata version
		  // values. Delete these values since the upgrade process is not yet done.
		  // At the end of upgrade, VERSIONS table will be updated with the
		  // new version values.
		  cliRC = beginXn(&cliInterface);
		  if (cliRC < 0)
		    {
		      cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());

		      mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
		      mdui->setSubstep(0);
		      break;
		    }

		  str_sprintf(buf, "delete from %s.\"%s\".%s;",
			      TRAFODION_SYSCAT_LIT,
			      SEABASE_MD_SCHEMA,
			      SEABASE_VERSIONS);
                  cliRC = cliInterface.executeImmediate(buf);

		  if (cliRC < 0)
		    {
		      cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
		      
		      mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
		      mdui->setSubstep(0);
		      break;
		    }

		  cliRC = commitXn(&cliInterface);
		  if (cliRC < 0)
		    {
		      cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
		      
		      mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
		      mdui->setSubstep(0);

		      break;
		    }

		  mdui->setMsg("Initialize New Metadata: done");
		  mdui->setStep(COPY_MD_TABLES_PROLOGUE);
		  mdui->setSubstep(0);
		  mdui->setEndStep(TRUE);

		  return 0;
		}
		break;
	      } // case
	  }
	  break;

	case COPY_MD_TABLES_PROLOGUE:
	  {
	    mdui->setMsg("Copy Old Metadata: started");
	    mdui->setStep(COPY_MD_TABLES);
	    mdui->setSubstep(0);
	    mdui->setEndStep(FALSE);

	    if (xnInProgress(&cliInterface))
	      {
		*CmpCommon::diags() << DgSqlCode(-20123);

		mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
		mdui->setSubstep(0);

		break;
	      }

            cliRC = autoCommit(&cliInterface, TRUE); // set autocommit ON.
	    if (cliRC < 0)
	      {
		cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());

		mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
		mdui->setSubstep(0);

		break;
	      }

	    return 0;
	  }
	  break;

	case COPY_MD_TABLES:
	  {
	    const MDUpgradeInfo &mdti = allMDupgradeInfo[mdui->subStep()];
	  
	    if ((mdui->subStep() < sizeof(allMDupgradeInfo)/sizeof(MDUpgradeInfo)) &&
		((NOT mdti.addedTable) && (NOT mdti.droppedTable) && 
                 (NOT mdti.isIndex) && (NOT mdti.mdOnly)))
	      {
		str_sprintf(buf, "upsert into %s.\"%s\".%s %s%s%s select %s from %s.\"%s\".%s SRC %s;",
			    TRAFODION_SYSCAT_LIT,
			    SEABASE_MD_SCHEMA,
			    mdti.newName, 
			    (mdti.insertedCols ? "(" : ""),
			    (mdti.insertedCols ? mdti.insertedCols : ""),
			    (mdti.insertedCols ? ")" : ""),
			    (mdti.selectedCols ? mdti.selectedCols : "*"),
			    TRAFODION_SYSCAT_LIT,
			    SEABASE_MD_SCHEMA,
			    mdti.oldName,
			    (mdti.wherePred ? mdti.wherePred : ""));

		// copy this table as is.
		if (NOT mdui->startStep())
		  {
		    str_sprintf(msgBuf, "  Start: Copy %20s ==> %s",
				mdti.oldName, mdti.newName);
		      
		    mdui->setStartStep(TRUE);
		    mdui->setEndStep(FALSE);

		    //mdui->setMsg(buf);
		    mdui->setMsg(msgBuf);

		    break;
		    //return 0;
		  }
		
		mdui->setStartStep(FALSE);
		mdui->setEndStep(TRUE);

		// execute the insert...select
		cliRC = cliInterface.executeImmediate(buf);
		if (cliRC < 0)
		  {
		    cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
		    
		    mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
		    mdui->setSubstep(0);

		    break;
		  }
		
		str_sprintf(msgBuf, "  End:   Copy %20s ==> %s",
			    mdti.oldName, mdti.newName);
		
		mdui->setMsg(msgBuf);
		mdui->subStep()++;

		break;
		//return 0;
	      } // if

	    mdui->subStep()++;
	    if (mdui->subStep() >= sizeof(allMDupgradeInfo)/sizeof(MDUpgradeInfo))
	      {
		mdui->setStep(COPY_MD_TABLES_EPILOGUE);
		mdui->setSubstep(0);
	      }

	  }
	  break;
	  
	case COPY_MD_TABLES_EPILOGUE:
	  {
	    mdui->setMsg("Copy Old Metadata: done");
	    mdui->setStep(VALIDATE_DATA_COPY);
	    mdui->setSubstep(0);
	    mdui->setEndStep(TRUE);

            cliRC = autoCommit(&cliInterface, FALSE); // set to OFF
	    if (cliRC < 0)
	      {
		cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
		
		mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
		mdui->setSubstep(0);

		break;
	      }

	    return 0;
	  }
	  break;

	case VALIDATE_DATA_COPY:
	  {
	    switch (mdui->subStep())
	      {
	      case 0:
		{
		  mdui->setMsg("Validate Metadata Copy: started");
		  mdui->subStep()++;
		  mdui->setEndStep(FALSE);

		  return 0;
		}
		break;
		
	      case 1:
		{
		  //
		  // validate that data got copied. Do some counts, etc.
		  //
		  // TBD
		  //
		  mdui->setMsg("Validate Metadata Copy: done");
		  mdui->setStep(CUSTOMIZE_NEW_MD);
		  mdui->setSubstep(0);
		  mdui->setEndStep(TRUE);

		  return 0;
		}
		break;
	      } // case
	  }
	  break;

	case CUSTOMIZE_NEW_MD:
	  {
            short rc = customizeNewMD(mdui, cliInterface);
            if (rc == 1)
              {
                mdui->setStep(OLD_TABLES_MD_DELETE);
                mdui->setSubstep(0);
                mdui->setEndStep(TRUE);
              }
            else if (rc == -1)
              break;
            
            return 0;
          }
          break;

	case OLD_TABLES_MD_DELETE:
	  {
	    switch (mdui->subStep())
	      {
	      case 0:
		{
		  if (xnInProgress(&cliInterface))
		    {
		      *CmpCommon::diags() << DgSqlCode(-20123);

		      mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
		      mdui->setSubstep(0);

		      break;
		    }
		  
		  cliRC = beginXn(&cliInterface);
		  if (cliRC < 0)
		    {
		      cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());

		      mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
		      mdui->setSubstep(0);

		      break;
		    }

		  mdui->setMsg("Delete Old Metadata Info: started");
		  mdui->subStep()++;
		  mdui->setEndStep(FALSE);

		  return 0;
		}
		break;
		
	      case 1:
		{
		  ehi = allocEHI();

		  // drop info about old tables from the new metadata.
		  // do not drop the actual hbase tables. 
		  for (Lng32 i = 0; i < sizeof(allMDupgradeInfo)/sizeof(MDUpgradeInfo); i++)
		    {
		      const MDUpgradeInfo &mdti = allMDupgradeInfo[i];

		      if (! mdti.oldName)
			continue;

                      if ((mdti.addedTable) || (mdti.droppedTable)) // || (mdti.isIndex))
                        continue;

		      NAString catName(TRAFODION_SYSCAT_LIT);
		      NAString schName;
		      schName += "\"";
		      schName += SEABASE_MD_SCHEMA;
		      schName += "\"";

                      char objType[5];
                      if (mdti.isIndex)
                        strcpy(objType, COM_INDEX_OBJECT_LIT);
                      else
                        strcpy(objType, COM_BASE_TABLE_OBJECT_LIT);

		      Int64 objUID = getObjectUID(&cliInterface,
						  TRAFODION_SYSCAT_LIT, SEABASE_MD_SCHEMA,
						  mdti.oldName,
                                                  objType);
		      if (objUID < 0)
			{
                          CmpCommon::diags()->clear();

                          strcpy(objType, "LB");
                          objUID = getObjectUID(&cliInterface,
                                                TRAFODION_SYSCAT_LIT, SEABASE_MD_SCHEMA,
                                                mdti.oldName,
                                                objType);
                          if (objUID < 0)
                            {
                              CmpCommon::diags()->clear();

                              strcpy(objType, "UR");
                              objUID = getObjectUID(&cliInterface,
                                                    TRAFODION_SYSCAT_LIT, SEABASE_MD_SCHEMA,
                                                    mdti.oldName,
                                                    objType);
                              if (objUID < 0)
                                {
                                  // could not find the object or an error.
                                  // Ignore and continue.
                                  CmpCommon::diags()->clear();
                                  continue;
                                }
                            }
			}
                      ComObjectType objectType = PrivMgr::ObjectLitToEnum(objType);
		      if (dropSeabaseObject(ehi, mdti.oldName,
					    catName, schName,
                                            objectType,
                                            FALSE,
					    TRUE, FALSE))
			{
			  deallocEHI(ehi); 

			  mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
			  mdui->setSubstep(0);

			  break;
			}
		    } // for

		  if (mdui->step() != OLD_TABLES_MD_DELETE)
		    break;

		  // drop info about old metadata views from the new metadata.
		  for (Int32 i = 0; i < sizeof(allMDviewsInfo)/sizeof(MDViewInfo); i++)
		    {
		      const MDViewInfo &mdi = allMDviewsInfo[i];
		      
		      if (! mdi.viewName)
			continue;
		      
		      NAString oldViewName(mdi.viewName);
		      oldViewName += OLD_MD_EXTENSION;
		      
		      NAString catName(TRAFODION_SYSCAT_LIT);
		      NAString schName;
		      schName += "\"";
		      schName += SEABASE_MD_SCHEMA;
		      schName += "\"";

		      Int64 objUID = getObjectUID(&cliInterface,
						  TRAFODION_SYSCAT_LIT, SEABASE_MD_SCHEMA,
						  oldViewName.data(),
                                                  COM_VIEW_OBJECT_LIT);
		      if (objUID < 0)
			{
			  // could not find the view or an error.
			  // Ignore and continue.
			  CmpCommon::diags()->clear();
			  continue;
			}

		      if (dropSeabaseObject(ehi, oldViewName,
					    catName, schName,
					    COM_VIEW_OBJECT,
                                            FALSE))
			{
			  deallocEHI(ehi); 

			  mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
			  mdui->setSubstep(0);

			  break;
			}
		    } // for

		  if (mdui->step() != OLD_TABLES_MD_DELETE)
		    break;

		  deallocEHI(ehi); 

		  mdui->setMsg("Delete Old Metadata Info: done");
		  mdui->setStep(UPDATE_MD_VIEWS);
		  mdui->setSubstep(0);
		  mdui->setEndStep(TRUE);

		  if (xnInProgress(&cliInterface))
		    {
		      cliRC = commitXn(&cliInterface);
		      if (cliRC < 0)
			{
			  cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
			  
			  mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
			  mdui->setSubstep(0);

			  break;
			}
		    }

		  return 0;
		}
		break;
	      } // case

	  }
	  break;

        case UPDATE_MD_VIEWS:
          {
	    switch (mdui->subStep())
	      {
	      case 0:
		{
                  if (NOT isViewsUpgradeNeeded())
                    {
                      mdui->setStep(UPGRADE_REPOS);
                      mdui->setSubstep(0);
                      break;
                    }

		  mdui->setMsg("Update Metadata Views: started");
		  mdui->subStep()++;
		  mdui->setEndStep(FALSE);

		  return 0;
		}
		break;
		
	      case 1:
		{
		  if (xnInProgress(&cliInterface))
		    {
		      *CmpCommon::diags() << DgSqlCode(-20123);

		      mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
		      mdui->setSubstep(0);

		      break;
		    }
		  
		  cliRC = beginXn(&cliInterface);
		  if (cliRC < 0)
		    {
		      cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());

		      mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
		      mdui->setSubstep(0);

		      break;
		    }
		  
		  cliRC = dropMetadataViews(&cliInterface);
		  if (cliRC < 0)
		    {
		      mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
		      mdui->setSubstep(0);

		      break;
		    }

		  cliRC = createMetadataViews(&cliInterface);
		  if (cliRC < 0)
		    {
		      mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
		      mdui->setSubstep(0);

		      break;
		    }

		  cliRC = commitXn(&cliInterface);
		  if (cliRC < 0)
		    {
		      cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
		    
		      mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
		      mdui->setSubstep(0);

		      break;
		    }
		  
		  mdui->setMsg("Update Metadata Views: done");
		  mdui->setStep(UPGRADE_REPOS);
		  mdui->setSubstep(0);
		  mdui->setEndStep(TRUE);

		  return 0;
		}
		break;
	      } // case

          }
          break;

        case UPGRADE_PRIV_MGR:
          {
            // Note: We used to do this case before UPGRADE_REPOS, but
            // that was changed in Trafodion 2.1 to do it afterwards instead.
            // The reason is that the Privilege Manager does not adhere
            // to the CmpSeabaseUpgradeSubsystem class contract; its drop
            // and recovery logic is packaged in its upgrade method. So,
            // we have to do the Privilege Manager upgrade last since there
            // is no way to undo it if we have an error afterward.
	    switch (mdui->subStep())
	      {
	      case 0:
		{
                  if (NOT upgradePrivMgr.needsUpgrade(this))
                    {
                      mdui->setStep(UPDATE_VERSION);
                      mdui->setSubstep(0);
                      break;
                    }

		  mdui->setMsg("Upgrade Priv Mgr: started");
		  mdui->subStep()++;
		  mdui->setEndStep(FALSE);

		  return 0;
		}
		break;
		
	      case 1:
		{
		  if (xnInProgress(&cliInterface))
		    {
		      *CmpCommon::diags() << DgSqlCode(-20123);

		      mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_REPOS);
		      mdui->setSubstep(0);

		      break;
		    }
		  
		  cliRC = beginXn(&cliInterface);
		  if (cliRC < 0)
		    {
		      cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());

		      mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_REPOS);
		      mdui->setSubstep(0);

		      break;
		    }
		  
		  cliRC = upgradePrivMgr.doUpgrade(&cliInterface,mdui,this,ddlXns);
		  if (cliRC != 0)
		    {
		      mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_REPOS);
		      mdui->setSubstep(0);

		      break;
		    }

		  cliRC = commitXn(&cliInterface);
		  if (cliRC < 0)
		    {
		      cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
		    
		      mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_REPOS);
		      mdui->setSubstep(0);

		      break;
		    }
		  
                  // mdui->setMsg() was called in upgradePrivMgr.doUpgrade()
		  mdui->setStep(UPDATE_VERSION);
		  mdui->setSubstep(0);
		  mdui->setEndStep(TRUE);

		  return 0;
		}
		break;
	      } // case

          }
          break;

        case UPGRADE_REPOS:
          {
            if (NOT isReposUpgradeNeeded())
              {
                mdui->setStep(UPGRADE_PRIV_MGR);
                mdui->setSubstep(0);
                break;
              }

            if (xnInProgress(&cliInterface))
              {
                *CmpCommon::diags() << DgSqlCode(-20123);
                
                mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
                mdui->setSubstep(0);
                
                break;
              }
            
            cliRC = upgradeRepository.doUpgrade(&cliInterface, mdui, this, ddlXns);
            if (cliRC != 0)
              {
                mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_REPOS);
                mdui->setSubstep(-(cliRC+1));
                
                break;
              }
            
            if (mdui->endStep())
              {
                mdui->setStep(UPGRADE_PRIV_MGR);
                mdui->setSubstep(0);
              }
            
            return 0;
          }
          break;

	case UPDATE_VERSION:
	  {
	    switch (mdui->subStep())
	      {
	      case 0:
		{
		  mdui->setMsg("Update Metadata Version: started");
		  mdui->subStep()++;
		  mdui->setEndStep(FALSE);

		  return 0;
		}
		break;
		
	      case 1:
		{
		  if (xnInProgress(&cliInterface))
		    {
		      *CmpCommon::diags() << DgSqlCode(-20123);

		      mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_REPOS);
		      mdui->setSubstep(0);

		      break;
		    }
		  
		  cliRC = beginXn(&cliInterface);
		  if (cliRC < 0)
		    {
		      cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());

		      mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_REPOS);
		      mdui->setSubstep(0);

		      break;
		    }
		  
		  cliRC = updateSeabaseVersions(&cliInterface, TRAFODION_SYSCAT_LIT);
		  if (cliRC < 0)
		    {
		      mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_REPOS);
		      mdui->setSubstep(0);

		      break;
		    }

                  CmpCommon::context()->setIsUninitializedSeabase(FALSE);
                  CmpCommon::context()->uninitializedSeabaseErrNum() = 0;

		  cliRC = commitXn(&cliInterface);
		  if (cliRC < 0)
		    {
		      cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
		    
		      mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_REPOS);
		      mdui->setSubstep(0);

		      break;
		    }
		  
		  mdui->setMsg("Update Metadata Version: done");

                  if ((NOT isMDUpgradeNeeded()) &&
                      (NOT isViewsUpgradeNeeded()))
                    mdui->setStep(METADATA_UPGRADED);
                  else
                    mdui->setStep(OLD_REPOS_DROP);
		  mdui->setSubstep(0);
		  mdui->setEndStep(TRUE);
                  
		  return 0;
		}
		break;
	      } // case
	  }
	  break;

	case OLD_REPOS_DROP:
	  {
            if (upgradeRepository.needsUpgrade(this))
              {
                if (upgradeRepository.doDrops(&cliInterface,mdui,this))
                  {
                    // no status message in this case so no return
                    cliInterface.clearGlobalDiags();
                    mdui->setStep(OLD_MD_TABLES_HBASE_DELETE);
                    mdui->setSubstep(0);
                    mdui->setEndStep(TRUE);
                  }
                else
                  {
                    if (mdui->endStep())
                      {
                        mdui->setStep(OLD_MD_TABLES_HBASE_DELETE);
                        mdui->setSubstep(0);
                        mdui->setEndStep(TRUE);
                      }                   
                    return 0;
                  }
              }
	  }
	  break;

	case OLD_MD_TABLES_HBASE_DELETE:
	  {
	    switch (mdui->subStep())
	      {
	      case 0:
		{
		  if (xnInProgress(&cliInterface))
		    {
		      *CmpCommon::diags() << DgSqlCode(-20123);

		      mdui->setStep(METADATA_UPGRADED);
		      break;
		    }
		  
		  cliRC = beginXn(&cliInterface);
		  if (cliRC < 0)
		    {
		      cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());

		      mdui->setStep(METADATA_UPGRADED);
		      break;
		    }

		  mdui->setMsg("Drop Old Metadata from Hbase: started");
		  mdui->subStep()++;
		  mdui->setEndStep(FALSE);

		  return 0;
		}
		break;
		
	      case 1:
		{
		  ehi = allocEHI();

		  // drop old tables from hbase.
		  for (Lng32 i = 0; i < sizeof(allMDupgradeInfo)/sizeof(MDUpgradeInfo); i++)
		    {
		      const MDUpgradeInfo &mdti = allMDupgradeInfo[i];

		      if ((! mdti.oldName) || (mdti.mdOnly))
			continue;

		      NAString catName(TRAFODION_SYSCAT_LIT);
		      NAString schName;
		      schName += "\"";
		      schName += SEABASE_MD_SCHEMA;
		      schName += "\"";
		      if (dropSeabaseObject(ehi, mdti.oldName,
					    catName, schName,
					    (mdti.isIndex ? COM_INDEX_OBJECT : COM_BASE_TABLE_OBJECT),
                                            FALSE,
					    FALSE, TRUE))
			{
			  // ignore errors. Continue dropping old md tables.
			}
		    } // for

		  deallocEHI(ehi); 

		  mdui->setMsg("Drop Old Metadata from Hbase: done");
		  mdui->setStep(METADATA_UPGRADED);
		  mdui->setSubstep(0);
		  mdui->setEndStep(TRUE);

		  if (xnInProgress(&cliInterface))
		    {
		      cliRC = commitXn(&cliInterface);
		      if (cliRC < 0)
			{
			  cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());

			  mdui->setStep(METADATA_UPGRADED);
			  break;
			}
		    }

		  return 0;
		}
		break;
	      } // case

	  }
	  break;

	case METADATA_UPGRADED:
	  {
	    str_sprintf(msgBuf, "Metadata Upgrade to Version %d.%d.%d: done",
                        METADATA_MAJOR_VERSION, 
                        METADATA_MINOR_VERSION,
                        METADATA_UPDATE_VERSION);

	    mdui->setMsg(msgBuf);
	    mdui->setDone(TRUE);

	    return 0;
	  }
	  break;

	case UPGRADE_DONE:
	  {
	    mdui->setMsg("Metadata Upgrade: done");
	    mdui->setDone(TRUE);

	    return 0;
	  }
	  break;

	case DONE_RETURN:
	  {
	    mdui->setMsg("");
	    mdui->setDone(TRUE);

	    return 0;
	  }
	  break;

        case UPGRADE_FAILED_RESTORE_OLD_REPOS:
          {
            // Note: We can't combine this case with UPGRADE_FAILED etc.
            // below, because the subsystem code uses mdui->subStep()
            // to keep track of its progress.

            if (upgradeRepository.needsUpgrade(this))
              {
                if (xnInProgress(&cliInterface))
                  {
                    cliRC = rollbackXn(&cliInterface);
                    if (cliRC < 0)
                      {
                        // ignore errors
                      }
                  }

                if (upgradeRepository.doUndo(&cliInterface,mdui,this))
                  {
                    // ignore errors; no status message so just continue on
                    cliInterface.clearGlobalDiags();
                    mdui->setStep(UPGRADE_FAILED_DROP_OLD_MD);
                    mdui->setSubstep(0);
                    mdui->setEndStep(TRUE);
                  }
                else
                  {
                    if (mdui->endStep())
                      {
                        mdui->setStep(UPGRADE_FAILED_DROP_OLD_MD);
                        mdui->setSubstep(0);
                        mdui->setEndStep(TRUE);
                      }
                    return 0;
                  }
              }
            else
              {
                mdui->setStep(UPGRADE_FAILED_DROP_OLD_MD);
                mdui->setSubstep(0);
                mdui->setEndStep(TRUE);
              }
          }
          break;

	case UPGRADE_FAILED:
	case UPGRADE_FAILED_RESTORE_OLD_MD:
	case UPGRADE_FAILED_DROP_OLD_MD:
	  {
            if (xnInProgress(&cliInterface))
              {
                cliRC = rollbackXn(&cliInterface);
                if (cliRC < 0)
                  {
                    // ignore errors
                  }
              }
            
	    switch (mdui->subStep())
	      {
	      case 0:
		{
		  if (mdui->step() == UPGRADE_FAILED_DROP_OLD_MD)
		    {
		      mdui->setSubstep(1);
		      break;
		    }
		  else if (mdui->step() == UPGRADE_FAILED_RESTORE_OLD_MD)
		    {
		      mdui->setSubstep(4);
		      break;
		    }
		  else
		    {
		      mdui->setSubstep(7);
		      break;
		    }
		}
		break;
		
	      case 1:
		{
		  mdui->setMsg("Drop Old Metadata: started");
		  mdui->subStep()++;
		  mdui->setEndStep(FALSE);
		  
		  return 0;
		}
		break;

	      case 2:
		{
		  if (ehi == NULL)
		    ehi = allocEHI();
		  
		  dropMDtables(ehi, TRUE); // drop old MD
		  deallocEHI(ehi);
		  
		  mdui->subStep()++;
		  mdui->setEndStep(FALSE);
		}
		break;

	      case 3:
		{
		  mdui->setMsg("Drop Old Metadata: done");
		  mdui->setSubstep(7);
		  mdui->setEndStep(TRUE);

		  return 0;
		}
		break;

	      case 4:
		{
		  mdui->setMsg("Restore from Old Metadata: started");
		  mdui->subStep()++;
		  mdui->setEndStep(FALSE);

		  return 0;
		}
		break;

	      case 5:
		{
		  if (ehi == NULL)
		    ehi = allocEHI();
		  
		  restoreOldMDtables(ehi); // restore old MD and make them current
		  deallocEHI(ehi);

		  mdui->subStep()++;
		  mdui->setEndStep(FALSE);
		}
		break;
		
	      case 6:
		{
		  mdui->setMsg("Restore from Old Metadata: done");
		  mdui->setSubstep(1); // now drop old metadata tables
		  mdui->setEndStep(TRUE);
		  
		  return 0;
		}
		break;

	      case 7: 
		{
		  deallocEHI(ehi);
		  
		  mdui->setMsg("Metadata Upgrade: failed");
		  mdui->setDone(TRUE);
		  
		  return 0;
		}
		break;
	      } // switch
	  } 
	  break;

	} // step
    } // while
  
  return 0;
}

short CmpSeabaseMDupgrade::customizeNewMD(CmpDDLwithStatusInfo *mdui,
                                          ExeCliInterface &cliInterface)
{
  if ((METADATA_OLD_MAJOR_VERSION == 2) && (METADATA_OLD_MINOR_VERSION == 3) &&
      (METADATA_MAJOR_VERSION == 3) && (METADATA_MINOR_VERSION == 0))
    return customizeNewMDv23tov30(mdui, cliInterface);

  // done, move to next step.
  return 1;
}

short CmpSeabaseMDupgrade::customizeNewMDv23tov30(CmpDDLwithStatusInfo *mdui,
                                                  ExeCliInterface &cliInterface)
{
  Lng32 cliRC = 0;
  char buf[10000];

  if (NOT ((METADATA_OLD_MAJOR_VERSION == 2) && (METADATA_OLD_MINOR_VERSION == 3) &&
           (METADATA_MAJOR_VERSION == 3) && (METADATA_MINOR_VERSION == 0)))
    {
      // done, move to next step.
      return 1;
    }

  switch (mdui->subStep())
    {
    case 0:
      {
        mdui->setMsg("Customize New Metadata: started");
        mdui->subStep()++;
        mdui->setEndStep(FALSE);
        
        // For other upgrades, it is not needed.
        // Customize this section as needed.
        if (NOT ((METADATA_OLD_MAJOR_VERSION == 2) && (METADATA_OLD_MINOR_VERSION == 3) &&
                 (METADATA_MAJOR_VERSION == 3) && (METADATA_MINOR_VERSION == 0)))
          {
            mdui->setSubstep(11);
            mdui->setEndStep(FALSE);
            
            return 0;
          }
        
        if (xnInProgress(&cliInterface))
          {
            *CmpCommon::diags() << DgSqlCode(-20123);
            
            mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
            mdui->setSubstep(0);
            
            return -1;
          }
        
        return 0;
      }
      return -1;
      
    case 1:
      {
        mdui->setMsg("  Start: Update COLUMNS");
        mdui->subStep()++;
        
        cliRC = beginXn(&cliInterface);
        if (cliRC < 0)
          {
            cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
            
            mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
            mdui->setSubstep(0);
            
            return -1;
          }
        
        return 0;
      }
      return -1;
      
    case 2:
      {
        str_sprintf(buf, "update %s.\"%s\".%s set sql_data_type = cast( case when fs_data_type = 130 then '" COM_SMALLINT_SIGNED_SDT_LIT"' when fs_data_type = 131 then '" COM_SMALLINT_UNSIGNED_SDT_LIT"' when fs_data_type = 132 then '" COM_INTEGER_SIGNED_SDT_LIT"' when fs_data_type = 133 then '" COM_INTEGER_UNSIGNED_SDT_LIT"' when fs_data_type = 134 then '" COM_LARGEINT_SIGNED_SDT_LIT"' when fs_data_type = 135 then '" COM_SMALLINT_UNSIGNED_SDT_LIT"' when fs_data_type = 140 then '" COM_REAL_SDT_LIT"' when fs_data_type = 141 then '" COM_DOUBLE_SDT_LIT"' when fs_data_type = 150 then '" COM_DECIMAL_UNSIGNED_SDT_LIT"' when fs_data_type = 151 then '" COM_DECIMAL_SIGNED_SDT_LIT"' when fs_data_type = 155 then '" COM_NUMERIC_UNSIGNED_SDT_LIT"' when fs_data_type = 156 then '" COM_NUMERIC_SIGNED_SDT_LIT"' when fs_data_type = 0     then '" COM_CHARACTER_SDT_LIT"' when fs_data_type = 2     then '" COM_CHARACTER_SDT_LIT"' when fs_data_type = 70    then '" COM_LONG_VARCHAR_SDT_LIT"' when fs_data_type = 64    then '" COM_VARCHAR_SDT_LIT"' when fs_data_type = 66    then '" COM_VARCHAR_SDT_LIT"' when fs_data_type = 100   then '" COM_VARCHAR_SDT_LIT"' when fs_data_type = 101   then '" COM_VARCHAR_SDT_LIT"' when fs_data_type = 192 then '" COM_DATETIME_SDT_LIT"' when fs_data_type >= 196 and fs_data_type <= 207 then '" COM_INTERVAL_SDT_LIT"' else '' end as char(24))    ",
                       getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_COLUMNS);
        cliRC = cliInterface.executeImmediate(buf);
        
        if (cliRC < 0)
          {
            cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
            
            *CmpCommon::diags() << DgSqlCode(-1423)
                                << DgString0(SEABASE_TEXT);
            
            mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
            mdui->setSubstep(0);
            
            return -1;
          }
        
        if (mdui->step() != CUSTOMIZE_NEW_MD)
          return -1;
        
        mdui->setMsg("  End: Update COLUMNS");
        mdui->subStep()++;
        
        if (xnInProgress(&cliInterface))
          {
            cliRC = commitXn(&cliInterface);
            if (cliRC < 0)
              {
                cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
                
                mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
                mdui->setSubstep(0);
                
                return -1;
              }
          }
        
        return 0;
      }
      return -1;
      
    case 3:
      {
        mdui->setMsg("  Start: Update TABLES");
        mdui->subStep()++;
        
        cliRC = beginXn(&cliInterface);
        if (cliRC < 0)
          {
            cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
            
            mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
            mdui->setSubstep(0);
            
            return -1;
          }
        
        return 0;
      }
      return -1;
      
    case 4:
      {
        str_sprintf(buf, "select table_uid, hbase_create_options from %s.\"%s\".%s where char_length(hbase_create_options) > 0",
                    getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_TABLES_OLD_MD);
        
        Queue * tablesQueue = NULL;
        cliRC = cliInterface.fetchAllRows(tablesQueue, buf, 0, FALSE, FALSE, TRUE);
        if (cliRC < 0)
          {
            cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
               
            mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
            mdui->setSubstep(0);
               
            return -1;
          }
           
        tablesQueue->position();
        for (int idx = 0; idx < tablesQueue->numEntries(); idx++)
          {
            OutputInfo * oi = (OutputInfo*)tablesQueue->getNext(); 
               
            Int64 tableUID = *(Int64*)oi->get(0);
            NAString hbaseCreateOptions((char*)oi->get(1));
               
            Lng32 numSaltPartns = 0;
               
            // get num salt partns from hbaseCreateOptions.
            // It is stored as:  NUM_SALT_PARTNS=>NNNN
            size_t idx2 = hbaseCreateOptions.index("NUM_SALT_PARTNS=>");
            if ((int)idx2 >= 0)
              {
                char  numSaltPartnsCharStr[5];
                const char * startNumSaltPartns = 
                  &hbaseCreateOptions.data()[idx2 + strlen("NUM_SALT_PARTNS=>")];
                memcpy(numSaltPartnsCharStr, startNumSaltPartns, 4);
                numSaltPartnsCharStr[4] = 0;
                   
                numSaltPartns = str_atoi(numSaltPartnsCharStr, 4);
                   
                hbaseCreateOptions.remove(idx2, strlen("NUM_SALT_PARTNS=>")+4);
                hbaseCreateOptions = hbaseCreateOptions.strip();
              }
               
            str_sprintf(buf, "update %s.\"%s\".%s set num_salt_partns = %d where table_uid = %ld",
                        getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_TABLES,
                        numSaltPartns,
                        tableUID);
            cliRC = cliInterface.executeImmediate(buf);
               
            if (cliRC < 0)
              {
                cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
                   
                *CmpCommon::diags() << DgSqlCode(-1423)
                                    << DgString0(SEABASE_TABLES);
                   
                mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
                mdui->setSubstep(0);
                   
                return -1;
              }
               
            if (NOT hbaseCreateOptions.isNull())
              {
                if (updateTextTable(&cliInterface, tableUID, 
                                    COM_HBASE_OPTIONS_TEXT, 0,
                                    hbaseCreateOptions))
                  {
                    *CmpCommon::diags() << DgSqlCode(-1423)
                                        << DgString0(SEABASE_TABLES);
                       
                    mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
                    mdui->setSubstep(0);
                       
                    return -1;
                  }
              }
          } // for
           
        if (mdui->step() != CUSTOMIZE_NEW_MD)
          return -1;
           
        str_sprintf(buf, "merge into %s.\"%s\".%s using (select C.object_uid, sum(C.column_size  + case when C.nullable != 0 then 1 else 0 end) from %s.\"%s\".%s C, %s.\"%s\".%s K where C.object_uid = K.object_uid and C.column_number = K.column_number group by 1) T(a, b) on table_uid = T.a when matched then update set key_length = T.b",
                    getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_TABLES,
                    getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_COLUMNS,
                    getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_KEYS);
        cliRC = cliInterface.executeImmediate(buf);
           
        if (cliRC < 0)
          {
            cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
               
            *CmpCommon::diags() << DgSqlCode(-1423)
                                << DgString0(SEABASE_TABLES);
               
            mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
            mdui->setSubstep(0);
               
            return -1;
          }
           
        str_sprintf(buf, "merge into %s.\"%s\".%s using (select object_uid, sum(column_size + case when nullable != 0 then 1 else 0 end), sum(column_size + case when nullable != 0 then 1 else 0 end + %lu + %d), count(*) from %s.\"%s\".%s group by 1) T(a,b,c,d) on table_uid = T.a when matched then update set (row_data_length, row_total_length) = (T.b, T.c + key_length * T.d)",
                    getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_TABLES,
                    sizeof(Int64),
                    5,
                    getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_COLUMNS);
        cliRC = cliInterface.executeImmediate(buf);
           
        if (cliRC < 0)
          {
            cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
               
            *CmpCommon::diags() << DgSqlCode(-1423)
                                << DgString0(SEABASE_TABLES);
               
            mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
            mdui->setSubstep(0);
               
            return -1;
          }
           
        if (mdui->step() != CUSTOMIZE_NEW_MD)
          return -1;
           
        mdui->setMsg("  End: Update TABLES");
        mdui->subStep()++;
           
        if (xnInProgress(&cliInterface))
          {
            cliRC = commitXn(&cliInterface);
            if (cliRC < 0)
              {
                cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
                   
                mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
                mdui->setSubstep(0);
                   
                return -1;
              }
          }
           
        return 0;
      }
      return -1;
         
    case 5:
      {
        mdui->setMsg("  Start: Update TEXT");
        mdui->subStep()++;
           
        cliRC = beginXn(&cliInterface);
        if (cliRC < 0)
          {
            cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
               
            mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
            mdui->setSubstep(0);
               
            return -1;
          }
           
        return 0;
      }
      return -1;
         
    case 6:
      {
        str_sprintf(buf, "update %s.\"%s\".%s set text_type = 1 where text not like 'CREATE VIEW %%' and text not like 'HBASE_OPTIONS=>%%' and NOT (text_type = 4 and text like 'HASH2PARTFUNC%%' ) ",
                    getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_TEXT);
        cliRC = cliInterface.executeImmediate(buf);
           
        if (cliRC < 0)
          {
            cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
               
            *CmpCommon::diags() << DgSqlCode(-1423)
                                << DgString0(SEABASE_TEXT);
               
            mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
            mdui->setSubstep(0);
               
            return -1;
          }
           
        if (mdui->step() != CUSTOMIZE_NEW_MD)
          return -1;
           
        mdui->setMsg("  End: Update TEXT");
        mdui->subStep()++;
           
        if (xnInProgress(&cliInterface))
          {
            cliRC = commitXn(&cliInterface);
            if (cliRC < 0)
              {
                cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
                   
                mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
                mdui->setSubstep(0);
                   
                return -1;
              }
          }
           
        return 0;
      }
      return -1;
         
    case 7:
      {
        mdui->setMsg("  Start: Update SEQ_GEN");
        mdui->subStep()++;
           
        cliRC = beginXn(&cliInterface);
        if (cliRC < 0)
          {
            cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
               
            mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
            mdui->setSubstep(0);
               
            return -1;
          }
           
        return 0;
      }
      return -1;
         
    case 8:
      {
        str_sprintf(buf, "delete from %s.\"%s\".%s where object_type = 'PK' and object_uid = (select TC.constraint_uid from %s.\"%s\".%s TC where TC.constraint_type = 'P' and TC.table_uid = (select O2.object_uid from %s.\"%s\".%s O2 where O2.catalog_name = '%s' and O2.schema_name = '%s' and O2.object_name = '%s' and O2.object_type = 'BT')) ",
                    TRAFODION_SYSCAT_LIT, SEABASE_MD_SCHEMA, SEABASE_OBJECTS,
                    TRAFODION_SYSCAT_LIT, SEABASE_MD_SCHEMA, SEABASE_TABLE_CONSTRAINTS,
                    TRAFODION_SYSCAT_LIT, SEABASE_MD_SCHEMA, SEABASE_OBJECTS,
                    TRAFODION_SYSCAT_LIT, SEABASE_MD_SCHEMA, SEABASE_SEQ_GEN_OLD_MD);                          
           
        cliRC = cliInterface.executeImmediate(buf);
        if (cliRC < 0)
          {
            cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
               
            mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
            mdui->setSubstep(0);
               
            return -1;
          }
           
        str_sprintf(buf, "delete from %s.\"%s\".%s  where constraint_type = 'P' and table_uid = (select O.object_uid from %s.\"%s\".%s O where O.catalog_name = '%s' and O.schema_name = '%s' and O.object_name = '%s' and O.object_type = 'BT') ",
                    TRAFODION_SYSCAT_LIT, SEABASE_MD_SCHEMA, SEABASE_TABLE_CONSTRAINTS,
                    TRAFODION_SYSCAT_LIT, SEABASE_MD_SCHEMA, SEABASE_OBJECTS,
                    TRAFODION_SYSCAT_LIT, SEABASE_MD_SCHEMA, SEABASE_SEQ_GEN_OLD_MD);                          
           
        cliRC = cliInterface.executeImmediate(buf);
        if (cliRC < 0)
          {
            cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
               
            mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
            mdui->setSubstep(0);
               
            return -1;
          }
           
        if (mdui->step() != CUSTOMIZE_NEW_MD)
          return -1;
           
        mdui->setMsg("  End: Update SEQ_GEN");
        mdui->subStep()++;
           
        if (xnInProgress(&cliInterface))
          {
            cliRC = commitXn(&cliInterface);
            if (cliRC < 0)
              {
                cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
                   
                mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
                mdui->setSubstep(0);
                   
                return -1;
              }
          }
           
        return 0;
      }
      return -1;
         
    case 9:
      {
        mdui->setMsg("  Start: Create Schema Objects");
        mdui->subStep()++;
           
        return 0;
      }
      return -1;
         
    case 10:
      {
        cliRC = createSchemaObjects(&cliInterface);
        if (cliRC < 0)
          {
            mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
            mdui->setSubstep(0);
               
            return -1;
          }
           
        if (mdui->step() != CUSTOMIZE_NEW_MD)
          return -1;
           
        mdui->setMsg("  End: Create Schema Objects");
        mdui->subStep()++;
           
        return 0;
      }
      return -1;
         
    case 11:
      {
        mdui->setMsg("Customize New Metadata: done");

        // done, move to next step.
        return 1;
      }
      return -1;
      
    default:
      {
        mdui->setStep(UPGRADE_FAILED_RESTORE_OLD_MD);
        mdui->setSubstep(0);
      }
      return -1;
    }

  return -1;
}

// ----------------------------------------------------------------------------
// Methods for class CmpSeabaseUpgradeRepository
// ----------------------------------------------------------------------------
NABoolean CmpSeabaseUpgradeRepository::needsUpgrade(CmpSeabaseMDupgrade * ddlState)
{ 
  return ddlState->isReposUpgradeNeeded();
}

short CmpSeabaseUpgradeRepository::doUpgrade(ExeCliInterface * cliInterface,
  CmpDDLwithStatusInfo * mdui,
  CmpSeabaseMDupgrade * ddlState,
  NABoolean /* ddlXns */)
{
  return ddlState->upgradeRepos(cliInterface,mdui);
}

short CmpSeabaseUpgradeRepository::doDrops(ExeCliInterface * cliInterface,
  CmpDDLwithStatusInfo * mdui, CmpSeabaseMDupgrade * ddlState)
{
  return ddlState->upgradeReposComplete(cliInterface,mdui);
}

short CmpSeabaseUpgradeRepository::doUndo(ExeCliInterface * cliInterface,
  CmpDDLwithStatusInfo * mdui, CmpSeabaseMDupgrade * ddlState)
{
  return ddlState->upgradeReposUndo(cliInterface,mdui);
}

// ----------------------------------------------------------------------------
// Methods for class CmpSeabaseUpgradePrivMgr
// ----------------------------------------------------------------------------
NABoolean CmpSeabaseUpgradePrivMgr::needsUpgrade(CmpSeabaseMDupgrade * ddlState)
{ 
  return ddlState->isPrivsUpgradeNeeded();
}

short CmpSeabaseUpgradePrivMgr::doUpgrade(ExeCliInterface * cliInterface,
  CmpDDLwithStatusInfo * mdui,
  CmpSeabaseMDupgrade * ddlState,
  NABoolean ddlXns)
{
  // If this is refactored in the future to return multiple messages
  // then mdui will need to be passed in, and setEndStep called when
  // we want to stop redriving this method.
  NAString doneString;
  short retcode = ddlState->upgradePrivMgr(cliInterface, ddlXns, doneString);
  if (!retcode)
    {
      mdui->setMsg(doneString.data());
      mdui->setEndStep(TRUE);
    }
  return retcode;
}

short CmpSeabaseUpgradePrivMgr::doDrops(ExeCliInterface * cliInterface,
  CmpDDLwithStatusInfo * mdui, CmpSeabaseMDupgrade * ddlState)
{
  // At the moment, the privilege manager does not adhere to the contract.
  // It does its drops inside the CmpSeabaseMDupgrade::upgradePrivMgr
  // method. That is why the upgrade state machine above must do the
  // privilege manager last. Because if there were an error afterward
  // that required us to revert to previous state, we couldn't since
  // the drops have already been done.
  return 0;  // stubbed, until Privilege Manager upgrade is refactored
}

short CmpSeabaseUpgradePrivMgr::doUndo(ExeCliInterface * cliInterface,
  CmpDDLwithStatusInfo * mdui, CmpSeabaseMDupgrade * ddlState)
{
  // At the moment, the privilege manager does not adhere to the contract.
  // It does its recovery inside the CmpSeabaseMDupgrade::upgradePrivMgr
  // method. That is why the upgrade state machine above must do the
  // privilege manager last. Because if there were an error afterward
  // that required us to revert to previous state, we couldn't since
  // the drops have already been done.
  return 0;  // stubbed, until Privilege Manager upgrade is refactored
}
// ----------------------------------------------------------------------------
// method: upgradePrivMgr
//
// This method upgrades the privilege manager repository
//
// Params:
//   cliInterface - pointer to a CLI helper class
//   privMgrDoneMsg - message indicating the result
//
// returns:
//   0 - successful
//  -1 - failed
//
// The diags area is populated with any unexpected errors
// ----------------------------------------------------------------------------
short CmpSeabaseMDupgrade::upgradePrivMgr (
  ExeCliInterface *cliInterface, 
  NABoolean ddlXns,
  NAString &privMgrDoneMsg)
{
  std::vector<std::string> tablesCreated;
  std::vector<std::string> tablesUpgraded;

  // initSeabaseAuthorization will create or upgrade PrivMgr metadata tables
  if (initSeabaseAuthorization(cliInterface, ddlXns,
                               tablesCreated, tablesUpgraded) < 0)
    return -1;

  // Report which tables were created and which were upgraded
  if (tablesCreated.size() > 0)
    privMgrDoneMsg += "  Privilege manager tables created: ";
    {
      for (int i = 0; i < tablesCreated.size(); i++)
        {
          privMgrDoneMsg += tablesCreated[i].c_str();
          privMgrDoneMsg += " ";
        }
    }

  if (tablesUpgraded.size() > 0)
    {
      privMgrDoneMsg +=  "\n  Privilege manager tables upgraded: ";
      for (int i = 0; i < tablesUpgraded.size(); i++)
        {
          privMgrDoneMsg += tablesUpgraded[i].c_str();
          privMgrDoneMsg += " ";
        }
    }
  privMgrDoneMsg += "\nUpgrade Priv Mgr: ended";

  return 0;
}