
// @@@ 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 @@@
/**********************************************************************/
#ifndef CONTEXT_H
#define CONTEXT_H

/* -*-C++-*-
 *****************************************************************************
 *
 * File:         Context.h
 * Description:  CLI context. A CLI context is an entire execution environment
 *               for an SQL client (including a user id, transactions,
 *               prepared statements, cursor states, etc). Right now
 *               (December 1999) we only support a single context.
 *
 * Created:      7/10/95
 * Language:     C++
 *
 *
 *
 *
 *****************************************************************************
 */


#include "Platform.h"
#include "CliDefs.h"
#include "ComDiags.h"
#include "DllExportDefines.h"
#include "CliSemaphore.h"
#include "sqlcli.h"
#include "Statement.h"
#include "ex_god.h"
#include "timeout_data.h" 
#include "Module.h"
#include "Globals.h"
#include "NAUserId.h"
#include "SessionDefaults.h"
#include "ex_transaction.h"
#include "CmpCommon.h"
#include "ExSqlComp.h"
#include "ExStats.h"
#include "ExpSeqGen.h"
#include "ssmpipc.h"
#include "hdfs.h"
#include "HdfsClient_JNI.h"

class CliGlobals;
class HashQueue;
class Queue;
class ExSqlComp;
class ExStatisticsArea;
class ExControlArea;
class ExUdrServer;
class UdrContextMsg;
class SequenceValueGenerator;
class LmRoutine;
class ContextCli : public ExGod {
  
public:
  enum ArkcmpFailMode { arkcmpIS_OK_ = FALSE/*no failure*/,
			arkcmpWARN_,
			arkcmpERROR_ };

  enum CloseCursorType {
    CLOSE_ALL,       // close all non-holdable cursors 
    CLOSE_ALL_INCLUDING_ANSI_PUBSUB_HOLDABLE,  // close all cursors including pubsub and ansi holdable cursors 
    CLOSE_ALL_INCLUDING_ANSI_HOLDABLE, // close all non-holdable cursors and ansi holdable cursors
    CLOSE_ALL_INCLUDING_PUBSUB_HOLDABLE, // close all non-holdable cursors and pubsub holdable cursors
    CLOSE_ALL_INCLUDING_ANSI_PUBSUB_HOLDABLE_WHEN_CQD // close all incl AHC holdable cursors and pubsub holdable cursors
                                                      // when CQD PSHOLD_CLOSE_ON_ROLLBACK
  };

  enum closeTransactionType {
    CLOSE_ALL_XN,   // close cursors belonging to any transaction
    CLOSE_CURR_XN,  // close only those that are part of current transaction
    CLOSE_ENDED_XN  // close those cursors whose
                    // associated xns are no longer active
  };

  SQLCTX_HANDLE getContextHandle() { return contextHandle_; }

  // Accessor functions to retrieve the current user name and ID
  const char *getDatabaseUserName() { return databaseUserName_;}
  Int32 *getDatabaseUserID() { return &databaseUserID_; }
  Int32 *getSessionUserID() { return &sessionUserID_; }
  
  // Functions to switch user identity. The specified user must exist
  // as a valid user in the USERS metadata table. Otherwise an error
  // code is returned and error conditions will be written to the
  // context's diagnostics area. These functions are only supported on
  // Linux.
  RETCODE setDatabaseUserByID(Int32 userID);
  RETCODE setDatabaseUserByName(const char *userName);

  void setDatabaseUser(const Int32 &uid, // IN
                       const char *uname);   // IN

  // Functions to map between Trafodion authentication IDs and names. 
  RETCODE getAuthIDFromName(
     const char *authName,  
     Int32 & authID);   
  
  RETCODE getAuthNameFromID(
     Int32 authID,         // IN
     char *authNameBuffer, // OUT
     Int32 maxBufLen,      // IN
     Int32 &requiredLen);   // OUT optional
  RETCODE getDBUserNameFromID(Int32 userID,         // IN
                              char *userNameBuffer, // OUT
                              Int32 maxBufLen,      // IN
                              Int32 *requiredLen);  // OUT
  RETCODE getDBUserIDFromName(const char *userName, // IN
                              Int32 *userID);       // OUT

  // Function to be used only in ESPs to establish user identity. This
  // call will update data members and will NOT verify the input
  // arguments by querying the USERS table.
  void setDatabaseUserInESP(const Int32 &uid, const char *uname,
                            bool closeAllOpens = false);

  char * getExternalUserName() { return externalUsername_; }

  char * userSpecifiedSessionName() { return userSpecifiedSessionName_; }
  void setUserSpecifiedSessionName(const char * un) 
  { 
    strcpy(userSpecifiedSessionName_, un);
  }

  void setAuthStateInCmpContexts(NABoolean authEnabled,
                                 NABoolean authReady);

  void getAuthState (bool &authenticationEnabled,
                     bool &authorizationEnabled,
                     bool &authorizationReady,
                     bool &auditingEnabled);


  // functions to get and set roles for the current user
  RETCODE getRoleList(Int32  &numRoles,
                      Int32  *&roleIDs);

  RETCODE resetRoleList();

