/* -*-C++-*-
 *****************************************************************************
 *
 * File:         ComObjectName.cpp
 * Description:  methods for classes ComObjectName and
 *               ComRoutineActionName
 *
 *
 * Created:      7/26/95
 * Language:     C++
 *
 *
// @@@ START COPYRIGHT @@@
//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
//
// @@@ END COPYRIGHT @@@
 *
 *
 *****************************************************************************
 */


#define  SQLPARSERGLOBALS_NADEFAULTS            // must be first
#include <string.h>
#include "BaseTypes.h"
#include "ComASSERT.h"
#include "ComRtUtils.h"
#include "ComMPLoc.h"
#include "ComObjectName.h"
#include "ComSqlText.h"
#include "NAString.h"
#include "ComAnsiNamePart.h"
#include "ComDistribution.h"

#include "SqlParserGlobals.h"                   // must be last


// -----------------------------------------------------------------------
// definitions of methods of class ComObjectName
// -----------------------------------------------------------------------

//
// global friend functions
//

//
// ostream insertion operator
//
ostream&
operator << (ostream &out, const ComObjectName &name)
{
#ifndef NDEBUG
  out << "CLASS:  ComObjectName";

  if (NOT name.isValid())
  {
    out << "  *** INVALID NAME ***  " << endl;
  };

  out << endl;
  out << "        catalogNamePart_ = ["
      << name.catalogNamePart_.getExternalName().length() << "] "
      << name.catalogNamePart_.getExternalName() << endl;
  out << "         schemaNamePart_ = ["
      << name.schemaNamePart_.getExternalName().length()  << "] "
      << name.schemaNamePart_.getExternalName()  << endl;
  out << "         objectNamePart_ = ["
      << name.objectNamePart_.getExternalName().length()  << "] "
      << name.objectNamePart_.getExternalName()  << endl;
  out << "              nameSpace_ = " << (Int32)name.nameSpace_ << endl;
  
#endif		// NDEBUG
  return out;
}

//
// static (global) functions:
//

ComBoolean
ComRoutineActionName::extractUudfUidAndIntActNameFromFunnyIntActNameInOBJECTS_OBJECT_NAME
  ( const ComString & pr_funnyIntActNameStoredInOBJECTS_OBJECT_NAME  // in
  , ComUID          & pr_uudfUid                                     // out
  , ComString       & pr_computedIntActName                          // out
  )
{
  // Example of the format of the for-internal-use-only funny internal-format
  // action name stored in the metadata column OBJECTS.OBJECT_NAME:
  //
  //                 0123456789012345678_$ActionName

  const char *p = pr_funnyIntActNameStoredInOBJECTS_OBJECT_NAME.data();
  if (p[19] NEQ '_')
    return FALSE; // wrong parameter value
  char uidStrBuf[20];
  memcpy(uidStrBuf, p, 19);
  uidStrBuf[19] = '\0';
  ComString uidStr(uidStrBuf);
  RemoveLeadingZeros(uidStr);
  if (NOT NAStringHasOnlyDecimalDigitAsciiChars(uidStr))
    return FALSE; // wrong parameter value
  Int64 i64 = atoInt64(uidStr.data()); // in - const char * src
  if (i64 <= 0)
    return FALSE; // wrong parameter value
  pr_uudfUid = i64;
  pr_computedIntActName = &p[20];
  return TRUE;    // success
}

//
// constructors
//
#ifdef NDEBUG
  #define CHECK_INCOMPLETE
#else				// check for and display warning message
  #define CHECK_INCOMPLETE \
    { if (catalogNamePart_.isEmpty()) getExternalName(); }
#endif

ComObjectName::ComObjectName(CollHeap * h)
: nameSpace_ (COM_UNKNOWN_NAME),
  catalogNamePart_(h),
  schemaNamePart_(h),
  objectNamePart_(h),
  heap_(h),
  flags_(0)
{
}

ComObjectName::ComObjectName ( const ComObjectName &rhs
                             , CollHeap * h // default is NULL - i.e. use C/C+ runtime heap
                             )
  : nameSpace_      (rhs.getNameSpace())
  , catalogNamePart_(rhs.getCatalogNamePart(), h)
  , schemaNamePart_ (rhs.getSchemaNamePart (), h)
  , objectNamePart_ (rhs.getObjectNamePart (), h)
  , flags_          (rhs.getFlags())
  , heap_           (h)
{
}

ComObjectName::ComObjectName ( const NAString         &externalObjectName
			     , const ComAnsiNameSpace  nameSpace
                             , NABoolean               createDropAlias
                             , CollHeap * h
                             , unsigned short toInternalIdentifierFlags
			     )
: nameSpace_ (nameSpace),
  catalogNamePart_(h),
  schemaNamePart_(h),
  objectNamePart_(h),
  heap_(h),
  flags_(0)
{
  if (nameSpace EQU COM_UUDF_ACTION_NAME)
    objectNamePart_.toInternalIdentifierFlags_ |= toInternalIdentifierFlags |
      NASTRING_REGULAR_IDENT_WITH_DOLLAR_PREFIX | NASTRING_DELIM_IDENT_WITH_DOLLAR_PREFIX;
  scan(externalObjectName, createDropAlias, objectNamePart_.toInternalIdentifierFlags_);
  CHECK_INCOMPLETE;
}

