core/sql/comexe/CmpMessage.h

/**********************************************************************
// @@@ 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:         CmpMessage.h
* Description:  This is the class definition for the Compiler/Executor 
*               messages.
*
* Created:      5/6/98
* Language:     C++
*
*
*
*
****************************************************************************
*/

#ifndef CMPMESSAGE_H
#define CMPMESSAGE_H

#include "Platform.h"
#include "Ipc.h"
#include "str.h"
#include "Int64.h"
#include "NABasicObject.h"
#include "SQLCLIdev.h"
#include "ComDefs.h"

#define EXECMPIPCVERSION 100

typedef ULng32 CmpMsgBufLenType;

// this file contains

class CmpMessageObj;
class CmpMessageExit;
class CmpMessageLast;
class CmpMessageSQLText;
class CmpMessageReplyCode;
class CmpMessageCompileStmt;

// forward declaration

class ex_expr;
class sql_buffer;
class FragmentDir;

// -----------------------------------------------------------------------
// The base class for all the executor/compiler messages 
// -----------------------------------------------------------------------
class CmpMessageObj : public IpcMessageObj
{
public:
  enum MessageTypeEnum
    {
      NULL_REQUEST = IPC_MSG_SQLCOMP_FIRST,
      EXIT_CONNECTION,
      LAST_MESSAGE,
      ENVS_SETUP,
      SQLTEXT_COMPILE,
      SQLTEXT_STATIC_COMPILE,
      DESCRIBE,
      PROCESSDDL,	
      DDL = PROCESSDDL,	// synonyms
      UPDATE_HIST_STAT,
      SET_TRANS,
      DDL_NATABLE_INVALIDATE,
      INTERNALSP_REQUEST,
      INTERNALSP_GETNEXT,
      ENVS_REFRESH,
      SQLTEXT_RECOMPILE, // tells mxcmp to decache & recompile query
      SQLTEXT_STATIC_RECOMPILE,
      END_SESSION,
      DATABASE_USER,
      DDL_WITH_STATUS,
      REPLY_CODE = IPC_MSG_SQLCOMP_FIRST + 700,
      REPLY_ISP,
      CONNECTION_TYPE = IPC_MSG_SQLCOMP_FIRST + 900,
      EXE_CMP_MESSAGE = IPC_MSG_SQLCOMP_LAST
    };

  typedef Int64 ID;
  
  CmpMessageObj(IpcMessageObjType t=NULL_REQUEST,
		CollHeap* h=0);
        
  IpcMessageObjSize mypackedLength();
  IpcMessageObjSize packMyself(IpcMessageBufferPtr& buffer);
  void unpackMyself(IpcMessageObjType objType,
		    IpcMessageObjVersion objVersion,
		    NABoolean sameEndianness,
		    IpcMessageObjSize objSize,
		    IpcConstMessageBufferPtr& buffer);
  

  virtual IpcMessageObjSize packedLength() 
    { return mypackedLength();  }
  
  virtual IpcMessageObjSize packObjIntoMessage(IpcMessageBufferPtr buffer) 
    { return packMyself(buffer); }
      
  virtual void unpackObj(IpcMessageObjType objType,
			 IpcMessageObjVersion objVersion,
			 NABoolean sameEndianness,
			 IpcMessageObjSize objSize,
			 IpcConstMessageBufferPtr buffer)
    { unpackMyself(objType,objVersion,sameEndianness, objSize,buffer); }

  // decrRefCount() needs to be redefined to call the destructor and 
  // deallocate space. For the classes derived from this, if there is
  // special thing to be done in destructor, needs to write its own
  // destroyMe() method
  virtual void destroyMe() {  }
  virtual IpcMessageRefCount decrRefCount();
 
  CollHeap* getHeap() { return h_;  }  
  ID id() const { return id_; } 

  virtual ULng32 getFlags() const { return 0L; }
  virtual void setFlags(ULng32)	 {}

  friend ostream& operator<<(ostream&, const CmpMessageObj&);

  virtual ~CmpMessageObj()  { }

  // Virtual method that sets the version field of the message to the 
  // version specified by the caller. If the structure of the message
  // has changed in an incompatible way from one version to the next this
  // method will also do the translation of the new structure to the old 
  // before sending it to the downrev compiler.

  virtual void migrateToVersion(short version)
    {
    setVersion(EXECMPIPCVERSION);
    }
protected:    
// -----------------------------------------------------------------------
// Some helper routines for CmpMessageObj family
// -----------------------------------------------------------------------

  IpcMessageObjSize packIntoBuffer(char* &buffer,
				   char* strPtr);
  IpcMessageObjSize packIntoBuffer(char* &buffer,
				   void* strPtr, Lng32 sz);

  void unpackBuffer  (const char* &buffer,
		      void* &strPtr, CollHeap* h=0)
  {
    char* temp=0;
    unpackBuffer(buffer, temp, h);
    strPtr = temp;
  }
  
  // unpack a char* buffer
  void unpackBuffer  (const char* &buffer,
		      char* &strPtr, CollHeap* h=0);

  // unpack a char* buffer, but strPtr is a preallocated space
  // with size maxSize. maxSize has to be big enough to hold the
  // whole buffer. 
  void unpackBuffer  (const char* &buffer,
                      char* strPtr, ULng32 maxSize,
                      ULng32& sizeMoved);

  void advanceSize(IpcMessageObjSize &size, 
		   const void * const buffPtr, Lng32 sz=0)
    {
      const Int32 lenSize = sizeof(CmpMsgBufLenType);
      size += lenSize;
      if (buffPtr != NULL)
	size += ((sz) ? sz : (str_len((char*)buffPtr) + 1));
    }

  ID id_;
  
  void advanceSize(IpcMessageObjSize &size, Int64 i64)
  { size += sizeof(i64); }

  IpcMessageObjSize packIntoBuffer(char* &buffer, Int64 i64)
  {
    IpcMessageObjSize sz = sizeof(Int64);
    str_cpy_all((char*)buffer, (char*)&i64, sz);
    buffer += sz;
    return sz;
  }

  void unpackBuffer (const char* &buffer, Int64& i64)
  {
    IpcMessageObjSize sz = sizeof(Int64);
    str_cpy_all((char*)&i64, (char*)buffer, sz);
    buffer += sz;
  }

private:
  CmpMessageObj& operator=(const CmpMessageObj&);
  CmpMessageObj(const CmpMessageObj&);

  CollHeap* h_;
  
}; // end of CmpMessageObj

// -----------------------------------------------------------------------
// Basic request objects
// -----------------------------------------------------------------------

