/[svn]/linuxsampler/trunk/src/db/InstrumentsDb.cpp
ViewVC logotype

Diff of /linuxsampler/trunk/src/db/InstrumentsDb.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1345 by iliev, Thu Sep 13 21:46:25 2007 UTC revision 1727 by iliev, Tue Apr 29 15:44:09 2008 UTC
# Line 1  Line 1 
1  /***************************************************************************  /***************************************************************************
2   *                                                                         *   *                                                                         *
3   *   Copyright (C) 2007 Grigor Iliev                                       *   *   Copyright (C) 2007, 2008 Grigor Iliev                                 *
4   *                                                                         *   *                                                                         *
5   *   This program is free software; you can redistribute it and/or modify  *   *   This program is free software; you can redistribute it and/or modify  *
6   *   it under the terms of the GNU General Public License as published by  *   *   it under the terms of the GNU General Public License as published by  *
# Line 20  Line 20 
20    
21  #include "InstrumentsDb.h"  #include "InstrumentsDb.h"
22    
23  #if HAVE_SQLITE3  #include "../common/File.h"
24    #include "../common/global_private.h"
25    
26  #include <iostream>  #include <iostream>
27  #include <sstream>  #include <sstream>
28  #include <vector>  #include <vector>
 #include <dirent.h>  
29  #include <errno.h>  #include <errno.h>
30  #include <fnmatch.h>  #include <fnmatch.h>
31    
# Line 33  Line 33 
33    
34  namespace LinuxSampler {  namespace LinuxSampler {
35    
36      InstrumentsDb* InstrumentsDb::pInstrumentsDb = new InstrumentsDb;      InstrumentsDb InstrumentsDb::instance;
37    
38      void InstrumentsDb::CreateInstrumentsDb(String File) {      void InstrumentsDb::CreateInstrumentsDb(String FilePath) {
39          struct stat statBuf;          File f = File(FilePath);
40          int res = stat(File.c_str(), &statBuf);          if (f.Exist()) {
41          if (!res) {              throw Exception("File exists: " + FilePath);
             throw Exception("File exists: " + File);  
42          }          }
43                    
44          GetInstrumentsDb()->SetDbFile(File);          GetInstrumentsDb()->SetDbFile(FilePath);
45    
46          String sql =          String sql =
47              "  CREATE TABLE instr_dirs (                                      "              "  CREATE TABLE instr_dirs (                                      "
# Line 58  namespace LinuxSampler { Line 57  namespace LinuxSampler {
57                    
58          GetInstrumentsDb()->ExecSql(sql);          GetInstrumentsDb()->ExecSql(sql);
59    
60          sql = "INSERT INTO instr_dirs (dir_id, parent_dir_id, dir_name) VALUES (0, 0, '/');";          sql = "INSERT INTO instr_dirs (dir_id, parent_dir_id, dir_name) VALUES (0, -2, '/');";
61          GetInstrumentsDb()->ExecSql(sql);          GetInstrumentsDb()->ExecSql(sql);
62    
63          sql =          sql =
# Line 95  namespace LinuxSampler { Line 94  namespace LinuxSampler {
94          if (db != NULL) sqlite3_close(db);          if (db != NULL) sqlite3_close(db);
95      }      }
96            
     void InstrumentsDb::Destroy() {  
         if (pInstrumentsDb != NULL) {  
             delete pInstrumentsDb;  
             pInstrumentsDb = NULL;  
         }  
     }  
   
97      void InstrumentsDb::AddInstrumentsDbListener(InstrumentsDb::Listener* l) {      void InstrumentsDb::AddInstrumentsDbListener(InstrumentsDb::Listener* l) {
98          llInstrumentsDbListeners.AddListener(l);          llInstrumentsDbListeners.AddListener(l);
99      }      }
# Line 111  namespace LinuxSampler { Line 103  namespace LinuxSampler {
103      }      }
104            
105      InstrumentsDb* InstrumentsDb::GetInstrumentsDb() {      InstrumentsDb* InstrumentsDb::GetInstrumentsDb() {
106          return pInstrumentsDb;          return &instance;
107      }      }
108            
109      void InstrumentsDb::SetDbFile(String File) {      void InstrumentsDb::SetDbFile(String File) {
# Line 127  namespace LinuxSampler { Line 119  namespace LinuxSampler {
119      sqlite3* InstrumentsDb::GetDb() {      sqlite3* InstrumentsDb::GetDb() {
120          if ( db != NULL) return db;          if ( db != NULL) return db;
121    
122          if (DbFile.empty()) DbFile = "/var/lib/linuxsampler/instruments.db";          if (DbFile.empty()) DbFile = CONFIG_DEFAULT_INSTRUMENTS_DB_LOCATION;
123                    #if defined(__APPLE__)  /* 20071224 Toshi Nagata  */
124                    if (DbFile.find("~") == 0)
125                            DbFile.replace(0, 1, getenv("HOME"));
126                    #endif
127          int rc = sqlite3_open(DbFile.c_str(), &db);          int rc = sqlite3_open(DbFile.c_str(), &db);
128          if (rc) {          if (rc) {
129              sqlite3_close(db);              sqlite3_close(db);
# Line 136  namespace LinuxSampler { Line 132  namespace LinuxSampler {
132          }          }
133          rc = sqlite3_create_function(db, "regexp", 2, SQLITE_UTF8, NULL, Regexp, NULL, NULL);          rc = sqlite3_create_function(db, "regexp", 2, SQLITE_UTF8, NULL, Regexp, NULL, NULL);
134          if (rc) { throw Exception("Failed to add user function for handling regular expressions."); }          if (rc) { throw Exception("Failed to add user function for handling regular expressions."); }
135    
136            // TODO: remove this in the next version
137            try {
138                int i = ExecSqlInt("SELECT parent_dir_id FROM instr_dirs WHERE dir_id=0");
139                // The parent ID of the root directory should be -2 now.
140                if(i != -2) ExecSql("UPDATE instr_dirs SET parent_dir_id=-2 WHERE dir_id=0");
141            } catch(Exception e) { }
142            ////////////////////////////////////////
143                    
144          return db;          return db;
145      }      }
# Line 149  namespace LinuxSampler { Line 153  namespace LinuxSampler {
153                    
154          int count = ExecSqlInt(sql.str());          int count = ExecSqlInt(sql.str());
155    
         // While the root dir has ID 0 and parent ID 0, the directory  
         // count for the root dir will be incorrect, so we should fix it.  
         if (count != -1 && DirId == 0) count--;  
