mirror/musikcube
1
0
Fork 0
mirror of https://github.com/clangen/musikcube.git synced 2025-03-14 04:18:36 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fixed queries based on ListBase to all handle the TrackInfoSignal.

Browse Source
This commit is contained in:
Daniel Önnerby 2008-06-04 10:28:34 +00:00
parent 26d6abf31d
commit 8cb6178229
4 changed files with 47 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
src/core/Query/ListBase.cpp
View File

@ -134,3 +134,36 @@ Query::ListBase::TrackInfoSignal& Query::ListBase::OnTrackInfoEvent(){
return this->trackInfoEvent;
}
bool Query::ListBase::ParseTracksSQL(std::string sql,Library::Base *oLibrary,db::Connection &db){
if(this->trackEvent.has_connections() && !oLibrary->QueryCanceled()){
db::Statement selectTracks(sql.c_str(),db);
TrackVector tempTrackResults;
tempTrackResults.reserve(101);
int row(0);
while(selectTracks.Step()==db::ReturnCode::Row){
tempTrackResults.push_back(TrackPtr(new Track(selectTracks.ColumnInt(0))));
this->trackInfoDuration += selectTracks.ColumnInt64(1);
this->trackInfoSize += selectTracks.ColumnInt64(2);
this->trackInfoTracks++;
if( (++row)%100==0 ){
boost::mutex::scoped_lock lock(oLibrary->oResultMutex);
this->trackResults.insert(this->trackResults.end(),tempTrackResults.begin(),tempTrackResults.end());
tempTrackResults.clear();
trackResults.reserve(101);
}
}
if(!tempTrackResults.empty()){
boost::mutex::scoped_lock lock(oLibrary->oResultMutex);
this->trackResults.insert(this->trackResults.end(),tempTrackResults.begin(),tempTrackResults.end());
}
return true;
}else{
return false;
}
}

2
src/core/Query/ListBase.h
View File

