SQLDBC_IRuntime.h

Go to the documentation of this file.

#line 1 "C:\\SAPDevelop\\DEV\\develop\\sys\\src\\SAPDB\\Interfaces\\SQLDBC\\SQLDBC_IRuntime.h"

#ifndef SQLDBC_IRUNTIME_H
#define SQLDBC_IRUNTIME_H

#include <string.h>

#ifdef SQLDBC_FOR_KERNEL
#  define IFR_NAMESPACE SQLDBC_Kernel
#  define SQLDBC SQLDBC_Kernel
#  define SQLDBC_RUNTIME_IN_NAMESPACE
#elif defined(SQLDBC_FOR_LOADER)
#  define IFR_NAMESPACE SQLDBC_Loader
#endif

// For encoding
#include "Interfaces/SQLDBC/SQLDBC_Types.h"
#include "SAPDBCommon/SAPDB_Types.h"
#include "SAPDB/SAPDBCommon/MemoryManagement/SAPDBMem_IRawAllocator.hpp"
#include "SAPDB/Interfaces/SQLDBC/SQLDBC_Internals.h"

#ifdef IFR_NAMESPACE
namespace IFR_NAMESPACE {
class IFR_Environment;
class IFR_ParseInfoCacheImpl;
class IFR_ParseInfoCache;
};
using namespace IFR_NAMESPACE;
#else
class IFR_Environment;
class IFR_ParseInfoCacheImpl;
class IFR_ParseInfoCache;
#endif

namespace SQLDBC {
    class SQLDBC_Connection;
}
using namespace SQLDBC;

#ifdef SQLDBC_RUNTIME_IN_NAMESPACE
namespace SQLDBC {
#endif

class SQLDBC_IRuntime
{
public:

    struct Error
    {
        inline Error()
        :errorcode(0)
        {
            errortext[0]='\0';
        }

        inline operator SAPDB_Bool () const { return errorcode != 0; }

        SAPDB_Int4 errorcode;     
        char       errortext[80]; 
    };
    
    typedef void *MutexHandle;

    typedef void *SemaphoreHandle;

    typedef void *CounterHandle;

    struct TaskTraceContext
    {
        void           *currentEntry;   
        // -- further settings, used by the trace stream abstraction.
        SAPDB_Bool  hex;               
        SAPDB_UInt4 inputlength;       
        SQLDBC_StringEncoding encoding;
        SAPDB_UInt4 indent;            
        SAPDB_UInt4 flags;             
        SAPDB_UInt4 traceableLimit;    
        SAPDB_UInt4 pos;               
    };
        
    typedef SAPDB_UInt4 TaskID;

    virtual ~SQLDBC_IRuntime() {}

    virtual const char *getIdentifier() const { return ""; }

    virtual SAPDB_Bool checkKeyOption(const char *keyoption,
                                      char *servernode,
                                      SAPDB_Int4& servernodelength,
                                      char *serverdb,
                                      SAPDB_Int4& serverdblength,
                                      SAPDB_Int4& isolationlevel,
                                      SAPDB_Int4& cachelimit,
                                      SAPDB_Int4& sqlmode,
                                      SAPDB_Int4& timeout,
                                      char *username,
                                      SAPDB_Int4& usernamelength,
                                      SQLDBC_StringEncoding& usernameEncoding,
                                      SQLDBC_IRuntime::Error& error)
    {
        return false;
    }
                                  

    
    virtual SAPDBMem_IRawAllocator& getGlobalAllocator() = 0;

    // Packet and Session Handling

    virtual SAPDB_Bool getSession(const char *connectUrl,
                                  const char *connectCommand,
                                  const char *password,
                                  SAPDB_Int4  passwordLength,
                                  const SQLDBC_StringEncoding commandEncoding,
                                  SAPDB_Int8&  sessionID,
                                  SAPDB_UInt4& packetSize,
                                  SAPDB_Int4& packetListSize,
                                  void **packetList,  
                                  void **sessionInfoReply,
                                  SQLDBC_IRuntime::Error& error,
                                  SAPDBMem_IRawAllocator* allocator = 0) = 0;


    virtual SAPDB_Bool getSession(const char *connectUrl,
                                  const char *connectCommand,
                                  const char *username,
                                  SAPDB_Int4  usernamelength,
                                  const char *password,
                                  SAPDB_Int4  passwordLength,
                                  const SQLDBC_StringEncoding commandEncoding,
                                  SAPDB_Int8&  sessionID,
                                  SAPDB_UInt4& packetSize,
                                  SAPDB_Int4& packetListSize,
                                  void **packetList,  
                                  void **sessionInfoReply,
                                  SQLDBC_IRuntime::Error& error,
                                  SAPDBMem_IRawAllocator* allocator = 0) = 0;

    virtual SAPDB_Bool releaseSession(SAPDB_Int8 sessionID,
                                      SQLDBC_IRuntime::Error& error) = 0;
    
    virtual SAPDB_Bool request(SAPDB_Int8  sessionID,
                               void       *requestData,
                               SAPDB_UInt4 requestDataLength,
                               SQLDBC_IRuntime::Error& error) = 0; 

    virtual SAPDB_Bool receive(SAPDB_Int8 sessionID,
                               void **replyData,
                               SAPDB_Int4& replyDataLength,
                               SQLDBC_IRuntime::Error& error) = 0;

    virtual SAPDB_Bool isReplyAvailable(SAPDB_Int8 sessionID)
    {
        return true;
    }
    