// This ctor parses as much of the string as is valid,
// and returns the number of valid bytes scanned.
// Thus, 'a.@' and 'a.b.c.d' would always fail,
// but 'a.b as foo' would build object 'a.b' and return bytesScanned of 3.
//
// The caller must explicitly check for validity.
//
ComObjectName::ComObjectName ( const NAString         &externalObjectName
                             , size_t                 &bytesScanned
			     , const ComAnsiNameSpace  nameSpace
                             , CollHeap * h
			     )
: nameSpace_ (nameSpace),
  catalogNamePart_(h),
  schemaNamePart_(h),
  objectNamePart_(h),
  heap_(h),
  flags_(0)
{
  if (nameSpace EQU COM_UUDF_ACTION_NAME)
    objectNamePart_.toInternalIdentifierFlags_ |=
      NASTRING_REGULAR_IDENT_WITH_DOLLAR_PREFIX | NASTRING_DELIM_IDENT_WITH_DOLLAR_PREFIX;
  bytesScanned = 1;	// special initial value!
  scan(externalObjectName, bytesScanned, FALSE/*createDropAlias*/,
       objectNamePart_.toInternalIdentifierFlags_);
  // Do *not* do this; caller must check isValid() on return:  CHECK_INCOMPLETE;
}

//
// Initializing constructor - If parameter  format  contains
// the value ComAnsiNamePart::EXTERNAL_FORMAT (the default),
// the three *NamePart parameters must contain the name parts in external
// format (the format used by ANSI SQL users).  If parameter
// format  contains the value ComAnsiNamePart::INTERNAL_FORMAT,
// the parameters ...NamePart must contain the name parts in
// internal format (the format stored in the Metadata Dictionary tables).
//
// If an input name part is illegal, the constructed object is empty.
//
ComObjectName::ComObjectName ( const NAString  &catalogNamePart
                             , const NAString  &schemaNamePart
                             , const NAString  &objectNamePart
                             , const ComAnsiNameSpace  nameSpace
                             , const ComAnsiNamePart::formatEnum  format
                             , CollHeap * h
                             )
: nameSpace_(nameSpace),
  catalogNamePart_(h),
  schemaNamePart_(h),
  objectNamePart_(h),
  heap_(h),
  flags_(0)
{
  if (nameSpace EQU COM_UUDF_ACTION_NAME)
    objectNamePart_.toInternalIdentifierFlags_ |=
      NASTRING_REGULAR_IDENT_WITH_DOLLAR_PREFIX | NASTRING_DELIM_IDENT_WITH_DOLLAR_PREFIX;

  switch (format)
  {
  case ComAnsiNamePart::EXTERNAL_FORMAT :
    {
      catalogNamePart_ = catalogNamePart;
      schemaNamePart_  = schemaNamePart;
      ComAnsiNamePart obj ( objectNamePart
                          , ComAnsiNamePart::EXTERNAL_FORMAT
                          , h
                          , objectNamePart_.toInternalIdentifierFlags_
                          );
      objectNamePart_  = obj;
      break;
    }

  case ComAnsiNamePart::INTERNAL_FORMAT :
    {
      ComAnsiNamePart cat(catalogNamePart, ComAnsiNamePart::INTERNAL_FORMAT);
      ComAnsiNamePart sch(schemaNamePart,  ComAnsiNamePart::INTERNAL_FORMAT);
      ComAnsiNamePart obj(objectNamePart,  ComAnsiNamePart::INTERNAL_FORMAT,
                          h, objectNamePart_.toInternalIdentifierFlags_);
      catalogNamePart_ = cat;
      schemaNamePart_  = sch;
      objectNamePart_  = obj;
      break;
    }

  default :
    ABORT("");
  }

  clearIfInvalid();
  CHECK_INCOMPLETE;
}

// This method constructs ComObjectName directly from input strings.  Use this 
// constructor only if the input strings have already been parsed, such as
// calling from CatExecCreateAlias, CatExecDropalias.  The last param
// doNotParse is used to differentiate from the previous constructor.
//
ComObjectName::ComObjectName ( const NAString  &catalogNamePart
                             , const NAString  &schemaNamePart
                             , const NAString  &objectNamePart
                             , const ComAnsiNameSpace  nameSpace
                             , NABoolean doNotParse
                             )
: nameSpace_(nameSpace),
  flags_(0)
{
  if (doNotParse)  // This constructor does not parse input string
  {
    ComAnsiNamePart cat; 
    cat.setExternalName(catalogNamePart);
    cat.setInternalName(catalogNamePart); 
    catalogNamePart_ = cat;
    ComAnsiNamePart sch;
    sch.setExternalName(schemaNamePart);
    sch.setInternalName(schemaNamePart);
    schemaNamePart_ = sch;
    ComAnsiNamePart obj;
    obj.setExternalName(objectNamePart);
    obj.setInternalName(objectNamePart);
    if (nameSpace EQU COM_UUDF_ACTION_NAME)
      obj.toInternalIdentifierFlags_ |=
        NASTRING_REGULAR_IDENT_WITH_DOLLAR_PREFIX | NASTRING_DELIM_IDENT_WITH_DOLLAR_PREFIX;
    objectNamePart_ = obj;
  }
} // end of ComObjectName::ComObjectName

ComObjectName::ComObjectName ( const ComAnsiNamePart &objectNamePart
			     , const ComAnsiNameSpace  nameSpace
			     )
