DbWriteDriverMySql.cpp

gehe zur Dokumentation dieser Datei

// Copyright (C) 2004 Bernhard Assmann <bernie@tuxomania.net>
//  
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//  
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//  
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
//  

#include <iostream>
#include <vector>
#include <algorithm>
#include <sstream>
#include <utility>
#include <fstream>
#include <iterator>

#include "psfa/DbWriteDriverMySql.hpp"
#include "psfa/Config.hpp"
#include "psfa/Helper.hpp"
#include "psfa/CheckData.hpp"
#include "psfa/UnitParser.hpp"



psfa::DbWriteDriverMySql::DbWriteDriverMySql()
{
  success_ = myHelper_.connect();
  if( !success_ ) {
    std::cout << "Es konnte keine Verbindung zur Datenbank hergestellt werden."
         << std::endl;
    exit(1);
  }
}



psfa::DbWriteDriverMySql::~DbWriteDriverMySql() 
{
  success_ = myHelper_.disconnect();
  if( !success_ ) {
    std::cerr << "Die Verbindung zur DB konnte nicht erfolgreich abgebaut werden."
         << std::endl;
  }
  
}


  
void
psfa::DbWriteDriverMySql::initPsfa() 
{
  using std::string;
  using psfahelper::splitString;
  using psfahelper::getFilePaths;
  typedef std::vector< string > sVec;

  Config* conf = Config::getConfig();
  string p = conf->getConfigValue( "psfa", "pools" );
  sVec pools;
  splitString( p, pools );

  sVec::iterator iEnd = pools.end();
  
  for( sVec::iterator i = pools.begin(); i != iEnd; ++i ) {
    if( existPool( *i ) ) {
      delPool( *i );
    }
    int poolId = insertPool( *i );
    insertKontext( *i, poolId );
    insertSearch( *i, poolId );
    string path = conf->getConfigValue( *i, "root" );
    sVec files;
    getFilePaths( path, "*.xml", files );
    insertFiles( poolId, files, path );
  }
  return;
}

  