    virtual SAPDB_Bool cancelCurrentCommand(SAPDB_Int8 sessionID,
                                            SQLDBC_IRuntime::Error& error) = 0;

    // -- synchronization primitives
    virtual SQLDBC_Spinlock* createSpinlock(SAPDBMem_IRawAllocator& allocator)  = 0;

    virtual SAPDB_Bool releaseSpinlock(SAPDBMem_IRawAllocator& allocator, SQLDBC_Spinlock* lock) = 0;

    virtual SAPDB_Bool createMutex(MutexHandle& mutexHandle, 
                                   SAPDBMem_IRawAllocator& allocator,
                                   SQLDBC_IRuntime::Error& error)  = 0;

    virtual SAPDB_Bool lockMutex(MutexHandle mutexHandle) = 0;
    
    virtual SAPDB_Bool releaseMutex(MutexHandle mutexHandle) = 0;
    
    virtual SAPDB_Bool destroyMutex(MutexHandle& mutexHandle, 
                                    SAPDBMem_IRawAllocator& allocator,
                                    SQLDBC_IRuntime::Error& error) = 0;
    
    virtual SAPDB_Bool  createCounter(CounterHandle& counterHandle,
                                      SAPDBMem_IRawAllocator& allocator,
                                      SQLDBC_IRuntime::Error& error)  = 0;

    
    virtual SAPDB_UInt4 nextCounter(CounterHandle counterHandle) = 0;
    
    virtual SAPDB_Bool  destroyCounter(CounterHandle counterHandle,
                                      SAPDBMem_IRawAllocator& allocator,
                                      SQLDBC_IRuntime::Error& error)  = 0;
           
    virtual TaskID getCurrentTaskID() = 0;                                      
                                      
    virtual SAPDB_Bool createSemaphore(SemaphoreHandle& semaphoreHandle,
                                       SAPDB_Int4 initialValue,
                                       SAPDBMem_IRawAllocator& allocator,
                                       SQLDBC_IRuntime::Error& error) = 0;

    virtual SAPDB_Bool waitSemaphore(SemaphoreHandle semaphoreHandle) =0;

    virtual SAPDB_Bool signalSemaphore(SemaphoreHandle semaphoreHandle) =0;
    
    virtual SAPDB_Bool destroySemaphore(SemaphoreHandle& semaphoreHandle,
                                        SAPDBMem_IRawAllocator& allocator,
                                        SQLDBC_IRuntime::Error& error)  = 0;
    
    // -- Tracing    
    virtual TaskTraceContext* getTaskTraceContext() = 0;
    
    virtual void write(const char *s, SAPDB_Int4 size) = 0;
    
    virtual void writeln(const char *s, SAPDB_Int4 size) = 0;
    
    virtual void updateTraceFlags(SAPDB_Bool& traceEnabled) {
        TaskTraceContext *ctx = getTaskTraceContext();
        if(ctx) {
            if(ctx->flags) {
                traceEnabled = true;
                return;
            }
        } 
        traceEnabled = false;
        return;
    }

    virtual SAPDB_Bool traceError(SAPDB_Int4 errorcode) { return false; }

    //-- internally for client runtime used, no use in Kernel/OMS/...
    
    virtual void setTraceOptions(const char *optionstring) 
    { 
        return; 
    }
    
    virtual SAPDB_Int4 getTraceOptions(char *options, SAPDB_Int4 optionslength) 
    { 
        if(options && optionslength>0) {
            *options = '\0';
        }
        return 0; 
    }

    virtual void addTraceFlags(unsigned int flags) = 0;

    virtual void removeTraceFlags(unsigned int flags) = 0;

    virtual unsigned int getTraceFlags()
    {
        return 0;
    }


    virtual SAPDB_Bool getSessionInformation(SQLDBC_Connection *connection,
                                             SAPDB_Int8& sessionID,
                                             SAPDB_UInt4& packetSize,
                                             SAPDB_UInt4& pagesSize,
                                             SAPDB_Int4&  packetListSize,
                                             void **packetList,
                                             char *usergroup,
                                             char *sysdba,
                                             SQLDBC_StringEncoding& userencoding)
    {
        return false;
    }
    

protected:
    struct EnvironmentList
    {
        EnvironmentList   *next;
        EnvironmentList   *prev;
        SQLDBC_Spinlock *spinlock;
    };
    
    struct Profile
    {
        SQLDBC_UInt8      counter[SQLDBC_PROFILE_MAX];
        void             *environmentlist;  // SUN cannot use pointer to EnvironmentList list here 
                                            // (compiler bug)
    };

    SQLDBC_IRuntime (SQLDBC_Spinlock* lock)
    {
        m_environmentlist.next = &m_environmentlist;
        m_environmentlist.prev = &m_environmentlist;
        m_environmentlist.spinlock = lock;
        
        memset(m_profile.counter, 0, sizeof(m_profile.counter));
        m_profile.environmentlist = &m_environmentlist;
    }
    
    EnvironmentList m_environmentlist;
    Profile         m_profile;
    
private:
#if defined(IFR_NAMESPACE)
    friend class ::IFR_NAMESPACE::IFR_Environment;
    friend class ::IFR_NAMESPACE::IFR_ParseInfoCacheImpl;
    friend class ::IFR_NAMESPACE::IFR_ParseInfoCache;
#else
    friend class IFR_Environment;
    friend class IFR_ParseInfoCacheImpl;
    friend class IFR_ParseInfoCache;
#endif
};

#ifdef SQLDBC_RUNTIME_IN_NAMESPACE
};
#endif

#endif