: objectNamePart_ (objectNamePart)
, nameSpace_      (nameSpace)
, flags_(0)
{
  if (nameSpace EQU COM_UUDF_ACTION_NAME)
    objectNamePart_.toInternalIdentifierFlags_ |=
      NASTRING_REGULAR_IDENT_WITH_DOLLAR_PREFIX | NASTRING_DELIM_IDENT_WITH_DOLLAR_PREFIX;

  // clearIfInvalid() not necessary
  CHECK_INCOMPLETE;	// this will always trigger (no cat+sch passed)
}

ComObjectName::ComObjectName ( const ComAnsiNamePart  &schemaNamePart
                             , const ComAnsiNamePart  &objectNamePart
			     , const ComAnsiNameSpace  nameSpace
			     )
: schemaNamePart_ (schemaNamePart)
, objectNamePart_ (objectNamePart)
, nameSpace_      (nameSpace)
, flags_(0)
{
  if (nameSpace EQU COM_UUDF_ACTION_NAME)
    objectNamePart_.toInternalIdentifierFlags_ |=
      NASTRING_REGULAR_IDENT_WITH_DOLLAR_PREFIX | NASTRING_DELIM_IDENT_WITH_DOLLAR_PREFIX;

  clearIfInvalid();
  CHECK_INCOMPLETE;	// this will always trigger (no cat passed)
}

ComObjectName::ComObjectName ( const ComAnsiNamePart  &catalogNamePart
                             , const ComAnsiNamePart  &schemaNamePart 
                             , const ComAnsiNamePart  &objectNamePart
			     , const ComAnsiNameSpace  nameSpace
			     )
: catalogNamePart_ (catalogNamePart)
, schemaNamePart_  (schemaNamePart)
, objectNamePart_  (objectNamePart)
, nameSpace_       (nameSpace)
, flags_           (0)
{
  if (nameSpace EQU COM_UUDF_ACTION_NAME)
    objectNamePart_.toInternalIdentifierFlags_ |=
      NASTRING_REGULAR_IDENT_WITH_DOLLAR_PREFIX | NASTRING_DELIM_IDENT_WITH_DOLLAR_PREFIX;

  clearIfInvalid();
  CHECK_INCOMPLETE;
}

// a protected member -
// The following constructor is invoked by a constructor of class CatRoutineActionName
ComObjectName::ComObjectName( const ComUID    &uudfUid     // UID of UUDF associating with UDF action
                            , const NAString  &catalogNamePart
                            , const NAString  &schemaNamePart
                            , const NAString  &routineActionNamePart
                            , const ComAnsiNameSpace  nameSpace       // must be COM_UUDF_ACTION_NAME
                            , const ComAnsiNamePart::formatEnum  format // default is EXTERNAL_FORMAT
                            , ComBoolean       parseInputNameParts      // default is TRUE
                            , CollHeap * h                              // default is 0 (i.e., NULL)
                            )
  : nameSpace_ (nameSpace),
    catalogNamePart_(h),
    schemaNamePart_(h),
    objectNamePart_(h),
    heap_(h),
    flags_(0)
{
  if (nameSpace NEQ COM_UUDF_ACTION_NAME)
  {
    clear();
    return;
  }

  initialize ( uudfUid
             , catalogNamePart
             , schemaNamePart
             , routineActionNamePart
             , nameSpace
             , format
             , parseInputNameParts
             );

} // ComObjectName::ComObjectName()

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

//
// virtual cast methods
//

//virtual
const ComRoutineActionName * ComObjectName::castToComRoutineActionName() const
{
  return NULL;
}

// virtual
ComRoutineActionName * ComObjectName::castToComRoutineActionName()
{
  return NULL;
}

//
// assignment operator
//
ComObjectName &
ComObjectName::operator= (const NAString &rhsObjectName)
{
  clear();
  scan(rhsObjectName);
  return *this;
}

ComObjectName &
ComObjectName::operator= (const ComObjectName &rhsObjectName)
{
  this->setCatalogNamePart(rhsObjectName.getCatalogNamePart());
  this->setSchemaNamePart(rhsObjectName.getSchemaNamePart());
  this->setObjectNamePart(rhsObjectName.getObjectNamePart());
  this->setNameSpace(rhsObjectName.getNameSpace());
  return *this;
}

//
// accessor
//

const NAString &
ComObjectName::getCatalogNamePartAsAnsiString(NABoolean v) const
{
  if (v == FALSE)
    return catalogNamePart_.getExternalName();
  else
    return catalogNamePart_.getInternalName();
}

const NAString &
ComObjectName::getSchemaNamePartAsAnsiString(NABoolean v) const
{
  if (v == FALSE)
    return schemaNamePart_.getExternalName();
  else
    return schemaNamePart_.getInternalName();
}

const NAString &
ComObjectName::getObjectNamePartAsAnsiString(NABoolean v) const
{
  if (v == FALSE)
    return objectNamePart_.getExternalName();
  else
    return objectNamePart_.getInternalName();
}


