otlv4.h

Oracle template library,oracle数据库联接非常好用的工具

  {
    return len;
  }

  unsigned int get_all_mask() const
  {
    return all_mask;
  }

  short int get_col_type(int ndx) const
  {
    return col_type[ndx];
  }

  int get_col_size(int ndx) const
  {
    return col_size[ndx];
  }

  void setLen(const int alen)
  {
    len=alen;
  }

  bool get_lob_stream_mode() const
  {
    return lob_stream_mode;
  }

  void set_lob_stream_mode(const bool alobs_tream_mode)
  {
    lob_stream_mode=alobs_tream_mode;
  }

private:

  short int* col_ndx;
  short int* col_type;
  int* col_size;
  int len;
  
  unsigned int all_mask;
  bool lob_stream_mode;

  int container_size_;


// this class is not meant to be copied: copy constructor and
// operator= are declared private

  otl_select_struct_override(const otl_select_struct_override&):
    col_ndx(0),
    col_type(0),
    col_size(0),
    len(0),
    all_mask(0),
    lob_stream_mode(false),
    container_size_(0)
  {
  }

  otl_select_struct_override& operator=(const otl_select_struct_override&)
  {
    return *this;
  }

};

inline int otl_decimal_degree(unsigned int num)
{
  int n=0;
  while(num!=0){
    ++n;
    num/=10;
  }
  return n;
}

inline bool otl_isspace(char c)
{
  return c==' '||c=='\t'||c=='\n'||
         c=='\r'||c=='\f'||c=='\v';
}

inline char otl_to_upper(char c)
{
 return OTL_SCAST(char,toupper(c));
}

inline bool otl_str_case_insensitive_equal(const char* s1, const char* s2)
{
  while(*s1 && *s2){
    if(otl_to_upper(*s1)!=otl_to_upper(*s2))
      return false;
    ++s1;
    ++s2;
  }
  if(*s1==0 && *s2==0)
    return true;
  else
    return false;
}

inline unsigned int otl_to_fraction
(unsigned int fraction,int frac_prec)
{
  if(fraction==0||frac_prec==0)return fraction;
  int degree_diff=9-frac_prec;
  for(int i=0;i<degree_diff;++i)
    fraction*=10;
  return fraction;
}

inline unsigned int otl_from_fraction
(unsigned int fraction,int frac_prec)
{
  if(fraction==0||frac_prec==0)return fraction;
  int degree_diff=9-frac_prec;
  for(int i=0;i<degree_diff;++i)
    fraction/=10;
  return fraction;
}

#define OTL_NO_STM_TEXT "#No Stm Text available#"

class otl_datetime{
public:

  int year;
  int month;
  int day;
  int hour;
  int minute;
  int second;
  unsigned long fraction;
  int frac_precision;

#if defined(OTL_ORA_TIMESTAMP) || defined(OTL_ODBC_TIME_ZONE)
  short int tz_hour;
  short int tz_minute;
#endif

  otl_datetime():
    year(1900),
    month(1),
    day(1),
    hour(0),
    minute(0),
    second(0),
    fraction(0),
    frac_precision(0)
#if defined(OTL_ORA_TIMESTAMP) || defined(OTL_ODBC_TIME_ZONE)
    ,tz_hour(0),
    tz_minute(0)
#endif
 {
 }

 otl_datetime
 (const int ayear,
  const int amonth,
  const int aday,
  const int ahour,
  const int aminute,
  const int asecond,
  const unsigned long afraction=0,
  const int afrac_precision=0
#if defined(OTL_ORA_TIMESTAMP)||defined(OTL_ODBC_TIME_ZONE)
  , 
  const short int atz_hour=0,
  const short int atz_minute=0
#endif
   ):
   year(ayear),
   month(amonth),
   day(aday),
   hour(ahour),
   minute(aminute),
   second(asecond),
   fraction(afraction),
   frac_precision(afrac_precision)
#if defined(OTL_ORA_TIMESTAMP)||defined(OTL_ODBC_TIME_ZONE)
   ,tz_hour(atz_hour),
   tz_minute(atz_minute)
#endif
 {
 }

  otl_datetime(const otl_datetime& dt):
    year(dt.year),
    month(dt.month),
    day(dt.day),
    hour(dt.hour),
    minute(dt.minute),
    second(dt.second),
    fraction(dt.fraction),
    frac_precision(dt.frac_precision)
#if defined(OTL_ORA_TIMESTAMP)||defined(OTL_ODBC_TIME_ZONE)
    ,tz_hour(dt.tz_hour),
    tz_minute(dt.tz_minute)
#endif
 {
 }

 ~otl_datetime(){}

 otl_datetime& operator=(const otl_datetime& dt)
 {
   copy(dt);
   return *this;
 }

private:

  void copy(const otl_datetime& dt)
  {
    year=dt.year;
    month=dt.month;
    day=dt.day;
    hour=dt.hour;
    minute=dt.minute;
    second=dt.second;
    fraction=dt.fraction;
    frac_precision=dt.frac_precision;
#if defined(OTL_ORA_TIMESTAMP)||defined(OTL_ODBC_TIME_ZONE)
    tz_hour=dt.tz_hour;
    tz_minute=dt.tz_minute;
#endif
  }

};

struct otl_oracle_date{