  SequenceValueGenerator* &seqGen() { return seqGen_; }

  HashQueue * trafSElist() { return trafSElist_; }

  inline void incStmtReclaimCount()
  {
    stmtReclaimCount_++;
    if (processStats_ != NULL) 
       processStats_->incReclaimStmtCount();
  }

  inline void decStmtReclaimCount() 
  {
    stmtReclaimCount_--;
    if (processStats_ != NULL) 
       processStats_->decReclaimStmtCount();
  }

  inline void incCloseStmtListSize()
  {
    closeStmtListSize_--;
    if (processStats_ != NULL)
       processStats_->incCloseStmtCount();
  }

  inline void decCloseStmtListSize()
  {
    closeStmtListSize_--;
    if (processStats_ != NULL)
       processStats_->decCloseStmtCount();
  }

  inline ExProcessStats *getExProcessStats() { return processStats_; }
  void setHbaseClient(HBaseClient_JNI *hbaseClientJNI)
  { hbaseClientJNI_ = hbaseClientJNI; }
  HBaseClient_JNI *getHBaseClient() { return hbaseClientJNI_; }

  HiveClient_JNI *getHiveClient() { return hiveClientJNI_; }
  void setHiveClient(HiveClient_JNI *hiveClientJNI)
  { hiveClientJNI_ = hiveClientJNI; }

  HdfsClient *getHDFSClient() { return hdfsClientJNI_; }
  void setHDFSClient(HdfsClient *hdfsClientJNI)
  { hdfsClientJNI_ = hdfsClientJNI; }

  //expose cmpContextInfo_ to get HQC info of different contexts
  const NAArray<CmpContextInfo *> & getCmpContextInfo() const { return cmpContextInfo_; }

  //expose cmpContext stack to allow search
  const LIST(CmpContext *)& getCmpContextsInUse() const { return  cmpContextInUse_; }

  CollIndex addTrustedRoutine(LmRoutine *r);
  LmRoutine *findTrustedRoutine(CollIndex ix);
  void putTrustedRoutine(CollIndex ix);

  ExSqlComp::ReturnStatus sendXnMsgToArkcmp
  (char * data, Lng32 dataSize, 
   Lng32 xnMsgType, ComDiagsArea* &diagsArea);

  inline NABoolean grabMemoryQuotaIfAvailable(ULng32 size)
  {
    if ( unusedBMOsMemoryQuota_ < size ) return FALSE;
    unusedBMOsMemoryQuota_ -= size ;
    return TRUE;
  }

  inline void resetMemoryQuota() { unusedBMOsMemoryQuota_ = 0 ; }

  inline ULng32 unusedMemoryQuota() { return unusedBMOsMemoryQuota_; }

  inline void yieldMemoryQuota(ULng32 size)
  { unusedBMOsMemoryQuota_ += size; }

private:

  // The heap where executor 'stuff' will be allocated from.
  // exHeap_ must be first so that it's dtor is called last (Gil)
  NAHeap exHeap_;

  SQLCTX_HANDLE contextHandle_;

  CliGlobals *cliGlobals_;

  SessionDefaults * sessionDefaults_;

  HashQueue * bdrConfigInfoList_;

  // this class defined in file SessionDefaults.h
  //  AQRInfo * aqrInfo_;

  char * authID_;
  char * authToken_;
  NABoolean validAuthID_;
  SQLAUTHID_TYPE authIDType_;

  //External name, max 128 characters
  char* externalUsername_;

  // Database user name. On Linux the values come from the USER_NAME
  // column in the USERS table. Max 128 characters.
  char *databaseUserName_;

  // List of active roles for the databaseUser
  Int32  *roleIDs_;
  Int32   numRoles_;

  NABoolean userNameChanged_;

  // queues(lists) to keep track of loaded modules, statements
  // and descriptors.
  HashQueue * moduleList_;
  HashQueue * statementList_;
  HashQueue * descriptorList_;
  HashQueue * cursorList_;
  // this is a subset of statementList_. It contains all statements in
  // state OPEN_ or EOF_
  HashQueue * openStatementList_;

  // list of non-audited tbat have been locked.
  HashQueue * nonAuditedLockedTableList_;

  // List of closed statements with ESPs assigned
  Queue * statementWithEspsList_;

  // remember the last assigned descriptor handle
  ULong lastDescriptorHandle_;
  ULong lastStatementHandle_;

  Int32 databaseUserID_;
  // With SPJ Definer Rights, we need to support different values for
  // SESSION_USER and CURRENT_USER/USER. SESSION_USER is the user that is 
  // logged on to the current SQL session. CURRENT_USER is the one with 
  // whose privileges a SQL statement is executed, With Definer Rights SPJ, 
  // the CURRENT_USER is the owner of the SPJ while SESSION_USER is the 
  // user who invoked the SPJ.
  Int32 sessionUserID_;

  // keeps track of current define context.
  unsigned short defineContext_;

  // flag and pointer to the embedded arkcmp context
  NABoolean isEmbeddedArkcmpInitialized_;
  CmpContext * embeddedArkcmpContext_;

  CmpContext * prevCmpContext_;