class CmpMessageRequestBasic : public CmpMessageObj
{
public:
  CmpMessageRequestBasic(MessageTypeEnum t = NULL_REQUEST,
			 CollHeap* h=0);
  virtual ~CmpMessageRequestBasic();

  IpcMessageObjSize mypackedLength();
  IpcMessageObjSize packMyself(IpcMessageBufferPtr& buffer);
  void unpackMyself(IpcMessageObjType objType,
		    IpcMessageObjVersion objVersion,
		    NABoolean sameEndianness,
		    IpcMessageObjSize objSize,
		    IpcConstMessageBufferPtr& buffer);
  

  virtual IpcMessageObjSize packedLength() 
    { return mypackedLength();  }
  
  virtual IpcMessageObjSize packObjIntoMessage(IpcMessageBufferPtr buffer) 
    { return packMyself(buffer); }
      
  virtual void unpackObj(IpcMessageObjType objType,
			 IpcMessageObjVersion objVersion,
			 NABoolean sameEndianness,
			 IpcMessageObjSize objSize,
			 IpcConstMessageBufferPtr buffer)
    { unpackMyself(objType,objVersion,sameEndianness, objSize,buffer); }

private:
  CmpMessageRequestBasic(const CmpMessageRequestBasic&);
  const CmpMessageRequestBasic& operator=(const CmpMessageRequestBasic&);

}; // end of CmpMessageRequestBasic

class CmpMessageReplyBasic : public CmpMessageObj
{
public:
  CmpMessageReplyBasic(MessageTypeEnum t=NULL_REQUEST,
		       ID request=0,
		       CollHeap* h=0); 
  IpcMessageObjSize mypackedLength();
  IpcMessageObjSize packMyself(IpcMessageBufferPtr& buffer);
  void unpackMyself(IpcMessageObjType objType,
		    IpcMessageObjVersion objVersion,
		    NABoolean sameEndianness,
		    IpcMessageObjSize objSize,
		    IpcConstMessageBufferPtr& buffer);
  

  virtual IpcMessageObjSize packedLength() 
    { return mypackedLength();  }
  
  virtual IpcMessageObjSize packObjIntoMessage(IpcMessageBufferPtr buffer) 
    { return packMyself(buffer); }
      
  virtual void unpackObj(IpcMessageObjType objType,
			 IpcMessageObjVersion objVersion,
			 NABoolean sameEndianness,
			 IpcMessageObjSize objSize,
			 IpcConstMessageBufferPtr buffer)
    { unpackMyself(objType,objVersion,sameEndianness, objSize,buffer); }

  ID& request() { return request_; }

protected:
  ID request_;
}; // end of CmpMessageReplyBasic

// -----------------------------------------------------------------------
// Basic class for requests from executor
// -----------------------------------------------------------------------
// -----------------------------------------------------------------------
// Information that is sent to recompile a dynamic or static statement.
// This class is sent as part of the data() field.
// -----------------------------------------------------------------------
class CmpCompileInfo 
{
public:
  CmpCompileInfo(char * sourceStr, Lng32 sourceStrLen,
		 Lng32 sourceStrCharSet,
		 char * schemaName, Lng32 schemaNameLen, 
		 ULng32 inputArrayMaxsize,
		 short rowsetAtomicity);
  CmpCompileInfo();

  void init();

  short getClassSize() { return (short)sizeof(CmpCompileInfo); }
  Lng32 getVarLength();
  Lng32 getLength();
  void packVars(char * buffer, CmpCompileInfo *ci,
                Lng32 &nextOffset);
  void pack(char * buffer);
  void unpack(char * base);
  
  void getUnpackedFields(char* &sqltext,
			 char* &schemaName);

  const ULng32 getInputArrayMaxsize() {return inputArrayMaxsize_ ;}

  const short getRowsetAtomicity();

  NABoolean odbcProcess() { return (flags_ & ODBC_PROCESS) != 0; }
  void setOdbcProcess(NABoolean v)      
           { (v ? flags_ |= ODBC_PROCESS : flags_ &= ~ODBC_PROCESS); }

  NABoolean isSystemModuleStmt (void) {return (flags_ & SYSTEM_MODULE_STMT) != 0;}
  void setSystemModuleStmt (NABoolean v)
           { (v ? flags_ |= SYSTEM_MODULE_STMT : flags_ &= ~SYSTEM_MODULE_STMT); }

  NABoolean isAnsiHoldable() { return (flags_ & ANSI_HOLDABLE_CURSOR) != 0; }
  void setAnsiHoldable(NABoolean v)      
           { (v ? flags_ |= ANSI_HOLDABLE_CURSOR : flags_ &= ~ANSI_HOLDABLE_CURSOR); }
  
  NABoolean isPubsubHoldable() { return (flags_ & PUBSUB_HOLDABLE_CURSOR) != 0; }
  void setPubsubHoldable(NABoolean v)      
           { (v ? flags_ |= PUBSUB_HOLDABLE_CURSOR : flags_ &= ~PUBSUB_HOLDABLE_CURSOR); }

  const short getHoldableAttr();
  NABoolean noTextCache() { return (flags_ & NO_TEXT_CACHE) != 0; }
  void setNoTextCache(NABoolean v)      
           { (v ? flags_ |= NO_TEXT_CACHE : flags_ &= ~NO_TEXT_CACHE); }

  NABoolean aqrPrepare() { return (flags_ & AQR_PREPARE) != 0; }
  void setAqrPrepare(NABoolean v)      
           { (v ? flags_ |= AQR_PREPARE : flags_ &= ~AQR_PREPARE); }

  NABoolean standaloneQuery() { return (flags_ & STANDALONE_QUERY) != 0; }
  void setStandaloneQuery(NABoolean v)      
           { (v ? flags_ |= STANDALONE_QUERY : flags_ &= ~STANDALONE_QUERY); }

  Lng32 getSqlTextLen() const { return sqlTextLen_; }
  void setSqlTextLen(Lng32 len) { sqlTextLen_ = len; }

  Lng32 getSqlTextCharSet() const { return sqlTextCharSet_; }
  void setSqlTextCharSet(Lng32 cs) { sqlTextCharSet_ = cs; }

 NABoolean isHbaseDDL()
    { return (flags_ & HBASE_DDL) != 0; }
  void setHbaseDDL(NABoolean v)
    { (v ? flags_ |= HBASE_DDL : flags_ &= ~HBASE_DDL); }

  NABoolean doNotCachePlan()
    { return (flags_ & DO_NOT_CACHE_PLAN) != 0; }
  void setDoNotCachePlan(NABoolean v)
    { (v ? flags_ |= DO_NOT_CACHE_PLAN : flags_ &= ~DO_NOT_CACHE_PLAN); }

