#ifndef COMOBJECTNAME_H
#define COMOBJECTNAME_H
/* -*-C++-*-
 *****************************************************************************
 *
 * File:         ComObjectName.h
 * Description:  ComObjectName represents a three part ANSI name.  The
 *               three parts being the catalog name part, the schema
 *               name part, and the object name part.  The syntax of
 *               the external-format ANSI SQL name is:
 *               [ [ <catalog-name-part> . ] <schema-name-part> . ]
 *                      <object-name-part>
 *
 *               Class ComRoutineActionName represents a partially- or fully-
 *               qualified routine action name.  The UID of the associating
 *               universal user-defined function (UUDF - e.g. sas_score)
 *               must be provided to distinguish 2 different actions with
 *               with the same name (note that their corresponding associating
 *               UUDF's are not the same).
 *
 * Created:      7/21/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 @@@
 *
 *
 *****************************************************************************
 */

#include <iosfwd>
using namespace std;

#include "NABoolean.h"
#include "NAString.h"
#include "ComOperators.h"
#include "ComSmallDefs.h"
#include "ComAnsiNamePart.h"
#include "ComRoutineActionNamePart.h"
#include "ComSchemaName.h"
#include "ComMisc.h"

// -----------------------------------------------------------------------
// forward declarations
// -----------------------------------------------------------------------
class ComObjectName;
class ComRoutineActionName;

// -----------------------------------------------------------------------
// definition of class ComObjectName
// -----------------------------------------------------------------------

class ComObjectName : public NABasicObject
{

  //
  // global friend functions
  //

  friend ostream& operator<<(ostream &out, const ComObjectName &name);
  friend void ComObjTest(const NAString &e);	//##

  public:

  //
  // constructors
  //

    // Default constructor
    ComObjectName(CollHeap * h=0);

    // Copy constructor
    ComObjectName( const ComObjectName & rhs
                 , CollHeap * h=0
		 );

    ComObjectName( const NAString         &objectName
		 , const ComAnsiNameSpace  nameSpace = COM_UNKNOWN_NAME
                 , NABoolean createDropAlias = FALSE
                 , CollHeap * h=0
                 , unsigned short toInternalIdentifierFlags = NASTRING_ALLOW_NSK_GUARDIAN_NAME_FORMAT
		 );

        // Initializing constructor.  The method scans the input
        // object name to find out whether the input name is legal.
        // If the input object name is legal, the method decomposes
        // the input into separate name components.  If the input
        // name does not include the catalog or schema name part,
        // the methods treats the corresponding name part to be empty.
        //
        // If the input object name is illegal, the constructed
        // object is empty.
        //
        // Examples of the contents of the input objectName parameter:
        //
        //   cat.sch."A USER-DEFINED TABLE"
        //   catalog_name_part.schema_name_part.object_name_part
        //
        // Parameter toInternalIdentifierFlags is the same as
        // parameter pv_flags in the declaration of routine
        // ToInternalIdentifier() in header file NAString.h --
        // It is different from the data member flags_.

    ComObjectName( const NAString         &objectName
		 , size_t                 &count
		 , const ComAnsiNameSpace  nameSpace = COM_UNKNOWN_NAME
                 , CollHeap * h=0
		 );

        // Similar to the previous ctor, except:
        // - the number of bytes scanned is returned via the parameter  count.
	// - successful scans proceed up to the first illegal unquoted char
	// (or end-of-string); e.g.
	//	"cat . sch . tbl . col"
	//	 123456789 123456789
	// returns an object "cat.sch.tbl" and a count of 16.
	// The caller can then continue scanning the rest of the string.
        //
        // If the object name is not found or is illegal, the
        // parameter  count  contains the number of bytes examined
        // when the name is determined to be invalid.  If the
        // input object name is legal, the parameter  count
        // contains the length of the input object name.

    ComObjectName( const NAString  &catalogNamePart
                 , const NAString  &schemaNamePart
                 , const NAString  &objectNamePart
		 , const ComAnsiNameSpace  nameSpace = COM_UNKNOWN_NAME
                 , const ComAnsiNamePart::formatEnum  format =
                         ComAnsiNamePart::EXTERNAL_FORMAT
                 , CollHeap * h=0
		 );

        // Initializing constructor - If parameter  format  contains
        // the value ComAnsiNamePart::EXTERNAL_FORMAT (the default),
        // the first three (3) parameters (whose names contain the
        // NamePart suffix) 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.  If the catalog name part is not empty and the schema
        // name part is empty, the constructed object is empty (that is,
        // the input name parts are considered as being illegal).

