podbc.cxx

sloedgy open sip stack source code

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

      case PODBC::Time:
        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()
{
   return SQL_OK(SQLFetch(m_hStmt));
}

BOOL PODBCStmt::FetchPrevious()
{