156          return count;          return count;
157      }      }
158    
# Line 259  namespace LinuxSampler { Line 260  namespace LinuxSampler {
260          return ExecSqlInt(sql.str(), DirName);          return ExecSqlInt(sql.str(), DirName);
261      }      }
262    
263        int InstrumentsDb::GetDirectoryId(int InstrId) {
264            dmsg(2,("InstrumentsDb: GetDirectoryId(InstrId=%d)\n", InstrId));
265            std::stringstream sql;
266            sql << "SELECT dir_id FROM instruments WHERE instr_id=" << InstrId;
267            return ExecSqlInt(sql.str());
268        }
269    
270      String InstrumentsDb::GetDirectoryName(int DirId) {      String InstrumentsDb::GetDirectoryName(int DirId) {
271          String sql = "SELECT dir_name FROM instr_dirs WHERE dir_id=" + ToString(DirId);          String sql = "SELECT dir_name FROM instr_dirs WHERE dir_id=" + ToString(DirId);
272          String name = ExecSqlString(sql);          String name = ExecSqlString(sql);
# Line 283  namespace LinuxSampler { Line 291  namespace LinuxSampler {
291                  path = "/" + path;                  path = "/" + path;
292                  break;                  break;
293              }              }
294              path = GetDirectoryName(DirId) + path;              path = GetDirectoryName(DirId) + "/" + path;
295              DirId = GetParentDirectoryId(DirId);              DirId = GetParentDirectoryId(DirId);
296          }          }
297    
# Line 291  namespace LinuxSampler { Line 299  namespace LinuxSampler {
299    
300          return path;          return path;
301      }      }
302        
303        StringListPtr InstrumentsDb::GetInstrumentsByFile(String File) {
304            dmsg(2,("InstrumentsDb: GetInstrumentsByFile(File=%s)\n", File.c_str()));
305    
306            StringListPtr instrs(new std::vector<String>);
307            
308            BeginTransaction();
309            try {
310                File = toEscapedFsPath(File);
311                IntListPtr ids = ExecSqlIntList("SELECT instr_id FROM instruments WHERE instr_file=?", File);
312                
313                for (int i = 0; i < ids->size(); i++) {
314                    String name = GetInstrumentName(ids->at(i));
315                    String dir = GetDirectoryPath(GetDirectoryId(ids->at(i)));
316                    instrs->push_back(dir + name);
317                }
318            } catch (Exception e) {
319                EndTransaction();
320                throw e;
321            }
322            EndTransaction();
323            
324            return instrs;
325        }
326    
327      void InstrumentsDb::AddDirectory(String Dir) {      void InstrumentsDb::AddDirectory(String Dir) {
328          dmsg(2,("InstrumentsDb: AddDirectory(Dir=%s)\n", Dir.c_str()));          dmsg(2,("InstrumentsDb: AddDirectory(Dir=%s)\n", Dir.c_str()));
# Line 496  namespace LinuxSampler { Line 528  namespace LinuxSampler {
528          }          }
529    
530          EndTransaction();          EndTransaction();
531          FireDirectoryNameChanged(Dir, Name);          FireDirectoryNameChanged(Dir, toAbstractName(Name));
532      }      }
533    
534      void InstrumentsDb::MoveDirectory(String Dir, String Dst) {      void InstrumentsDb::MoveDirectory(String Dir, String Dst) {
# Line 659  namespace LinuxSampler { Line 691  namespace LinuxSampler {
691              int dirId = GetDirectoryId(DbDir);              int dirId = GetDirectoryId(DbDir);
692              if (dirId == -1) throw Exception("Invalid DB directory: " + toEscapedText(DbDir));              if (dirId == -1) throw Exception("Invalid DB directory: " + toEscapedText(DbDir));
693    
694              struct stat statBuf;              File f = File(FilePath);
695              int res = stat(FilePath.c_str(), &statBuf);              if (!f.Exist()) {
             if (res) {  
696                  std::stringstream ss;                  std::stringstream ss;
697                  ss << "Fail to stat `" << FilePath << "`: " << strerror(errno);                  ss << "Fail to stat `" << FilePath << "`: " << f.GetErrorMsg();
698                  throw Exception(ss.str());                  throw Exception(ss.str());
699              }              }
700    
701              if (!S_ISREG(statBuf.st_mode)) {              if (!f.IsFile()) {
702                  std::stringstream ss;                  std::stringstream ss;
703                  ss << "`" << FilePath << "` is not an instrument file";                  ss << "`" << FilePath << "` is not an instrument file";
704                  throw Exception(ss.str());                  throw Exception(ss.str());
# Line 691  namespace LinuxSampler { Line 722  namespace LinuxSampler {
722              int dirId = GetDirectoryId(DbDir);              int dirId = GetDirectoryId(DbDir);
723              if (dirId == -1) throw Exception("Invalid DB directory: " + toEscapedPath(DbDir));              if (dirId == -1) throw Exception("Invalid DB directory: " + toEscapedPath(DbDir));
724    
725              struct stat statBuf;              File f = File(FsDir);
726              int res = stat(FsDir.c_str(), &statBuf);              if (!f.Exist()) {
             if (res) {  
727                  std::stringstream ss;                  std::stringstream ss;
728                  ss << "Fail to stat `" << FsDir << "`: " << strerror(errno);                  ss << "Fail to stat `" << FsDir << "`: " << f.GetErrorMsg();
729                  throw Exception(ss.str());                  throw Exception(ss.str());
730              }              }
731    
732              if (!S_ISDIR(statBuf.st_mode)) {              if (!f.IsDirectory()) {
733                  throw Exception("Directory expected");                  throw Exception("Directory expected: " + FsDir);
734              }              }
735                            
736              if (FsDir.at(FsDir.length() - 1) != '/') FsDir.append("/");              if (FsDir.at(FsDir.length() - 1) != File::DirSeparator) {
737                    FsDir.push_back(File::DirSeparator);
             DIR* pDir = opendir(FsDir.c_str());  
             if (pDir == NULL) {  
                 std::stringstream ss;  
                 ss << "The scanning of directory `" << FsDir << "` failed: ";  
                 ss << strerror(errno);  
                 std::cerr << ss.str();  
                 DbInstrumentsMutex.Unlock();  
                 return;  
738              }              }
739                
740              struct dirent* pEnt = readdir(pDir);              try {
741              while (pEnt != NULL) {                  FileListPtr fileList = File::GetFiles(FsDir);
742                  if (pEnt->d_type != DT_REG) {                  for (int i = 0; i < fileList->size(); i++) {
743                      pEnt = readdir(pDir);                      AddInstrumentsFromFile(DbDir, FsDir + fileList->at(i), -1, pProgress);
                     continue;  
744                  }                  }
745                } catch(Exception e) {
746                  AddInstrumentsFromFile(DbDir, FsDir + String(pEnt->d_name), -1, pProgress);                  e.PrintMessage();
747                  pEnt = readdir(pDir);                  DbInstrumentsMutex.Unlock();
748              }                  return;
   
             if (closedir(pDir)) {  
                 std::stringstream ss;  
                 ss << "Failed to close directory `" << FsDir << "`: ";  
                 ss << strerror(errno);  
                 std::cerr << ss.str();  
749              }              }
750          } catch (Exception e) {          } catch (Exception e) {
751              DbInstrumentsMutex.Unlock();              DbInstrumentsMutex.Unlock();
# Line 743  namespace LinuxSampler { Line 758  namespace LinuxSampler {
758      void InstrumentsDb::AddInstrumentsRecursive(String DbDir, String FsDir, bool Flat, ScanProgress* pProgress) {      void InstrumentsDb::AddInstrumentsRecursive(String DbDir, String FsDir, bool Flat, ScanProgress* pProgress) {
759          dmsg(2,("InstrumentsDb: AddInstrumentsRecursive(DbDir=%s,FsDir=%s,Flat=%d)\n", DbDir.c_str(), FsDir.c_str(), Flat));          dmsg(2,("InstrumentsDb: AddInstrumentsRecursive(DbDir=%s,FsDir=%s,Flat=%d)\n", DbDir.c_str(), FsDir.c_str(), Flat));
760          if (pProgress != NULL) {          if (pProgress != NULL) {
761              pProgress->SetTotalFileCount(InstrumentFileCounter::Count(FsDir));              InstrumentFileCounter c;
762                pProgress->SetTotalFileCount(c.Count(FsDir));
763          }          }
764    
765          DirectoryScanner::Scan(DbDir, FsDir, Flat, pProgress);          DirectoryScanner d;
766            d.Scan(DbDir, FsDir, Flat, pProgress);
767      }      }
768    
769      int InstrumentsDb::GetInstrumentCount(int DirId) {      int InstrumentsDb::GetInstrumentCount(int DirId) {
# Line 808  namespace LinuxSampler { Line 825  namespace LinuxSampler {
825                  sql << "SELECT instr_name FROM instruments WHERE dir_id=" << dirId;                  sql << "SELECT instr_name FROM instruments WHERE dir_id=" << dirId;
826    
827                  pInstrs = ExecSqlStringList(sql.str());                  pInstrs = ExecSqlStringList(sql.str());
828                    // Converting to abstract names
829                    for (int i = 0; i < pInstrs->size(); i++) {
830                        for (int j = 0; j < pInstrs->at(i).length(); j++) {
831                            if (pInstrs->at(i).at(j) == '/') pInstrs->at(i).at(j) = '\0';
832                        }
833                    }
834              }              }
835              EndTransaction();              EndTransaction();
836              return pInstrs;              return pInstrs;
# Line 968  namespace LinuxSampler { Line 991  namespace LinuxSampler {
991              throw e;              throw e;
992          }          }
993          EndTransaction();          EndTransaction();
994          FireInstrumentNameChanged(Instr, Name);          FireInstrumentNameChanged(Instr, toAbstractName(Name));
995      }      }
996    
997      void InstrumentsDb::MoveInstrument(String Instr, String Dst) {      void InstrumentsDb::MoveInstrument(String Instr, String Dst) {
# Line 1036  namespace LinuxSampler { Line 1059  namespace LinuxSampler {
1059                  return;                  return;
1060              }              }
1061    
             if (GetInstrumentId(dstId, instrName) != -1) {  
                 String s = toEscapedPath(instrName);  
                 throw Exception("Cannot copy. Instrument with that name already exists: " + s);  
             }  
   
             if (GetDirectoryId(dstId, instrName) != -1) {  
                 String s = toEscapedPath(instrName);  
                 throw Exception("Cannot copy. Directory with that name already exists: " + s);  
             }  
   