    ComObjectName( const NAString  &catalogNamePart
                 , const NAString  &schemaNamePart
                 , const NAString  &objectNamePart
                 , const ComAnsiNameSpace  nameSpace
                 , NABoolean doNotParse // must be TRUE
                 );

        // 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( const ComAnsiNamePart  &objectNamePart
		 , const ComAnsiNameSpace  nameSpace = COM_UNKNOWN_NAME
		 );

        // Initializing constructor.  The catalog and schema name
        // parts in the constructed object is empty.

    ComObjectName( const ComAnsiNamePart  &schemaNamePart
                 , const ComAnsiNamePart  &objectNamePart
		 , const ComAnsiNameSpace  nameSpace = COM_UNKNOWN_NAME
		 );

        // Initializing constructor.  The catalog name part in the
        // constructed object is empty.

    ComObjectName( const ComAnsiNamePart  &catalogNamePart
                 , const ComAnsiNamePart  &schemaNamePart
                  , const ComAnsiNamePart  &objectNamePart
		  , const ComAnsiNameSpace  nameSpace = COM_UNKNOWN_NAME
		  );

        // Initializing constructor.

    //
    // virtual destructor
    //

    virtual ~ComObjectName();

    //
    // virtual cast methods
    //

    virtual const ComRoutineActionName * castToComRoutineActionName() const;
    virtual       ComRoutineActionName * castToComRoutineActionName();

    //
    // operators
    //

		 ComObjectName&   operator=(const NAString &rhsObjectName);
		 ComObjectName&   operator=(const ComObjectName &rhsObjectName);
    inline       ComBoolean       operator==(const ComObjectName &rhs) const;
    inline       ComBoolean       operator>=(const ComObjectName &rhs) const;

    //
    // accessors
    //

    const ComAnsiNamePart &getCatalogNamePart() const {return catalogNamePart_;}
    const ComAnsiNamePart &getSchemaNamePart()  const {return schemaNamePart_;}
    const ComAnsiNamePart &getObjectNamePart()  const {return objectNamePart_;}
    
    const NAString &getCatalogNamePartAsAnsiString(NABoolean = FALSE) const;
    const NAString &getSchemaNamePartAsAnsiString (NABoolean = FALSE) const;
    const NAString &getObjectNamePartAsAnsiString (NABoolean = FALSE) const;

    virtual NAString getExternalName(NABoolean formatForDisplay = FALSE,
                                     NABoolean displayedExternally = FALSE) const;

        // 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.  If the name is to be displayed
        // externall, for example in SHOWDDL, the catalog name is not included.

    ComAnsiNameSpace getNameSpace() const	  { return nameSpace_; }
    NAString getExternalNameWithNameSpace(NABoolean formatForDisplay = FALSE) const;

    virtual inline NABoolean isEmpty() const;
    virtual inline NABoolean isValid() const;

    inline void getComSchemaNameObject(ComSchemaName & comSchNameObj) const; // out

    //
    // mutators
    //

    virtual void clear();
    virtual void clearIfInvalid(); // Make all data members in this object empty.

    void PLACEHOLDER_FOR_NONVIRTUAL_METHOD();	// ## remove, or rename+reuse
        
    inline void setCatalogNamePart(const ComAnsiNamePart  &catalogNamePart);
    inline void setSchemaNamePart (const ComAnsiNamePart  &schemaNamePart);
    inline void setObjectNamePart (const ComAnsiNamePart  &objectNamePart);
    inline void setNameSpace      (const ComAnsiNameSpace  nameSpace);

    void applyDefaults( const ComAnsiNamePart &catalogNamePart
                      , const ComAnsiNamePart &schemaNamePart
                      );

    NABoolean isVolatile() const      { return (flags_ & IS_VOLATILE) != 0; }
    void setIsVolatile(NABoolean v)
    { (v ? flags_ |= IS_VOLATILE : flags_ &= ~IS_VOLATILE);}

    inline NABoolean isExternalHive() const;  
    inline NABoolean isExternalHbase() const;

    // external format of an HBase mapped table: HBASE."_MAP_".<tablename>
    inline NABoolean isHBaseMappedExtFormat() const;

    // internal format of HBase mapped table: TRAFODION."_HB_MAP_".<tablename>
    inline NABoolean isHBaseMappedIntFormat() const;

  protected:

    // The following constructor is invoked by a constructor of class CatRoutineActionName
    ComObjectName( const ComUID    &uudfUid
                 , const NAString  &catalogNamePart
                 , const NAString  &schemaNamePart
                 , const NAString  &routineActionNamePart
                 , const ComAnsiNameSpace  nameSpace  // must be COM_UUDF_ACTION_NAME
                 , const ComAnsiNamePart::formatEnum  format = ComAnsiNamePart::EXTERNAL_FORMAT
                 , ComBoolean parseInputNameParts = TRUE
                 , CollHeap * h=0
                 );

    // The following method is invoked by the corresponding initializing constructor
    // and one of theCatRoutineActionName::set() method.  The following method clears
    // the object and returns FALSE, if the input parameters are invalid.
    NABoolean 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 = ComAnsiNamePart::EXTERNAL_FORMAT
                         , ComBoolean       parseInputNameParts = TRUE
                         );

    inline Lng32 getFlags() const { return flags_; }

  private:
    enum Flags { IS_VOLATILE = 0x1 };

    ComAnsiNamePart   catalogNamePart_;
    ComAnsiNamePart   schemaNamePart_;
    ComAnsiNamePart   objectNamePart_;
    ComAnsiNameSpace  nameSpace_;
    CollHeap          *heap_;

    Lng32              flags_;

    NABoolean scan(const NAString &objectName, size_t &count
                   , NABoolean createDropAlias = FALSE
                   , unsigned short toInternalIdentifierFlags = NASTRING_ALLOW_NSK_GUARDIAN_NAME_FORMAT
                  );

        // This method scans the specified external-format ANSI
        // SQL object name.
        //
        // The method returns TRUE and decomposes the input object
        // name and then stores the name components into the data
        // members if the object name is valid.  The method also
        // returns the length of the scanned name via the
        // parameter  count.
        //
        // If the object name is not found or is illegal, the method
        // returns FALSE and the number of bytes examined (via
        // parameter  count) when the name is determined to be
        // invalid.  In this case, the method does not change the
        // contents of the data members.
        //
        // This method assumes that the parameter  objectName
        // contains only the external-format object name.  Therefore,
        // the method treats the following input as illegal because
        // the input contain other characters besides an object name:
        //
        //   "catalog_name_part.schema_name_part.object_name_part "
        //
        // (The double-quotes in the example are not part of the ANSI
        // SQL name.  They are used to represent a C string constant.)

    NABoolean scan(const NAString &objectName
                   , NABoolean createDropAlias = FALSE
                   , unsigned short toInternalIdentifierFlags = NASTRING_ALLOW_NSK_GUARDIAN_NAME_FORMAT
                  );

        // Same as above except that this method does not return
        // the number of bytes scanned.

}; // class ComObjectName