  // pointer to the array of server  versions used to communicate with ARKCMP.
  ARRAY(ExSqlComp *) arkcmpArray_;

  // Arkcmp context (CmpContext) switching related info
  // known CmpContext instance set to be used for different catagory
  ARRAY(CmpContextInfo *) cmpContextInfo_;
  // stack of CmpContexts in use except current one
  LIST(CmpContext *) cmpContextInUse_; 

  // Array of failure modes for each arkcmp 
  ARRAY(ArkcmpFailMode) arkcmpInitFailed_;
  short versionOfMxcmp_;
  char *mxcmpNodeName_;
  short indexIntoCompilerArray_;
  // the transaction object
  ExTransaction * transaction_;

  // A diagnostics area for this context
  ComDiagsArea   diagsArea_;

  // Points to the statistics area of current statement
  // being executed. Used to return stat info for the
  // 'last' statement that was executed.
  ExStatisticsArea * stats_;

  // this area contains the defaults and other controls
  // specified by user using CONTROL QUERY statements.
  ExControlArea * controlArea_;

  // used by asynchronous CLI cancel feature to
  // synchronize the main thread and the cancel thread.
  CLISemaphore cancelSemaphore_;

  // parser flags to be sent to mxcmp
  ULng32 sqlParserFlags_;

  // Hold all the dynamicly set (in this process) timeout data
  TimeoutData  * timeouts_;  // it is NULL if not used

  // logical timestamp; increment each time SET TIMEOUT executes
  // (We ignore counter overlap; this can only affect a statement that
  //  remained fixed up after 2^32 times of timeout-settings .... :-)
  UInt32  timeoutChangeCounter_; 

  // A list of closed statements maintained in LRU order.
  // Used to determine aging statements for space deallocation.
  // Rules: (when there are enough allocated statements).
  // - A statement is added to the head of the list at close() time. 
  // - A statement is removed from the list at open() and
  //   deallocate() time.
  // - Each statement on the list has a unique sequence > 0.
  //   A zero or negative sequence indicates the statement is not on the list.
  // - The sequence numbers indicate the sequence of closes of  
  //   those statements.
  //
  // closeStatementList points to the most recently closed static statement,
  // which has the largest close sequence number.
  // nextReclaimStatement points to the statement most eligible for 
  // space reclaim.  nextReclaimStatement will move toward the head of
  // the list as statements are reclaimed one by one.
  // 
  Statement * closeStatementList_;
  Statement * nextReclaimStatement_;

  // Statistics data.
  // stmtReclaimCount_ is the number of statements on the closeStmtList_
  // for which space reclaim has been done.

  Lng32 closeStmtListSize_;
  Lng32 stmtReclaimCount_;
  Lng32 stmtReclaimMinPctFree_; // Reclaim space when free is <= percent of total
  IpcTimeout espReleaseTimeout_;

  // currSequence_ is the sequence of the latest close of a statement.
  // prevFixupSequence_ is the sequence of the latest fixup.
  Lng32 currSequence_;
  Lng32 prevFixupSequence_;

  // a pointer containing information that catman
  // wants to persist across multiple calls to catman interface
  // from executor. 
  // Its contents are unknown to cli or executor. It is allocated
  // and maintained by catman code.
  // Passed to CatManAnsiNameToGuardianName.
  void * catmanInfo_;

  enum Flags
  {
    // If the stmt for which stats were collected is deallocated,
    // then a copy of it ExStatisticsArea is made and pointed to
    // by the stats_ field. This flag, if set, indicates that.
    // If this flag is not set, then stats_ points to the stats
    // area of the corresponding stmt.
    STATS_COPY_ = 0x0001,
    DELETE_MERGED_STATS_ = 0x0002,
    STATS_IN_SHARED_SEGMENT_ = 0x0004,
    // an inMemory object definition was created during this session.
    // Kill mxcmp at the end of this session.
    IN_MEMORY_OBJECT_DEFN = 0x0008
  };

  ULng32 flags_;

  // List of UDR servers servicing this context. Each list element is
  // an ExUdrServer pointer. There may be duplicates in the list. Each
  // element represents a reference on an ExUdrServer instance. A
  // context may own multiple references on a given ExUdrServer, one
  // for each fixed up CALL statement that has been executed within
  // the context. When a context is destroyed all ExUdrServer
  // references must be released by calling the ExUdrServerManager
  // interface.
  HashQueue *udrServerList_;

  // Strings to store UDR runtime options that have been set
  // dynamically by the calling application. These strings can only be
  // set via an internal CLI function and catman is the only caller of
  // that function.
  char *udrRuntimeOptions_;
  char *udrRuntimeOptionDelimiters_;
  Statement *pendingNoWaitPrepare_;
  ExProcessStats *processStats_;

  inline HashQueue * moduleList(){return moduleList_;};
  inline HashQueue * statementList(){return statementList_;};
  inline HashQueue * descriptorList(){return descriptorList_;};
  inline HashQueue * cursorList(){return cursorList_;};
  inline HashQueue * openStatementList(){return openStatementList_;};

  // Used to reclaim space from a list of closed statements.
  void addToCloseStatementList(Statement *statement);