1062              CopyInstrument(instrId, instrName, dstId, Dst);              CopyInstrument(instrId, instrName, dstId, Dst);
1063          } catch (Exception e) {          } catch (Exception e) {
1064              EndTransaction();              EndTransaction();
# Line 1056  namespace LinuxSampler { Line 1069  namespace LinuxSampler {
1069      }      }
1070    
1071      void InstrumentsDb::CopyInstrument(int InstrId, String InstrName, int DstDirId, String DstDir) {      void InstrumentsDb::CopyInstrument(int InstrId, String InstrName, int DstDirId, String DstDir) {
1072            if (GetInstrumentId(DstDirId, InstrName) != -1) {
1073                String s = toEscapedPath(InstrName);
1074                throw Exception("Cannot copy. Instrument with that name already exists: " + s);
1075            }
1076    
1077            if (GetDirectoryId(DstDirId, InstrName) != -1) {
1078                String s = toEscapedPath(InstrName);
1079                throw Exception("Cannot copy. Directory with that name already exists: " + s);
1080            }
1081    
1082          DbInstrument i = GetInstrumentInfo(InstrId);          DbInstrument i = GetInstrumentInfo(InstrId);
1083          sqlite3_stmt *pStmt = NULL;          sqlite3_stmt *pStmt = NULL;
1084          std::stringstream sql;          std::stringstream sql;
# Line 1069  namespace LinuxSampler { Line 1092  namespace LinuxSampler {
1092              throw Exception("DB error: " + ToString(sqlite3_errmsg(db)));              throw Exception("DB error: " + ToString(sqlite3_errmsg(db)));
1093          }          }
1094    
1095          BindTextParam(pStmt, 1, toDbName(InstrName));          String s = toDbName(InstrName);
1096            BindTextParam(pStmt, 1, s);
1097          BindTextParam(pStmt, 2, i.InstrFile);          BindTextParam(pStmt, 2, i.InstrFile);
1098          BindTextParam(pStmt, 3, i.FormatFamily);          BindTextParam(pStmt, 3, i.FormatFamily);
1099          BindTextParam(pStmt, 4, i.FormatVersion);          BindTextParam(pStmt, 4, i.FormatVersion);
# Line 1128  namespace LinuxSampler { Line 1152  namespace LinuxSampler {
1152                  }                  }
1153              }              }
1154          } catch(Exception e) {          } catch(Exception e) {
1155              std::cerr << e.Message() << std::endl;              e.PrintMessage();
1156          }          }
1157      }      }
1158    
1159      void InstrumentsDb::AddGigInstruments(String DbDir, String File, int Index, ScanProgress* pProgress) {      void InstrumentsDb::AddGigInstruments(String DbDir, String FilePath, int Index, ScanProgress* pProgress) {
1160          dmsg(2,("InstrumentsDb: AddGigInstruments(DbDir=%s,File=%s,Index=%d)\n", DbDir.c_str(), File.c_str(), Index));          dmsg(2,("InstrumentsDb: AddGigInstruments(DbDir=%s,FilePath=%s,Index=%d)\n", DbDir.c_str(), FilePath.c_str(), Index));
1161          int dirId = GetDirectoryId(DbDir);          int dirId = GetDirectoryId(DbDir);
1162          if (dirId == -1) throw Exception("Invalid DB directory: " + toEscapedPath(DbDir));          if (dirId == -1) throw Exception("Invalid DB directory: " + toEscapedPath(DbDir));
1163    
1164          struct stat statBuf;          File f = File(FilePath);
1165          int res = stat(File.c_str(), &statBuf);          if (!f.Exist()) {
         if (res) {  
1166              std::stringstream ss;              std::stringstream ss;
1167              ss << "Fail to stat `" << File << "`: " << strerror(errno);              ss << "Fail to stat `" << FilePath << "`: " << f.GetErrorMsg();
1168              throw Exception(ss.str());              throw Exception(ss.str());
1169          }          }
1170    
1171          if (!S_ISREG(statBuf.st_mode)) {          if (!f.IsFile()) {
1172              std::stringstream ss;              std::stringstream ss;
1173              ss << "`" << File << "` is not a regular file";              ss << "`" << FilePath << "` is not a regular file";
1174              throw Exception(ss.str());              throw Exception(ss.str());
1175          }          }
1176    
1177          RIFF::File* riff = NULL;          RIFF::File* riff = NULL;
1178          gig::File* gig = NULL;          gig::File* gig = NULL;
1179          try {          try {
1180              riff = new RIFF::File(File);              riff = new RIFF::File(FilePath);
1181              gig::File* gig = new gig::File(riff);              gig::File* gig = new gig::File(riff);
1182                gig->SetAutoLoad(false); // avoid time consuming samples scanning
1183    
1184              std::stringstream sql;              std::stringstream sql;
1185              sql << "INSERT INTO instruments (dir_id,instr_name,instr_file,";              sql << "INSERT INTO instruments (dir_id,instr_name,instr_file,";
1186              sql << "instr_nr,format_family,format_version,instr_size,";              sql << "instr_nr,format_family,format_version,instr_size,";
1187              sql << "description,is_drum,product,artists,keywords) VALUES (";              sql << "description,is_drum,product,artists,keywords) VALUES (";
1188              sql << dirId << ",?,?,?,'GIG',?," << statBuf.st_size << ",?,?,?,?,?)";              sql << dirId << ",?,?,?,'GIG',?," << f.GetSize() << ",?,?,?,?,?)";
1189    
1190              sqlite3_stmt* pStmt = NULL;              sqlite3_stmt* pStmt = NULL;
1191    
# Line 1170  namespace LinuxSampler { Line 1194  namespace LinuxSampler {
1194                  throw Exception("DB error: " + ToString(sqlite3_errmsg(db)));                  throw Exception("DB error: " + ToString(sqlite3_errmsg(db)));
1195              }              }
1196    
1197              BindTextParam(pStmt, 2, File);              String s = toEscapedFsPath(FilePath);
1198                BindTextParam(pStmt, 2, s);
1199              String ver = "";              String ver = "";
1200              if (gig->pVersion != NULL) ver = ToString(gig->pVersion->major);              if (gig->pVersion != NULL) ver = ToString(gig->pVersion->major);
1201              BindTextParam(pStmt, 4, ver);              BindTextParam(pStmt, 4, ver);
# Line 1183  namespace LinuxSampler { Line 1208  namespace LinuxSampler {
1208                      BindTextParam(pStmt, 7, gig->pInfo->Product);                      BindTextParam(pStmt, 7, gig->pInfo->Product);
1209                      BindTextParam(pStmt, 8, gig->pInfo->Artists);                      BindTextParam(pStmt, 8, gig->pInfo->Artists);
1210                      BindTextParam(pStmt, 9, gig->pInfo->Keywords);                      BindTextParam(pStmt, 9, gig->pInfo->Keywords);
1211                      AddGigInstrument(pStmt, DbDir, dirId, File, pInstrument, instrIndex);                      AddGigInstrument(pStmt, DbDir, dirId, FilePath, pInstrument, instrIndex);
1212    
1213                      instrIndex++;                      instrIndex++;
1214                      pInstrument = gig->GetNextInstrument();                      pInstrument = gig->GetNextInstrument();
# Line 1196  namespace LinuxSampler { Line 1221  namespace LinuxSampler {
1221                      BindTextParam(pStmt, 7, gig->pInfo->Product);                      BindTextParam(pStmt, 7, gig->pInfo->Product);
1222                      BindTextParam(pStmt, 8, gig->pInfo->Artists);                      BindTextParam(pStmt, 8, gig->pInfo->Artists);
1223                      BindTextParam(pStmt, 9, gig->pInfo->Keywords);                      BindTextParam(pStmt, 9, gig->pInfo->Keywords);
1224                      AddGigInstrument(pStmt, DbDir, dirId, File, pInstrument, Index);                      AddGigInstrument(pStmt, DbDir, dirId, FilePath, pInstrument, Index);
1225                  }                  }
1226              }              }
1227    
# Line 1207  namespace LinuxSampler { Line 1232  namespace LinuxSampler {
1232              if (gig != NULL) delete gig;              if (gig != NULL) delete gig;
1233              if (riff != NULL) delete riff;              if (riff != NULL) delete riff;
1234              std::stringstream ss;              std::stringstream ss;
1235              ss << "Failed to scan `" << File << "`: " << e.Message;              ss << "Failed to scan `" << FilePath << "`: " << e.Message;
1236                            
1237              throw Exception(ss.str());              throw Exception(ss.str());
1238          } catch (Exception e) {          } catch (Exception e) {
# Line 1217  namespace LinuxSampler { Line 1242  namespace LinuxSampler {
1242          } catch (...) {          } catch (...) {
1243              if (gig != NULL) delete gig;              if (gig != NULL) delete gig;
1244              if (riff != NULL) delete riff;              if (riff != NULL) delete riff;
1245              throw Exception("Failed to scan `" + File + "`");              throw Exception("Failed to scan `" + FilePath + "`");
1246          }          }
1247      }      }
1248    
1249      void InstrumentsDb::AddGigInstrument(sqlite3_stmt* pStmt, String DbDir, int DirId, String File, gig::Instrument* pInstrument, int Index) {      void InstrumentsDb::AddGigInstrument(sqlite3_stmt* pStmt, String DbDir, int DirId, String File, gig::Instrument* pInstrument, int Index) {
1250            dmsg(2,("InstrumentsDb: AddGigInstrument(DbDir=%s,DirId=%d,File=%s,Index=%d)\n", DbDir.c_str(), DirId, File.c_str(), Index));
1251          String name = pInstrument->pInfo->Name;          String name = pInstrument->pInfo->Name;
1252          if (name == "") return;          if (name == "") return;
1253          name = GetUniqueInstrumentName(DirId, name);          name = GetUniqueInstrumentName(DirId, name);
# Line 1229  namespace LinuxSampler { Line 1255  namespace LinuxSampler {
1255          std::stringstream sql2;          std::stringstream sql2;
1256          sql2 << "SELECT COUNT(*) FROM instruments WHERE instr_file=? AND ";          sql2 << "SELECT COUNT(*) FROM instruments WHERE instr_file=? AND ";
1257          sql2 << "instr_nr=" << Index;          sql2 << "instr_nr=" << Index;
1258          if (ExecSqlInt(sql2.str(), File) > 0) return;          String s = toEscapedFsPath(File);
1259            if (ExecSqlInt(sql2.str(), s) > 0) return;
1260    
1261          BindTextParam(pStmt, 1, name);          BindTextParam(pStmt, 1, name);
1262          BindIntParam(pStmt, 3, Index);          BindIntParam(pStmt, 3, Index);
# Line 1319  namespace LinuxSampler { Line 1346  namespace LinuxSampler {
1346    
1347          return instrumentFinder.GetInstruments();          return instrumentFinder.GetInstruments();
1348      }      }
1349        
1350        StringListPtr InstrumentsDb::FindLostInstrumentFiles() {
1351            dmsg(2,("InstrumentsDb: FindLostInstrumentFiles()\n"));
1352    
1353            BeginTransaction();
1354            try {
1355                StringListPtr files = ExecSqlStringList("SELECT DISTINCT instr_file FROM instruments");
1356                StringListPtr result(new std::vector<String>);
1357                for (int i = 0; i < files->size(); i++) {
1358                    File f(toNonEscapedFsPath(files->at(i)));
1359                    if (!f.Exist()) result->push_back(files->at(i));
1360                }
1361                return result;
1362            } catch (Exception e) {
1363                EndTransaction();
1364                throw e;
1365            }
1366            EndTransaction();
1367        }
1368        
1369        void InstrumentsDb::SetInstrumentFilePath(String OldPath, String NewPath) {
1370            if (OldPath == NewPath) return;
1371            StringListPtr instrs;
1372            BeginTransaction();
1373            try {
1374                std::vector<String> params(2);
1375                params[0] = toEscapedFsPath(NewPath);
1376                params[1] = toEscapedFsPath(OldPath);
1377                instrs = GetInstrumentsByFile(OldPath);
1378                ExecSql("UPDATE instruments SET instr_file=? WHERE instr_file=?", params);
1379            } catch (Exception e) {
1380                EndTransaction();
1381                throw e;
1382            }
1383            EndTransaction();
1384            
1385            for (int i = 0; i < instrs->size(); i++) {
1386                FireInstrumentInfoChanged(instrs->at(i));
1387            }
1388        }
1389    
1390      void InstrumentsDb::BeginTransaction() {      void InstrumentsDb::BeginTransaction() {
1391          dmsg(2,("InstrumentsDb: BeginTransaction(InTransaction=%d)\n", InTransaction));          dmsg(2,("InstrumentsDb: BeginTransaction(InTransaction=%d)\n", InTransaction));
# Line 1380  namespace LinuxSampler { Line 1447  namespace LinuxSampler {
1447    
1448      void InstrumentsDb::ExecSql(String Sql) {      void InstrumentsDb::ExecSql(String Sql) {
1449          dmsg(2,("InstrumentsDb: ExecSql(Sql=%s)\n", Sql.c_str()));          dmsg(2,("InstrumentsDb: ExecSql(Sql=%s)\n", Sql.c_str()));
1450          sqlite3_stmt *pStmt = NULL;          std::vector<String> Params;
1451                    ExecSql(Sql, Params);
         int res = sqlite3_prepare(GetDb(), Sql.c_str(), -1, &pStmt, NULL);  
         if (res != SQLITE_OK) {  
             throw Exception("DB error: " + ToString(sqlite3_errmsg(db)));  
         }  
           
         res = sqlite3_step(pStmt);  
         if(res != SQLITE_DONE) {  
             sqlite3_finalize(pStmt);  
             throw Exception("DB error: " + ToString(sqlite3_errmsg(db)));  
         }  
   
         sqlite3_finalize(pStmt);  
1452      }      }
1453    
1454      void InstrumentsDb::ExecSql(String Sql, String Param) {      void InstrumentsDb::ExecSql(String Sql, String Param) {
1455          dmsg(2,("InstrumentsDb: ExecSql(Sql=%s,Param=%s)\n", Sql.c_str(), Param.c_str()));          dmsg(2,("InstrumentsDb: ExecSql(Sql=%s,Param=%s)\n", Sql.c_str(), Param.c_str()));
1456            std::vector<String> Params;
1457            Params.push_back(Param);
1458            ExecSql(Sql, Params);
1459        }
1460    
1461        void InstrumentsDb::ExecSql(String Sql, std::vector<String>& Params) {
1462            dmsg(2,("InstrumentsDb: ExecSql(Sql=%s,Params)\n", Sql.c_str()));
1463          sqlite3_stmt *pStmt = NULL;          sqlite3_stmt *pStmt = NULL;
1464                    
1465          int res = sqlite3_prepare(GetDb(), Sql.c_str(), -1, &pStmt, NULL);          int res = sqlite3_prepare(GetDb(), Sql.c_str(), -1, &pStmt, NULL);
# Line 1406  namespace LinuxSampler { Line 1468  namespace LinuxSampler {
1468              throw Exception("DB error: " + ToString(sqlite3_errmsg(db)));              throw Exception("DB error: " + ToString(sqlite3_errmsg(db)));
1469          }          }
1470    
1471          BindTextParam(pStmt, 1, Param);          for(int i = 0; i < Params.size(); i++) {
1472                BindTextParam(pStmt, i + 1, Params[i]);
1473            }
1474    
1475          res = sqlite3_step(pStmt);          res = sqlite3_step(pStmt);
1476          if (res != SQLITE_DONE) {          if (res != SQLITE_DONE) {
# Line 1488  namespace LinuxSampler { Line 1552  namespace LinuxSampler {
1552      }      }
1553    
1554      IntListPtr InstrumentsDb::ExecSqlIntList(String Sql) {      IntListPtr InstrumentsDb::ExecSqlIntList(String Sql) {
1555            dmsg(2,("InstrumentsDb: ExecSqlIntList(Sql=%s)\n", Sql.c_str()));
1556            std::vector<String> Params;
1557            return ExecSqlIntList(Sql, Params);
1558        }
1559    
1560        IntListPtr InstrumentsDb::ExecSqlIntList(String Sql, String Param) {
1561            dmsg(2,("InstrumentsDb: ExecSqlIntList(Sql=%s,Param=%s)\n", Sql.c_str(), Param.c_str()));
1562            std::vector<String> Params;
1563            Params.push_back(Param);
1564            return ExecSqlIntList(Sql, Params);
1565        }
1566    
1567        IntListPtr InstrumentsDb::ExecSqlIntList(String Sql, std::vector<String>& Params) {
1568            dmsg(2,("InstrumentsDb: ExecSqlIntList(Sql=%s)\n", Sql.c_str()));
1569          IntListPtr intList(new std::vector<int>);          IntListPtr intList(new std::vector<int>);
1570                    
1571          sqlite3_stmt *pStmt = NULL;          sqlite3_stmt *pStmt = NULL;
# Line 1497  namespace LinuxSampler { Line 1575  namespace LinuxSampler {
1575              throw Exception("DB error: " + ToString(sqlite3_errmsg(db)));              throw Exception("DB error: " + ToString(sqlite3_errmsg(db)));
1576          }          }
1577                    
1578            for(int i = 0; i < Params.size(); i++) {
1579                BindTextParam(pStmt, i + 1, Params[i]);
1580            }
1581            
1582          res = sqlite3_step(pStmt);          res = sqlite3_step(pStmt);
1583          while(res == SQLITE_ROW) {          while(res == SQLITE_ROW) {
1584              intList->push_back(sqlite3_column_int(pStmt, 0));              intList->push_back(sqlite3_column_int(pStmt, 0));
# Line 1514  namespace LinuxSampler { Line 1596  namespace LinuxSampler {
1596      }      }
1597            
1598      StringListPtr InstrumentsDb::ExecSqlStringList(String Sql) {      StringListPtr InstrumentsDb::ExecSqlStringList(String Sql) {
1599            dmsg(2,("InstrumentsDb: ExecSqlStringList(Sql=%s)\n", Sql.c_str()));
1600          StringListPtr stringList(new std::vector<String>);          StringListPtr stringList(new std::vector<String>);
1601                    
1602          sqlite3_stmt *pStmt = NULL;          sqlite3_stmt *pStmt = NULL;
# Line 1609  namespace LinuxSampler { Line 1692  namespace LinuxSampler {
1692          return Dir.substr(0, i);          return Dir.substr(0, i);
1693      }      }
1694    
1695        void InstrumentsDb::Format() {
1696            DbInstrumentsMutex.Lock();
1697            if (db != NULL) {
1698                sqlite3_close(db);
1699                db = NULL;
1700            }
1701    
1702            if (DbFile.empty()) DbFile = CONFIG_DEFAULT_INSTRUMENTS_DB_LOCATION;
1703            String bkp = DbFile + ".bkp";
1704            remove(bkp.c_str());
1705            if (rename(DbFile.c_str(), bkp.c_str()) && errno != ENOENT) {
1706                DbInstrumentsMutex.Unlock();
1707                throw Exception(String("Failed to backup database: ") + strerror(errno));
1708            }
1709            
1710            String f = DbFile;
1711            DbFile = "";
1712            try { CreateInstrumentsDb(f); }
1713            catch(Exception e) {
1714                DbInstrumentsMutex.Unlock();
1715                throw e;
1716            }
1717            DbInstrumentsMutex.Unlock();
1718            
1719            FireDirectoryCountChanged("/");
1720            FireInstrumentCountChanged("/");
1721        }
1722    
1723      void InstrumentsDb::CheckFileName(String File) {      void InstrumentsDb::CheckFileName(String File) {
1724          if (File.empty()) throw Exception("Invalid file name: " + File);          if (File.empty()) throw Exception("Invalid file name: " + File);
1725      }      }
# Line 1638  namespace LinuxSampler { Line 1749  namespace LinuxSampler {
1749    
1750      String InstrumentsDb::toEscapedPath(String AbstractName) {      String InstrumentsDb::toEscapedPath(String AbstractName) {
1751          for (int i = 0; i < AbstractName.length(); i++) {          for (int i = 0; i < AbstractName.length(); i++) {
1752              if (AbstractName.at(i) == '\0')      AbstractName.replace(i++, 1, "\\/");              if (AbstractName.at(i) == '\0')      AbstractName.replace(i++, 1, "\\x2f");
1753              else if (AbstractName.at(i) == '\\') AbstractName.replace(i++, 1, "\\\\");              else if (AbstractName.at(i) == '\\') AbstractName.replace(i++, 1, "\\\\");
1754              else if (AbstractName.at(i) == '\'') AbstractName.replace(i++, 1, "\\'");              else if (AbstractName.at(i) == '\'') AbstractName.replace(i++, 1, "\\'");
1755              else if (AbstractName.at(i) == '"')  AbstractName.replace(i++, 1, "\\\"");              else if (AbstractName.at(i) == '"')  AbstractName.replace(i++, 1, "\\\"");
# Line 1659  namespace LinuxSampler { Line 1770  namespace LinuxSampler {
1770          return text;          return text;
1771      }      }
1772            
1773      String InstrumentsDb::toEscapedName(String AbstractName) {      String InstrumentsDb::toNonEscapedText(String text) {
1774          for (int i = 0; i < AbstractName.length(); i++) {          String sb;
1775              if (AbstractName.at(i) == '\0')      AbstractName.at(i) = '/';          for (int i = 0; i < text.length(); i++) {
1776              else if (AbstractName.at(i) == '\\') AbstractName.replace(i++, 1, "\\\\");              char c = text.at(i);
1777              else if (AbstractName.at(i) == '\'') AbstractName.replace(i++, 1, "\\'");                          if(c == '\\') {
1778              else if (AbstractName.at(i) == '"')  AbstractName.replace(i++, 1, "\\\"");                                  if(i >= text.length()) {
1779              else if (AbstractName.at(i) == '\r') AbstractName.replace(i++, 1, "\\r");                                          std::cerr << "Broken escape sequence!" << std::endl;
1780              else if (AbstractName.at(i) == '\n') AbstractName.replace(i++, 1, "\\n");                                          break;
1781                                    }
1782                                    char c2 = text.at(++i);
1783                                    if(c2 == '\'')      sb.push_back('\'');
1784                                    else if(c2 == '"')  sb.push_back('"');
1785                                    else if(c2 == '\\') sb.push_back('\\');
1786                                    else if(c2 == 'r')  sb.push_back('\r');
1787                                    else if(c2 == 'n')  sb.push_back('\n');
1788                                    else std::cerr << "Unknown escape sequence \\" << c2 << std::endl;
1789                            } else {
1790                                    sb.push_back(c);
1791                            }
1792          }          }
1793          return AbstractName;          return sb;
1794        }
1795        
1796        String InstrumentsDb::toEscapedFsPath(String FsPath) {
1797            return toEscapedText(FsPath);
1798        }
1799        
1800        String InstrumentsDb::toNonEscapedFsPath(String FsPath) {
1801            return toNonEscapedText(FsPath);
1802      }      }
1803            
1804      String InstrumentsDb::toAbstractName(String DbName) {      String InstrumentsDb::toAbstractName(String DbName) {
# Line 1721  namespace LinuxSampler { Line 1851  namespace LinuxSampler {
1851      }      }
1852    
1853  } // namespace LinuxSampler  } // namespace LinuxSampler
   
 #endif // HAVE_SQLITE3  
Legend:
Removed from v.1345  
changed lines
  Added in v.1727
  ViewVC Help
Powered by ViewVC