vmsqllite3.cpp

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

    Close();
  }
  catch (...) 
  {
  }
}


VMSqlite3xQuery& VMSqlite3xQuery::operator=( const VMSqlite3xQuery& roOther )
{
  try
  {
    Close();
  }
  catch (...)
  {
  }
  m_poDb3VirtualMachineInstance = roOther.m_poDb3VirtualMachineInstance;

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

  m_bIsAtEof                = roOther.m_bIsAtEof;
  m_iColumnCount            = roOther.m_iColumnCount;
  m_bThisOwnsVirtualMachine = roOther.m_bThisOwnsVirtualMachine;

  return( *this );
}


int VMSqlite3xQuery::GetColumnCount( void )
{
  CheckDatabaseVirtualMachine();

  return( m_iColumnCount );
}


const char* VMSqlite3xQuery::GetColumnBufferAtIndex( int iColumnIndex )
{
  CheckDatabaseVirtualMachine();

  if ( iColumnIndex < 0 || iColumnIndex > m_iColumnCount - 1 )
  {
    throw VMSqlite3xException( CPPSQLITE_ERROR,
                               "Invalid field index requested",
                               DONT_DELETE_MSG );
  }
  return( (const char*)sqlite3_column_text( m_poDb3VirtualMachineInstance, iColumnIndex ) );
}


const char* VMSqlite3xQuery::GetColumnBufferByName( const char* pchColumnName )
{
  int iIndex = GetColumnIndexByName( pchColumnName );
  return( (const char*)sqlite3_column_text( m_poDb3VirtualMachineInstance, iIndex ) );
}


int VMSqlite3xQuery::GetColumnValueAtIndexAsInt( int iColumnIndex, int iValueIfNull )
{
  if ( GetColumnDataTypeByIndex( iColumnIndex ) == SQLITE_NULL )
  {
    return( iValueIfNull );
  }
  else 
  {
    return( sqlite3_column_int( m_poDb3VirtualMachineInstance, iColumnIndex ) );
  }
}


int VMSqlite3xQuery::GetColumnValueByNameAsInt( const char* pchColumnName, int iValueIfNull )
{
  int iIndex = GetColumnIndexByName( pchColumnName );
  return( GetColumnValueAtIndexAsInt( iIndex, iValueIfNull ) );
}


double VMSqlite3xQuery::GetColumnValueAtIndexAsDouble( int iColumnIndex, double dblValueIfNull )
{
  if ( GetColumnDataTypeByIndex( iColumnIndex ) == SQLITE_NULL )
  {
    return( dblValueIfNull );
  }
  else
  {
    return( sqlite3_column_double( m_poDb3VirtualMachineInstance, iColumnIndex ) );
  }
}


double VMSqlite3xQuery::GetColumnValueByNameAsDouble( const char* pchColumnName, double dblValueIfNull )
{
  int iIndex = GetColumnIndexByName( pchColumnName );
  return( GetColumnValueAtIndexAsDouble( iIndex, dblValueIfNull ) );
}


const char* VMSqlite3xQuery::GetColumnValueAtIndexAsString( int iColumnIndex, const char* pchValueIfNull )
{
  if ( GetColumnDataTypeByIndex( iColumnIndex ) == SQLITE_NULL )
  {
    return( pchValueIfNull );
  }
  else
  {
    return( (const char*)sqlite3_column_text( m_poDb3VirtualMachineInstance, iColumnIndex ) );
  }
}


const char* VMSqlite3xQuery::GetColumnValueByNameAsString( const char* pchColumnName, const char* pchValueIfNull )
{
  int iIndex = GetColumnIndexByName( pchColumnName );
  return( GetColumnValueAtIndexAsString( iIndex, pchValueIfNull ) );
}


const unsigned char* VMSqlite3xQuery::GetColumnValueAtIndexAsBlob( int iColumnIndex, int& riResultLength )
{
  CheckDatabaseVirtualMachine();

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

  riResultLength = sqlite3_column_bytes( m_poDb3VirtualMachineInstance, iColumnIndex );
	return( (const unsigned char*)sqlite3_column_blob( m_poDb3VirtualMachineInstance, iColumnIndex ) );
}


const unsigned char* VMSqlite3xQuery::GetColumnValueByNameAsBlob( const char* pchColumnName, int& riResultLength )
{
  int iIndex = GetColumnIndexByName( pchColumnName );
  return( GetColumnValueAtIndexAsBlob( iIndex, riResultLength ) );
}


bool VMSqlite3xQuery::IsColumnValueNullAtIndex( int iColumnIndex )
{
  return( GetColumnDataTypeByIndex(iColumnIndex ) == SQLITE_NULL );
}


bool VMSqlite3xQuery::IsColumnValueNullAtColumnName( const char* pchColumnName )
{
  int iIndex = GetColumnIndexByName( pchColumnName );
  return( GetColumnDataTypeByIndex( iIndex ) == SQLITE_NULL );
}