  // SPJ add on
  void issueCtrlStmts(IpcConstMessageBufferPtr ctrlStmtBuffer, Int32 length);
  void internalPrepareExecuteFetchStmt(char *sqlText);
  UdrContextMsg * manufactureUdrContextMsg();  

  // Locate a matching UDR server within this context
  ExUdrServer *findUdrServer(const char *runtimeOptions,
                             const char *optionDelimiters,
                             NABoolean dedicated);

  // Release all ExUdrServer references currently held
  void releaseUdrServers();

  // Remove a child statement such as a clone or a stored procedure
  // result set proxy from the context's statement lists. Do not call
  // the child's destructor (that job is left to the parent
  // statement's destructor).
  RETCODE cleanupChildStmt(Statement *child);

  char * userSpecifiedSessionName_;

  // created whenever user begins a session.
  // Should never be NULL as we are always in a session.
  char * sessionID_;

  // list of volatile tables created in a session.
  HashQueue * volTabList_;

  HashQueue *hdfsHandleList_;
  SequenceValueGenerator * seqGen_;

  NABoolean sessionInUse_;
  NABoolean mxcmpSessionInUse_;
  NABoolean volatileSchemaCreated_;
  ExStatisticsArea *mergedStats_;
  StmtStats *prevStmtStats_;
  
  CLISemaphore *cliSemaphore_;
  Lng32 numCliCalls_;
  IpcEnvironment *env_;
  NAHeap *ipcHeap_;
  UInt32 eventConsumed_;
  NABoolean breakEnabled_;
  // ESP manager for the context
  ExEspManager *espManager_;
  ExeTraceInfo *exeTraceInfo_;
  // UDR server manager for this process
  ExUdrServerManager *udrServerManager_;
  // trusted routines in use locally in this context,
  // without going through udrserv
  ARRAY(LmRoutine *) trustedRoutines_;
  // SSMP manager for this context.
  ExSsmpManager *ssmpManager_;
  NABoolean dropInProgress_;

  // set to true if ddl stmts are issued.
  // Reset at begin and commit Xn. Used to do NATable invalidation
  // for ddl stmts issued within a transaction.
  NABoolean ddlStmtsExecuted_;

  //   
  //
  //  Fields to enforce SQL semantics inside the UDR server. These
  //  fields are checked by the UDR server after a user-defined routine
  //  returns control, to see if that routine violated any SQL
  //  semantics for UDRs. Some examples of violations include a NO SQL
  //  routine attempting to access SQL, and a routine attempting to
  //  issue SQL transaction statements such as BEGIN WORK.
  //  If the udrErrorChecksEnabled_ flag is FALSE then none of this UDR
  //  error checking is performed. The only SQL application that
  //  enables the UDR error checking is the UDR server.
  //   
  NABoolean udrErrorChecksEnabled_;
  Lng32 udrSqlAccessMode_;
  NABoolean udrAccessModeViolation_;
  NABoolean udrXactViolation_;
  NABoolean udrXactAborted_;
  Int64 udrXactId_;  // transid that UDR Server is interested to know
                     // if aborted
  NAString jniErrorStr_; 
  HBaseClient_JNI *hbaseClientJNI_;
  HiveClient_JNI *hiveClientJNI_;
  HdfsClient *hdfsClientJNI_;

  // this points to data used by trafSE (traf storage engine) that is context specific.
  // It points to a list of 'black box' of data allocated by user and is returned
  // back whenever this context is in use.
  HashQueue * trafSElist_;
  // memory quota allocation given back by BMOs to be used by other BMOs
  ULng32 unusedBMOsMemoryQuota_;

  NABoolean deleteStats()
  {
    return (flags_ & DELETE_MERGED_STATS_) != 0; 
  }

  void setDeleteStats(NABoolean v)      
  {
    (v ? flags_ |= DELETE_MERGED_STATS_ : flags_ &= ~DELETE_MERGED_STATS_); 
  }

  // An enumeration for different types of lookups into the AUTHS table 
  //   USER BY USER NAME      -- Find the row matching a database user name
  //   USER BY USER ID        -- Find the row matching a database user ID
  //   USER BY EXTERNAL NAME  -- Find the row matching an external user name
  //   ROLE BY ROLE ID	      -- Find the row matching a database role ID
  //   AUTH BY NAME           -- Find the row matching the database name
  enum AuthQueryType
    {
      USERS_QUERY_BY_USER_NAME = 2,
      USERS_QUERY_BY_USER_ID,
      USERS_QUERY_BY_EXTERNAL_NAME,
      ROLE_QUERY_BY_ROLE_ID,
      AUTH_QUERY_BY_NAME,
      ROLES_QUERY_BY_AUTH_ID
    };

  // Private method to perform single-row lookups into the AUTHS
  // table. If a matching row is found, column values are returned in
  // the users_type structure. users_type is defined in
  // smdio/CmTableDefs.h.
  //
  // For query type USERS_QUERY_BY_USER_ID, the authID argument must
  // be provided.
  //
  // For query types USERS_QUERY_BY_USER_NAME and
  // USERS_QUERY_BY_EXTERNAL_NAME, the authName argument must be
  // provided.
  RETCODE authQuery(
     AuthQueryType          queryType,         
     const char           * authName,          
     Int32                  authID,            
     char                 * authNameFromTable,
     Int32                  authNameMaxLen, 
     Int32                & authIDFromTable,
     std::vector<int32_t> & roleIDs);  
      