 unsigned char century;
 unsigned char year;
 unsigned char month;
 unsigned char day;
 unsigned char hour;
 unsigned char minute;
 unsigned char second;

  otl_oracle_date():
    century(0),
    year(0),
    month(0),
    day(0),
    hour(0),
    minute(0),
    second(0)
  {
  }

 ~otl_oracle_date(){}

};

inline void convert_date(otl_datetime& t,const otl_oracle_date& s)
{
 t.year=(OTL_SCAST(int, s.century-100)*100+(OTL_SCAST(int, s.year-100)));
 t.month=s.month;
 t.day=s.day;
 t.hour=s.hour-1;
 t.minute=s.minute-1;
 t.second=s.second-1;
}

inline void convert_date(otl_oracle_date& t,const otl_datetime& s)
{
 t.year=OTL_SCAST(unsigned char, ((s.year%100)+100));
 t.century=OTL_SCAST(unsigned char, ((s.year/100)+100));
 t.month=OTL_SCAST(unsigned char, s.month);
 t.day=OTL_SCAST(unsigned char, s.day);
 t.hour=OTL_SCAST(unsigned char, (s.hour+1));
 t.minute=OTL_SCAST(unsigned char, (s.minute+1));
 t.second=OTL_SCAST(unsigned char, (s.second+1));
}

class otl_null{
public:

 otl_null(){}
 ~otl_null(){}

private:

#if (defined(_MSC_VER)&&(_MSC_VER==1200))
 int dummy; // this is to fix a compiler bug in VC++ 6.0
#endif

};

class otl_column_desc{
public:

  char* name;
  int  dbtype;
  int  otl_var_dbtype;
#if defined(_WIN64)
  __int64 dbsize;
#else
  int  dbsize;
#endif
  int  scale;
#if defined(_WIN64)
  __int64 prec;
#else
  int  prec;
#endif
  int  nullok;
#if defined(OTL_ORA_UNICODE)||defined(OTL_ORA_UTF8)
  int charset_form;
  int char_size;
#endif

  otl_column_desc():
    name(0),
    dbtype(0),
    otl_var_dbtype(0),
    dbsize(0),
    scale(0),
    prec(0),
    nullok(0),
#if defined(OTL_ORA_UNICODE)||defined(OTL_ORA_UTF8)
    charset_form(0),
    char_size(0),
#endif
    name_len_(0)
  {
  }

  ~otl_column_desc()
  {
    delete[] name;
  }

  otl_column_desc& operator=(const otl_column_desc& desc)
  {
    if(name_len_>=desc.name_len_)
      OTL_STRCPY_S(name,name_len_,desc.name);
    else if(name==0 && desc.name!=0){
      name=new char[desc.name_len_];
      name_len_=desc.name_len_;
      OTL_STRCPY_S(name,name_len_,desc.name);
    }else if(name_len_<desc.name_len_ && desc.name!=0){
      delete[] name;
      name=new char[desc.name_len_];
      name_len_=desc.name_len_;
      OTL_STRCPY_S(name,name_len_,desc.name);
    }
    dbtype=desc.dbtype;
    otl_var_dbtype=desc.otl_var_dbtype;
    dbsize=desc.dbsize;
    scale=desc.scale;
    prec=desc.prec;
    nullok=desc.nullok;
#if defined(OTL_ORA_UNICODE)||defined(OTL_ORA_UTF8)
    charset_form=desc.charset_form;
    char_size=desc.char_size;
#endif

    return *this;
  }

  void set_name(const char* aname,const int aname_len=0)
  {
    int len;
    if(aname_len==0)
      len=OTL_SCAST(int,strlen(aname))+1;
    else
      len=aname_len+1;
    if(name_len_<len){
      if(name)delete[] name;
      name=new char[len];
      name_len_=len;
      for(int i=0;i<len-1;++i)
        name[i]=aname[i];
      name[len-1]=0;
    }
  }

private:

  int name_len_;

  otl_column_desc(const otl_column_desc&):
    name(0),
    dbtype(0),
    otl_var_dbtype(0),
    dbsize(0),
    scale(0),
    prec(0),
    nullok(0),
#if defined(OTL_ORA_UNICODE)||defined(OTL_ORA_UTF8)
    charset_form(0),
    char_size(0),
#endif
    name_len_(0)
  {
  }

};

class otl_var_desc{
public:

  int  param_type;
  int  ftype;
  int  elem_size;
  int  array_size;
  int  pos;
  int  name_pos;
  char name[128];
  int  pl_tab_flag;

  otl_var_desc():
    param_type(0),
    ftype(0),
    elem_size(0),
    array_size(0),
    pos(0),
    name_pos(0),
    name(),
    pl_tab_flag(0)
 {
   name[0]=0;
 }

 ~otl_var_desc(){}

 void copy_name(const char* nm)
 {
  if(!nm)
   name[0]=0;
  else{
#if defined(_MSC_VER)
#if (_MSC_VER >= 1400)
   OTL_STRNCPY_S(name,sizeof(name),nm,sizeof(name)-1);
   name[sizeof(name)-1]=0;
#else
   strncpy(name,nm,sizeof(name));
   name[sizeof(name)-1]=0;
#endif
#else
   strncpy(name,nm,sizeof(name));