//
// returns an empty string if this object is empty; otherwise,
// returns the ANSI SQL object name, in external-format (the
// format used by ANSI SQL users).  If the catalog name part
// does not exist (in this object), it will not be included
// in the returned object name (in external format).  If the
// schema name part does not exist, only the object name part
// (in external format) is returned.
//
/* virtual */ NAString
ComObjectName::getExternalName(NABoolean formatForDisplay,
			       NABoolean displayedExternally) const
{
  #ifndef NDEBUG
  Int32 ok = 0;
  #endif
  NAString extObjName(getObjectNamePartAsAnsiString());

  if ((NOT isVolatile()) ||
      (NOT formatForDisplay))
    {
      if (NOT schemaNamePart_.isEmpty())
	{
	  extObjName = getSchemaNamePartAsAnsiString() + 
	    NAString(ComSqlText.getPeriod()) + extObjName;
	  
	  if (NOT catalogNamePart_.isEmpty() && NOT displayedExternally)
	    {
#ifndef NDEBUG
	      ok = 1;
#endif
	      extObjName = getCatalogNamePartAsAnsiString() +
		NAString(ComSqlText.getPeriod()) + extObjName;
	    }
	}
    }

  return extObjName;
}

NAString
ComObjectName::getExternalNameWithNameSpace(NABoolean formatForDisplay) const
{
  NAString extObjName;
  const ComRoutineActionName *pActName = castToComRoutineActionName();
  if (pActName EQU NULL)
  {
    extObjName += getExternalName(formatForDisplay);
  }
  else // is a ComRoutineActionName
  {
    const ComObjectName uudfName = pActName->getUudfComObjectName();
    if (uudfName.isValid())
    {
      extObjName += "[Universal Function ";
      extObjName += uudfName.getExternalName(formatForDisplay);
      extObjName += "] ";
    }
    extObjName += getExternalName(formatForDisplay);
  }

  if (getNameSpace() != COM_TABLE_NAME)
  {
    NAString nameSpaceName;
    switch(getNameSpace())
    {
      case COM_TRIGTEMP_TABLE_NAME: 
	nameSpaceName = " (TrigTemp)";
	break;
      case COM_IUD_LOG_TABLE_NAME:
	nameSpaceName = " (IudLog)";
	break;
      case COM_RANGE_LOG_TABLE_NAME:
	nameSpaceName = " (RangeLog)";
	break;
      case COM_GHOST_TABLE_NAME: 
	nameSpaceName = " (GhostTable)";
	break;
      case COM_GHOST_INDEX_NAME: 
	nameSpaceName = " (GhostIndex)";
	break;
      case COM_EXCEPTION_TABLE_NAME: 
	nameSpaceName = " (Exception)";
	break;
      case COM_GHOST_IUD_LOG_TABLE_NAME:
	nameSpaceName = " (GhostIudLog)";
	break;
      case COM_SEQUENCE_GENERATOR_NAME:
	nameSpaceName = " (SG Table)";
	break;
      case COM_UDF_NAME:
	nameSpaceName = " (User-defined Function)";
	break;
      case COM_UUDF_ACTION_NAME:
	nameSpaceName = " (Routine Action)";
	break;
      default:;
    }
    extObjName += nameSpaceName;
  }

  return extObjName;
}

//
// mutators
//

void ComObjectName::applyDefaults( const ComAnsiNamePart &catalogNamePart
                                 , const ComAnsiNamePart &schemaNamePart
                                 )
{
  if (getSchemaNamePart().isEmpty())
    setSchemaNamePart(schemaNamePart);
  if (getCatalogNamePart().isEmpty())
    setCatalogNamePart(catalogNamePart);
}

//
// Reset data members
//

// virtual
void ComObjectName::clear()
{
  catalogNamePart_ = "";
  schemaNamePart_  = "";
  objectNamePart_  = "";
  if (castToComRoutineActionName() NEQ NULL)
    objectNamePart_.toInternalIdentifierFlags_ = ( NASTRING_REGULAR_IDENT_WITH_DOLLAR_PREFIX |
                                                   NASTRING_DELIM_IDENT_WITH_DOLLAR_PREFIX );
  else
    objectNamePart_.toInternalIdentifierFlags_ = NASTRING_ALLOW_NSK_GUARDIAN_NAME_FORMAT;
  nameSpace_       = COM_UNKNOWN_NAME;
  flags_           = 0;
}

// virtual
void ComObjectName::clearIfInvalid()
{
  if (NOT catalogNamePart_.isEmpty())
  {
    if (schemaNamePart_.isEmpty() OR objectNamePart_.isEmpty())
      clear();
    // else okay
  }
  else // catalog name part is empty
  {
    if (NOT schemaNamePart_.isEmpty() AND objectNamePart_.isEmpty())
      clear();
    // else okay
  }
}

//
// protected methods
//