  RETCODE storeName(
     const char *src,
     char       *dest,
     int         maxLength);

  RETCODE storeName(
     const char *src,
     char       *dest,
     int         maxLength,
     int        &actualLength);
  
public:
  ContextCli(CliGlobals *cliGlobals);
  ~ContextCli();
  void deleteMe();
  inline UInt32 * getEventConsumed() { return &eventConsumed_; }
  inline IpcEnvironment * getEnvironment() { return env_; }
  inline ExEspManager * getEspManager() { return espManager_; }
  inline ExSsmpManager *getSsmpManager() { return ssmpManager_; }
  inline ExeTraceInfo *getExeTraceInfo() { return exeTraceInfo_; }
  NAHeap *getIpcHeap() { return ipcHeap_; }
  inline ExUdrServerManager *getUdrServerManager() { return udrServerManager_; }
  //
  // Accessor and mutator functions for UDR error checking. Notes on
  // UDR error checking appear below with the data member
  // declarations.
  // 
  NABoolean getUdrErrorChecksEnabled() { return udrErrorChecksEnabled_; }
  Lng32 getUdrSQLAccessMode() { return udrSqlAccessMode_; }
  NABoolean getUdrAccessModeViolation() { return udrAccessModeViolation_; }
  NABoolean getUdrXactViolation() { return udrXactViolation_; }
  NABoolean getUdrXactAborted() { return udrXactAborted_; }

  void setUdrErrorChecksEnabled(NABoolean b) { udrErrorChecksEnabled_ = b; }
  void setUdrSQLAccessMode(Lng32 mode) { udrSqlAccessMode_ = mode; }
  void setUdrAccessModeViolation(NABoolean b) { udrAccessModeViolation_ = b; }
  void setUdrXactViolation(NABoolean b) { udrXactViolation_ = b; }
  void setUdrXactAborted(Int64 currTransId, NABoolean b);
  //
  // A few useful wrapper functions to ease management of the UDR
  // error checking fields
  // 
  void clearUdrErrorFlags();

  NABoolean sqlAccessAllowed() const;

  void getUdrErrorFlags(NABoolean &sqlViolation,
                        NABoolean &xactViolation,
                        NABoolean &xactAborted) const
  {
    sqlViolation = udrAccessModeViolation_;
    xactViolation = udrXactViolation_;
    xactAborted = udrXactAborted_;
  }

  inline void setJniErrorStr(NAString errorStr)
  {  jniErrorStr_ = errorStr; }

  inline void setJniErrorStr(const char *errorStr)
  {  jniErrorStr_ = errorStr; }

  inline NAString getJniErrorStr()
  { return jniErrorStr_; }

  inline const char* getJniErrorStrPtr()
  { return (const char*)jniErrorStr_.data(); }

  inline CLISemaphore *getSemaphore()
  { 
     return cliSemaphore_;
  }
  inline Lng32 incrNumOfCliCalls()  { return ++numCliCalls_; }
  inline Lng32 decrNumOfCliCalls()
  {
     if (numCliCalls_ > 0)
        return --numCliCalls_;
     else
        return numCliCalls_;
  }
  inline Lng32 getNumOfCliCalls() { return numCliCalls_; }
  Lng32 initializeSessionDefaults();
  Lng32 initializeExeBDRConfigInfo(char *mgbltyCatName,
				  ComDiagsArea * diagsArea);

  short moduleAdded(const SQLMODULE_ID * module_name);

  RETCODE allocateDesc(SQLDESC_ID * desc_id, Lng32 max_entries);
  RETCODE deallocDesc(SQLDESC_ID * desc_id,
		      NABoolean deallocStaticDesc);
  Descriptor * getDescriptor(SQLDESC_ID * desc_id);

  RETCODE allocateStmt(SQLSTMT_ID * stmt_id, 
		       Statement::StatementType stmt_type = Statement::DYNAMIC_STMT,
                       SQLSTMT_ID * cloned_stmt_id = NULL);

  RETCODE deallocStmt(SQLSTMT_ID * stmt_id, 
		      NABoolean deallocStaticStmt);

  Statement * getStatement(SQLSTMT_ID * statement_id, HashQueue * stmtList = NULL);

  Statement * getNextStatement(SQLSTMT_ID * statement_id, NABoolean position,
			       NABoolean advance);

  // Upgrade both argument types for multi charset module names
  void removeCursor(SQLSTMT_ID* cursorName, const SQLMODULE_ID* moduleName);

  void addToCursorList(Statement &s);

  void addToOpenStatementList(SQLSTMT_ID *statement_id, Statement *statement);
  void removeFromOpenStatementList(SQLSTMT_ID * statement_id);

  short commitTransaction(NABoolean waited);
  short releaseAllTransactionalRequests();

