vmsqllite3.cpp

TOOL (Tiny Object Oriented Language) is an easily-embedded, object-oriented, C++-like-language inter

const char* VMSqlite3xTable::GetColumnBufferByName( const char* pchColumnName )
{
  CheckResults();

  if ( pchColumnName )
	{
    for ( int iIndex = 0; iIndex < m_iColumnCount; iIndex++ )
		{
      if ( strcmp( pchColumnName, m_ppchResults[ iIndex ] ) == 0)
      {
        int iOffset = ( m_iCurrentRowIndex * m_iColumnCount ) + m_iColumnCount + iIndex;
        return( m_ppchResults[ iOffset ] );
      }
    }
  }

  throw VMSqlite3xException( CPPSQLITE_ERROR,
                             "Invalid field name requested",
                             DONT_DELETE_MSG );
}


int VMSqlite3xTable::GetColumnValueAtIndexAsInt( int iColumnIndex, int iValueIfNull )
{
  if ( IsColumnValueNullAtIndex( iColumnIndex ) )
  {
    return( iValueIfNull );
  }
  else
  {
    return( atoi( GetColumnBufferAtIndex( iColumnIndex ) ) );
  }
}


int VMSqlite3xTable::GetColumnValueByNameAsInt( const char* pchColumnName, int iValueIfNull )
{
  if ( IsColumnValueNullAtColumnName( pchColumnName ) )
  {
    return( iValueIfNull );
  }
  else
  {
    return( atoi( GetColumnBufferByName( pchColumnName ) ) );
  }
}


double VMSqlite3xTable::GetColumnValueAtIndexAsDouble( int iColumnIndex, double dblValueIfNull )
{
  if ( IsColumnValueNullAtIndex( iColumnIndex ) )
  {
    return( dblValueIfNull );
  }
  else
  {
    return( atof( GetColumnBufferAtIndex( iColumnIndex ) ) );
  }
}


double VMSqlite3xTable::GetColumnValueByNameAsDouble( const char* pchColumnName, double dblValueIfNull )
{
  if ( IsColumnValueNullAtColumnName( pchColumnName ) )
  {
    return( dblValueIfNull );
  }
  else
  {
    return( atof( GetColumnBufferByName( pchColumnName ) ) );
  }
}


const char* VMSqlite3xTable::GetColumnValueAtIndexAsString( int iColumnIndex, const char* pchValueIfNull )
{
  if ( IsColumnValueNullAtIndex( iColumnIndex ) )
  {
    return( pchValueIfNull );
  }
  else
  {
    return( GetColumnBufferAtIndex( iColumnIndex ) );
  }
}


const char* VMSqlite3xTable::GetColumnValueByNameAsString( const char* pchColumnName, const char* pchValueIfNull )
{
  if ( IsColumnValueNullAtColumnName( pchColumnName ) )
  {
    return( pchValueIfNull );
  }
  else
  {
    return( GetColumnBufferByName( pchColumnName ) );
  }
}


bool VMSqlite3xTable::IsColumnValueNullAtIndex( int iColumnIndex )
{
  CheckResults();
  return( GetColumnBufferAtIndex( iColumnIndex ) == 0 );
}


bool VMSqlite3xTable::IsColumnValueNullAtColumnName( const char* pchColumnName )
{
  CheckResults();
  return( GetColumnBufferByName(pchColumnName ) == 0 );
}


const char* VMSqlite3xTable::GetColumnNameAtIndex( int iColumnIndex )
{
  CheckResults();

  if ( iColumnIndex < 0 || iColumnIndex > m_iColumnCount - 1 )
  {
    throw VMSqlite3xException( CPPSQLITE_ERROR,
                               "Invalid field index requested",
                               DONT_DELETE_MSG );
  }
  return( m_ppchResults[ iColumnIndex ] );
}


void VMSqlite3xTable::MoveToRow( int iGotoRow )
{
  CheckResults();

  if ( iGotoRow < 0 || iGotoRow > m_iRowCount - 1 )
	{
    throw VMSqlite3xException( CPPSQLITE_ERROR,
                               "Invalid row index requested",
                               DONT_DELETE_MSG );
	}
  m_iCurrentRowIndex = iGotoRow;
}