  enum { FILLERSIZE = 60 };

protected:
  enum Flags 
  {
    // if nametype was specified as NSK at static compilation time.
    // Used to send this info to mxcmp at auto recompilation time.
    NAMETYPE_NSK        = 0x0001,

    // if odbc_process was ON as NSK at static compilation time.
    // Used to send this info to mxcmp at auto recompilation time.
    ODBC_PROCESS        = 0x0002,
    SYSTEM_MODULE_STMT  = 0x0008,
    // the next two flags go together. 
    // The first flag denotes whether rowset atomicity has been specified.
    // The second flag is read on only if the first one is turned ON.
    // The second flag denotes whether the statement is ATOMIC or NOT ATOMIC
    ROWSET_ATOMICITY_SPECIFIED = 0x0010,
    ROWSET_NOT_ATOMIC = 0x0020,

    // do not use text cache during compile.
    NO_TEXT_CACHE     = 0x0040,

    // internal prepare during AQR
    AQR_PREPARE       = 0x0080,

    // not an user explicitly prepared query 
    STANDALONE_QUERY  = 0x0100,
    ANSI_HOLDABLE_CURSOR     = 0x0200,
    PUBSUB_HOLDABLE_CURSOR    = 0x0400,

    // this is a request to perform a SQL ddl operation that will be converted
    // to an hbase object
    HBASE_DDL                               = 0x0800,

    // do not cache the resulting query plan
    DO_NOT_CACHE_PLAN = 0x1000
  };

  char * sqltext_;        // 00-07
  Lng32 sqlTextLen_;      // 08-11
  Lng32 unused_;          // 12-15
  char * schemaName_;     // 16-23
  Lng32 schemaNameLen_;   // 24-27
  Lng32 unused2_;         // 28-31
  ULng32 inputArrayMaxsize_;  // 32-35
  ULng32 flags_;              // 36-39

  Lng32  sqlTextCharSet_;            // 40-43
  char fillerBytes_[FILLERSIZE];     // 44-103
};

class CmpMessageRequest : public CmpMessageRequestBasic
{
public:
  CmpMessageRequest(MessageTypeEnum e, char* data=NULL,CmpMsgBufLenType size=0,
		    CollHeap* h=0,
                    Lng32 cs=SQLCHARSETCODE_UTF8,
                    const char *parentQid = NULL, Lng32 parentQidLen = 0);

  IpcMessageObjSize mypackedLength();
  IpcMessageObjSize packMyself(IpcMessageBufferPtr& buffer);
  void unpackMyself(IpcMessageObjType objType,
		    IpcMessageObjVersion objVersion,
		    NABoolean sameEndianness,
		    IpcMessageObjSize objSize,
		    IpcConstMessageBufferPtr& buffer);

  virtual IpcMessageObjSize packedLength()
    { return mypackedLength(); }
  virtual IpcMessageObjSize packObjIntoMessage(IpcMessageBufferPtr buffer)
    { return packMyself(buffer); }
  virtual void unpackObj(IpcMessageObjType objType,
			 IpcMessageObjVersion objVersion,
			 NABoolean sameEndianness,
			 IpcMessageObjSize objSize,
			 IpcConstMessageBufferPtr buffer)
    { unpackMyself(objType,objVersion,sameEndianness, objSize,buffer); }

  void copyToString(char* & dest, CmpMsgBufLenType& sz, 
		    char* s, CmpMsgBufLenType sz1);
  
  char* data() const { return data_; }
  Lng32 charSet() const { return charSet_; } 

  virtual ULng32 getFlags() const { return flags_; }
  virtual void setFlags(ULng32 f) { flags_ = f; }
  
  virtual void destroyMe();
  virtual ~CmpMessageRequest() { destroyMe(); }
   
  CmpMsgBufLenType getSize() const { return sz_; };

  inline const char *getParentQid() const { return parentQid_; }
  inline Lng32 getParentQidLen() const { return parentQidLen_; }
  CmpCompileInfo * getCmpCompileInfo() const 
  { return (CmpCompileInfo *)data();};
  

private:
  CmpMessageRequest& operator=(const CmpMessageRequest&);
  CmpMessageRequest(const CmpMessageRequest&);
  
  char* data_;
  CmpMsgBufLenType sz_;
  ULng32 flags_;
  Lng32 charSet_; // sender's character set
  Lng32 parentQidLen_;
  const char *parentQid_;
  NABoolean allocated_;
}; // end of CmpMessageRequest

// -----------------------------------------------------------------------
// Basic class for reply to executor
// -----------------------------------------------------------------------

class CmpMessageReply : public CmpMessageReplyBasic
{
public:

  // The memeber data_ of this class can be set through data() member function
  // with any pointer. After data_ is set, this class owns that pointer. 
  // This memory is supposed to be allocated from outh CollHeap*, 
  // NADELETEBASIC will be called to delete the memory.

  CmpMessageReply(MessageTypeEnum e, ID request =0,
		  CollHeap* h=0, 
                  char* preAllocatedData=0,
                  ULng32 preAllocatedDataSize=0,
                  CollHeap* outh=0);

  IpcMessageObjSize mypackedLength();
  IpcMessageObjSize packMyself(IpcMessageBufferPtr& buffer);
  void unpackMyself(IpcMessageObjType objType,
		    IpcMessageObjVersion objVersion,
		    NABoolean sameEndianness,
		    IpcMessageObjSize objSize,
		    IpcConstMessageBufferPtr& buffer);

  virtual IpcMessageObjSize packedLength() 
    {  return mypackedLength();   }
  virtual IpcMessageObjSize packObjIntoMessage(IpcMessageBufferPtr buffer) 
    {  return packMyself(buffer); }
  virtual void unpackObj(IpcMessageObjType objType,
			 IpcMessageObjVersion objVersion,
			 NABoolean sameEndianness,
			 IpcMessageObjSize objSize,
			 IpcConstMessageBufferPtr buffer)
    { unpackMyself(objType,objVersion,sameEndianness, objSize,buffer); }

  CollHeap* outHeap() {  return outh_;  }
  

  Lng32 getSize() const { return sz_; }
  char* getData() const { return data_; }    
  char* takeData() {dataAllocated_ = FALSE; char* temp = data_; data_ = 0; return temp;}
  char* data() const   {  return data_; }
  char*& data() { dataAllocated_ = TRUE; return data_; }
  CmpMsgBufLenType & size()  { return sz_; }

  virtual void destroyMe();
  virtual ~CmpMessageReply();
       
private:
  
  CmpMessageReply& operator=(const CmpMessageReply&);
  CmpMessageReply(const CmpMessageReply&);

