Work/sql/SQLDATA.HPP

#ifndef _SQL_SQLDATA_HPP_
#define _SQL_SQLDATA_HPP_
#ifndef _COMMON_STDIO_HPP_
#include <common/stdio.hpp>
#endif
#ifndef _COMMON_WINDOWS_HPP_
#include <common/windows.hpp>
#endif
#ifndef _COMMON_SMARTPOINTER_HPP_
#include <common/pointer.hpp>
#endif
#ifndef _COMMON_STRING_HPP_
#include <common/string.hpp>
#endif
#ifndef _SQL_SQLSTRING_HPP_
#include <sql/sqlstring.hpp>
#endif
#ifndef _SQL_SQL_HPP_
#include <sql/sql.hpp>
#endif

class SQLData
{
public:
	enum DataType{SQLDataCChar=SQL_C_CHAR,
								SQLDataCLong=SQL_C_LONG,
								SQLDataCShort=SQL_C_SHORT,
								SQLDataCFloat=SQL_C_FLOAT,
								SQLDataCDouble=SQL_C_DOUBLE,
								SQLDataDate=SQL_DATE,
								SQLDataTime=SQL_TIME,
								SQLDataTimeStamp=SQL_TIMESTAMP,
								SQLDataLongVarChar=SQL_LONGVARCHAR,
								SQLDataBigInt=SQL_BIGINT,
								SQLDataBinary=SQL_BINARY,
								SQLDataBit=SQL_BIT,
								SQLDataChar=SQL_CHAR,
								SQLDataDecimal=SQL_DECIMAL,
								SQLDataDouble=SQL_DOUBLE,
								SQLDataFloat=SQL_FLOAT,
								SQLDataInteger=SQL_INTEGER,
								SQLDataLongVarBinary=SQL_LONGVARBINARY,
								SQLDataNumeric=SQL_NUMERIC,
								SQLDataReal=SQL_REAL,
								SQLDataSmallInt=SQL_SMALLINT,
								SQLTimeStamp=SQL_TIMESTAMP,
								SQLDataTinyInt=SQL_TINYINT,
								SQLDataVarBinary=SQL_VARBINARY,
								SQLDataVarChar=SQL_VARCHAR};
	enum Disposition{Assume,Delete};
	SQLData(void);
	SQLData(DWORD sizeData,DataType typeData);
	SQLData(SmartPointer<BYTE> &sqlData,DWORD sizeData,DataType typeData);
  SQLData(const SQLData &somePureData);
	virtual ~SQLData();
	WORD operator==(const SQLData &someSQLData)const;
  SQLData &operator=(const SQLData &someSQLData);
	DWORD size(void)const;
	void size(DWORD sizeData);
  void type(DataType typeData);
	DataType type(void)const;
	const String &name(void)const;
	void name(const String &name);
  LONG *resultLength(void);
	SmartPointer<BYTE> &sqlData(void);
	void sqlData(const SmartPointer<BYTE> &sqlData);
  SQLString toString(void);
	int toInt(void);
  bool toBool(void);
	float toFloat(void);
	double toDouble(void);
private:
  void handleTimeStamp(String &stringData);

	SmartPointer<BYTE> mSqlData;
	DWORD mSizeData;
	DataType mDataType;
  LONG mResultLength;
	String mNameData;
};

inline
SQLData::SQLData(void)
: mSizeData(0), mDataType(SQLDataChar), mResultLength(0)
{
}

inline
SQLData::SQLData(DWORD sizeData,DataType typeData)
: mSizeData(sizeData), mDataType(typeData), mResultLength(0)
{
  mSqlData=new BYTE[sizeData];
	::memset((BYTE*)mSqlData,0,sizeData);
	mSqlData.disposition(PointerDisposition::Delete);
}

inline
SQLData::SQLData(SmartPointer<BYTE> &sqlData,DWORD sizeData,DataType typeData)
: mResultLength(0)
{
  mSqlData=sqlData;
	size(sizeData);
	type(typeData);
}

inline
SQLData::SQLData(const SQLData &someSQLData)
: mSizeData(someSQLData.mSizeData), mDataType(someSQLData.mDataType), mResultLength(someSQLData.mResultLength)
{
  *this=someSQLData;
}

inline
SQLData::~SQLData()
{
}

inline
WORD SQLData::operator==(const SQLData &someSQLData)const
{
  return FALSE;
}

inline
SQLData &SQLData::operator=(const SQLData &someSQLData)
{
	size(someSQLData.size());
  type(someSQLData.type());
	sqlData(((SQLData&)someSQLData).sqlData());
	name(someSQLData.name());
	return *this;  
}

inline
DWORD SQLData::size()const
{
	return mSizeData;
}

inline
void SQLData::size(DWORD size)
{
	mSizeData=size;
}

inline
SQLData::DataType SQLData::type(void)const
{
  return mDataType;
}

inline
void SQLData::type(DataType type)
{
	mDataType=type;
}

inline
const String &SQLData::name(void)const
{
  return mNameData;
}

inline
void SQLData::name(const String &name)
{
  mNameData=name;
}

inline
LONG *SQLData::resultLength(void)
{
  return &mResultLength;
}

inline
SmartPointer<BYTE> &SQLData::sqlData(void)
{
  return mSqlData;
}

inline
void SQLData::sqlData(const SmartPointer<BYTE> &sqlData)
{
  mSqlData=sqlData;
}

inline
bool SQLData::toBool(void)
{
  if(!mSqlData.isOkay())return false;
	return *((BYTE*)mSqlData)&0x01;
}

inline
int SQLData::toInt(void)
{
  if(!mSqlData.isOkay())return 0;
	return *((int*)(BYTE*)mSqlData);
}

inline
float SQLData::toFloat(void)
{
 if(!mSqlData.isOkay())return 0.00;
	return *((float*)(BYTE*)mSqlData);
}

inline
double SQLData::toDouble(void)
{
  if(!mSqlData.isOkay())return 0.00;
	return *((double*)(BYTE*)mSqlData);
}
#endif