@ -72,6 +72,8 @@ namespace musik{ namespace core{
protected:
bool RunCallbacks(Library::Base *oLibrary);
bool ParseTracksSQL(std::string sql,Library::Base *oLibrary,db::Connection &db);
MetadataResults metadataResults;
TrackVector trackResults;

49
src/core/Query/ListSelection.cpp
View File

@ -443,53 +443,12 @@ bool Query::ListSelection::ParseQuery(Library::Base *oLibrary,db::Connection &db
////////////////////////////////////////////////
// Select tracks
if(this->trackEvent.has_connections() && !oLibrary->QueryCanceled()){
std::string sql("SELECT t.id,t.duration,t.filesize FROM tracks t ORDER BY t.sort_order1");
if(!metakeysSelectedCopy.empty()){
sql = "SELECT t.id,t.sum_duration,t.sum_filesize FROM temp_tracks_list t";
}
db::CachedStatement tracks(sql.c_str(),db);
// For optimization, lets just add to results every 100 track
TrackVector tempTrackResults;
tempTrackResults.reserve(101);
int row(0);
UINT64 duration(0);
UINT64 filesize(0);
while(tracks.Step()==db::ReturnCode::Row){
tempTrackResults.push_back(TrackPtr(new Track(tracks.ColumnInt(0))));
duration += tracks.ColumnInt64(1);
filesize += tracks.ColumnInt64(2);
if( (++row)%100==0 ){
boost::mutex::scoped_lock lock(oLibrary->oResultMutex);
this->trackResults.insert(this->trackResults.end(),tempTrackResults.begin(),tempTrackResults.end());
this->trackInfoTracks += tempTrackResults.size();
this->trackInfoDuration += duration;
this->trackInfoSize += filesize;
filesize = 0;
duration = 0;
tempTrackResults.clear();
trackResults.reserve(101);
}
}
if(!tempTrackResults.empty()){
boost::mutex::scoped_lock lock(oLibrary->oResultMutex);
this->trackResults.insert(this->trackResults.end(),tempTrackResults.begin(),tempTrackResults.end());
this->trackInfoTracks += tempTrackResults.size();
this->trackInfoDuration += duration;
this->trackInfoSize += filesize;
}
std::string sql("SELECT t.id,t.duration,t.filesize FROM tracks t ORDER BY t.sort_order1");
if(!metakeysSelectedCopy.empty()){
sql = "SELECT t.id,t.sum_duration,t.sum_filesize FROM temp_tracks_list t";
}
return success;
return (success && this->ParseTracksSQL(sql,oLibrary,db));
}
//////////////////////////////////////////

19
src/core/Query/SortTracks.cpp
View File

@ -61,7 +61,7 @@ bool Query::SortTracks::ParseQuery(Library::Base *oLibrary,db::Connection &db){
std::vector<int> sortFieldsMetakeyId;
// Create smart SQL statment
std::string selectSQL("SELECT temp_track_sort.track_id ");
std::string selectSQL("SELECT temp_track_sort.track_id,tracks.duration,tracks.filesize ");
std::string selectSQLTables("temp_track_sort LEFT OUTER JOIN tracks ON tracks.id=temp_track_sort.track_id ");
// std::string selectSQLWhere(" WHERE 1=1 ");
std::string selectSQLWhere(" ");
@ -80,7 +80,7 @@ bool Query::SortTracks::ParseQuery(Library::Base *oLibrary,db::Connection &db){
// Check if it's a fixed field
if(musik::core::Library::Base::IsStaticMetaKey(metakey)){
selectSQL += ",tracks."+metakey;
// selectSQL += ",tracks."+metakey;
selectSQLSort += (selectSQLSort.empty()?" ORDER BY tracks.":",tracks.") + metakey;
// Check if it's a special MTO field
@ -89,21 +89,21 @@ bool Query::SortTracks::ParseQuery(Library::Base *oLibrary,db::Connection &db){
selectSQLTables += " LEFT OUTER JOIN albums ON albums.id=tracks.album_id ";
// selectSQLTables += " albums al ";
// selectSQLWhere += "al.id=t.album_id";
selectSQL += ",albums.sort_order";
// selectSQL += ",albums.sort_order";
selectSQLSort += (selectSQLSort.empty()?" ORDER BY albums.sort_order":",albums.sort_order");
}
if(metakey=="visual_genre" || metakey=="genre"){
selectSQLTables += " LEFT OUTER JOIN genres ON genres.id=tracks.visual_genre_id ";
// selectSQLTables += ",genres g";
// selectSQLWhere += "g.id=t.visual_genre_id";
selectSQL += ",genres.sort_order";
// selectSQL += ",genres.sort_order";
selectSQLSort += (selectSQLSort.empty()?" ORDER BY genres.sort_order":",genres.sort_order");
}
if(metakey=="visual_artist" || metakey=="artist"){
selectSQLTables += " LEFT OUTER JOIN artists ON artists.id=tracks.visual_artist_id";
// selectSQLTables += ",artists ar";
// selectSQLWhere += "ar.id=t.visual_artist_id";
selectSQL += ",artists.sort_order";
// selectSQL += ",artists.sort_order";
selectSQLSort += (selectSQLSort.empty()?" ORDER BY artists.sort_order":",artists.sort_order");
}
} else {
@ -160,15 +160,12 @@ bool Query::SortTracks::ParseQuery(Library::Base *oLibrary,db::Connection &db){
}
}
// Finaly keep sort order of inserted order.
selectSQLSort += ",temp_track_sort.id";
std::string sql=selectSQL+" FROM "+selectSQLTables+selectSQLWhere+selectSQLGroup+selectSQLSort;
db::Statement selectTracks(sql.c_str(),db);
while(selectTracks.Step()==db::Row){
boost::mutex::scoped_lock lock(oLibrary->oResultMutex);
this->trackResults.push_back(TrackPtr(new Track(selectTracks.ColumnInt(0))));
}
return true;
return this->ParseTracksSQL(sql,oLibrary,db);
}
//////////////////////////////////////////