/www/proggenOrg/dedupe/export/trunk/dataholding/sqlitewrapper.cpp

#include "sqlitewrapper.h"
#include <sqlite3.h>
#include <cstring>
#include <stdexcept>

#include <iostream>


Dedupe::Dataholding::SqliteWrapper::
SqliteWrapper( std::string Path ) : dbs_path( Path ),
                                    db_handle( NULL ),
                                    ReturningTable( )
{
  //Open Database throw an error, if it fails
  Check( sqlite3_open( dbs_path.c_str(), &db_handle ) );
}

Dedupe::Dataholding::SqliteWrapper::~SqliteWrapper()
{
  //Free Memory
  FreeResult();
  //Close Databaseconnection
  sqlite3_close( db_handle );
}

Dedupe::Dataholding::SqliteWrapper::WrapperCode
Dedupe::Dataholding::SqliteWrapper::Check( short SqlState )
{
  switch( SqlState )
  {
    case SQLITE_OK : return WrapperOk; break;
    default        : sqlite3_errmsg( db_handle );
                     throw std::runtime_error( sqlite3_errmsg( db_handle ) );
    }

    return WrapperError;
}

Dedupe::Dataholding::SqliteWrapper::WrapperCode
Dedupe::Dataholding::SqliteWrapper::SqlExec( const std::string &SqlCommand )
{
  //Free the last result, if some data is stored in ReturningResult
  FreeResult();

  sqlite3_stmt* stmt;
  const char* PointerToCommand = SqlCommand.c_str();
  int size = SqlCommand.size();
  const char* NextSqlCommand = NULL;
  Dedupe::Dataholding::SqliteWrapper::Row CurrentRow;

  //runs until no more commands existing
  while( PointerToCommand != NULL )
  {
    Dedupe::Dataholding::SqliteWrapper::Check( sqlite3_prepare_v2(
      db_handle, PointerToCommand, size, &stmt, &NextSqlCommand ) );

    //find out if one more command is waiting
    if( strlen( NextSqlCommand ) != 0 ) PointerToCommand = NextSqlCommand;
    else PointerToCommand = NULL;

    //get how many columns are in the table
    int cols = sqlite3_column_count( stmt );

    //step until all results are readed out
    std::string name, value;
    while ( sqlite3_step( stmt ) == SQLITE_ROW )
    {
      for( int i = 0; i < cols; i++ )
      {
        if( !sqlite3_column_name( stmt, i ) ) continue;

        name = sqlite3_column_name( stmt, i );
        if( name.empty() ) continue;

        if( sqlite3_column_text( stmt, i ) )
        value = reinterpret_cast<const char*>( sqlite3_column_text( stmt, i ));
        CurrentRow[ name ] = value;
       }
        ReturningTable.push_back( CurrentRow );
      }


  //Delete compiled SQL Statement
  sqlite3_finalize(stmt);
  }
  return WrapperOk;
}

Dedupe::Dataholding::SqliteWrapper::WrapperCode
Dedupe::Dataholding::SqliteWrapper::ExecStatement( sqlite3_stmt *stmt )
{
   //Free the last result, if some data is stored in ReturningResult
  FreeResult();


  Dedupe::Dataholding::SqliteWrapper::Row CurrentRow;

  //get how many columns are in the table
  int cols = sqlite3_column_count( stmt );

  //step until all results are readed out
  std::string name, value;
  while ( sqlite3_step( stmt ) == SQLITE_ROW )
  {
    for( int i = 0; i < cols; i++ )
    {
      if( !sqlite3_column_name( stmt, i ) ) continue;

      name = sqlite3_column_name( stmt, i );
      if( name.empty() ) continue;

      if( sqlite3_column_text( stmt, i ) )
      value = reinterpret_cast<const char*>( sqlite3_column_text( stmt, i ));
      CurrentRow[ name ] = value;
    }
    ReturningTable.push_back( CurrentRow );
  }
  //Delete compiled SQL Statement
  sqlite3_finalize(stmt);

  return WrapperOk;
}

Dedupe::Dataholding::SqliteWrapper::Result
Dedupe::Dataholding::SqliteWrapper::GetTabledata()
{
  return Dedupe::Dataholding::SqliteWrapper::ReturningTable;
}

void Dedupe::Dataholding::SqliteWrapper::FreeResult()
{
  ReturningTable.clear();
}