// The following method is invoked by an initializing constructor and one of the
// CatRoutineActionName::set() method.
NABoolean
ComObjectName::initialize ( const ComUID    &uudfUid     // UID of UUDF associating with UDF action
                          , const NAString  &catalogNamePart
                          , const NAString  &schemaNamePart
                          , const NAString  &routineActionNamePart
                          , const ComAnsiNameSpace  nameSpace       // must be COM_UUDF_ACTION_NAME
                          , const ComAnsiNamePart::formatEnum  format // default is EXTERNAL_FORMAT
                          , ComBoolean       parseInputNameParts      // default is TRUE
                          )
{
  if (nameSpace NEQ COM_UUDF_ACTION_NAME)
  {
    clear();
    return FALSE;
  }
  nameSpace_ = nameSpace;

  if (parseInputNameParts)
  {
    if (format EQU ComAnsiNamePart::EXTERNAL_FORMAT)
    {
      catalogNamePart_ = catalogNamePart;
      schemaNamePart_  = schemaNamePart;
      ComRoutineActionNamePart actNP;
      actNP.setUudfUID(uudfUid);
      actNP.setExternalName(routineActionNamePart);
      ComSInt32 status = 0; // < 0 = error -- > 0 length of internal name
      NAString workName(routineActionNamePart);
      status = (ComSInt32)
        ToInternalIdentifier ( workName  // in/out
                             , TRUE      // in - NABoolean upCase           - default is TRUE
                             , FALSE     // in - NABoolean acceptCircumflex - default is FALSE
                             , actNP.toInternalIdentifierFlags_
                             );
      if (status > 0)
      {
        actNP.setInternalName(workName);
        actNP.getRoutineActionNameStoredInOBJECTS_OBJECT_NAME(objectNamePart_);
      }
    }
    else // INTERNAL_FORMAT
    {
      ComAnsiNamePart catNP(catalogNamePart, ComAnsiNamePart::INTERNAL_FORMAT);
      ComAnsiNamePart schNP(schemaNamePart,  ComAnsiNamePart::INTERNAL_FORMAT);
      ComRoutineActionNamePart actNP2(uudfUid,
                                      routineActionNamePart,
                                      ComAnsiNamePart::INTERNAL_FORMAT);
      if (actNP2.isValid())
      {
        catalogNamePart_ = catNP;
        schemaNamePart_  = schNP;
        actNP2.getRoutineActionNameStoredInOBJECTS_OBJECT_NAME(objectNamePart_);
      }
    }
    ComObjectName::clearIfInvalid();
    return ComObjectName::isValid();
  }
  else // DO NOT parseInputNameParts
  {
    // Assume that the input names are legal;
    // if they are not, we have a problem ...
    if (format EQU ComAnsiNamePart::EXTERNAL_FORMAT)
    {
      NAString workName2;

      catalogNamePart_.setExternalName(catalogNamePart);
      workName2 = catalogNamePart;
      ToInternalIdentifier(workName2);
      catalogNamePart_.setInternalName(workName2);

      schemaNamePart_.setExternalName(schemaNamePart);
      workName2 = schemaNamePart;
      ToInternalIdentifier(workName2);
      schemaNamePart_.setInternalName(workName2);

      ComRoutineActionNamePart actNP3;
      actNP3.setUudfUID(uudfUid);
      actNP3.setExternalName(routineActionNamePart);
      ToInternalIdentifier ( workName2 // in/out
                           , TRUE      // in - NABoolean upCase           - default is TRUE
                           , FALSE     // in - NABoolean acceptCircumflex - default is FALSE
                           , actNP3.toInternalIdentifierFlags_
                           );
      actNP3.setInternalName(workName2);
      actNP3.getRoutineActionNameStoredInOBJECTS_OBJECT_NAME(objectNamePart_);
    }
    else // INTERNAL_FORMAT
    {
      catalogNamePart_.setInternalName(catalogNamePart);
      catalogNamePart_.setExternalName(ToAnsiIdentifier(catalogNamePart,
                                                        FALSE/*assertShort*/));
      schemaNamePart_.setInternalName(schemaNamePart);
      schemaNamePart_.setExternalName(ToAnsiIdentifier(schemaNamePart,
                                                       FALSE/*assertShort*/));
      ComRoutineActionNamePart actNP4;
      actNP4.setUudfUID(uudfUid);
      actNP4.setInternalName(routineActionNamePart);
      actNP4.setExternalName(ToAnsiIdentifier(routineActionNamePart,
                                              FALSE/*assertShort*/));
      actNP4.getRoutineActionNameStoredInOBJECTS_OBJECT_NAME(objectNamePart_);
    } // INTERNAL_FORMAT
    return TRUE; // no checking - assume everything went smoothly
  } // DO NOT parseInputNameParts
}

//
// private methods
//

//
// Scans (parses) the specified external-format ANSI SQL object name.
//
NABoolean
ComObjectName::scan( const NAString &externalObjectName
                    ,NABoolean createDropAlias
                    ,unsigned short toInternalIdentifierFlags
                   )
{
  size_t bytesScanned = 0;	// initialize this to 'off' for scan()
  return scan(externalObjectName, bytesScanned, 
              createDropAlias, toInternalIdentifierFlags);
}