  CmpMsgBufLenType sz_;
  char* data_;
  // flag to identiy whethere data_ is allocated internally or taken from 
  // preAllocatedData_.
  NABoolean dataAllocated_;

  // Executor wants to allocate the storage for the reply buffer. 
  // preAllocatedData_ is the pre allocated buffer to hold the reply data
  // in unpackObj. preAllocatedDataSize_ is the size allocated.
  char* preAllocatedData_;
  CmpMsgBufLenType preAllocatedSize_;

  // This CollHeap* is used to allocate data_.
  CollHeap* outh_;
}; // end of CmpMessageReply

// -----------------------------------------------------------------------
// connection control messages
// -----------------------------------------------------------------------

class CmpMessageExit : public CmpMessageObj
{
public:
  CmpMessageExit(CollHeap* h=0) : CmpMessageObj(EXIT_CONNECTION,h) {}
  ~CmpMessageExit() {}
  
private:
  CmpMessageExit& operator=(const CmpMessageExit&);
  CmpMessageExit(const CmpMessageExit&);
  
}; // end of CmpMessageExit

class CmpMessageLast : public CmpMessageObj
{
public:
  CmpMessageLast(CollHeap* h=0) : CmpMessageObj(LAST_MESSAGE,h) 
   {  }
  ~CmpMessageLast() 
   {  }

private:
  CmpMessageLast& operator=(const CmpMessageLast&);
  CmpMessageLast(const CmpMessageLast&);
}; // end of CmpMessageLast

// -----------------------------------------------------------------------
// Requests from executor
// -----------------------------------------------------------------------

// -----------------------------------------------------------------------
// Run time environment setup messages
// -----------------------------------------------------------------------
   
class CmpMessageEnvs : public CmpMessageObj
{
public:
  // An EXGLOBALS request will be sent to arkcmp at the beginning of each request to make
  // sure arkcmp has same info as executor. It contains:
  // . environemnt variables
  // . current working directory
  // . transId
  // . .etc ....
  // In the future, for performance reason, it can be changed so that this request only
  // be sent when
  // . info changed in executor, needs to refresh arkcmp. this needs a trigger in the info
  //   change code.
  // . arkcmp dies, a new arkcmp is spawned from executor.
  enum EnvsOperatorEnum 
    {
      NONE, EXGLOBALS, UNSETENV /* not used currently */
    };
  
  // constructors
  CmpMessageEnvs(EnvsOperatorEnum, char ** envvars,
		 NABoolean emptyOne, CollHeap* h);
  CmpMessageEnvs(EnvsOperatorEnum, char*, CollHeap* h=0);

  // Ipc related routines 
  IpcMessageObjSize mypackedLength();
  IpcMessageObjSize packMyself(IpcMessageBufferPtr& buffer);
  void unpackMyself(IpcMessageObjType objType,
		    IpcMessageObjVersion objVersion,
		    NABoolean sameEndianness,
		    IpcMessageObjSize objSize,
		    IpcConstMessageBufferPtr& buffer);

  virtual IpcMessageObjSize packedLength()
    { return mypackedLength(); }
  virtual IpcMessageObjSize packObjIntoMessage(IpcMessageBufferPtr buffer)
    { return packMyself(buffer); }
  virtual void unpackObj(IpcMessageObjType objType,
			 IpcMessageObjVersion objVersion,
			 NABoolean sameEndianness,
			 IpcMessageObjSize objSize,
			 IpcConstMessageBufferPtr buffer)
    { unpackMyself(objType,objVersion,sameEndianness, objSize,buffer); }

  Lng32 nEnvs() const { return nEnvs_; }
  char** envs() const { return envs_; }
  char* cwd() const { return cwd_; }
  NABoolean activeTrans() const { return activeTrans_==1; }
  Int64 transId() const { return transId_; }
  EnvsOperatorEnum getOperator() const { return operator_;  }

  virtual void destroyMe();
  virtual ~CmpMessageEnvs();
  
private:
  CmpMessageEnvs(const CmpMessageEnvs&);
  CmpMessageEnvs& operator=(const CmpMessageEnvs&);

  EnvsOperatorEnum operator_;

  // Information sent to arkcmp from executor, these info need to be in synch with
  // executor. 
  // envs_ is a null terminated array of string which is also null terminated
  Lng32 nEnvs_;
  char** envs_; 

  // current working directory.
  char* cwd_;

  // for EXGLOBALS operator. It will pass the globals executor wants to share with 
  // compiler (arkcmp).
  Lng32 activeTrans_; // 0 if not. 1 if yes, transId_ then contains valid info
  Int64 transId_;
  
}; // end of CmpMessageEnvs

// -----------------------------------------------------------------------
// messages to perform cleanup, userid change, etc.
// Issued from master exe when cleanup session command is issued,
// or userid changes, or something else need to be cleaned up.
// Currently only used for cleanupEsps.
// -----------------------------------------------------------------------

class CmpMessageEndSession : public CmpMessageRequest
{
public:
  CmpMessageEndSession(char* input_data,CmpMsgBufLenType size,
		       CollHeap* h=0) : CmpMessageRequest(END_SESSION, NULL, 0, h),
    flags_(0)
  {
    if (input_data)
      {
	Lng32 flags = *(Lng32*)input_data;
	setCleanupEsps((flags & CLEANUP_ESPS) != 0);
	setResetAttrs((flags & RESET_ATTRS) != 0);
      }
  }
  virtual ~CmpMessageEndSession() {}
  
  enum
  {
    CLEANUP_ESPS = 0x0001,
    RESET_ATTRS  = 0x0002,
    CLEAR_CACHE = 0x0004
  };

  // Ipc related routines 
  IpcMessageObjSize mypackedLength();
  IpcMessageObjSize packMyself(IpcMessageBufferPtr& buffer);
  void unpackMyself(IpcMessageObjType objType,
		    IpcMessageObjVersion objVersion,
		    NABoolean sameEndianness,
		    IpcMessageObjSize objSize,
		    IpcConstMessageBufferPtr& buffer);

  virtual IpcMessageObjSize packedLength()
    { return mypackedLength(); }
  virtual IpcMessageObjSize packObjIntoMessage(IpcMessageBufferPtr buffer)
    { return packMyself(buffer); }
  virtual void unpackObj(IpcMessageObjType objType,
			 IpcMessageObjVersion objVersion,
			 NABoolean sameEndianness,
			 IpcMessageObjSize objSize,
			 IpcConstMessageBufferPtr buffer)
    { unpackMyself(objType,objVersion,sameEndianness, objSize,buffer); }

  void setCleanupEsps(NABoolean v)
    { ( v ? flags_ |= CLEANUP_ESPS : flags_ &= ~CLEANUP_ESPS);}
  NABoolean cleanupEsps() { return (flags_ & CLEANUP_ESPS) != 0; };

