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

Go to the documentation of this file.

#include "dataholding.h"
#include <boost/bind.hpp>

using namespace Dedupe::Dataholding;

Dataholding::Dataholding( Dedupe::FilePath Path )
: Dataholding::SqliteWrapper( Path.string() )
{
  Check( sqlite3_open_v2( Path.string().c_str(), &db_handle,
                    SQLITE_OPEN_READWRITE | //open in read and write mode
                    SQLITE_OPEN_CREATE |  //create file if not existing
                    SQLITE_OPEN_FULLMUTEX, //serialised mode for multithreading
                    NULL ) ); //use default virtual filesystem in sqlite

  std::string DatabasePattern;

 //Define pattern of database for hashed files
  DatabasePattern =
  "CREATE TABLE IF NOT EXISTS StoredFiles (\
  Path TEXT NOT NULL,\
  Size UNSIGNED BIG INT NOT NULL,\
  ChangeDate UNSIGNED BIG INT NOT NULL,\
  Type INTEGER NOT NULL,\
  Keep BOOLEAN NOT NULL,\
  Hash UNSIGNED BIG INT NOT NULL);";
  SqlExec( DatabasePattern );
}

bool Dataholding::AlreadyInDatabase( Dedupe::FileInfo const & File )
{
  sqlite3_stmt *stmt( NULL );
  std::string SqlString(
  "SELECT * FROM StoredFiles WHERE Path=? AND Size=? AND ChangeDate=?;");
  SqliteWrapper::Check(sqlite3_prepare_v2(
                               db_handle,
                               SqlString.c_str(),
                               SqlString.size(),
                               &stmt,
                               NULL ));

  sqlite3_bind_text( stmt, 1, File.GetPath().string().c_str(), -1, SQLITE_TRANSIENT);
  sqlite3_bind_int64( stmt, 2, File.GetSize());
  sqlite3_bind_int64( stmt, 3, File.GetDateChanged());

  Dedupe::FileStream ReturningFiles = ExecStatement( stmt );
  sqlite3_finalize( stmt );

  if( ReturningFiles.size() > 0 ) return true;
  else return false;
}

void Dataholding::AddFile( Dedupe::FileInfo const &IncomingFile )
{
  sqlite3_stmt *stmt( NULL );
  std::string SqlString(
  "INSERT INTO StoredFiles( Path, Size, ChangeDate, Type, Keep, Hash) VALUES (?,?,?,?,?,?)");
  SqliteWrapper::Check(sqlite3_prepare_v2(
                               db_handle,
                               SqlString.c_str(),
                               SqlString.size(),
                               &stmt,
                               NULL ));

  sqlite3_bind_text( stmt, 1, IncomingFile.GetPath().string().c_str(), -1, SQLITE_TRANSIENT);
  sqlite3_bind_int64( stmt, 2, IncomingFile.GetSize());
  sqlite3_bind_int64( stmt, 3, IncomingFile.GetDateChanged());
  sqlite3_bind_int( stmt, 4, IncomingFile.GetType());
  sqlite3_bind_int( stmt, 5, IncomingFile.GetKeep());
  sqlite3_bind_int64( stmt, 6, IncomingFile.GetHash());

  ExecStatement( stmt );

  sqlite3_finalize( stmt );

}

void Dataholding::AddFiles( Dedupe::FileStream const &IncomingFiles )
{
   std::for_each(
      IncomingFiles.begin(),
      IncomingFiles.end(),
      boost::bind( &Dataholding::AddFile, this, _1 ));
}

void Dataholding::UpdateFile( Dedupe::FileInfo const &Updated )
{
  sqlite3_stmt *stmt( NULL );
  std::string SqlString(
  "UPDATE StoredFiles SET Size=?, ChangeDate=?, Type=?, Keep=?, Hash=? WHERE Path=?");
  SqliteWrapper::Check(sqlite3_prepare_v2(
                       db_handle,
                       SqlString.c_str(),
                       SqlString.size(),
                       &stmt,
                       NULL ));


  sqlite3_bind_int64( stmt, 1, Updated.GetSize());
  sqlite3_bind_int64( stmt, 2, Updated.GetDateChanged());
  sqlite3_bind_int( stmt, 3, Updated.GetType());
  sqlite3_bind_int( stmt, 4, Updated.GetKeep());
  sqlite3_bind_int64( stmt, 5, Updated.GetHash());
  sqlite3_bind_text( stmt, 6, Updated.GetPath().string().c_str(), -1, SQLITE_TRANSIENT);

  ExecStatement( stmt );

  sqlite3_finalize( stmt );
}

void Dataholding::DelFile( Dedupe::FileInfo const &FileToDel )
{
  sqlite3_stmt *stmt( NULL );
  std::string SqlString(
  "DELETE FROM StoredFiles WHERE Path=?;");
  SqliteWrapper::Check(sqlite3_prepare_v2(
                               db_handle,
                               SqlString.c_str(),
                               SqlString.size(),
                               &stmt,
                               NULL ));

  sqlite3_bind_text( stmt, 1, FileToDel.GetPath().string().c_str(), -1, SQLITE_TRANSIENT);

  ExecStatement( stmt );

  sqlite3_finalize( stmt );
}

void Dataholding::DelFiles( Dedupe::FileStream const &FilesToDel )
{
  std::for_each(
      FilesToDel.begin(),
      FilesToDel.end(),
      boost::bind( &Dataholding::DelFile, this, _1 ));
}

Dedupe::FileStream Dataholding::GetFiles()
{
  //Get all stored data from the database
  return SqlExec( "SELECT * FROM StoredFiles;" );

}

Dedupe::FileStream Dataholding::ExecStatement( sqlite3_stmt *stmt )
{
  Dedupe::FileStream ReturningInfos;
  Dedupe::FilePath Path( "" );
  unsigned long long Size( 0 ), Hash( 0 );
  time_t ChangeDate( 0 );
  Dedupe::FileInfo::FileType Type( Dedupe::FileInfo::TNotDefined );
  bool Keep( false );

  //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( name == "Path" )
      {
        Path = reinterpret_cast<const char*>( sqlite3_column_text( stmt, i ));
      }

      if( name == "Size" )
      {
        Size = sqlite3_column_int64( stmt, i );
      }

      if( name == "ChangeDate")
      {
        ChangeDate = sqlite3_column_int64( stmt, i );
      }

      if( name == "Hash" )
      {
        Hash = sqlite3_column_int64( stmt, i );
      }

      if( name == "Type" )
      {
        Type = static_cast<Dedupe::FileInfo::FileType>(sqlite3_column_int( stmt, i ));
      }

      if( name == "Keep" )
      {
        Keep = sqlite3_column_int( stmt, i );
      }

    }
    Dedupe::FileInfo Current( Path, Size, ChangeDate, Type, Keep, Hash );

    ReturningInfos.push_back( Current );
  }

  return ReturningInfos;
}

Dedupe::FileStream Dataholding::SqlExec( const std::string &SqlCommand )
{
  sqlite3_stmt* stmt;
  const char* PointerToCommand = SqlCommand.c_str();
  int size = SqlCommand.size();
  const char* NextSqlCommand = NULL;

  Dedupe::FileStream Returning;

  //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;

    //TODO: only last result is stored in returning!!
    Returning = ExecStatement( stmt );
  }
  sqlite3_finalize( stmt );

  return Returning;
}