void
psfa::DbWriteDriverMySql::delPool( const std::string poolName ) 
{
  std::ostringstream sql;
  sql << "SELECT pool_id FROM pool WHERE p_name = '"
      << poolName
      << "'";
  int id = myHelper_.getSingleValueInt( sql );
  sql.str( "" );
  sql << "DELETE FROM pool WHERE pool_id = "
      << id;
  myHelper_.executeSql( sql );
  
  sql.str( "" );
  std::ostringstream ids;
  sql << "SELECT file_id FROM file WHERE pool_id = "
      << id;
  myHelper_.getValueStream( sql, ids, ", " );
  std::string idList = ids.str();
  if( !idList.empty() ) {
    sql.str("");
    sql << "DELETE FROM file_row WHERE file_id IN("
   << idList
   << ")";
    myHelper_.executeSql( sql );
  }

  sql.str("");
  sql << "DELETE FROM file WHERE pool_id = "
      << id;
  myHelper_.executeSql( sql );
  
  sql.str("");
  sql << "DELETE FROM unit WHERE pool_id = "
      << id;
  myHelper_.executeSql( sql );
  
  sql.str( "" );
  sql << "DELETE FROM kontext WHERE pool_id = "
      << id;
  myHelper_.executeSql( sql );
  
  sql.str( "" );
  sql << "DELETE FROM search WHERE pool_id = "
      << id;
  myHelper_.executeSql( sql );
  
  sql.str( "" );
  sql << "SELECT entry_id FROM entry WHERE pool_id = "
      << id;
  ids.str("");
  myHelper_.getValueStream( sql, ids, ", " );
  idList = ids.str();
  if( !idList.empty() ) {
    sql.str("");
    sql << "DELETE FROM attribut WHERE entry_id IN("
   << idList
   << ")";
    myHelper_.executeSql( sql );
  }
  sql.str( "" );
  sql << "DELETE FROM entry WHERE pool_id = "
      << id;
  myHelper_.executeSql( sql );

  return;
}


  
int
psfa::DbWriteDriverMySql::index( const std::string poolName, 
             CheckData& check )
{
  using std::string;
  typedef std::vector< string > sVec;

  UnitParser up( poolName );
  std::vector< IndexData_SP > index;
  std::ostringstream sql;

  sql.str("");
  sql << "SELECT pool_id FROM pool WHERE p_name = '"
      << poolName
      << "'";
  int poolId = myHelper_.getSingleValueInt( sql );
  Config* conf = Config::getConfig();
  string path = conf->getConfigValue( poolName, "root" );
  sVec errorFiles;
 
  if( check.poolIndex ) {
    sVec files = check.poolIndexList[ poolName ];
    up.parse( files, index, errorFiles );
    insertEntries( poolId, index );
    if( !errorFiles.empty() ) {
      removeFiles( poolId, errorFiles );
      errorFiles.clear();
    }
    index.clear();
  }
  if( check.poolInsert ) {
    sVec files = check.poolInsertList[ poolName ];
    up.parse( files, index, errorFiles );
    insertFiles( poolId, files, path );
    insertEntries( poolId, index );
    if( !errorFiles.empty() ) {
      removeFiles( poolId, errorFiles );
      errorFiles.clear();
    }
    index.clear();
  }
  if( check.poolUpdate ) {
    sVec files = check.poolUpdateList[ poolName ];
    up.parse( files, index, errorFiles );
    removeFiles( poolId, files );
    insertFiles( poolId, files, path );
    insertEntries( poolId, index );
    if( !errorFiles.empty() ) {
      removeFiles( poolId, errorFiles );
      errorFiles.clear();
    }
    index.clear();
  }
  if( check.poolRemove ) {
    sVec files = check.poolRemoveList[ poolName ];
    removeFiles( poolId, files );
  }

  sql.str("");
  sql << "SELECT COUNT( entry_id ) FROM entry WHERE pool_id = '"
      << poolId
      << "'";
  return myHelper_.getSingleValueInt( sql );
}



bool
psfa::DbWriteDriverMySql::existPool( const std::string poolName ) 
{
  std::ostringstream sql;
  sql << "SELECT pool_id FROM pool WHERE p_name = '"
      << poolName
      << "'";
  int id = myHelper_.getSingleValueInt( sql );
  if( id != 0 ) {
    return true;
  }
  return false;
}