//
// This method assumes that the parameter  externalObjectName  only
// contains the external-format object name.  The syntax of an
// object name is
//
//   [ [ <catalog-name-part> ] . <schema-name-part> . ] <object-name-part>
//
// An object name part must be specified; the other name parts are optional.
// Use CmpCommon::applyDefaults(ComObjectName&) to fill in cat + sch.
//
// ## It might be a good idea to extend this method with a
// ## minimum-number-of-nameparts-required.
//
// The method returns the number of bytes scanned via the parameter
// bytesScanned.  If the scanned object name is illegal, bytesScanned
// contains the number of bytes examined when the name is determined
// to be invalid.
//
// If the specified external-format object name is valid, this method
// returns TRUE and decomposes the specified ANSI SQL name part into
// data members catalogNamePart_, schemaNamePart_, and objectNamePart_.
//
// If the specified name is invalid:
//   if what's invalid is trailing stuff AND bytesScanned was passed in nonzero,
//	return TRUE, with data members updated with the scan result
//	preceding the junk
//	(see the bytesScanned ctor for why this is useful!);
//   else,
//	this method returns FALSE and does not change the data members;
//
NABoolean
ComObjectName::scan( const NAString &externalObjectName
                    ,size_t &bytesScanned
                    ,NABoolean createDropAlias
                    ,unsigned short toInternalIdentifierFlags
                   )
{
  size_t count;
  size_t externalObjectNameLen = externalObjectName.length();
  size_t trailingJunkIsOk = bytesScanned;
  bytesScanned = 0;

  // ---------------------------------------------------------------------
  // Scan the leftmost ANSI SQL name part.
  // ---------------------------------------------------------------------

  count = trailingJunkIsOk;
  ComAnsiNamePart part1(externalObjectName, count, 0,
                        createDropAlias
                        , FALSE                     // NABoolean acceptCircumflex
                        , toInternalIdentifierFlags // unsigned short
                        );
  bytesScanned += count;
  if (NOT part1.isValid())
    return FALSE;

  if (bytesScanned == externalObjectNameLen)
  {
    obj__:
      objectNamePart_  = part1;
      return TRUE;			// "obj"
  }

  // Get past the period separator
  if (externalObjectName[bytesScanned++] != '.') {
    if (trailingJunkIsOk) { bytesScanned--; goto obj__; }
    return FALSE;
  }

  // ---------------------------------------------------------------------
  // Scan the next ANSI SQL name part
  // ---------------------------------------------------------------------

  Int32 remainingLen = externalObjectNameLen - bytesScanned;
  NAString remainingName = externalObjectName(bytesScanned, remainingLen);
  count = trailingJunkIsOk;
  ComAnsiNamePart part2(remainingName, count, 0, 
                        createDropAlias
                        , FALSE                     // NABoolean acceptCircumflex
                        , toInternalIdentifierFlags // unsigned short
                        );
  bytesScanned += count;
  if (NOT part2.isValid())
    return FALSE;

  if (bytesScanned == externalObjectNameLen)
  {
    sch_obj__:
    schemaNamePart_  = part1;
    objectNamePart_  = part2;
    return TRUE;			// "sch.obj"
  }

  if (externalObjectName[bytesScanned++] != '.') {
    if (trailingJunkIsOk) { bytesScanned--; goto sch_obj__; }
    return FALSE;
  }

  // ---------------------------------------------------------------------
  // Scan the last ANSI SQL name part
  // ---------------------------------------------------------------------

  remainingLen = externalObjectNameLen - bytesScanned;
  remainingName = externalObjectName(bytesScanned, remainingLen);
  count = trailingJunkIsOk;
  ComAnsiNamePart part3(remainingName, count, 0,
                        createDropAlias
                        , (nameSpace_ == COM_MODULE_NAME) // NABoolean acceptCircumflex
                        , toInternalIdentifierFlags       // unsigned short
                        );
  bytesScanned += count;
  if (NOT part3.isValid())
    return FALSE;

  if (bytesScanned == externalObjectNameLen || trailingJunkIsOk)
  {
    //cat_sch_obj__:
      catalogNamePart_ = part1;
      schemaNamePart_  = part2;
      objectNamePart_  = part3;
      return TRUE;			// "cat.sch.obj"
  }

  // The specified external-format object name contains some extra 
  // trailing characters -- illegal.
  //
  return FALSE;

} // ComObjectName::scan()

// ----------------------------------------------------------------------------
// Test scaffolding
// ----------------------------------------------------------------------------
#if 0
  	#ifndef NDEBUG
	void ComObjTest(const NAString &e)	//## undo .h kludge!
	{
	  ComObjectName o;
	  size_t z;
	  NABoolean b = o.scan(e,z);
	  NAString ee("<"); ee += e; ee += ">";
	  NAString oo("<"); oo += o.getExternalName(); oo += ">";
	  printf("%-16s %-16s %d %d\n", ee.data(), oo.data(), b, z);
	}
	#endif

  	#ifndef NDEBUG
 Int32 test = 0;
	if (test) {
	  ComObjTest("a.b.c");		//ok
	  ComObjTest(" A . B . C ");	//ok
	  ComObjTest("");
	  ComObjTest("a.b.c.");
	  ComObjTest(" A . B . C . ");
	  ComObjTest("a.b.c.d");
	  ComObjTest(" A . B . C . D");
	  ComObjTest(".b.c");
	  ComObjTest("a..c");
	  ComObjTest("a.b.");
	  ComObjTest("  . B . C ");
	  ComObjTest(" A .  . C ");
	  ComObjTest(" A . B .  ");
	  ComObjTest("");
	  ComObjTest("a");		//ok
	  ComObjTest(" a ");		//ok
	  ComObjTest("a.b");		//ok
	  ComObjTest(" a . b ");	//ok
	  ComObjTest("");
	  ComObjTest("a.1.c");
	  ComObjTest("a.zone.c");
	  ComObjTest("z_ne.\"b@2\".c");
	  ComObjTest("\"ZONE\".\"zone\".\"z.z,y+y\"");	//ok
	  ComObjTest("a.\"b.c");
	  ComObjTest("a. \"	 \" .c");
	  ComObjTest("");
	  ComObjTest("...");
	  ComObjTest("a...");
	  ComObjTest("a.b...");
	}
	#endif
#endif // test scaffolding

// -----------------------------------------------------------------------
// definitions of methods of class ComObjectName
// -----------------------------------------------------------------------

//
// global friend functions
//

//
// ostream insertion operator
//
ostream&
operator << (ostream &out, const ComRoutineActionName &name)
{
  return out;
}

//
// constructors
//