  void closeAllCursors(enum CloseCursorType, 
          enum closeTransactionType transType, const Int64 executorXnId = 0, 
          NABoolean inRollback = FALSE);
  void checkIfNeedToClose(Statement *stmt, enum CloseCursorType type, 
          NABoolean &closeStmt, NABoolean &releaseStmt);
  void clearAllTransactionInfoInClosedStmt(Int64 transid);
  void closeAllCursorsFor(SQLSTMT_ID * statement_id);

  inline NAHeap * exHeap()                            { return &exHeap_; }
  inline CollHeap * exCollHeap()                      { return &exHeap_; }
  inline HashQueue *getStatementList() const;
  inline HashQueue *getCursorList() const;
  inline HashQueue *getOpenStatementList() const;
  inline HashQueue * getNonAuditedLockedTableList()
                                    { return nonAuditedLockedTableList_; }

  inline ULong getNextDescriptorHandle()
                                       { return lastDescriptorHandle_++; }
  inline ULong getNextStatementHandle() {return ++lastStatementHandle_;}
  
#ifdef _DEBUG
  // dumps a list of all statements with info about allocated memory
  // for debugging purposes only
  void dumpStatementInfo();
#endif

  void dumpStatementAndGlobalInfo(ostream* outstream);

  // Returns a reference to the ComDiagsArea, diagsArea_, of this context.
  ComDiagsArea  &diags() { return diagsArea_; }

  ComDiagsArea *getDiagsArea() { return &diagsArea_; }
 
  ExStatisticsArea* getStats() { return stats_; }

  void setStatsArea(ExStatisticsArea *stats, NABoolean statsCopy = FALSE, 
      NABoolean inSharedSegment = TRUE, NABoolean getSemaphore = TRUE);

  ExControlArea * getControlArea() { return controlArea_; }

  // return the TimeoutData field of the context (if it is NULL --allocate it)
  // (If allocate == FALSE, just return it as is, even if it is NULL)
  TimeoutData * getTimeouts( NABoolean allocate = TRUE );

  void clearTimeoutData();  // deallocate the TimeoutData 

  // make these functions non-inline on NT and inline on NSK.
  // These methods are called from code in executor directory
  // which creates a problem when linking for arkesp since arkesp
  // does not link in with cli code.
  // By making them non-inline on nt, a stub could be added.
  // This problem does not show up on nsk since inline functions
  // are really inline out there.
  void incrementTimeoutChangeCounter();
  UInt32 getTimeoutChangeCounter();

  void* &catmanInfo() {return catmanInfo_;}

  ////////////////////////////////////////////////////
  // Used to communicate with the embedded ARKCMP.
  ////////////////////////////////////////////////////

  NABoolean isEmbeddedArkcmpInitialized()
                { return isEmbeddedArkcmpInitialized_;}
  void setEmbeddedArkcmpIsInitialized(NABoolean val)
                { isEmbeddedArkcmpInitialized_ = val;}
  CmpContext *getEmbeddedArkcmpContext()
                { return embeddedArkcmpContext_; }
  void setEmbeddedArkcmpContext(CmpContext * cntx)
                { embeddedArkcmpContext_ = cntx; }

  ////////////////////////////////////////////////////
  // Used to communicate with the ARKCMP process.
  ////////////////////////////////////////////////////

  void setArkcmp(ExSqlComp *es)
  {
    short index = arkcmpArray_.entries();
    arkcmpArray_.insertAt(index, es);
  }
  void setArkcmpFailMode(ContextCli::ArkcmpFailMode afm)
  {
   short index = arkcmpInitFailed_.entries();
   arkcmpInitFailed_.insertAt(index, afm); 
  }
  ExSqlComp * getArkcmp(short index = 0)   
  {
    return arkcmpArray_[index];
  }
  ArkcmpFailMode & arkcmpInitFailed(short index = 0)	
  { 
    return (ContextCli::ArkcmpFailMode &)arkcmpInitFailed_[index];
  }

  short getNumArkcmps()
  {
    return arkcmpArray_.entries(); 
  }
  Lng32 setOrStartCompiler(short mxcmpVersionToUse, char *remoteNodeName,
			  short &indexIntoCompilerArray);

  inline short getVersionOfCompiler() {return versionOfMxcmp_;}
  inline void setVersionOfMxcmp(short version)
  { versionOfMxcmp_ = version; }
  inline void setIndexToCompilerArray(short index)
  { indexIntoCompilerArray_ = index; }
  inline short getIndexToCompilerArray()
    {
      return indexIntoCompilerArray_;
    }
  inline const char * getMxcmpNodeName() {return mxcmpNodeName_;}
  inline void setMxcmpNodeName( char *mxcmpNodeName)
    { mxcmpNodeName_ = mxcmpNodeName; }

  inline NABoolean sendSettingsToCompiler (const short index) const
    // Send controls if current compiler is the default compiler, or if caller asks
    // for the current compiler
    { return ( (indexIntoCompilerArray_ == 0) || (indexIntoCompilerArray_ == index) ); };

