ocilob.cpp

一个通用的oracle OCI开发程序包

#ifndef _COCILob
#include "ocilob.h"
#endif

#ifndef _COCISession
#include "ocisess.h"
#endif

#ifndef _COCIBinary
#include "ocibin.h"
#endif


COCILob::COCILob(const COCISession& Sess, ub4 type)
: m_Session(Sess)
, m_pLobLocator(0)
, m_read_offset(1)
, m_write_offset(1)
, m_ctxp((dvoid*)0)
, m_cbfpRead(NULL)
, m_cbfpWrite(NULL)
, m_csid(0)
, m_csfrm(SQLCS_IMPLICIT)
, m_type(type)
{
  CHECK(m_Session.get_error(), OCIDescriptorAlloc(m_Session.get_env(), (void**)&m_pLobLocator, type, 
                                               (size_t)0, (dvoid**)0));

  m_Indicator = OCI_IND_NOTNULL;
}

COCILob::~COCILob()
{
  CHECK(m_Session.get_error(), OCIDescriptorFree( m_pLobLocator, m_type ));
}

COCILob::COCILob(const COCISession& Sess, dvoid* instance)
: m_Session(Sess)
, m_pLobLocator(0)
, m_read_offset(1)
, m_write_offset(1)
, m_ctxp((dvoid*)0)
, m_cbfpRead(NULL)
, m_cbfpWrite(NULL)
, m_csid(0)
, m_csfrm(SQLCS_IMPLICIT)
, m_type(OCI_DTYPE_LOB)
{
  CHECK(m_Session.get_error(), OCIDescriptorAlloc(m_Session.get_env(), (void**)&m_pLobLocator, m_type, 
                                               (size_t)0, (dvoid**)0));

  CHECK(m_Session.get_error(), OCILobAssign(m_Session.get_env(), 
                                            m_Session.get_error(), 
                                            (OCILobLocator*)instance, 
                                            (OCILobLocator**)&m_pLobLocator));

  m_Indicator = OCI_IND_NOTNULL;

  //m_pLobLocator = (OCILobLocator*)instance;
}

COCILob::COCILob(const COCILob& src)
: m_Session(src.m_Session)
, m_type(src.m_type)
{
  assign(src);
}

void COCILob::append(const COCILob& src)
{
  CHECK(m_Session.get_error(), OCILobAppend(m_Session.get_svc(), 
                                              m_Session.get_error(), 
                                              m_pLobLocator, 
                                              ((COCILob&)src).get_locator()));
}

void COCILob::assign(const COCILob& src)
{
  CHECK(m_Session.get_error(), OCILobAssign(m_Session.get_env(), 
                                              m_Session.get_error(), 
                                              ((COCILob&)src).get_locator(), 
                                              (OCILobLocator**)&m_pLobLocator));
}

void COCILob::copy(const COCILob& src, ub4 amount, ub4 dst_offset, ub4 src_offset)
{
  CHECK(m_Session.get_error(), OCILobCopy(m_Session.get_svc(), 
                                            m_Session.get_error(), 
                                            m_pLobLocator, 
                                            ((COCILob&)src).get_locator(), 
                                            amount, 
                                            dst_offset, 
                                            src_offset));
}

void COCILob::set_buffering(bool buffer)
{
  if(buffer)
  {
    CHECK(m_Session.get_error(), OCILobEnableBuffering(m_Session.get_svc(),
                                                         m_Session.get_error(),
                                                         m_pLobLocator));
  }
  else
  {
    CHECK(m_Session.get_error(), OCILobDisableBuffering(m_Session.get_svc(),
                                                          m_Session.get_error(),
                                                          m_pLobLocator));
  }
}

ub4 COCILob::erase(ub4 amount, ub4 offset)
{
  ub4 amnt = amount;
  CHECK(m_Session.get_error(), OCILobErase(m_Session.get_svc(),
                                             m_Session.get_error(),
                                             m_pLobLocator,
                                             &amnt,
                                             offset));
  return amnt;
}

void COCILob::flush_buffer(ub4 flag)
{
  CHECK(m_Session.get_error(), OCILobFlushBuffer(m_Session.get_svc(),
                                                   m_Session.get_error(),
                                                   m_pLobLocator,
                                                   flag));
}


ub4 COCILob::get_length(void)
{
  ub4 len;
  CHECK(m_Session.get_error(), OCILobGetLength( m_Session.get_svc(),
                                             m_Session.get_error(),
                                             (OCILobLocator*)m_pLobLocator,
                                             &len));

  return len;
}