// default constructor
ComRoutineActionName::ComRoutineActionName(CollHeap * h) // default of h is NULL - i.e. use C/C++ runtime heap
  : ComObjectName         (h)
  , routineActionNamePart_(h)
  , uudfComObjectName_    (h)
{
}

// copy constructor
ComRoutineActionName::ComRoutineActionName( const ComRoutineActionName &rhs
                                          , CollHeap * h // default of h is NULL - i.e. use C/C++ runtime heap
                                          ) 
  : ComObjectName         (rhs, h)
  , routineActionNamePart_(rhs.getRoutineActionNamePart(), h)
  , uudfComObjectName_    (rhs.getUudfComObjectName(), h)
{
}

// initializing constructors

ComRoutineActionName::ComRoutineActionName( const ComUID   & uudfUid  // e.g., UID of UUDF sas_score
                                          , const NAString & uudfNameAsAnsiName
                                          , const NAString & routineActionNameAsAnsiName
                                          , CollHeap * h // default of h is NULL - i.e. use C/C++ runtime heap
                                          )
  : ComObjectName         (h)
  , routineActionNamePart_(h)
  , uudfComObjectName_    ( uudfNameAsAnsiName
                          , COM_UDF_NAME // const ComAnsiNameSpace nameSpace
                          , FALSE        // NABoolean              createDropAlias = FALSE (the default)
                          , h            // CollHeap *             h
                          )
{
  set(uudfUid, uudfNameAsAnsiName, routineActionNameAsAnsiName);
}

ComRoutineActionName::ComRoutineActionName( const ComUID        & uudfUid  // e.g., UID of UUDF sas_score
                                          , const ComObjectName & uudfObjName
                                          , const NAString      & catalogNamePart
                                          , const NAString      & schemaNamePart
                                          , const NAString      & routineActionNamePart
                                          , const ComAnsiNamePart::formatEnum  format
                                          , ComBoolean       parseInputNameParts  // default is TRUE
                                          , CollHeap * h     // default of h is 0 (i.e., NULL)
                                          )
  : ComObjectName ( uudfUid
                  , catalogNamePart
                  , schemaNamePart
                  , routineActionNamePart
                  , COM_UUDF_ACTION_NAME
                  , format
                  , parseInputNameParts
                  , h
                  )
  , routineActionNamePart_(h)
  , uudfComObjectName_(uudfObjName, h)
{
  initializeRoutineActionNamePart ( uudfUid
                                  , uudfObjName
                                  , catalogNamePart
                                  , schemaNamePart
                                  , routineActionNamePart
                                  , format
                                  , parseInputNameParts
                                  );
}

//
// virtual destructor
//

ComRoutineActionName::~ComRoutineActionName()
{
}

//
// virtual cast methods
//

// virtual
const ComRoutineActionName * ComRoutineActionName::castToComRoutineActionName() const
{
  return this;
}

// virtual
ComRoutineActionName * ComRoutineActionName::castToComRoutineActionName()
{
  return this;
}

//
// accessors
//

const NAString &
ComRoutineActionName::getRoutineActionNamePartAsAnsiString(NABoolean) const
{
  return routineActionNamePart_.getExternalName();
}

//
// returns an empty string if this object is empty; otherwise,
// returns the qualified routine action name, in external-format
// (the format used by ANSI SQL users).  If the catalog name part
// does not exist (in this object), it will not be included
// in the returned qualified routine action name. If the schema
// name part does not exist, only the rightmost name part (i.e.,
// the routine action name part) - in external format - is
// returned.
//
/* virtual */ NAString
ComRoutineActionName::getExternalName(NABoolean formatForDisplay,
                                      NABoolean displayedExternally) const
{
  ComASSERT(NOT isVolatile());
#ifdef _DEBUG
  Int32 ok = 0;
#endif

  NAString extActName(getRoutineActionNamePartAsAnsiString());

  if (NOT formatForDisplay)
  {
    if (NOT getSchemaNamePart().isEmpty())
    {
      extActName = getSchemaNamePartAsAnsiString()
        + NAString(ComSqlText.getPeriod())
        + extActName;

      if (NOT getCatalogNamePart().isEmpty() AND
          NOT displayedExternally)
      {
#ifdef _DEBUG
        ok = 1;
#endif
        extActName = getCatalogNamePartAsAnsiString()
          + NAString(ComSqlText.getPeriod())
          + extActName;
      }
    }
  }

#ifdef _DEBUG
  if (NOT ok)
  {
    if (extActName.isNull())
      cerr << "ERROR: empty ComRoutineActionName" << endl;
    // else
    //   cerr << "WARNING: incomplete ComRoutineActionName " << extActName << endl;
  }
#endif
  return extActName;
}


//
// mutators
//