  void setResetAttrs(NABoolean v)
    { ( v ? flags_ |= RESET_ATTRS : flags_ &= ~RESET_ATTRS);}
  NABoolean resetAttrs() { return (flags_ & RESET_ATTRS) != 0; };
 
  void setClearCache(NABoolean v)
    { ( v ? flags_ |= CLEAR_CACHE : flags_ &= ~CLEAR_CACHE);}
  NABoolean clearCache() { return (flags_ & CLEAR_CACHE) != 0; };
  
private:
  CmpMessageEndSession& operator=(const CmpMessageEndSession&);
  CmpMessageEndSession(const CmpMessageEndSession&);
  
  UInt32 flags_;
}; // end of CmpMessageEndSession

// -----------------------------------------------------------------------
// The SQL text message for SQL compilation 
// -----------------------------------------------------------------------

class CmpMessageSQLText : public CmpMessageRequest
{
public:
  CmpMessageSQLText(char* sqltext=NULL,CmpMsgBufLenType size=0,CollHeap* h=0,
                    Lng32 charset=SQLCHARSETCODE_UTF8,
                    MessageTypeEnum op=SQLTEXT_COMPILE)
    : CmpMessageRequest(op, sqltext,size,h,charset)
    { };

  virtual ~CmpMessageSQLText() {};
   
private:
  CmpMessageSQLText& operator=(const CmpMessageSQLText&);
  CmpMessageSQLText(const CmpMessageSQLText&);
}; // end of CmpMessageSQLText

// -----------------------------------------------------------------------
// The SQL text message for recompilation of a static statement. 
// -----------------------------------------------------------------------

class CmpMessageCompileStmt : public CmpMessageRequest
{
public:
  CmpMessageCompileStmt(char* sqltext=NULL,CmpMsgBufLenType size=0,CollHeap* h=0,
                        Lng32 cs=SQLCHARSETCODE_UTF8
                        ):
  CmpMessageRequest(SQLTEXT_STATIC_COMPILE, sqltext,size,h, cs)
    { };

  CmpMessageCompileStmt(char* sqltext,
                        CmpMsgBufLenType size,
                        MessageTypeEnum op,
                        CollHeap* h=0,
                        Lng32 cs=SQLCHARSETCODE_UTF8
                        ):
  CmpMessageRequest(op, sqltext,size,h, cs)
    { };

  virtual ~CmpMessageCompileStmt() {};
   
private:
  CmpMessageCompileStmt& operator=(const CmpMessageCompileStmt&);
  CmpMessageCompileStmt(const CmpMessageCompileStmt&);
}; // end of CmpMessageCompileStmt

// -----------------------------------------------------------------------
// The DDL commands
// -----------------------------------------------------------------------

class CmpMessageDDL : public CmpMessageRequest 
{
public:
  CmpMessageDDL(char* stmt=NULL,CmpMsgBufLenType size=0,CollHeap* h=0,
                Lng32 charset=SQLCHARSETCODE_UTF8,
                const char *parentQid = NULL,
                Lng32 parentQidLen = 0):
  CmpMessageRequest(DDL, stmt,size,h,charset, parentQid, parentQidLen)
    { };

  virtual ~CmpMessageDDL() {};
   
private:
  CmpMessageDDL& operator=(const CmpMessageDDL&);
  CmpMessageDDL(const CmpMessageDDL&);
}; // end of CmpMessageDDL

// -----------------------------------------------------------------------
// Info about DDL operations that return status.
// -----------------------------------------------------------------------
class CmpDDLwithStatusInfo : public CmpCompileInfo
{
 public:
  //  enum { MAX_MSG_LEN_ = 500; };

  enum
  {
    DONE_           = 0x0001,
    COMPUTE_ST_     = 0x0002,
    COMPUTE_ET_     = 0x0004,
    RETURN_ET_      = 0x0008,
    START_          = 0x0010,
    END_            = 0x0020,
    XN_STARTED_     = 0x0040,
    MD_UPGRADE_     = 0x0080,
    GET_MD_VERSION_ = 0x0100,
    GET_SW_VERSION_ = 0x0200,
    MD_CLEANUP_     = 0x0400,
    CHECK_ONLY_     = 0x0800,
    RETURN_DETAILS_ = 0x1000,
    INIT_TRAF_      = 0x2000,
    MINIMAL_IT_     = 0x4000,
    DDL_XNS_        = 0x8000,
  };

 public:

  CmpDDLwithStatusInfo();

  CmpDDLwithStatusInfo(char * sourceStr, Lng32 sourceStrLen,
                       Lng32 sourceStrCharSet,
                       char * schemaName, Lng32 schemaNameLen);
  
  short getClassSize() { return (short)sizeof(CmpDDLwithStatusInfo); }
  Lng32 getLength();
  void pack(char * buffer);
  void unpack(char * base);

  void copyStatusInfo(CmpDDLwithStatusInfo*from);

  void setStartStep(NABoolean v) {(v ? statusFlags_ |= START_ : statusFlags_ &= ~START_); };
  NABoolean startStep() { return (statusFlags_ & START_) != 0; };

  void setEndStep(NABoolean v) {(v ? statusFlags_ |= END_ : statusFlags_ &= ~END_); };
  NABoolean endStep() { return (statusFlags_ & END_) != 0; };

  void setDone(NABoolean v) {(v ? statusFlags_ |= DONE_ : statusFlags_ &= ~DONE_); };
  NABoolean done() { return (statusFlags_ & DONE_) != 0; };

  void setReturnET(NABoolean v) 
  {(v ? statusFlags_ |= RETURN_ET_ : statusFlags_ &= ~RETURN_ET_); };
  NABoolean returnET() { return (statusFlags_ & RETURN_ET_) != 0; };

  void setComputeST(NABoolean v) 
  {(v ? statusFlags_ |= COMPUTE_ST_ : statusFlags_ &= ~COMPUTE_ST_); };
  NABoolean computeST() { return (statusFlags_ & COMPUTE_ST_) != 0; };

  void setComputeET(NABoolean v) 
  {(v ? statusFlags_ |= COMPUTE_ET_ : statusFlags_ &= ~COMPUTE_ET_); };
  NABoolean computeET() { return (statusFlags_ & COMPUTE_ET_) != 0; };

  void setXnStarted(NABoolean v) 
  {(v ? statusFlags_ |= XN_STARTED_ : statusFlags_ &= ~XN_STARTED_); };
  NABoolean xnStarted() { return (statusFlags_ & XN_STARTED_) != 0; };