bool COCILob::is_equal(const COCILob& src)
{
  boolean is_equal = false; 
  CHECK(m_Session.get_error(), OCILobIsEqual(m_Session.get_env(), 
                                               m_pLobLocator,
                                               ((COCILob&)src).get_locator(),
                                               &is_equal));
  return is_equal;
}

void COCILob::load_from_file(const COCIFile& src, ub4 amount, ub4 dst_offset, ub4 src_offset)
{
  CHECK(m_Session.get_error(), OCILobLoadFromFile(m_Session.get_svc(), 
                                                    m_Session.get_error(),
                                                    m_pLobLocator,
                                                    ((COCILob&)src).get_locator(),
                                                    amount,
                                                    dst_offset,
                                                    src_offset));
}

bool COCILob::is_init(void)
{
  boolean is_initialised = false;
  CHECK(m_Session.get_error(), OCILobLocatorIsInit(m_Session.get_env(),
                                                     m_Session.get_error(),
                                                     m_pLobLocator,
                                                     &is_initialised));
  return is_initialised;
}

ub4 COCILob::read(ub4* bufp, ub4 amount)
{
  ub4 amnt = amount;
  CHECK(m_Session.get_error(), OCILobRead(m_Session.get_svc(),
                                            m_Session.get_error(),
                                            m_pLobLocator,
                                            &amnt,
                                            m_read_offset,
                                            bufp,
                                            amnt,
                                            m_ctxp,
                                            m_cbfpRead,
                                            m_csid,
                                            m_csfrm));
  return amnt;
}

void COCILob::trim(ub4 newlen)
{
  CHECK(m_Session.get_error(), OCILobTrim(m_Session.get_svc(),
                                            m_Session.get_error(),
                                            m_pLobLocator,
                                            newlen));
}

ub4 COCILob::write(ub4* buffer, ub4 amount)
{
  ub4 amnt = amount;
  CHECK(m_Session.get_error(), OCILobWrite(m_Session.get_svc(), 
                                             m_Session.get_error(), 
                                             (OCILobLocator*)m_pLobLocator, 
                                             &amnt, 
                                             (ub4) m_write_offset, 
                                             (dvoid*)buffer, 
                                             amnt, 
                                             OCI_ONE_PIECE,
                                             m_ctxp, 
                                             m_cbfpWrite, 
                                             (ub2) m_csid, 
                                             (ub1) m_csfrm));
  return amnt;
}

void COCILob::make_empty(void)
{
  ub4 lobEmpty = 0;

  CHECK(m_Session.get_error(), OCIAttrSet( (OCILobLocator*)m_pLobLocator, 
                      OCI_DTYPE_LOB, 
                      (ub4*)&lobEmpty, 
                      sizeof(ub4),
                      OCI_ATTR_LOBEMPTY, 
                      m_Session.get_error()));

}

COCILob& operator<<(COCILob& lob, COCIBinary& data)
{
  ub4 amnt = lob.write((ub4*)data.begin(), data.length());
  lob.set_write_offset(lob.get_write_offset() + amnt);
  return lob;
}

COCILob& operator >> (COCILob& lob, COCIBinary& data)
{
  ub4 amnt = lob.read((ub4*)data.begin(), data.length());
  lob.set_read_offset(lob.get_read_offset() + amnt);
  return lob;
}

COCILob& COCILob::operator = (const COCILob& src)
{
  assign(src);
  return *this;
}


COCICLob::COCICLob(const COCISession& Sess)
: COCILob(Sess,OCI_DTYPE_LOB)
{
  m_DataType = SQLT_CLOB;
}

COCICLob::COCICLob(const COCISession& Sess, dvoid* instance)
: COCILob(Sess,instance)
{
  m_DataType = SQLT_CLOB;
}

COCICLob::COCICLob(const COCICLob& src)
: COCILob(src)
{
}


COCICLob::~COCICLob()
{
}

ub1 COCICLob::get_char_set_form(void)
{
  ub1 csfrm = 0;
  CHECK(m_Session.get_error(), OCILobCharSetForm(m_Session.get_env(),
                                                   m_Session.get_error(),
                                                   m_pLobLocator,
                                                   &csfrm));
  return csfrm;
}

ub2 COCICLob::get_char_set_id(void)
{
  ub2 csid = 0;
  CHECK(m_Session.get_error(), OCILobCharSetId(m_Session.get_env(),
                                                 m_Session.get_error(),
                                                 m_pLobLocator,
                                                 &csid));
  return csid;
}

COCICLob& COCICLob::operator = (const COCICLob& src)
{
  assign(src);
  return *this;
}

COCICLob& operator<<(COCICLob& lob, char* data)
{
  ub4 amnt = lob.write((ub4*)data, strlen(data));
  lob.set_write_offset(lob.get_write_offset() + amnt);
  return lob;
}