// -----------------------------------------------------------------------
// definition of class ComRoutineActionName
// -----------------------------------------------------------------------

class ComRoutineActionName : public ComObjectName
{

  //
  // global friend functions
  //

  friend ostream& operator<<(ostream &out, const ComRoutineActionName &name);


public:

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

  static ComBoolean extractUudfUidAndIntActNameFromFunnyIntActNameInOBJECTS_OBJECT_NAME
                    ( const ComString & funnyIntActNameInOBJECTS_OBJECT_NAME  // in
                    , ComUID          & uudfUid                               // out
                    , ComString       & computedIntActName                    // out
                    );

  // ---------------------------------------------------------------------
  // constructors
  // ---------------------------------------------------------------------
  //

  // Default constructor
  ComRoutineActionName(CollHeap * h = NULL); // default is to use C/C++ runtime heap

  // Copy constructor
  ComRoutineActionName( const ComRoutineActionName &rhs
                      , CollHeap * h = NULL
                      );

  // Initializing constructors

  ComRoutineActionName( const ComUID        & uudfUid  // e.g., UID of UUDF sas_score
                      , const NAString      & uudfNameAsAnsiName
                      , const NAString      & routineActionNameAsAnsiName
                      , CollHeap            * h = NULL
                      );

        // Initializing constructor.  The method scans the input
        // routine action name to find out whether the input name is legal.
        // If the input routine action name is legal, the method decomposes
        // the input into separate name components.  If the input
        // name does not include the catalog and schema name parts, the
        // corresponding data members of those name parts are to be empty.
        //
        // If the input routine action name is illegal, the constructed
        // object is empty.
        //
        // Examples of the contents of the input
        // routineActionNameAsAnsiName parameter:
        //
        //   routine_action
        //   sch.routine_action
        //   cat.sch."$A ROUTINE ACTION"

  ComRoutineActionName( const ComUID        & uudfUid             // e.g., UID of UUDF sas_score
                      , const ComObjectName & uudfName
                      , const NAString      & catalogNamePart
                      , const NAString      & schemaNamePart
                      , const NAString      & routineActionNamePart
                      , const ComAnsiNamePart::formatEnum  format = ComAnsiNamePart::EXTERNAL_FORMAT
                      , ComBoolean parseInputNameParts = TRUE
                      , CollHeap * h = NULL
                      );