void
psfa::DbWriteDriverMySql::check( CheckData& check ) 
{
  using std::string;
  using std::equal;
  using std::sort;
  using std::set_difference;
  using psfahelper::splitString;
  using psfahelper::getFilePaths;
  using psfahelper::getMd5Sum;
    
  typedef std::vector< string > sVec;
  typedef sVec::size_type vSize;
  
  Config* conf = Config::getConfig();
  std::ostringstream sql;

  string pools = conf->getConfigValue( "psfa", "pools" );
  sVec inConfig;
  splitString( pools, inConfig );
  sql << "SELECT p_name FROM pool";
  sVec inDb;
  myHelper_.getValueVector( sql, inDb );

  sort( inConfig.begin(), inConfig.end() );
  sort( inDb.begin(), inDb.end() );
  bool isEqual = true;
  if( inConfig.size() == inDb.size() ) {
    isEqual = equal( inConfig.begin(), inConfig.end(), inDb.begin() );
  }
  else {
    isEqual = false;
  }
  if( !isEqual ) {
    check.init = true;
    sVec diff;
    vSize s = inConfig.size() + inDb.size();
    diff.reserve( s );
    // in der Db aber nicht in der Config
    sVec::iterator diffEnd = set_difference( inDb.begin(),
                    inDb.end(),
                    inConfig.begin(),
                    inConfig.end(),
                    diff.begin()
                    );
    if( diff.begin() != diffEnd ) {
      check.poolDel = true;
      check.poolDelList.reserve( diffEnd - diff.begin() );
      check.poolDelList.insert( check.poolDelList.begin(),
                diff.begin(),
                diffEnd
                );
    }
  }

  sVec::iterator p;
  sVec::iterator pEnd = inConfig.end();
  // für jeden Pool in der Config
  for( p = inConfig.begin(); p != pEnd; ++p ) {
    if( !existPool( *p ) ) {
      continue;
    }
    sql.str("");
    sql << "SELECT pool_id FROM pool WHERE p_name = '"
   << *p
   << "'";
    int poolId = myHelper_.getSingleValueInt( sql );
      
    // Searchs und Kontexts
    if( !check.init ) {
      // Searchs
      string tmp = conf->getConfigValue( *p, "tags" );
      sVec config;
      splitString( tmp, config );
      sql.str("");
      sql << "SELECT s_name FROM search WHERE pool_id = '"
     << poolId
     << "'";
      sVec db;
      myHelper_.getValueVector( sql, db );
      sort( config.begin(), config.end() );
      sort( db.begin(), db.end() );
      isEqual = true;
      if( config.size() == db.size() ) {
   isEqual = equal( config.begin(), config.end(), db.begin() );
      }
      else {
   isEqual = false;
      }
      if( !isEqual ) {
   check.init = true;
      }
      // Kontexts
      if( !check.init ) {
   tmp = conf->getConfigValue( *p, "kontexts" );
   config.clear();
   splitString( tmp, config );
   sql.str("");
   sql << "SELECT k_name FROM kontext WHERE pool_id = '"
       << poolId
       << "'";
   db.clear();
   myHelper_.getValueVector( sql, db );
   sort( config.begin(), config.end() );
   sort( db.begin(), db.end() );
   isEqual = true;
   if( config.size() == db.size() ) {
     isEqual = equal( config.begin(), config.end(), db.begin() );
   }
   else {
     isEqual = false;
   }
   if( !isEqual ) {
     check.init = true;
   }
      }
    }
    // Dateien
    sVec insertList;
    sVec updateList;
    sVec removeList;
    string path = conf->getConfigValue( *p, "root" );
    sVec files;
    getFilePaths( path, "*.xml", files );
    sVec::iterator i;
    sVec::iterator iEnd = files.end();
    for( i = files.begin(); i != iEnd; ++i ) {
      sql.str("");
      sql << "SELECT f_md5 FROM file WHERE f_name = '"
     << *i
     << "' AND pool_id = '"
     << poolId
     << "'";
      string md5Db = myHelper_.getSingleValueString( sql );
      if( md5Db == "" ) {
   // Neue Datei im FS
   check.poolInsert = true;
   insertList.push_back( *i );
   continue;
      }
      string md5File = getMd5Sum( path, *i );
      if( md5Db != md5File ) {
   // Geänderte Datei im FS
   check.poolUpdate = true;
   updateList.push_back( *i );
      }
    }
    sql.str("");
    sql << "SELECT f_name FROM file WHERE pool_id = '"
   << poolId
   << "'";
    inDb.clear();
    myHelper_.getValueVector( sql, inDb );


     // Anzahl der indizierten Tags
    sql.str("");
    sql << "SELECT COUNT( entry_id ) FROM entry WHERE pool_id = '"
   << poolId
   << "'";
    int count = myHelper_.getSingleValueInt( sql );
    if( count == 0 ) {
      check.poolIndex = true;
      check.poolIndexList.insert( std::make_pair( *p, inDb ) );
    }
    check.indexCountList.insert( std::make_pair( *p, count ) );

    sort( files.begin(), files.end() );
    sort( inDb.begin(), inDb.end() );
    isEqual = true;
    if( files.size() == inDb.size() ) {
      isEqual = equal( files.begin(), files.end(), inDb.begin() );
    }
    else {
      isEqual = false;
    }
    
    if( !isEqual ) {
      sVec diff;
      vSize s = files.size() + inDb.size();
      diff.reserve( s );
      sVec::iterator diffEnd = set_difference( inDb.begin(),
                      inDb.end(),
                      files.begin(),
                      files.end(),
                      diff.begin()
                      );
      if( diff.begin() != diffEnd ) {
   // Dateien in der DB aber nicht mehr im FS
   check.poolRemove = true;
   removeList.reserve( diffEnd - diff.begin() );
   removeList.insert( removeList.begin(),
            diff.begin(),
            diffEnd
            );
      }
    }
    check.poolInsertList.insert( std::make_pair( *p, insertList ) );
    check.poolUpdateList.insert( std::make_pair( *p, updateList ) );
    check.poolRemoveList.insert( std::make_pair( *p, removeList ) );
  }
  return;
}
  



