podbc.cxx

pwlib源码库

			if (B) SQLGetData(*row->rec->Stmt,col,ODBCType,&b.time,0,&b.dataLen);
			 return Convert(b.time);

		case PODBC::TimeStamp:
			if (B) SQLGetData(*row->rec->Stmt,col,ODBCType,&b.timestamp,0,&b.dataLen);
			return Convert(b.timestamp);

		case PODBC::Guid:   
			if (B) SQLGetData(*row->rec->Stmt,col,ODBCType,&b.guid,0,&b.dataLen);
			return Convert(b.guid);

	  /// Binary/Long Data Cannot be Bound Need to get it!
		case PODBC::Binary:
		case PODBC::VarBinary:
		case PODBC::LongVarBinary:
		case PODBC::LongVarChar:		
			return row->rec->GetLongData(col);;	
			
	  /// Character 
		case PODBC::DateTime:
		case PODBC::Unknown:
		case PODBC::VarChar:
		default:
		  if (B) SQLGetData(*row->rec->Stmt,col,ODBCType,b.sbin.GetPointer(len),len,&b.dataLen);
			return b.sbin;
	};
}

void PODBC::Field::SetValue(PString value)
{
 
Bind &b = Data;

/// If Field is marked as ReadOnly Do not Update
	if (isReadOnly) return;

/// If Field is not Nullable and the New Value length =0 No Update.
	if ((!isNullable) && (value.GetLength() == 0)) return;

	switch (ODBCType) {
		case PODBC::BigInt:
			Convert(b.sbint,value);
			break;

		case PODBC::TinyInt:
		case PODBC::Bit:
			 Convert(b.sbit,value);	
			 break;
	
		case PODBC::Char:
			 Convert(b.suchar,value);
			 break;

		case PODBC::Integer:
			 Convert(b.slint,value);
			 break;
				
		case PODBC::SmallInt:
			 Convert(b.ssint,value);
			 break;

		case PODBC::Numeric:
		case PODBC::Decimal:
		case PODBC::Float:
		case PODBC::Real:
		case PODBC::Double:
			 Convert(b.sdoub,value);
			 break;

	  /// Date Times
		case PODBC::Date:  
			 Convert(b.date,value);
			 break;

		case PODBC::Time:
			 Convert(b.time,value);
			 break;

		case PODBC::TimeStamp:
			 Convert(b.timestamp,value);
			 break;

		case PODBC::Guid:   
			 Convert(b.guid,value);

	  /// Binary Data
		case PODBC::Binary:
		case PODBC::VarBinary:
		case PODBC::LongVarBinary:
		case PODBC::LongVarChar:
			b.sbinlong = value;	
				if (row->rec->dbase == PODBC::MSAccess) {
					b.sbinlong.SetSize(MAX_DATA_LEN * PODBCRecord::MaxCharSize);
					b.dataLen = b.sbinlong.GetLength();
				}
			break;
			
	  /// Character 
		case PODBC::DateTime:
		case PODBC::Unknown:
		case PODBC::VarChar:
		default:
			b.sbin = value;
			b.sbin.SetSize(MAX_DATA_LEN);
			b.dataLen = b.sbin.GetLength();
	};
}

void PODBC::Field::SetDefaultValues() 
{

  if ((isReadOnly) || (isAutoInc))  return;
 
  /// Set Default Values
		switch (Type)
		{
			case oPString:	
			case ochar:	
				if (isNullable)
					SetValue(PString());
				else
					SetValue("?");
				break;
			case oPTime:
				SetValue(PTime().AsString());
				break;
			default:
				SetValue(0);
		} 
}

PString PODBC::Field::operator=(const PString & str)
{ 
	return AsString();
}


BOOL PODBC::Field::DataFragment(PString & Buffer,PINDEX & fragment,long & size)
{
  PINDEX fragcount = PINDEX(Data.sbinlong.GetLength()/size);
// Value less than Buffer Size
  if (fragcount == 0) {
	  Buffer = Data.sbinlong;
	  return FALSE;
  }
// Buffer Fragment
  if (fragcount < fragment) {
	  Buffer.Splice(Data.sbinlong,(fragment * size)+1,size);
	  fragment = fragment++;
	  return TRUE;
  }
// Last Fragment
  PINDEX blen = Data.sbinlong.GetLength() - (fragment * size);
  Buffer = Data.sbinlong.Right(blen);
  size = blen;
  return FALSE; 
}

BOOL PODBC::Field::Post() 
{
	return row->Post();
}

/////////////////////////////////////////////////////////////////////////////
// PODBC::Table
	  