  void setMDupgrade(NABoolean v)
  {(v ? statusFlags_ |= MD_UPGRADE_ : statusFlags_ &= ~MD_UPGRADE_); }
  NABoolean getMDupgrade() { return (statusFlags_ & MD_UPGRADE_) != 0;}

  void setGetMDVersion(NABoolean v)
  {(v ? statusFlags_ |= GET_MD_VERSION_ : statusFlags_ &= ~GET_MD_VERSION_); }
  NABoolean getMDVersion() { return (statusFlags_ & GET_MD_VERSION_) != 0;}

  void setGetSWVersion(NABoolean v)
  {(v ? statusFlags_ |= GET_SW_VERSION_ : statusFlags_ &= ~GET_SW_VERSION_); }
  NABoolean getSWVersion() { return (statusFlags_ & GET_SW_VERSION_) != 0;}

  void setMDcleanup(NABoolean v)
  {(v ? statusFlags_ |= MD_CLEANUP_ : statusFlags_ &= ~MD_CLEANUP_); }
  NABoolean getMDcleanup() { return (statusFlags_ & MD_CLEANUP_) != 0;}

  void setCheckOnly(NABoolean v)
  {(v ? statusFlags_ |= CHECK_ONLY_ : statusFlags_ &= ~CHECK_ONLY_); }
  NABoolean getCheckOnly() { return (statusFlags_ & CHECK_ONLY_) != 0;}

  void setReturnDetails(NABoolean v)
  {(v ? statusFlags_ |= RETURN_DETAILS_ : statusFlags_ &= ~RETURN_DETAILS_); }
  NABoolean getReturnDetails() { return (statusFlags_ & RETURN_DETAILS_) != 0;}

  void setInitTraf(NABoolean v)
  {(v ? statusFlags_ |= INIT_TRAF_ : statusFlags_ &= ~INIT_TRAF_); }
  NABoolean getInitTraf() { return (statusFlags_ & INIT_TRAF_) != 0;}

  void setMinimalInitTraf(NABoolean v)
  {(v ? statusFlags_ |= MINIMAL_IT_ : statusFlags_ &= ~MINIMAL_IT_); }
  NABoolean getMinimalInitTraf() { return (statusFlags_ & MINIMAL_IT_) != 0;}

  void setDDLXns(NABoolean v)
  {(v ? statusFlags_ |= DDL_XNS_ : statusFlags_ &= ~DDL_XNS_); }
  NABoolean getDDLXns() { return (statusFlags_ & DDL_XNS_) != 0;}

  void setMsg(const char * msg)
  {
    msgLen_ = strlen(msg);
    strcpy(msg_, msg);
  }

  char * msg() { return msg_; }
  Lng32 &step() {return step_;}
  Lng32 &subStep() {return substep_;}

  void setStep(Lng32 step) { step_ = step; }
  void setSubstep(Lng32 substep) { substep_ = substep; }

  Lng32 blackBoxLen() { return blackBoxLen_; }
  char * blackBox() { return blackBox_; }
  void setBlackBoxLen(Lng32 v) { blackBoxLen_ = v; }
  void setBlackBox(char * v) { blackBox_ = v; }

 private:
  Lng32 step_;
  Lng32 substep_;
  UInt32 statusFlags_;
  Lng32 msgLen_;
  char msg_[512];

  // black box data that can be sent and received. Contents are interpreted
  // based on the query that is being processed.
  Lng32 blackBoxLen_;
  char * blackBox_;
};

class CmpMessageDDLwithStatus : public CmpMessageRequest 
{
public:
  CmpMessageDDLwithStatus(char* stmt,CmpMsgBufLenType size,
                          CollHeap* h=0):
  CmpMessageRequest(DDL_WITH_STATUS, stmt,size,h)
    {};

  virtual ~CmpMessageDDLwithStatus() {};
   
  CmpDDLwithStatusInfo * getCmpDDLwithStatusInfo() const 
  { return (CmpDDLwithStatusInfo *)data();};
 
private:
  CmpMessageDDLwithStatus& operator=(const CmpMessageDDLwithStatus&);
  CmpMessageDDLwithStatus(const CmpMessageDDLwithStatus&);

}; // end of CmpMessageDDLwithStatus

// -----------------------------------------------------------------------
// The Describe command
// -----------------------------------------------------------------------

class CmpMessageDescribe : public CmpMessageRequest 
{
public:
  CmpMessageDescribe(char* stmt=NULL,CmpMsgBufLenType size=0,CollHeap* h=0,
                     Lng32 charset=SQLCHARSETCODE_UTF8
                     ):
  CmpMessageRequest(DESCRIBE, stmt,size,h,charset)
    { };

  virtual ~CmpMessageDescribe() {};
   
private:
  CmpMessageDescribe& operator=(const CmpMessageDescribe&);
  CmpMessageDescribe(const CmpMessageDescribe&);
}; // end of CmpMessageDescribe

// -----------------------------------------------------------------------
// The UPDATE_HIST_STAT
// -----------------------------------------------------------------------

class CmpMessageUpdateHist : public CmpMessageRequest 
{
public:
  CmpMessageUpdateHist(char* stmt=0, CmpMsgBufLenType size=0, CollHeap* h=0,
                       Lng32 charset=SQLCHARSETCODE_UTF8
                     ):
    CmpMessageRequest(UPDATE_HIST_STAT, stmt,size,h,charset)
      { }
  virtual ~CmpMessageUpdateHist()  { }
}; // end of CmpMessageUpdateHist
  
class CmpMessageMFStmt : public CmpMessageObj
{
}; // end of CmpMessageMFStmt

// -----------------------------------------------------------------------
// The SET TRANSACTION command
// -----------------------------------------------------------------------

class CmpMessageSetTrans : public CmpMessageRequest 
{
public:
  CmpMessageSetTrans(char* stmt=NULL,CmpMsgBufLenType size=0,CollHeap* h=0):
  CmpMessageRequest(SET_TRANS, stmt,size,h)
    { };

  virtual ~CmpMessageSetTrans() {};
   
private:
  CmpMessageSetTrans& operator=(const CmpMessageSetTrans&);
  CmpMessageSetTrans(const CmpMessageSetTrans&);
}; // end of CmpMessageSetTrans

// -----------------------------------------------------------------------
// The DDL NATABLE INVALIDATION command
// This command is send from executor to arkcmp at the end of a 
// transaction. On receiving it, arkcmp invalidates NATable for ddl objects 
// that were part of that transaction. They are then reloaded when that
// object is accessed.
// -----------------------------------------------------------------------