bool
psfa::DbWriteDriverMySql::success()
{
  return success_;
}




int
psfa::DbWriteDriverMySql::insertPool( const std::string poolName ) 
{
  std::ostringstream sql;
  int id = myHelper_.getNextId( "pool", "pool_id" );
  sql << "INSERT INTO pool VALUES("
      << "'" << id << "',"
      << "'" << poolName << "'"
      << ")";
  myHelper_.executeSql( sql );
  return id;
}



void
psfa::DbWriteDriverMySql::insertKontext( const std::string pool,
                const int poolId ) 
{
  typedef std::vector< std::string > sVec;
  using psfahelper::splitString;

  Config* conf = Config::getConfig();
  std::string k = conf->getConfigValue( pool, "kontexts" );
  sVec kontexts;
  splitString( k, kontexts );
  sVec::iterator i;
  sVec::iterator iEnd = kontexts.end();
  for( i = kontexts.begin(); i != iEnd; ++i ) {
    std::ostringstream sql;
    int id = myHelper_.getNextId( "kontext", "kontext_id" );
    sql << "INSERT INTO kontext VALUES("
   << "'" << id << "',"
   << "'" << poolId << "',"
   << "'" << *i << "'"
   << ")";
    myHelper_.executeSql( sql );
  }
  return;
}



void
psfa::DbWriteDriverMySql::insertSearch( const std::string pool, 
               const int poolId )
{
  using psfahelper::splitString;
  typedef std::vector< std::string > sVec;

  Config* conf = Config::getConfig();
  std::string t = conf->getConfigValue( pool, "tags" );
  sVec tags;
  splitString( t, tags );
  sVec::iterator i;
  sVec::iterator iEnd = tags.end();
  for( i = tags.begin(); i != iEnd; ++i ) {
    std::ostringstream sql;
    int id = myHelper_.getNextId( "search", "search_id" );
    sql << "INSERT INTO search VALUES("
   << "'" << id << "',"
   << "'" << poolId << "',"
   << "'" << *i << "'"
   << ")";
    myHelper_.executeSql( sql );
  }
  return;
}



void
psfa::DbWriteDriverMySql::insertFiles( const int poolId,
                   const std::vector< std::string >& files,
                   const std::string path )
{
  using std::string;
  using psfahelper::getMd5Sum;
  typedef std::vector< string > sVec;

  sVec::const_iterator i;
  sVec::const_iterator iEnd = files.end();
  for( i = files.begin(); i != iEnd; ++i ) {
    std::ostringstream sql;
    int id = myHelper_.getNextId( "file", "file_id" );
    int dos = 0;
    bool d = insertFileRows( id, path, *i );
    if( d ) {
      dos = 1;
    }
    string md5 = getMd5Sum( path, *i );
    sql << "INSERT INTO file VALUES("
   << "'" << id << "',"
   << "'" << poolId << "',"
   << "'" << *i << "',"
   << "'" << md5 << "',"
   << "'" << dos << "'"
   << ")";
    myHelper_.executeSql( sql );
  }
  return;
}