PODBC::Table::Table(PODBC * odbc, PString Query)
	:	stmt(PODBCStmt(odbc))
{
	PString query;
	tableName = PString();

// Do the Query
	if (Query.Trim().Left(6) == "SELECT") {		// Select Query
		query = Query;
	} else {									// Table Query
		tableName = Query;
		query = "SELECT * FROM [" + tableName + "];";
	}

	if (!stmt.Query(query))
		return;

	// Create the Row Handler
	RowHandler = new Row(&stmt);

}

PODBC::Table::~Table() 
{

}
     	  
PODBC::Row PODBC::Table::NewRow() 
{
	RowHandler->SetNewRow();

	return *RowHandler;
}

BOOL PODBC::Table::DeleteRow(PINDEX row)
{
	return RowHandler->Delete(row);
}


BOOL PODBC::Table::Post()
{
	return RowHandler->Post();
}

PINDEX PODBC::Table::Rows()  
{ 
	return RowHandler->RowCount; 
}

PINDEX PODBC::Table::Columns() 
{ 
	return RowHandler->Columns(); 
}
	  
PStringArray PODBC::Table::ColumnNames() 
{ 
	return RowHandler->ColumnNames(); 
}

PODBC::Row & PODBC::Table::operator[] (PINDEX row) 
{ 

	if (RowHandler->Navigate(row))
		return *RowHandler; 

	return *RowHandler;
}

PODBC::Row & PODBC::Table::RecordHandler()
{
	return *RowHandler;
}

PODBC::Field & PODBC::Table::operator() (PINDEX row, PINDEX col) 
{ 

	RowHandler->Navigate(row);
	return RowHandler->Column(col); 
}

PODBC::Field & PODBC::Table::Column(PINDEX col)
{
     return RowHandler->Column(col);
}

PODBC::Field & PODBC::Table::Column(PString Name)
{
	return RowHandler->Column(Name);

}
///////////////////////////////////////////////////////////////////
// PODBC::Row

PODBC::Row::Row(PODBCStmt * stmt)
	: rec(new PODBCRecord(stmt))	
{

  /// Create a blank Row (RecordHolder) with default Recordset Info.
	for (PINDEX i=0; i < rec->ColumnCount(); i++)
	{   
		Field * nfield = new Field;
		nfield->row = this;
		nfield->col = i+1;

	 // Default Attributes
		nfield->isReadOnly = FALSE;
		nfield->isNullable = TRUE;
		nfield->isAutoInc = FALSE;
		nfield->Decimals = 0;
		nfield->LongData = stmt->odbclink->NeedLongDataLen();

		rec->Data(i+1, *nfield);
	    		
  /// Append to PArray
		Fields.Append(nfield);
	}

   
   NewRow = FALSE;

// Attempt to get the first Record
  if (!stmt->FetchFirst())   
	  RowCount = 0; 
  else	  
	  RowCount = 1;

// Get the Record Count  (Need a better way other than fetching! :-( )
	 while(stmt->Fetch())
	 {
		 RowCount++;
	 }
	 
  /// Put the RecordHolder to point to the First Row
	 if (RowCount > 0) {
		stmt->FetchFirst();
		CurRow = 1;
	 } else 
		CurRow = 0;
}


PODBC::Field & PODBC::Row::Column(PINDEX col) 
{ 
  /// Column = 0 return blank field
	if ((col == 0) || (col > Fields.GetSize()))    
		return *(new PODBC::Field());

	 return Fields[col-1];
}

PODBC::Field & PODBC::Row::Column(PString name)
{
    PINDEX i = rec->ColumnByName(name);
	return Column(i);
}

PINDEX PODBC::Row::Columns()
{
	return rec->ColumnCount();
}

PStringArray PODBC::Row::ColumnNames()
{
	PStringArray Names;

	for (PINDEX i = 0; i < Fields.GetSize(); i++)
	{
		Names.AppendString(rec->ColumnName(i+1));
	}

	return Names;
}

PINDEX PODBC::Row::Rows()
{
	return RowCount;
}


PODBC::Field & PODBC::Row::operator[] (PINDEX col) 
{  
	return Column(col);
} 

PODBC::Field & PODBC::Row::operator[] (PString col) 
{  
    PINDEX i = rec->ColumnByName(col);
	return Column(i);

}

void PODBC::Row::SetNewRow()
{
	CurRow = RowCount+1;
	NewRow = TRUE;

	for (PINDEX i = 0; i < Fields.GetSize(); i++)
	{
		Column(i).SetDefaultValues();
	}
}

BOOL PODBC::Row::Navigate(PINDEX row)
{

	if ((row > 0) && (CurRow != row)) {
		if (!rec->Stmt->FetchRow(row,TRUE)) 
			return FALSE;

		CurRow = row;
	} 

  return TRUE;

}