void VMSqlite3xTable::CheckResults( void )
{
  if ( m_ppchResults == 0 )
  {
    throw VMSqlite3xException( CPPSQLITE_ERROR,
                               "Null Results pointer",
                               DONT_DELETE_MSG );
  }
}


///////////////////////////////////////////////////////////////////////////////
//
//
//
///////////////////////////////////////////////////////////////////////////////


VMSqlite3xStatement::VMSqlite3xStatement( void )
{
  m_poDb3Instance               = 0;
  m_poDb3VirtualMachineInstance = 0;
}


VMSqlite3xStatement::VMSqlite3xStatement( const VMSqlite3xStatement& roOther )
{
  m_poDb3Instance               = roOther.m_poDb3Instance;
	m_poDb3VirtualMachineInstance = roOther.m_poDb3VirtualMachineInstance;

	// Only one object can own VM
  //
	const_cast< VMSqlite3xStatement& >( roOther ).m_poDb3VirtualMachineInstance = 0;
}


VMSqlite3xStatement::VMSqlite3xStatement( sqlite3* poDB, sqlite3_stmt* poVM )
{
  m_poDb3Instance               = poDB;
  m_poDb3VirtualMachineInstance = poVM;
}


VMSqlite3xStatement::~VMSqlite3xStatement( void )
{
  try
  {
    Close();
  }
  catch (...)
  {
  }
}


VMSqlite3xStatement& VMSqlite3xStatement::operator=( const VMSqlite3xStatement& roOther )
{
  m_poDb3Instance               = roOther.m_poDb3Instance;
  m_poDb3VirtualMachineInstance = roOther.m_poDb3VirtualMachineInstance;

  // Only one object can own VM
  //
  const_cast< VMSqlite3xStatement& >( roOther ).m_poDb3VirtualMachineInstance = 0;

  return( *this );
}


int VMSqlite3xStatement::ExecuteDML( void )
{
  CheckDatabase();
  CheckDatabaseVirtualMachine();

  const char* pchError = 0;

  int iResult = sqlite3_step( m_poDb3VirtualMachineInstance );

  if ( iResult == SQLITE_DONE )
  {
    int iRowsChanged = sqlite3_changes( m_poDb3Instance );

    iResult = sqlite3_reset( m_poDb3VirtualMachineInstance );

    if ( iResult != SQLITE_OK )
    {
      pchError = sqlite3_errmsg( m_poDb3Instance );
      throw VMSqlite3xException( iResult, (char*)pchError, DONT_DELETE_MSG );
    }
    return( iRowsChanged );
  }
  else
  {
    iResult  = sqlite3_reset( m_poDb3VirtualMachineInstance );
    pchError = sqlite3_errmsg( m_poDb3Instance );

      throw VMSqlite3xException( iResult, (char*)pchError, DONT_DELETE_MSG );
  }
}


VMSqlite3xQuery VMSqlite3xStatement::ExecuteQuery( void )
{
  CheckDatabase();
  CheckDatabaseVirtualMachine();

  int iResult = sqlite3_step( m_poDb3VirtualMachineInstance );

  if ( iResult == SQLITE_DONE )
  {
    // no rows
    //
    return( VMSqlite3xQuery( m_poDb3Instance, m_poDb3VirtualMachineInstance, true, false ) );
  }
  else 
  if ( iResult == SQLITE_ROW )
	{
    // at least 1 row
    //
    return( VMSqlite3xQuery( m_poDb3Instance, m_poDb3VirtualMachineInstance, false, false ) );
  }
  else
  {
    iResult = sqlite3_reset( m_poDb3VirtualMachineInstance );
    const char* pchError = sqlite3_errmsg( m_poDb3Instance );

		throw VMSqlite3xException( iResult, (char*)pchError, DONT_DELETE_MSG );
  }
}