  // Methods to switch to different CmpContext
  Int32 switchToCmpContext(Int32 cmpCntxtType);
  Int32 switchToCmpContext(void *cmpCntxt);
  Int32 switchBackCmpContext(void);
  void copyDiagsAreaToPrevCmpContext();
  NABoolean isDropInProgress() { return dropInProgress_; }
  void setDropInProgress() { dropInProgress_ = TRUE; };

  // Method to acquire a reference to a UDR server associated with
  // a given set of JVM startup options
  ExUdrServer *acquireUdrServer(const char *runtimeOptions,
                                const char *optionDelimiters,
				NABoolean dedicated = FALSE);

  // Here are methods to manage the UDR runtime option strings that
  // can be set dynamically by the calling application. These strings
  // can only be set via an internal CLI function and catman is the
  // only caller of that function.
  const char *getUdrRuntimeOptions() const
  {
    return udrRuntimeOptions_;
  }
  const char *getUdrRuntimeOptionDelimiters() const
  {
    return udrRuntimeOptionDelimiters_;
  }
  Lng32 setUdrRuntimeOptions(const char *options, ULng32 optionsLen,
                            const char *delimiters, ULng32 delimsLen);

  ExTransaction * getTransaction()	{ return transaction_; }

  NABoolean &ddlStmtsExecuted() { return ddlStmtsExecuted_; }

  Lng32 setAuthID(
   const char * externalUsername,
   const char * databaseUsername,
   const char * authToken,
   Int32        authTokenLen,
   Int32        effectiveUserID,
   Int32        sessionUserID);
   
  void completeSetAuthID(
     Int32        userID,
     Int32        sessionUserID,
     const char  *logonUserName,
     const char  *authToken,
     Int32        authTokenLen,
     const char  *databaseUserName,
     bool         eraseCQDs,
     bool         recreateMXCMP,
     bool         releaseUDRServers,
     bool         dropVolatileSchema,
     bool         resetCQDs);
        
  char * getAuthID() 
  {
    if (authIDType_ == SQLAUTHID_TYPE_ASCII_USERROLE ||
        authIDType_ == SQLAUTHID_TYPE_ASCII_USERNAME )
      return authID_;
    else
      return NULL;
  }

  Lng32 boundsCheckMemory(void *startAddress, ULng32 length);

  inline SQLCTX_HANDLE getContextHandle() const {return contextHandle_;}

  void reset(void *contextMsg);

  void closeAllStatementsAndCursors(); // Close all statements

  void retrieveContextInfo(void *contextMsg);
  
  inline ULng32 getSqlParserFlags() const { return sqlParserFlags_; }
  inline void setSqlParserFlags(ULng32 flagbits)
                                        { sqlParserFlags_ |= flagbits; }
  inline void resetSqlParserFlags(ULng32 flagbits)
                                        { sqlParserFlags_ &= ~flagbits; }
  inline void assignSqlParserFlags(ULng32 flagbits) { sqlParserFlags_ = flagbits; }

  inline void semaphoreLock(){cancelSemaphore_.get();}
  inline void semaphoreRelease(){cancelSemaphore_.release();}

  void removeFromCloseStatementList(Statement *statement,
				    NABoolean forOpen);

  // Reclaim statements if it is available
  NABoolean reclaimStatements();

  // Dealocate statement space based on least recently used rule.
  NABoolean reclaimStatementSpace();

  // returns the current DEFINE context.
  unsigned short getCurrentDefineContext();

  unsigned short &defineContext() { return defineContext_;};

  // returns TRUE, if define context has changed.
  // Sets the current define context.
  NABoolean checkAndSetCurrentDefineContext();

  inline CliGlobals * getCliGlobals(void)
    { return cliGlobals_; } ;

  NABoolean statsCopy()      { return (flags_ & STATS_COPY_)    != 0; }
  void setStatsCopy(NABoolean v)      
  { (v ? flags_ |= STATS_COPY_ : flags_ &= ~STATS_COPY_); }

  NABoolean statsInSharedSegment()      { return (flags_ & STATS_IN_SHARED_SEGMENT_)    != 0; }
  void setStatsInSharedSegment(NABoolean v)      
  { (v ? flags_ |= STATS_IN_SHARED_SEGMENT_ : flags_ &= ~STATS_IN_SHARED_SEGMENT_); }

  inline Statement * pendingNoWaitPrepare() const
  { return pendingNoWaitPrepare_; }
  NABoolean inMemoryObjectDefn()
    { return (flags_ & IN_MEMORY_OBJECT_DEFN) != 0; }
  void setInMemoryObjectDefn(NABoolean v)
    { (v ? flags_ |= IN_MEMORY_OBJECT_DEFN : flags_ &= ~IN_MEMORY_OBJECT_DEFN); }
  

  inline void setPendingNoWaitPrepare(Statement *statement)
    { pendingNoWaitPrepare_ = statement; };

  inline void resetPendingNoWaitPrepare()
    { pendingNoWaitPrepare_ = NULL; };
  void logReclaimEvent(Lng32 freeSize, Lng32 totalSize);

  SessionDefaults * getSessionDefaults() { return sessionDefaults_; }
  HashQueue * getBDRConfigInfoList()     { return bdrConfigInfoList_; }
  void resetBDRConfigInfoList(); 