COCICLob& operator >> (COCICLob& lob, char* data)
{
  ub4 amnt = lob.read((ub4*)data, strlen(data));
  lob.set_read_offset(lob.get_read_offset() + amnt);
  return lob;
} 



COCIBLob::COCIBLob(const COCISession& Sess)
: COCILob(Sess, OCI_DTYPE_LOB)
{
  m_DataType = SQLT_BLOB;
}

COCIBLob::COCIBLob(const COCISession& Sess, dvoid* instance)
: COCILob(Sess, instance)
{
  m_DataType = SQLT_BLOB;
}

COCIBLob::COCIBLob(const COCIBLob& src)
: COCILob(src)
{
}

COCIBLob::~COCIBLob()
{
}

COCIBLob& COCIBLob::operator = (const COCIBLob& src)
{
  assign(src);
  return *this;
}


COCIFile::COCIFile(const COCISession& Sess)
: COCILob(Sess, OCI_DTYPE_FILE)
{
}

COCIFile::COCIFile(const COCISession& Sess, dvoid* instance)
: COCILob(Sess, instance)
{
}

COCIFile::COCIFile(const COCIFile& src)
: COCILob(src)
{
}


COCIFile::~COCIFile()
{
}

void COCIFile::close(void)
{
  CHECK(m_Session.get_error(), OCILobFileClose(m_Session.get_svc(),
                                                 m_Session.get_error(),
                                                 m_pLobLocator));
}

void COCIFile::close_all(void)
{
  CHECK(m_Session.get_error(), OCILobFileCloseAll(m_Session.get_svc(),
                                                    m_Session.get_error()));
}


bool COCIFile::exists(void)
{
  boolean flag = false;
  CHECK(m_Session.get_error(), OCILobFileExists(m_Session.get_svc(),
                                                  m_Session.get_error(),
                                                  m_pLobLocator,
                                                  &flag));
  return flag;
}

void COCIFile::get_name(void)
{
  ub2 d_length = strlen((char*)m_dir_alias);
  ub2 f_length = strlen((char*)m_filename);
  CHECK(m_Session.get_error(), OCILobFileGetName(m_Session.get_env(),
                                                   m_Session.get_error(),
                                                   m_pLobLocator,
                                                   (text*)m_dir_alias,
                                                   &d_length,
                                                   (text*)m_filename,
                                                   &f_length));
}

bool COCIFile::is_open(void)
{
  boolean flag = false;
  CHECK(m_Session.get_error(), OCILobFileIsOpen(m_Session.get_svc(),
                                                  m_Session.get_error(),
                                                  m_pLobLocator,
                                                  &flag));
  return flag;
}

void COCIFile::open(ub1 mode)
{
  CHECK(m_Session.get_error(), OCILobFileOpen(m_Session.get_svc(),
                                                m_Session.get_error(),
                                                m_pLobLocator,
                                                mode));
}


void COCIFile::set_name(char* dir_alias, char* filename)
{
  strcpy((char*)m_dir_alias, (char*)dir_alias);
  strcpy((char*)m_filename, (char*)filename);
  CHECK(m_Session.get_error(), OCILobFileSetName(m_Session.get_env(),
                                                   m_Session.get_error(),
                                                   (OCILobLocator**)&m_pLobLocator,
                                                   (text*)m_dir_alias,
                                                   strlen((char*)m_dir_alias),
                                                   (text*)m_filename,
                                                   strlen((char*)m_filename)));
}

COCIFile& COCIFile::operator = (const COCIFile& src)
{
  assign(src);
  return *this;
}


COCICFile::COCICFile(const COCISession& Sess)
: COCIFile(Sess)
{
  m_DataType = SQLT_CFILEE;
}


COCICFile::COCICFile(const COCISession& Sess, dvoid* instance)
: COCIFile(Sess, instance)
{
  m_DataType = SQLT_CFILEE;
}

COCICFile::COCICFile(const COCICFile& src)
: COCIFile(src)
{
}


COCICFile::~COCICFile()
{
}

COCICFile& COCICFile::operator = (const COCICFile& src)
{
  assign(src);
  return *this;
}


COCIBFile::COCIBFile(const COCISession& Sess)
: COCIFile(Sess)
{
  m_DataType = SQLT_BFILEE;
}

COCIBFile::COCIBFile(const COCISession& Sess, dvoid* instance)
: COCIFile(Sess, instance)
{
  m_DataType = SQLT_BFILEE;
}

COCIBFile::COCIBFile(const COCIBFile& src)
: COCIFile(src)
{
}


COCIBFile::~COCIBFile()
{
}

COCIBFile& COCIBFile::operator = (const COCIBFile& src)
{
  assign(src);
  return *this;
}