datahandler.cpp

絲路server源碼 Silk Road server source

    case SQL_C_CHAR:
      if(!isStreamed_) {
        return Time((ODBCXX_CHAR_TYPE*)this->data());
      }

    default:
      UNSUPPORTED_GET(ODBCXX_STRING_CONST("a Time"));
    }
  }

  return Time();
}

Timestamp DataHandler::getTimestamp() const
{
  if(!this->isNull()) {
    switch(cType_) {
    case C_TIMESTAMP:
      {
        TimestampStruct* ts=(TimestampStruct*)this->data();
        return Timestamp(ts->year,ts->month,ts->day,
                         ts->hour,ts->minute,ts->second,ts->fraction);
      }

    case C_DATE:
      {
        DateStruct* ds=(DateStruct*)this->data();
        return Timestamp(ds->year,ds->month,ds->day,
                         0,0,0);
      }

    case C_TIME:
      {
        TimeStruct* ts=(TimeStruct*)this->data();
        return Timestamp(0,0,0,ts->hour,ts->minute,ts->second);
      }

    case SQL_C_CHAR:
      if(!isStreamed_) {
        return Timestamp((ODBCXX_CHAR_TYPE*)this->data());
      }

    default:
      UNSUPPORTED_GET(ODBCXX_STRING_CONST("a Timestamp"));
    }
  }

  return Timestamp();
}


ODBCXX_STRING DataHandler::getString() const
{
  if(!this->isNull()) {
    switch(cType_) {
#if defined(ODBCXX_HAVE_SQLUCODE_H)
    case SQL_C_TCHAR:
#else
    case SQL_C_CHAR:
#endif
      if(!isStreamed_) {
        switch(this->getDataStatus()) {
           case SQL_NTS:
             return ODBCXX_STRING_C((ODBCXX_CHAR_TYPE*)this->data());
           case SQL_NO_TOTAL:
             return ODBCXX_STRING_CL((ODBCXX_CHAR_TYPE*)this->data(),
                                     bufferSize_/sizeof(ODBCXX_CHAR_TYPE));
           default:
             return ODBCXX_STRING_CL((ODBCXX_CHAR_TYPE*)this->data(),
                                     this->getDataStatus()/sizeof(ODBCXX_CHAR_TYPE));
        }
      } else {
        throw SQLException(ODBCXX_STRING_CONST("[libodbc++]: NYI: Getting a stream as a string"));
      }

    case C_DATE:
      return this->getDate().toString();

    case C_TIME:
      return this->getTime().toString();

    case C_TIMESTAMP:
      return this->getTimestamp().toString();

    case SQL_C_BIT:
    case SQL_C_TINYINT:
    case SQL_C_SHORT:
    case SQL_C_LONG:
      return intToString(this->getInt());

#if ODBCVER >= 0x0300
    case SQL_C_SBIGINT:
      return longToString(this->getLong());
#endif

    case SQL_C_FLOAT:
    case SQL_C_DOUBLE:
      return doubleToString(this->getDouble());

    default:
      UNSUPPORTED_GET(ODBCXX_STRING_CONST("a string"));
    }
  }

  return ODBCXX_STRING(ODBCXX_STRING_CONST(""));
}


ODBCXX_BYTES DataHandler::getBytes() const
{
  if(!this->isNull()) {
    switch(cType_) {
    case SQL_C_CHAR:
    case SQL_C_BINARY:
#if defined(ODBCXX_HAVE_SQLUCODE_H) && defined(ODBCXX_UNICODE)
    case SQL_C_WCHAR :
#endif
      if(!isStreamed_) {
        return ODBCXX_BYTES_C(this->data(),this->getDataStatus());
      }

    default:
      UNSUPPORTED_GET(ODBCXX_STRING_CONST("a Bytes"));
    }
  }

  return ODBCXX_BYTES_C(NULL,0);
}


ODBCXX_STREAM* DataHandler::getStream() const
{
  // in here, we can't trust this->isNull(), since
  // this probably isn't bound.
  switch(cType_) {
  case SQL_C_BINARY:
  case SQL_C_CHAR:
#if defined(ODBCXX_HAVE_SQLUCODE_H) && defined(ODBCXX_UNICODE)
  case SQL_C_WCHAR:
#endif
    if(isStreamed_) {
      return stream_;
    }

  default:
    UNSUPPORTED_GET(ODBCXX_STRING_CONST("a stream"));
  }

  // notreached
  assert(false);
  ODBCXX_DUMMY_RETURN(NULL);
}

#define SET_TO(type,val)                        \
*(type*)this->data()=(type)val;                        \
this->setDataStatus(sizeof(type))


#define ACCEPT_SET_VAL(id,type,val)                \
case id: SET_TO(type,val); break

#define ACCEPT_SET(id,type) ACCEPT_SET_VAL(id,type,val)

void DataHandler::setBoolean(bool b)
{
  this->setInt(b?1:0);
}