class CmpMessageDDLNATableInvalidate : public CmpMessageRequest 
{
public:
  CmpMessageDDLNATableInvalidate(char* stmt=NULL,CmpMsgBufLenType size=0,CollHeap* h=0):
  CmpMessageRequest(DDL_NATABLE_INVALIDATE, stmt,size,h)
    { };

  virtual ~CmpMessageDDLNATableInvalidate() {};
   
private:
  CmpMessageDDLNATableInvalidate& operator=(const CmpMessageDDLNATableInvalidate&);
  CmpMessageDDLNATableInvalidate(const CmpMessageDDLNATableInvalidate&);
}; // end of CmpMessageDDLNATableInvalidate

// -----------------------------------------------------------------------
// Database user ID
// -----------------------------------------------------------------------
class CmpMessageDatabaseUser : public CmpMessageRequest 
{
public:
  CmpMessageDatabaseUser(char *stmt = NULL,
                         CmpMsgBufLenType size = 0,
                         CollHeap* h = 0)
    : CmpMessageRequest(DATABASE_USER, stmt, size, h)
  {}

  virtual ~CmpMessageDatabaseUser()
  {}
   
private:
  CmpMessageDatabaseUser& operator=(const CmpMessageDatabaseUser&);
  CmpMessageDatabaseUser(const CmpMessageDatabaseUser&);
}; // end of CmpMessageDatabaseUser

// -----------------------------------------------------------------------
// The reply code message from arkcmp to executor, 
// containing the code generated by the generator.
// -----------------------------------------------------------------------

class CmpMessageReplyCode : public CmpMessageReply
{
public:
  CmpMessageReplyCode(CollHeap* h=0, ID request=0, 
		      char* preAllocatedData=0, 
		      ULng32 preAllocatedSize = 0, 
		      CollHeap* outh_=0,
		      FragmentDir * fragmentDir = NULL) :
  CmpMessageReply(REPLY_CODE, request, h, preAllocatedData, preAllocatedSize,
		  outh_),
  fragmentDir_(fragmentDir)
    { }
  
  virtual ~CmpMessageReplyCode();
       
  virtual void destroyMe();

  FragmentDir * getFragmentDir() { return fragmentDir_; }
  void setFragmentDir(FragmentDir * fd) { fragmentDir_ = fd; }

  virtual IpcMessageObjSize packedLength() 
    {  return mypackedLength();   }

  virtual IpcMessageObjSize packObjIntoMessage(IpcMessageBufferPtr buffer) 
    {  return packMyself(buffer); }

  IpcMessageObjSize mypackedLength();
  IpcMessageObjSize packMyself(IpcMessageBufferPtr& buffer);

  IpcMessageObjSize copyFragsToBuffer(IpcMessageBufferPtr& buffer);

private:
  
  CmpMessageReplyCode& operator=(const CmpMessageReplyCode&);
  CmpMessageReplyCode(const CmpMessageReplyCode&);

  FragmentDir * fragmentDir_;
}; // end of CmpMessageReplyCode
 

// -----------------------------------------------------------------------
// Class declarations for the CmpMessageObjects for internal stored
// procedure execution.
// -----------------------------------------------------------------------

// -----------------------------------------------------------------------
// CmpMessageISPRequest is the execution of SP request sent from executor.
// -----------------------------------------------------------------------

class CmpMessageISPRequest : public CmpMessageRequest
{
public:
  // When executor instantiate this object. 
  // The pointers will be copied into this object, not the contents 
  // because of the performance reason. 
  // So the caller should not free the memory before the object freed
  // When compiler instantiate this object.
  // The object will be unpacked from the IPC buffers, i.e. the member
  // will be allocated and contents will be copied over. Then this class
  // owns the pointers and delete them at the desructor time.
  // 
  CmpMessageISPRequest(char* procName = 0,
		void* inputExpr = 0,
		ULng32 inputExprSize = 0,
		void* outputExpr = 0,
		ULng32 outputExprSize = 0,
		void* keyExpr = 0,
		ULng32 keyExprSize = 0,
		void* inputData = 0,
		ULng32 inputDataSize = 0,
		ULng32 ouputRowSize = 0,
		ULng32 outputTotalSize = 0,
		CollHeap* h=0,
		const char *parentQid = NULL,
                Lng32 parentQidLen = 0);

  virtual ~CmpMessageISPRequest() ;
  
  IpcMessageObjSize mypackedLength();
  IpcMessageObjSize packMyself(IpcMessageBufferPtr& buffer);
  void unpackMyself(IpcMessageObjType objType,
		    IpcMessageObjVersion objVersion,
		    NABoolean sameEndianness,
		    IpcMessageObjSize objSize,
		    IpcConstMessageBufferPtr& buffer);

  virtual IpcMessageObjSize packedLength()
    { return mypackedLength(); }
  virtual IpcMessageObjSize packObjIntoMessage(IpcMessageBufferPtr buffer)
    { return packMyself(buffer); }
  virtual void unpackObj(IpcMessageObjType objType,
			 IpcMessageObjVersion objVersion,
			 NABoolean sameEndianness,
			 IpcMessageObjSize objSize,
			 IpcConstMessageBufferPtr buffer)
    { unpackMyself(objType,objVersion,sameEndianness, objSize,buffer); }

  
  virtual void destroyMe();

  // methods to access private members

  const char* procName() const { return procName_; }
  const ULng32 inputExprSize() const  { return inputExprSize_; }
  const void* inputExpr() const { return inputExpr_; }
  const ULng32 outputExprSize() const { return outputExprSize_; }
  const void* outputExpr() const { return outputExpr_; }
  const ULng32 keyExprSize() const { return keyExprSize_; }
  const void* keyExpr() const { return keyExpr_; }
  const ULng32 inputDataSize() const { return inputDataSize_; }
  const void* inputData() const { return inputData_; }
  const ULng32 keyDataSize() const { return keyDataSize_; }
  const void* keyData() const { return keyData_; }
  const ULng32 outputRowSize() const { return outputRowSize_; }
  const ULng32 outputTotalSize() const { return outputTotalSize_; }

private:
  CmpMessageISPRequest(const CmpMessageISPRequest &);
  const CmpMessageISPRequest& operator=(const CmpMessageISPRequest&);

  // members, information provided by executor
  char* procName_; // ISP name, null terminated

  // The expressions are packed as (length, data) by executor before
  // construct this object. executor will provide methods to access
  // the values.
  ULng32 inputExprSize_; // size of the inputExpr
  void* inputExpr_;             // expression for input data
  ULng32 outputExprSize_; // size of the outputExpr
  void* outputExpr_;             // expression for output data
  ULng32 keyExprSize_; // size of the key data
  void* keyExpr_;             // expression for key expression

  // The data is packed by executor before construct this object. 
  // executor will provide methods to access the values.