  AQRInfo * aqrInfo() { return (sessionDefaults_ 
				? sessionDefaults_->aqrInfo() : NULL); }

  void addToStatementWithEspsList(Statement *statement);
  void removeFromStatementWithEspsList(Statement *);
  bool unassignEsps(bool force = false);

  void beginSession(char * userSpecifiedSessionName);
  Lng32 reduceEsps();
  void endSession(NABoolean cleanupEsps = FALSE,	
                  NABoolean cleanupEspsOnly = FALSE,
		  NABoolean cleanupOpens = FALSE);
  void dropSession(NABoolean clearCmpCache = FALSE);
  void endMxcmpSession(NABoolean cleanupEsps, NABoolean clearCmpCache = FALSE);
  void resetAttributes();

  void createMxcmpSession();
  Int32 updateMxcmpSession();

  void resetVolatileSchemaState();

  void closeAllTables();

  char * getSessionId() { return sessionID_; }
  void   setSessionId(char * si);
  void   genSessionId();

  NABoolean sessionInUse()       { return sessionInUse_; }
  NABoolean mxcmpSessionInUse()  { return mxcmpSessionInUse_; }

  NABoolean volatileSchemaCreated() { return volatileSchemaCreated_;}
  void setVolatileSchemaCreated(NABoolean v)  
  { volatileSchemaCreated_ = v; }

  HashQueue * getVolTabList() { return volTabList_;}
  void initVolTabList();
  void resetVolTabList();

  void killIdleMxcmp();
  void killAndRecreateMxcmp();

#ifdef _DEBUG
public:
  void StmtListPrintf(const Statement *s, const char *formatString, ...) const;
#endif
  ExStatisticsArea *getMergedStats() 
  {
    return mergedStats_;
  }

  void setMergedStats(ExStatisticsArea *stats)
  {
    mergedStats_ = stats;
  }
  ExStatisticsArea *getMergedStats(
            /* IN */  	short statsReqType,
	    /* IN */  	char *statsReqStr,
	    /* IN */  	Lng32 statsReqStrLen,
	    /* IN */	short activeQueryNum,
	    /* IN */ 	short statsMergeType,
            /*IN/out */ short &retryAttempts);

  Lng32 GetStatistics2(
            /* IN */  	short statsReqType,
	    /* IN */  	char *statsReqStr,
	    /* IN */  	Lng32 statsReqStrLen,
	    /* IN */	short activeQueryNum,
	    /* IN */ 	short statsMergeType,
	    /* OUT */ 	short *statsCollectType,
	    /* IN/OUT */ 	SQLSTATS_DESC sqlstats_desc[],
	    /* IN */ 	Lng32 max_stats_desc,
	    /* OUT */	Lng32 *no_returned_stats_desc);
  StmtStats *getPrevStmtStats()
  {
    return prevStmtStats_;
  }

  void setPrevStmtStats(StmtStats *ss)
  {
    prevStmtStats_ = ss;
  }

  Lng32 setSecInvalidKeys( 
           /* IN */    Int32 numSiKeys,
           /* IN */    SQL_QIKEY siKeys[]);

  Lng32 holdAndSetCQD(const char * defaultName, const char * defaultValue);
  Lng32 restoreCQD(const char * defaultName);

  Lng32 setCS(const char * csName, char * csValue);
  Lng32 resetCS(const char * csName);
  inline IpcTimeout getEspReleaseTimeout() const
  { return espReleaseTimeout_; }

  // Private method to initialize the context's user identity based on
  // OS user identity. Should be called before any query processing
  // begins. This step requires a fully initialized CliGlobals so
  // should not be called before CliGlobals initialization completes.
  void initializeUserInfoFromOS();
  hdfsFS getHdfsServerConnection(char *hdfsServer, Int32 port);
  void disconnectHdfsConnections();
}; // class ContextCli

/* ContextTidMap - Maps contextCli to  a thread id
 * 1. Only one mapping entry is possible for a given thread id.
 * 2. A thread can work on only one ContextCli object at a time. 
 * 3. Multiple threads in the same process can work on the same ContextCli. 
 * `
*/

class ContextTidMap 
{
public:
   ContextTidMap(pid_t tid, ContextCli *context)
   {
     tid_ = tid;
     context_ = context;
   }
public:
   pid_t tid_;
   ContextCli *context_;
};


inline HashQueue *
ContextCli::getStatementList() const
{
  return statementList_;
}

inline HashQueue *
ContextCli::getCursorList() const
{
  return cursorList_;
}

inline HashQueue *
ContextCli::getOpenStatementList() const
{
  return openStatementList_;
}

struct hdfsConnectStruct
{
  hdfsFS hdfsHandle_;
  Int32 hdfsPort_;
  char  hdfsServer_[256]; // max length determined by dfs.namenode.fs-limits.max-component-length(255) 
};

#endif

Lng32 parse_statsReq(short statsReqType,char *statsReqPtr, Lng32 statsReqStrLen,
                     char *nodeName, short &cpu, pid_t &pid, Int64 &timeStamp,
                     Lng32 &queryNumber);