int VMSqlite3xQuery::GetColumnIndexByName( const char* pchColumnName )
{
  CheckDatabaseVirtualMachine();

  if ( pchColumnName )
  {
    for ( int iIndex = 0; iIndex < m_iColumnCount; iIndex++ )
    {
      const char* pchTemp = sqlite3_column_name( m_poDb3VirtualMachineInstance, iIndex );

      if ( strcmp( pchColumnName, pchTemp ) == 0 )
      {
        return( iIndex );
      }
    }
  }
  throw VMSqlite3xException( CPPSQLITE_ERROR,
                             "Invalid field name requested",
                             DONT_DELETE_MSG );
}


const char* VMSqlite3xQuery::GetColumnNameAtIndex( int iColumnIndex )
{
  CheckDatabaseVirtualMachine();

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

  return( sqlite3_column_name( m_poDb3VirtualMachineInstance, iColumnIndex ) );
}


const char* VMSqlite3xQuery::GetColumnDataTypeNameAtIndex( int iColumnIndex )
{
  CheckDatabaseVirtualMachine();

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

  return( sqlite3_column_decltype( m_poDb3VirtualMachineInstance, iColumnIndex ) );
}


int VMSqlite3xQuery::GetColumnDataTypeByIndex( int iColumnIndex )
{
  CheckDatabaseVirtualMachine();

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

  return( sqlite3_column_type( m_poDb3VirtualMachineInstance, iColumnIndex ) );
}


bool VMSqlite3xQuery::IsEOF( void )
{
  CheckDatabaseVirtualMachine();
  return( m_bIsAtEof );
}


void VMSqlite3xQuery::MoveToNextRow( void )
{
  CheckDatabaseVirtualMachine();

  int iResult = sqlite3_step( m_poDb3VirtualMachineInstance );

  if ( iResult == SQLITE_DONE )
  {
    // no rows
    //
    m_bIsAtEof = true;
  }
  else 
  if ( iResult == SQLITE_ROW )
  {
    // more rows, nothing to do
  }
  else
  {
    iResult = sqlite3_finalize( m_poDb3VirtualMachineInstance );

    m_poDb3VirtualMachineInstance = 0;

    const char* pchError = sqlite3_errmsg( m_poDb3Instance );

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


void VMSqlite3xQuery::Close( void )
{
  if ( m_poDb3VirtualMachineInstance && m_bThisOwnsVirtualMachine )
  {
    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 VMSqlite3xQuery::CheckDatabaseVirtualMachine( void )
{
  if ( m_poDb3VirtualMachineInstance == 0 )
  {
    throw VMSqlite3xException( CPPSQLITE_ERROR,
                               "Null Virtual Machine pointer",
                               DONT_DELETE_MSG );
  }
}


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


VMSqlite3xTable::VMSqlite3xTable( void )
{
  m_ppchResults      = 0;
  m_iRowCount        = 0;
  m_iColumnCount     = 0;
  m_iCurrentRowIndex = 0;
}


VMSqlite3xTable::VMSqlite3xTable( const VMSqlite3xTable& roOther )
{
  m_ppchResults = roOther.m_ppchResults;
  
  // Only one object can own the results
  //
  const_cast< VMSqlite3xTable&>( roOther ).m_ppchResults = 0;

  m_iRowCount        = roOther.m_iRowCount;
  m_iColumnCount     = roOther.m_iColumnCount;
  m_iCurrentRowIndex = roOther.m_iCurrentRowIndex;
}


VMSqlite3xTable::VMSqlite3xTable( char** ppchResults, int iRowCount, int iColumnCount )
{
  m_ppchResults      = ppchResults;
  m_iRowCount        = iRowCount;
  m_iColumnCount     = iColumnCount;
  m_iCurrentRowIndex = 0;
}


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


VMSqlite3xTable& VMSqlite3xTable::operator=( const VMSqlite3xTable& roOther )
{
  try
  {
    Close();
  }
  catch (...)
  {
  }

  m_ppchResults = roOther.m_ppchResults;

  // Only one object can own the results
  //
  const_cast< VMSqlite3xTable& >( roOther ).m_ppchResults = 0;

  m_iRowCount        = roOther.m_iRowCount;
  m_iColumnCount     = roOther.m_iColumnCount;
  m_iCurrentRowIndex = roOther.m_iCurrentRowIndex;

  return( *this );
}


void VMSqlite3xTable::Close( void )
{
  if ( m_ppchResults )
  {
    sqlite3_free_table( m_ppchResults );
    m_ppchResults = 0;
  }
}


int VMSqlite3xTable::GetColumnCount( void )
{
  CheckResults();

  return( m_iColumnCount );
}


int VMSqlite3xTable::GetRowCount( void )
{
  CheckResults();

  return( m_iRowCount );
}


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

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

  int iOffset = ( m_iCurrentRowIndex * m_iColumnCount ) + m_iColumnCount + iColumnIndex;
  return( m_ppchResults[ iOffset ] );
}