bool
psfa::DbWriteDriverMySql::insertFileRows( const int fileId,
                 const std::string path,
                 const std::string fileName )
{
  std::string filePath = path + "/" + fileName;
  int size = psfahelper::getFileSize( filePath );

  std::ifstream file( filePath.c_str() );
  std::istreambuf_iterator<char> in( file );
  std::istreambuf_iterator<char> eof;
  std::vector<char> fileData;
  fileData.reserve( size );
  std::copy( in, eof, std::back_inserter( fileData ) );
    
  std::vector<char>::iterator f    = fileData.begin();
  std::vector<char>::iterator fEnd = fileData.end();
  std::vector<char>::iterator g    = fileData.begin();
  char pattern  = 10; // Line Feed

  bool dos = false;
  f = std::find( g, fEnd, pattern );
  --f;
  if( *f == 13 ) {
    dos = true;
  }
  std::ostringstream sql;
  while( f != fEnd ) {
    f = std::find( g, fEnd, pattern );
    // Die zweite Bedingung sichert gegen eine Datei ohne abschließendes
    // Newline ab. Dann muß nämlich noch eine Zeile verarbeitet werden, ...
    if( f == fEnd && (f - g) == 0 ) {
      continue;
    }
    int laenge = f - g + 1;
    // ... die aber um ein Byte kürzer ist.
    if( f == fEnd ) {
      --laenge;
    }
    g = f;
    ++g;
    if( dos ) {
      --laenge;
    }
    int row_id = myHelper_.getNextId( "file_row", "__id" );
    sql.str("");
    sql << "INSERT INTO file_row VALUES("
   << "'" << row_id << "',"
   << "'" << fileId << "',"
   << "'" << laenge << "'"
   << ")";
    myHelper_.executeSql( sql );
  }
  return dos;
}

    

int
psfa::DbWriteDriverMySql::insertUnit( const std::string unit, 
                  const int poolId,
                  const int file_id ) 
{
  std::ostringstream sql;

  int unit_id = myHelper_.getNextId( "unit", "unit_id" );
  sql << "INSERT INTO unit VALUES("
      << "'" << unit_id << "',"
      << "'" << poolId << "',"
      << "'" << file_id << "',"
      << "'" << unit << "'"
      << ")";
  myHelper_.executeSql( sql );
  return unit_id;
}