        // Initializing constructor - If parameter  format  contains
        // the value ComAnsiNamePart::EXTERNAL_FORMAT (the default),
        // the first three (3) parameters (whose names contain the
        // NamePart suffix) 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).
        //
        // When parseInputNameParts is set to TRUE, the contents of the
        // input parameters catalogNamePart, schemaNamePart, and
        // routineActionNamePart will be scanned/parsed for correctness;
        // otherwise, the input name parts are assumed to be legal
        // without any checking (thus saving CPU cycles).
        //
        // If an input name part is illegal, the constructed object is
        // empty.  If the catalog name part is not empty and the schema
        // name part is empty, the constructed object is empty (that is,
        // the input name parts are considered as being illegal).

  // ---------------------------------------------------------------------
  // virtual destructor
  // ---------------------------------------------------------------------

  virtual ~ComRoutineActionName();

  // ---------------------------------------------------------------------
  // virtual cast methods
  // ---------------------------------------------------------------------

  virtual const ComRoutineActionName * castToComRoutineActionName() const;
  virtual       ComRoutineActionName * castToComRoutineActionName();

  // ---------------------------------------------------------------------
  // accessors
  // ---------------------------------------------------------------------

  const ComUID                   & getUudfUID()           const { return routineActionNamePart_.getUudfUID(); }
  const ComObjectName            & getUudfComObjectName() const { return uudfComObjectName_; }
  const ComRoutineActionNamePart & getRoutineActionNamePart() const { return routineActionNamePart_; }
  const NAString                 & getRoutineActionNamePartAsAnsiString(NABoolean = FALSE) const;

  virtual NAString getExternalName(NABoolean formatForDisplay = FALSE,
                                   NABoolean displayedExternally = FALSE) const;

        // 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.  If the name is to be displayed
        // externall, for example in SHOWDDL, the catalog name is not included.

  // ---------------------------------------------------------------------
  // mutators
  // ---------------------------------------------------------------------

  NABoolean set ( const ComUID   & uudfUid  // e.g., UID of UUDF sas_score
                , const NAString & uudfNameAsAnsiName
                , const NAString & routineActionNameAsAnsiName
                );

        // The method scans the input routine action name to find out
        // whether the input name is legal.
        //
        // If the input routine action name is legal, the method decomposes
        // the input into separate name components.  If the input
        // name does not include the catalog and schema name parts, the
        // corresponding data members of those name parts are to be empty.
        // The method returns TRUE for this case.
        //
        // If the input routine action name is illegal, the object will
        // be cleared and the method will return FALSE.
        //
        // Examples of the contents of the input
        // routineActionNameAsAnsiName parameter:
        //
        //   routine_action
        //   sch.routine_action
        //   cat.sch."$A ROUTINE ACTION"

  NABoolean 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 = ComAnsiNamePart::EXTERNAL_FORMAT
                , ComBoolean parseInputNameParts = TRUE
                );
  void           setUudfComObjectName(const ComObjectName &src) { uudfComObjectName_ = src; }
  ComObjectName &getUudfComObjectName()                         { return uudfComObjectName_; }

  inline void setRoutineActionNamePart (const ComRoutineActionNamePart  &actionNamePart);
 
  // ---------------------------------------------------------------------
  // helpers
  // ---------------------------------------------------------------------

  virtual NABoolean isEmpty() const;
  virtual NABoolean isValid() const;

  virtual void clear();
  virtual void clearIfInvalid();  // Make all data members in this object empty.


private:

  ComRoutineActionNamePart   routineActionNamePart_;
  ComObjectName              uudfComObjectName_;

  // ---------------------------------------------------------------------
  // private methods
  // ---------------------------------------------------------------------

  // The following methods are not defined - DO NOT USE them

        ComRoutineActionName& operator= (const NAString             &rhs);       // DO NOT USE
        ComRoutineActionName& operator= (const ComRoutineActionName &rhs);       // DO NOT USE
  const ComBoolean            operator==(const ComRoutineActionName &rhs) const; // DO NOT USE
  const ComBoolean            operator>=(const ComRoutineActionName &rhs) const; // DO NOT USE

  // The following method is called by one of the initializing constructors
  // and the set() method that is similar to the initializing constructor.
  // The following method should be not called from any other places.

  NABoolean 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 = ComAnsiNamePart::EXTERNAL_FORMAT
                      , ComBoolean parseInputNameParts = TRUE
                      );

}; // class ComRoutineActionName