void VMSqlite3xStatement::BindParameter( int iParamIndex, const char* pchValueToBind )
{
  CheckDatabaseVirtualMachine();

  int iResult = sqlite3_bind_text( m_poDb3VirtualMachineInstance, iParamIndex, pchValueToBind, -1, SQLITE_TRANSIENT );

  if ( iResult != SQLITE_OK)
  {
    throw VMSqlite3xException( iResult,
                               "Error binding string param",
                               DONT_DELETE_MSG );
  }
}


void VMSqlite3xStatement::BindParameter( int iParamIndex, const int iValueToBind )
{
  CheckDatabaseVirtualMachine();

  int iResult = sqlite3_bind_int(m_poDb3VirtualMachineInstance, iParamIndex, iValueToBind );

  if ( iResult != SQLITE_OK )
  {
    throw VMSqlite3xException( iResult,
                               "Error binding int param",
                               DONT_DELETE_MSG );
  }
}


void VMSqlite3xStatement::BindParameter( int iParamIndex, const double dblValueToBind )
{
  CheckDatabaseVirtualMachine();

  int iResult = sqlite3_bind_double( m_poDb3VirtualMachineInstance, iParamIndex, dblValueToBind );

  if ( iResult != SQLITE_OK )
  {
    throw VMSqlite3xException( iResult,
                               "Error binding double param",
                               DONT_DELETE_MSG );
  }
}


void VMSqlite3xStatement::BindParameter( int iParamIndex, const unsigned char* pchValueToBind, int iLength )
{
  CheckDatabaseVirtualMachine();

  int iResult = sqlite3_bind_blob( m_poDb3VirtualMachineInstance, 
                                   iParamIndex,
                                   (const void*)pchValueToBind, 
                                   iLength, 
                                   SQLITE_TRANSIENT );

  if ( iResult != SQLITE_OK )
  {
    throw VMSqlite3xException( iResult,
                               "Error binding blob param",
                               DONT_DELETE_MSG );
  }
}

	
void VMSqlite3xStatement::BindNullParameter( int iParamIndex )
{
  CheckDatabaseVirtualMachine();

  int iResult = sqlite3_bind_null( m_poDb3VirtualMachineInstance, iParamIndex );

  if ( iResult != SQLITE_OK )
  {
    throw VMSqlite3xException( iResult,
                               "Error binding NULL param",
                               DONT_DELETE_MSG );
  }
}


void VMSqlite3xStatement::Reset( void )
{
  if ( m_poDb3VirtualMachineInstance )
  {
    int iResult = sqlite3_reset( m_poDb3VirtualMachineInstance );

    if ( iResult != SQLITE_OK )
    {
      const char* pchError = sqlite3_errmsg( m_poDb3Instance );
      throw VMSqlite3xException( iResult, (char*)pchError, DONT_DELETE_MSG );
    }
  }
}


void VMSqlite3xStatement::Close( void )
{
  if ( m_poDb3VirtualMachineInstance )
  {
    int iResult = sqlite3_finalize( m_poDb3VirtualMachineInstance );

    m_poDb3VirtualMachineInstance = 0;

    if ( iResult != SQLITE_OK )
    {
      const char* pchError = sqlite3_errmsg( m_poDb3Instance );
      throw VMSqlite3xException( iResult, (char*)pchError, DONT_DELETE_MSG );
    }
  }
}


void VMSqlite3xStatement::CheckDatabase( void )
{
  if ( m_poDb3Instance == 0 )
  {
    throw VMSqlite3xException( CPPSQLITE_ERROR,
                               "Database not open",
                               DONT_DELETE_MSG );
  }
}


void VMSqlite3xStatement::CheckDatabaseVirtualMachine( void )
{
  if ( m_poDb3VirtualMachineInstance == 0 )
  {
    throw VMSqlite3xException( CPPSQLITE_ERROR,
                               "Null Virtual Machine pointer",
                               DONT_DELETE_MSG );
  }
}


////////////////////////////////////////////////////////////////////////////////

VMSqlite3xDatabase::VMSqlite3xDatabase( void )
{
  m_poDb3Instance = 0;