NABoolean
ComRoutineActionName::set ( const ComUID   &uudfUid  // e.g., UID of UUDF sas_score
                          , const NAString &uudfNameAsAnsiName
                          , const NAString &routineActionNameAsAnsiName
                          )
{
  // set the uudfComObjectName_ data member
  ComObjectName uudfObjName(uudfNameAsAnsiName, COM_UDF_NAME);
  uudfComObjectName_ = uudfObjName;

  // Use the kludge object to decompose the 1-, 2-, or 3-part input routine action name.
  ComObjectName kludge( routineActionNameAsAnsiName
                      , COM_UUDF_ACTION_NAME // ComAnsiNameSpace
                      , FALSE // NABoolean createDropAlias - not applicable
                      );
  if (kludge.isValid())
  {
    ComRoutineActionNamePart actNP( uudfUid
                                  , kludge.getObjectNamePart().getInternalName()
                                  , ComAnsiNamePart::INTERNAL_FORMAT
                                  );
    if (actNP.isValid())
    {
      ComAnsiNamePart objNP;
      NABoolean isOK =
        actNP.getRoutineActionNameStoredInOBJECTS_OBJECT_NAME( objNP  // out
                                                             , TRUE   // ComBoolean performCheck
                                                             );
      if (isOK)
      {
        setCatalogNamePart(kludge.getCatalogNamePart());
        setSchemaNamePart(kludge.getSchemaNamePart());
        setObjectNamePart(objNP);
        routineActionNamePart_ = actNP;
        setNameSpace(COM_UUDF_ACTION_NAME);
      }
    }
  }
  clearIfInvalid();
  return isValid();
}

NABoolean
ComRoutineActionName::set ( const ComUID        & uudfUid                // e.g., UID of UUDF sas_score
                          , const ComObjectName & uudfObjName            // in
                          , const NAString      & catalogNamePart        // in
                          , const NAString      & schemaNamePart         // in
                          , const NAString      & routineActionNamePart  // in
                          , const ComAnsiNamePart::formatEnum format     // in - default is EXTERNAL_FORMAT
                          , ComBoolean parseInputNameParts               // in - default is TRUE
                          )
{
  clear();
  NABoolean isOkay = ComObjectName::initialize ( uudfUid
                                               , catalogNamePart
                                               , schemaNamePart
                                               , routineActionNamePart
                                               , COM_UUDF_ACTION_NAME
                                               , format
                                               , parseInputNameParts
                                               );
  if (NOT isOkay)
    return FALSE;

  return initializeRoutineActionNamePart ( uudfUid
                                         , uudfObjName
                                         , catalogNamePart
                                         , schemaNamePart
                                         , routineActionNamePart
                                         , format
                                         , parseInputNameParts
                                         );
}

//
// helpers
//

// virtual
NABoolean ComRoutineActionName::isEmpty() const
{
  return (routineActionNamePart_.isEmpty() AND
          getSchemaNamePart().isEmpty() AND
          getCatalogNamePart().isEmpty());
}

// virtual
NABoolean ComRoutineActionName::isValid() const
{
  return (NOT routineActionNamePart_.isEmpty());
}

NABoolean ComRoutineActionName::initializeRoutineActionNamePart
          ( const ComUID        & uudfUid                 // e.g., UID of UUDF sas_score
          , const ComObjectName & uudfObjName             // in
          , const NAString      & catalogNamePart         // in
          , const NAString      & schemaNamePart          // in
          , const NAString      & routineActionNamePart   // in
          , const ComAnsiNamePart::formatEnum format      // in - default is EXTERNAL_FORMAT
          , ComBoolean            parseInputNameParts     // in - default is TRUE
          )
{
  uudfComObjectName_ = uudfObjName;
  if (uudfComObjectName_.isValid() AND
      uudfComObjectName_.getNameSpace() EQU COM_UNKNOWN_NAME)
  {
    uudfComObjectName_.setNameSpace(COM_UDF_NAME);
  }

  if (parseInputNameParts)
  {
    ComRoutineActionNamePart actNP(uudfUid,
                                   routineActionNamePart,
                                   format);
    if (actNP.isValid())
      routineActionNamePart_ = actNP;
    setNameSpace(COM_UUDF_ACTION_NAME);
    clearIfInvalid();
    return isValid();
  }
  else // DO NOT check - assume all input parameters are valid
  {
    routineActionNamePart_.setUudfUID(uudfUid);
    if (format EQU ComAnsiNamePart::EXTERNAL_FORMAT)
    {
      routineActionNamePart_.setExternalName(routineActionNamePart);
      NAString actName(routineActionNamePart);
      // ToInternalIdentifer() does do the checking, but if the input
      // parameters are valid, there should be no errors except for
      // the performance penalty.
      ToInternalIdentifier ( actName   // in/out
                           , TRUE      // in - NABoolean upCase           - default is TRUE
                           , FALSE     // in - NABoolean acceptCircumflex - default is FALSE
                           , routineActionNamePart_.toInternalIdentifierFlags_
                           );
      routineActionNamePart_.setInternalName(actName);
    }
    else // INTERNAL_FORMAT
    {
      routineActionNamePart_.setInternalName(routineActionNamePart);
      routineActionNamePart_.setExternalName(ToAnsiIdentifier(routineActionNamePart,
                                                              FALSE/*assertShort*/));
    } // INTERNAL_FORMAT
    setNameSpace(COM_UUDF_ACTION_NAME);
    return TRUE; // no checking - assume that everthing is okay
  } // DO NOT check
}

//
// Reset data members
//

// virtual
void ComRoutineActionName::clear()
{
  ComObjectName::clear();
  routineActionNamePart_.clear();
  uudfComObjectName_.clear();
}

// virtual
void ComRoutineActionName::clearIfInvalid()
{
  if (NOT getCatalogNamePart().isEmpty())
  {
    if (getSchemaNamePart().isEmpty() OR routineActionNamePart_.isEmpty())
      clear();
    // else okay
  }
  else// catalog name part is empty
  {
    if (NOT getSchemaNamePart().isEmpty() AND routineActionNamePart_.isEmpty())
      clear();
    // else okay
  }
}

//
// End of File ComObjectName.cpp
//