// -----------------------------------------------------------------------
// definitions of inline methods for class ComObjectName
// -----------------------------------------------------------------------

// virtual inline method
NABoolean
ComObjectName::isEmpty() const
{
  return (objectNamePart_.isEmpty() AND
	  schemaNamePart_.isEmpty() AND
	  catalogNamePart_.isEmpty());
}

// virtual inline method
NABoolean
ComObjectName::isValid() const
{
  return (NOT objectNamePart_.isEmpty());
}

// ----------------------------------------------------------------------------
// Method: isExternalHive
//
// Looks at the prefix and suffix of the schema name to see the schema contains
// external (native) hive table information.
//
// returns TRUE if it is a HIVE schema
// ----------------------------------------------------------------------------
NABoolean
ComObjectName::isExternalHive() const
{
  NAString schemaName(schemaNamePart_.getInternalName());

  if (ComIsTrafodionExternalSchemaName(schemaName))
    return (schemaName(0,sizeof(HIVE_EXT_SCHEMA_PREFIX)-1) == HIVE_EXT_SCHEMA_PREFIX); 
  return FALSE;
}
  
// ----------------------------------------------------------------------------
// Method: isExternalHbase
//
// Looks at the prefix and suffix of the schema name to see the schema contains
// external (native) hbase table information.
//
// returns TRUE if it is a hbase schema
// ----------------------------------------------------------------------------
NABoolean
ComObjectName::isExternalHbase() const
{
  NAString schemaName(schemaNamePart_.getInternalName());

  if (ComIsTrafodionExternalSchemaName(schemaName))
    return (schemaName(0,sizeof(HBASE_EXT_SCHEMA_PREFIX)-1) == HBASE_EXT_SCHEMA_PREFIX); 
  return FALSE;
}

NABoolean ComObjectName::isHBaseMappedExtFormat() const
{
  return ComIsHBaseMappedExtFormat(getCatalogNamePartAsAnsiString(), 
                                   getSchemaNamePartAsAnsiString(TRUE));
}

NABoolean ComObjectName::isHBaseMappedIntFormat() const
{
  return ComIsHBaseMappedIntFormat(getCatalogNamePartAsAnsiString(), 
                                   getSchemaNamePartAsAnsiString(TRUE));
}

void
ComObjectName::setCatalogNamePart(const ComAnsiNamePart &catalogNamePart)
{
  catalogNamePart_ = catalogNamePart;
}

void
ComObjectName::setSchemaNamePart(const ComAnsiNamePart &schemaNamePart)
{
  schemaNamePart_ = schemaNamePart;
}

void
ComObjectName::setObjectNamePart(const ComAnsiNamePart &objectNamePart)
{
  objectNamePart_ = objectNamePart;
}

void
ComObjectName::setNameSpace(const ComAnsiNameSpace nameSpace)
{
  nameSpace_ = nameSpace;
}

ComBoolean       
ComObjectName::operator==(const ComObjectName &rhs) const
{
  return ((catalogNamePart_ EQU rhs.catalogNamePart_) AND
	  (schemaNamePart_  EQU rhs.schemaNamePart_) AND
	  (objectNamePart_  EQU rhs.objectNamePart_) AND
	  (nameSpace_       EQU rhs.nameSpace_));
}

ComBoolean       
ComObjectName::operator>=(const ComObjectName &rhs) const
{
  if (nameSpace_ GT rhs.nameSpace_) return FALSE;
  if (nameSpace_ LT rhs.nameSpace_) return TRUE;
  
  Int32 compResult = catalogNamePart_.compareTo (rhs.catalogNamePart_);
  if (compResult GT 0) return FALSE;
  if (compResult LT 0) return TRUE;
  
  compResult = schemaNamePart_.compareTo (rhs.schemaNamePart_);
  if (compResult GT 0) return FALSE;
  if (compResult LT 0) return TRUE;
  
  compResult = objectNamePart_.compareTo (rhs.objectNamePart_);
  if (compResult GT 0) return FALSE;
  else return TRUE;
}

inline void
ComObjectName::getComSchemaNameObject(ComSchemaName & comSchNameObj) const // out
{
  comSchNameObj.setCatalogNamePart(getCatalogNamePart());
  comSchNameObj.setSchemaNamePart (getSchemaNamePart());
}

// -----------------------------------------------------------------------
// definitions of inline methods for class ComRoutineActionName
// -----------------------------------------------------------------------

void
ComRoutineActionName::setRoutineActionNamePart(const ComRoutineActionNamePart &actionNamePart)
{
  routineActionNamePart_ = actionNamePart;
}

#endif // COMOBJECTNAME_H