BOOL PODBC::Row::Post()
{
  BOOL Success;

	if (NewRow) {
	   NewRow = FALSE;
	   RowCount++;
	   CurRow = RowCount;
	   Success = rec->PostNew(*this);
	} else {
	   Success = rec->PostUpdate(*this);
	}

	return Success;
}



BOOL PODBC::Row::Delete(PINDEX row)
{
	if (row > 0) {
		if (!Navigate(row))
			return FALSE;
	}

	if (!rec->PostDelete())
		return FALSE;

	RowCount--;
	return TRUE;
}


// PDSNConnection
/////////////////////////////////////////////////////////////////////////////////////

PDSNConnection::PDSNConnection()
{

}

PDSNConnection::~PDSNConnection()
{

}


BOOL PDSNConnection::Connect( PString Source ,PString Username, PString Password)
{
   int nConnect = SQLAllocHandle( SQL_HANDLE_ENV, SQL_NULL_HANDLE, &m_hEnv );
	if( nConnect == SQL_SUCCESS || nConnect == SQL_SUCCESS_WITH_INFO ) {
	nConnect = SQLSetEnvAttr( m_hEnv, 
				 SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0 );
	if( nConnect == SQL_SUCCESS || nConnect == SQL_SUCCESS_WITH_INFO ) {
	 nConnect = SQLAllocHandle( SQL_HANDLE_DBC, m_hEnv, &m_hDBC );
	 if( nConnect == SQL_SUCCESS || nConnect == SQL_SUCCESS_WITH_INFO ) {
	  SQLSetConnectOption( m_hDBC,SQL_LOGIN_TIMEOUT,5 );                
	  nConnect=SQLConnect( m_hDBC,
		 ( SQLTCHAR *)(const char *)Source,
		 SQL_NTS, 
		 ( SQLTCHAR *)(const char *)Username,
		 SQL_NTS,
		 ( SQLTCHAR *)(const char *)Password,
		 SQL_NTS );
	  return ((nConnect == SQL_SUCCESS) || (nConnect == SQL_SUCCESS_WITH_INFO));
	 }
	}
	}
   if( m_hDBC != NULL ) {
    m_nReturn = SQLDisconnect( m_hDBC );
    m_nReturn = SQLFreeHandle( SQL_HANDLE_DBC,  m_hDBC );
   }
   if( m_hEnv!=NULL )
    m_nReturn = SQLFreeHandle( SQL_HANDLE_ENV, m_hEnv );
   m_hDBC              = NULL;
   m_hEnv              = NULL;
   m_nReturn           = SQL_ERROR;
   return FALSE;
}
 //--
PODBCStmt::PODBCStmt(PODBC * odbc)
	: odbclink(odbc)
{
   HDBC hDBCLink = *odbc;

   SQLRETURN m_nReturn;
   m_nReturn = SQLAllocHandle( SQL_HANDLE_STMT, hDBCLink, &m_hStmt );
   SQLSetStmtAttr(m_hStmt, SQL_ATTR_CONCURRENCY, 
                       (SQLPOINTER) SQL_CONCUR_ROWVER, 0);
   SQLSetStmtAttr(m_hStmt, SQL_ATTR_CURSOR_TYPE,
                       (SQLPOINTER)SQL_CURSOR_KEYSET_DRIVEN, 0);
   SQLSetStmtAttr(m_hStmt, SQL_ATTR_ROW_BIND_TYPE, 
					   (SQLPOINTER)SQL_BIND_BY_COLUMN, 0);
   SQLSetStmtAttr(m_hStmt, SQL_ATTR_ROW_ARRAY_SIZE, 
					   (SQLPOINTER)1, 0);
   SQLSetStmtAttr(m_hStmt, SQL_ATTR_ROW_STATUS_PTR, 
					   NULL, 0);

   dbase = odbc->dbase;

   if(!SQL_OK(m_nReturn))
    m_hStmt=INVALID_HANDLE_VALUE;
}


PODBCStmt::~PODBCStmt()
{
   SQLCloseCursor(m_hStmt);

   if(m_hStmt!=INVALID_HANDLE_VALUE)
    SQLFreeHandle(SQL_HANDLE_STMT,m_hStmt);
}

BOOL PODBCStmt::IsValid()
{
    return m_hStmt!=INVALID_HANDLE_VALUE;
}


DWORD PODBCStmt::GetChangedRowCount(void)
{
   long nRows=0;
   if(!SQL_OK(SQLRowCount(m_hStmt,&nRows)))
    return 0;
   return nRows;
}

BOOL PODBCStmt::Query(PString strSQL)
{
   SQLRETURN nRet=SQLExecDirect( m_hStmt, (SQLTCHAR *)(const char *)strSQL, SQL_NTS );
    return SQL_OK( nRet );
}

BOOL PODBCStmt::Fetch()