void DataHandler::setByte(signed char b)
{
  this->setInt(b);
}

void DataHandler::setShort(short s)
{
  this->setInt(s);
}

void DataHandler::setInt(int val)
{
  switch(cType_) {
    ACCEPT_SET(SQL_C_BIT,signed char);
    ACCEPT_SET(SQL_C_TINYINT,signed char);
    ACCEPT_SET(SQL_C_SHORT,short);
    ACCEPT_SET(SQL_C_LONG,SQLINTEGER);

#if ODBCVER >= 0x0300
    ACCEPT_SET(SQL_C_SBIGINT,SQLBIGINT);
#endif

    ACCEPT_SET(SQL_C_DOUBLE,double);
    ACCEPT_SET(SQL_C_FLOAT,float);

  case SQL_C_CHAR:
    this->setString(intToString(val));
    break;

  default:
    UNSUPPORTED_SET(ODBCXX_STRING_CONST("an int"));
  }
}

void DataHandler::setLong(Long val)
{
  switch(cType_) {
#if ODBCVER >= 0x0300
    ACCEPT_SET(SQL_C_SBIGINT,SQLBIGINT);
#endif

    ACCEPT_SET(SQL_C_BIT,signed char);
    ACCEPT_SET(SQL_C_TINYINT,signed char);
    ACCEPT_SET(SQL_C_SHORT,short);
    ACCEPT_SET(SQL_C_LONG,SQLINTEGER);
    ACCEPT_SET(SQL_C_DOUBLE,double);
    ACCEPT_SET(SQL_C_FLOAT,float);

  case SQL_C_CHAR:
    this->setString(longToString(val));
    break;

  default:
    UNSUPPORTED_SET(ODBCXX_STRING_CONST("a Long"));
  }
}

void DataHandler::setFloat(float val)
{
  switch(cType_) {
    ACCEPT_SET(SQL_C_FLOAT,float);
    ACCEPT_SET(SQL_C_DOUBLE,double);
#if ODBCVER >= 0x0300
    ACCEPT_SET(SQL_C_SBIGINT,SQLBIGINT);
#endif
    ACCEPT_SET(SQL_C_BIT,signed char);
    ACCEPT_SET(SQL_C_TINYINT,signed char);
    ACCEPT_SET(SQL_C_SHORT,short);
    ACCEPT_SET(SQL_C_LONG,SQLINTEGER);

  case SQL_C_CHAR:
    this->setString(doubleToString(val));
    break;

  default:
    UNSUPPORTED_SET(ODBCXX_STRING_CONST("a float"));
  }
}

void DataHandler::setDouble(double val)
{
  switch(cType_) {
    ACCEPT_SET(SQL_C_DOUBLE,double);
    ACCEPT_SET(SQL_C_FLOAT,float);
#if ODBCVER >= 0x0300
    ACCEPT_SET(SQL_C_SBIGINT,SQLBIGINT);
#endif
    ACCEPT_SET(SQL_C_BIT,signed char);
    ACCEPT_SET(SQL_C_TINYINT,signed char);
    ACCEPT_SET(SQL_C_SHORT,short);
    ACCEPT_SET(SQL_C_LONG,SQLINTEGER);

  case SQL_C_CHAR:
    this->setString(doubleToString(val));
    break;

  default:
    UNSUPPORTED_SET(ODBCXX_STRING_CONST("a double"));
  }
}


void DataHandler::setDate(const Date& d)
{
  switch(cType_) {
  case C_DATE:
    {
      DateStruct* ds=(DateStruct*)this->data();
      ds->year=d.getYear();
      ds->month=d.getMonth();
      ds->day=d.getDay();
      this->setDataStatus(sizeof(DateStruct));
    }
    break;

  case C_TIMESTAMP:
    {
      TimestampStruct* ts=(TimestampStruct*)this->data();
      ts->year=d.getYear();
      ts->month=d.getMonth();
      ts->day=d.getDay();
      ts->hour=0;
      ts->minute=0;
      ts->second=0;
      ts->fraction=0;
      this->setDataStatus(sizeof(TimestampStruct));
    }
    break;

  case SQL_C_CHAR:
    if(!isStreamed_) {
      // ODBC date escape
      this->setString(ODBCXX_STRING_CONST("{d '")+d.toString()+ODBCXX_STRING_CONST("'}"));
      break;
    }

  default:
    UNSUPPORTED_SET(ODBCXX_STRING_CONST("a Date"));
  }
}

void DataHandler::setTime(const Time& t)
{
  switch(cType_) {
  case C_TIME:
    {
      TimeStruct* ts=(TimeStruct*)this->data();
      ts->hour=t.getHour();
      ts->minute=t.getMinute();
      ts->second=t.getSecond();
      this->setDataStatus(sizeof(TimeStruct));
    }
    break;

  case SQL_C_CHAR:
    if(!isStreamed_) {
      this->setString(ODBCXX_STRING_CONST("{t '")+t.toString()+ODBCXX_STRING_CONST("'}"));
      break;
    }

  default:
    UNSUPPORTED_SET(ODBCXX_STRING_CONST("a Time"));
  }
}