  ULng32 inputDataSize_; // size of input data
  void* inputData_; // input data
  ULng32 keyDataSize_; // size of the key data
  void* keyData_; // key data

  ULng32 outputRowSize_; // the size of each row of output data
  ULng32 outputTotalSize_; // buffer size for output data, once the
  // output exceeds the limit, it should be sent back in multiple
  // replies. 

  // internal flag to identify whether the void* for data are allocated
  // internally in this class.
  // in executor side, where the constructor is called with parameters
  // the allocated_ flag will be FALSE, and the caller owns the pointers.
  // in compiler, where the constructor is called with 0 parameters, and
  // data is unpacked from IPC buffer, allocated_flag will be set to TRUE,
  // and this class owns ths pointers, should delete them in destructor.
  NABoolean allocated_; 
   
}; // end of CmpMessageISPRequest

// -----------------------------------------------------------------------
// CmpMessageISPGetNext is the request to arkcmp from executor to get
// more data. This is used to fetch more data when the previous 
// CmpMessageISPReply returns with status as more data to be fetched in 
// arkcmp site. 
// -----------------------------------------------------------------------

class CmpMessageISPGetNext : public CmpMessageRequest
{
public:
  CmpMessageISPGetNext(ULng32 bufSize = 0,
		       ID ispRequest = 0,
		       Lng32 serialNo = 0,
		       CollHeap* h=0,
                       const char *parentQid = NULL,
                       Lng32 parentQidLen = 0);
  virtual ~CmpMessageISPGetNext();

  IpcMessageObjSize mypackedLength();
  IpcMessageObjSize packMyself(IpcMessageBufferPtr& buffer);
  void unpackMyself(IpcMessageObjType objType,
		    IpcMessageObjVersion objVersion,
		    NABoolean sameEndianness,
		    IpcMessageObjSize objSize,
		    IpcConstMessageBufferPtr& buffer);

  virtual IpcMessageObjSize packedLength()
    { return mypackedLength(); }
  virtual IpcMessageObjSize packObjIntoMessage(IpcMessageBufferPtr buffer)
    { return packMyself(buffer); }
  virtual void unpackObj(IpcMessageObjType objType,
			 IpcMessageObjVersion objVersion,
			 NABoolean sameEndianness,
			 IpcMessageObjSize objSize,
			 IpcConstMessageBufferPtr buffer)
    { unpackMyself(objType,objVersion,sameEndianness, objSize,buffer); }

  ULng32 bufSize() const { return bufSize_; }
  ID ispRequest() const { return ispRequest_; }
private:
  CmpMessageISPGetNext(const CmpMessageISPGetNext&);
  const CmpMessageISPGetNext& operator=(const CmpMessageISPGetNext& );

  // members
  ULng32 bufSize_;
  ID ispRequest_;
  Lng32 serialNo_;
};


// -----------------------------------------------------------------------
// CmpMessageISPReply is the reply of the execution of SP request sent
// from compiler.
// -----------------------------------------------------------------------

class CmpMessageReplyISP : public CmpMessageReply
{
public:
  CmpMessageReplyISP(CollHeap* h=0, ID request=0, 
    char* preAllocatedData=0, ULng32 preAllocatedSize=0, CollHeap* outh_=0) : 
  CmpMessageReply(REPLY_ISP, request, h, preAllocatedData, preAllocatedSize, outh_) 
    { areMore_ = 0; }
  
  virtual ~CmpMessageReplyISP() { }

  IpcMessageObjSize mypackedLength();
  IpcMessageObjSize packMyself(IpcMessageBufferPtr& buffer);
  void unpackMyself(IpcMessageObjType objType,
		    IpcMessageObjVersion objVersion,
		    NABoolean sameEndianness,
		    IpcMessageObjSize objSize,
		    IpcConstMessageBufferPtr& buffer);

  virtual IpcMessageObjSize packedLength()
    { return mypackedLength(); }
  virtual IpcMessageObjSize packObjIntoMessage(IpcMessageBufferPtr buffer)
    { return packMyself(buffer); }
  virtual void unpackObj(IpcMessageObjType objType,
			 IpcMessageObjVersion objVersion,
			 NABoolean sameEndianness,
			 IpcMessageObjSize objSize,
			 IpcConstMessageBufferPtr buffer)
    { unpackMyself(objType,objVersion,sameEndianness, objSize,buffer); }
     
  void setAreMore(NABoolean b) { areMore_ = b; }
  NABoolean areMore() { return areMore_; }

private:
  
  CmpMessageReplyISP& operator=(const CmpMessageReplyISP&);
  CmpMessageReplyISP(const CmpMessageReplyISP&);

  // 0 if there is more data to be fetched, 1 if there is no more. 
  Lng32 areMore_;
}; // end of CmpMessageReplyISP

// -----------------------------------------------------------------------
// CmpMessageConnectionType is the message sent from executor to arkcmp
// to specify the property of connection, i.e. for DML/DDL or ISP execution.
// This message is sent at the beginning of each connection, so arkcmp can
// skip the functions only needed for DML/DDL. It saves resource for arkcmp
// spawned in ISP execution.
// -----------------------------------------------------------------------

class CmpMessageConnectionType : public CmpMessageRequestBasic
{
public:
  enum ConnectionTypeEnum { DMLDDL, ISP };
  CmpMessageConnectionType(ConnectionTypeEnum e = DMLDDL,
    CollHeap* h=0);

  ConnectionTypeEnum connectionType() { return type_; }

  IpcMessageObjSize mypackedLength();
  IpcMessageObjSize packMyself(IpcMessageBufferPtr& buffer);
  void unpackMyself(IpcMessageObjType objType,
		    IpcMessageObjVersion objVersion,
		    NABoolean sameEndianness,
		    IpcMessageObjSize objSize,
		    IpcConstMessageBufferPtr& buffer);

  virtual IpcMessageObjSize packedLength()
    { return mypackedLength(); }
  virtual IpcMessageObjSize packObjIntoMessage(IpcMessageBufferPtr buffer)
    { return packMyself(buffer); }
  virtual void unpackObj(IpcMessageObjType objType,
			 IpcMessageObjVersion objVersion,
			 NABoolean sameEndianness,
			 IpcMessageObjSize objSize,
			 IpcConstMessageBufferPtr buffer)
    { unpackMyself(objType,objVersion,sameEndianness, objSize,buffer); }

  virtual ~CmpMessageConnectionType() { }
   
private:
  ConnectionTypeEnum type_;
  CmpMessageConnectionType& operator=(const CmpMessageConnectionType&);
  CmpMessageConnectionType(const CmpMessageConnectionType&);

}; // end of CmpMessageConnectionType
#endif