void
psfa::DbWriteDriverMySql::insertEntries( const int poolId,
                const std::vector< IndexData_SP >& index ) 
{
  using std::string;
  typedef std::map< string, int > sMap;
  
  int search_id  = 0;
  int kontext_id = 0;
  int unit_id    = 0;
  int file_id    = 0;
  
  sMap idMap;
  sMap::iterator id;

  std::ostringstream sql;
  std::vector< IndexData_SP >::const_iterator i;
  std::vector< IndexData_SP >::const_iterator iEnd   = index.end();
  for( i = index.begin(); i < iEnd; ++i ) {
    IndexData_SP d = *i;
    int entry_id = myHelper_.getNextId( "entry", "entry_id" );

    id = idMap.find( d->tag );
    if( id == idMap.end() ) {
      sql.str("");
      sql << "SELECT search_id FROM search WHERE s_name = '"
     << d->tag
     << "'";
      search_id = myHelper_.getSingleValueInt( sql );
      sMap::value_type v( d->tag, search_id );
      idMap.insert( v );
    }
    else {
      search_id = id->second;
    }
    
    id = idMap.find( d->kontext );
    if( id == idMap.end() ) {
      sql.str("");
      sql << "SELECT kontext_id FROM kontext WHERE k_name = '"
     << d->kontext
     << "'";
      kontext_id = myHelper_.getSingleValueInt( sql );
      sMap::value_type v( d->kontext, kontext_id );
      idMap.insert( v );
    }
    else {
      kontext_id = id->second;
    }
    
    id = idMap.find( d->unit );
    if( id == idMap.end() ) {
      id = idMap.find( d->file );
      if( id == idMap.end() ) {
   sql.str("");
   sql << "SELECT file_id FROM file WHERE f_name = '"
       << d->file
       << "'";
   file_id = myHelper_.getSingleValueInt( sql );
   sMap::value_type v( d->file, file_id );
   idMap.insert( v );
      }
      else {
   file_id = id->second;
      }
      unit_id = insertUnit( d->unit, poolId, file_id );
      sMap::value_type v( d->unit, unit_id );
      idMap.insert( v );
    }
    else {
      unit_id = id->second;
    }

    int pstart = myHelper_.calculateFilePosition( d->lineStart,
                    d->columnStart,
                    file_id );
    int pstop = myHelper_.calculateFilePosition( d->lineStop,
                   d->columnStop,
                   file_id );
    sql.str("");
    sql << "INSERT into entry VALUES("
   << "'" << entry_id << "', "
   << "'" << poolId << "', "
   << "'" << search_id << "', "
   << "'" << kontext_id << "', "
   << "'" << unit_id << "', "
   << "'" << file_id << "', "
   << "'" << d->content << "', "
   << "'" << d->lineStart << "', "
   << "'" << d->columnStart << "', "
   << "'" << d->lineStop << "', "
   << "'" << d->columnStop << "',"
   << "'" << pstart << "', "
   << "'" << pstop << "'"
   << ")";
    myHelper_.executeSql( sql );

    AttMap atts = d->attributes;
    AttMap::iterator a;
    AttMap::iterator aEnd = atts.end();
    if( !atts.empty() ) {
      int att_id = 0;
      for( a = atts.begin(); a != aEnd; ++a ) {
   att_id = myHelper_.getNextId( "attribut", "__id" );
   sql.str("");
   sql << "INSERT into attribut VALUES("
       << "'" << att_id << "', "
       << "'" << entry_id << "', "
       << "'" << a->first << "', "
       << "'" << a->second << "'"
       << ")";
   myHelper_.executeSql( sql );
      }
    }
  }
  return;
}

void
psfa::DbWriteDriverMySql::removeFiles( const int poolId,
                   const std::vector< std::string >& files )
{
  using std::string;
  using std::ostringstream;
  using std::vector;
  using std::ostream_iterator;
  typedef std::vector< string > sVec;

  ostringstream fileNames;
  std::copy( files.begin(),
        files.end(),
        ostream_iterator<string>( fileNames, "', '")
        );

  std::ostringstream sql;
  sql << "SELECT file_id FROM file WHERE f_name IN('"
      << fileNames.str()
      << "') AND pool_id = "
      << poolId;
  ostringstream fileIds;
  myHelper_.getValueStream( sql, fileIds, "', '" );
   
  sql.str("");
  sql << "SELECT unit_id FROM unit WHERE file_id IN('"
      << fileIds.str()
      << "') AND pool_id = "
      << poolId;
  ostringstream unitIds;
  myHelper_.getValueStream( sql, unitIds, "', '" );

  sql.str("");
  sql << "SELECT entry_id FROM entry WHERE unit_id IN('"
      << unitIds.str()
      << "') AND pool_id = "
      << poolId;
  ostringstream entryIds;
  myHelper_.getValueStream( sql, entryIds, "', '" );

  sql.str( "" );
  sql << "DELETE FROM attribut WHERE entry_id IN('"
      << entryIds.str()
      << "')";
  myHelper_.executeSql( sql );

  sql.str( "" );
  sql << "DELETE FROM entry WHERE entry_id IN('"
      << entryIds.str()
      << "')";
  myHelper_.executeSql( sql );
  
  sql.str( "" );
  sql << "DELETE FROM unit WHERE unit_id IN('"
      << unitIds.str()
      << "')";
  myHelper_.executeSql( sql );
  
  sql.str( "" );
  sql << "DELETE FROM file_row WHERE file_id IN('"
      << fileIds.str()
      << "')";
  myHelper_.executeSql( sql );

  sql.str( "" );
  sql << "DELETE FROM file WHERE file_id IN('"
      << fileIds.str()
      << "')";
  myHelper_.executeSql( sql );

  return;
}

---