void DataHandler::setTimestamp(const Timestamp& t)
{
  switch(cType_) {
  case C_TIMESTAMP:
    {
      TimestampStruct* ts=(TimestampStruct*)this->data();
      ts->year=t.getYear();
      ts->month=t.getMonth();
      ts->day=t.getDay();
      ts->hour=t.getHour();
      ts->minute=t.getMinute();
      ts->second=t.getSecond();
      ts->fraction=t.getNanos();
      this->setDataStatus(sizeof(TimestampStruct));
    }
    break;

  case SQL_C_CHAR:
    if(!isStreamed_) {
      this->setString(ODBCXX_STRING_CONST("{ts '")+t.toString()+ODBCXX_STRING_CONST("'}"));
      break;
    }

  default:
    UNSUPPORTED_SET(ODBCXX_STRING_CONST("a Timestamp"));
  }
}


void DataHandler::setString(const ODBCXX_STRING& str)
{
  switch(cType_) {
#if defined(ODBCXX_HAVE_SQLUCODE_H)
  case SQL_C_TCHAR:
#else
  case SQL_C_CHAR:
#endif
    if(!isStreamed_) {
      unsigned int len=(unsigned int)ODBCXX_STRING_LEN(str);
      if((len+1)*sizeof(ODBCXX_CHAR_TYPE)>bufferSize_) {
        len=(bufferSize_-1)/sizeof(ODBCXX_CHAR_TYPE);
      }
      ODBCXX_CHAR_TYPE* buf=(ODBCXX_CHAR_TYPE*)this->data();
      // we want to pad (W)CHARs with spaces
      unsigned int padlen=(sqlType_==Types::CHAR
#if defined(ODBCXX_HAVE_SQLUCODE_H)
         ||sqlType_==Types::WCHAR
#endif
         ?(bufferSize_-1)/sizeof(ODBCXX_CHAR_TYPE)-len:0);

      memcpy(buf,ODBCXX_STRING_DATA(str),len*sizeof(ODBCXX_CHAR_TYPE));
      for(unsigned int i=0; i<padlen; i++) {
        buf[len+i]=' ';
      }

      buf[len+padlen]='\0'; //NULL

      this->setDataStatus((len+padlen)*sizeof(ODBCXX_CHAR_TYPE));
    } else {
      // we fake a real setStream()
      this->setStream(stringToStream(str),
                      ODBCXX_STRING_LEN(str));
      ownStream_=true;
    }
    break;

    ACCEPT_SET_VAL(SQL_C_BIT,signed char,stringToInt(str));
    ACCEPT_SET_VAL(SQL_C_TINYINT,signed char,stringToInt(str));
    ACCEPT_SET_VAL(SQL_C_SHORT,short,stringToInt(str));
    ACCEPT_SET_VAL(SQL_C_LONG,SQLINTEGER,stringToInt(str));
    ACCEPT_SET_VAL(SQL_C_DOUBLE,double,stringToDouble(str));
    ACCEPT_SET_VAL(SQL_C_FLOAT,float,stringToDouble(str));

  case C_DATE:
    this->setDate(Date(str));
    break;

  case C_TIME:
    this->setTime(Time(str));
    break;

  case C_TIMESTAMP:
    this->setTimestamp(Timestamp(str));
    break;

  default:
    UNSUPPORTED_SET(ODBCXX_STRING_CONST("a string"));
  }
}

void DataHandler::setBytes(const ODBCXX_BYTES& b)
{
  switch(cType_) {
  case SQL_C_BINARY:
    if(!isStreamed_) {
      size_t l=ODBCXX_BYTES_SIZE(b);
      // truncate if needed
      if(l>bufferSize_) {
        l=bufferSize_;
      }

      memcpy(this->data(),ODBCXX_BYTES_DATA(b),l);
      this->setDataStatus(l);

    } else {
      // fake a setStream()
      this->setStream(bytesToStream(b),
                      ODBCXX_BYTES_SIZE(b));
      ownStream_=true;
    }
    break;

  default:
    UNSUPPORTED_SET(ODBCXX_STRING_CONST("a const Bytes&"));
  }
}

void DataHandler::setStream(ODBCXX_STREAM* s)
{
  this->resetStream();
  stream_=s;
  ownStream_=true;
}

void DataHandler::setStream(ODBCXX_STREAM* s, int len)
{
  switch(cType_) {
  case SQL_C_CHAR:
  case SQL_C_BINARY:
    if(isStreamed_) {
      this->resetStream();
      stream_=s;
      ownStream_=false;
      this->setDataStatus(SQL_LEN_DATA_AT_EXEC(len*sizeof(ODBCXX_CHAR_TYPE)));
      break;
    }

  default:
    UNSUPPORTED_SET(ODBCXX_STRING_CONST("a stream"));
  }
}