git.maemo.org Git - someplayer/blob - src/dbstorage.cpp

   1 /*
   2  * SomePlayer - An alternate music player for Maemo 5
   3  * Copyright (C) 2010 Nikolay (somebody) Tischenko <niktischenko@gmail.com>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18  */
  19
  20 #include "dbstorage.h"
  21 #include <QSqlQuery>
  22 #include <QSqlResult>
  23 #include <QDebug>
  24 #include <QFileInfo>
  25
  26 using namespace SomePlayer::Storage;
  27 using namespace SomePlayer::DataObjects;
  28
  29 DbStorage::DbStorage(QString path) {
  30         QString dbname = path + _DATABASE_NAME_;
  31         db = QSqlDatabase::addDatabase("QSQLITE");
  32         db.setDatabaseName(dbname);
  33         if (!db.open()) {
  34                 // throw big exception
  35         }
  36         // create database structure
  37         _create_database_structure();
  38         _prepare_queries();
  39 }
  40
  41 void DbStorage::_prepare_queries() {
  42         _get_artists_query = new QSqlQuery(db);
  43         _get_artists_query->prepare("SELECT name FROM artist ORDER BY uname");
  44
  45         _get_albums_for_artist_sort_name_query = new QSqlQuery(db);
  46         _get_albums_for_artist_sort_name_query->prepare("SELECT name, year FROM album WHERE artist_id in (SELECT id from artist WHERE uname = :uname) ORDER BY uname;");
  47
  48         _get_albums_for_artist_sort_year_query = new QSqlQuery(db);
  49         _get_albums_for_artist_sort_year_query->prepare("SELECT name, year FROM album WHERE artist_id in (SELECT id from artist WHERE uname = :uname) ORDER BY year;");
  50
  51         _get_tracks_for_album_query = new QSqlQuery(db);
  52         _get_tracks_for_album_query->prepare("SELECT id, title, source, count, length FROM tracks WHERE artist_id IN "
  53                                                                 "(SELECT id FROM artist WHERE uname = :artist_uname) AND album_id IN "
  54                                                                 "(SELECT id FROM album WHERE uname = :album_uname);");
  55
  56         _get_favorites_query = new QSqlQuery(db);
  57         _get_favorites_query->prepare("SELECT track_id as id, title, artist, album.name as album, source, count, length FROM "
  58                                                                 "(SELECT tracks.id AS track_id, artist.name AS artist, title, count, source, tracks.album_id, length FROM "
  59                                                                 "tracks JOIN artist ON tracks.artist_id = artist.id) "
  60                                                                 "JOIN album ON album_id = album.id WHERE track_id IN "
  61                                                                 "(SELECT track_id FROM favorites);");
  62
  63         _get_most_played_query = new QSqlQuery(db);
  64         _get_most_played_query->prepare("SELECT track_id as id, title, artist, album.name as album, source, count, length FROM "
  65                                                                 "(SELECT tracks.id AS track_id, artist.name AS artist, title, count, source, tracks.album_id, length FROM "
  66                                                                 "tracks JOIN artist ON tracks.artist_id = artist.id) "
  67                                                                 "JOIN album ON album_id = album.id ORDER BY count DESC "
  68                                                                 "LIMIT 0, :max");
  69
  70         _get_never_played_query = new QSqlQuery(db);
  71         _get_never_played_query->prepare("SELECT track_id as id, title, artist, album.name as album, source, count, length FROM "
  72                                                                 "(SELECT tracks.id AS track_id, artist.name AS artist, title, count, source, tracks.album_id, length FROM "
  73                                                                 "tracks JOIN artist ON tracks.artist_id = artist.id) "
  74                                                                 "JOIN album ON album_id = album.id "
  75                                                                 "WHERE count = 0");
  76
  77         _get_recently_added_query = new QSqlQuery(db);
  78         _get_recently_added_query->prepare("SELECT track_id as id, title, artist, album.name as album, source, count, length FROM "
  79                                                                 "(SELECT tracks.id AS track_id, artist.name AS artist, title, count, source, tracks.album_id, length FROM "
  80                                                                 "tracks JOIN artist ON tracks.artist_id = artist.id) "
  81                                                                 "JOIN album ON album_id = album.id "
  82                                                                 "WHERE track_id IN "
  83                                                                 "(SELECT track_id FROM adding_date ORDER BY date DESC LIMIT 0, :max)");
  84
  85         _get_track_count_query = new QSqlQuery(db);
  86         _get_track_count_query->prepare("SELECT count from tracks WHERE id = :id");
  87
  88         _get_tracks_by_pattern_query = new QSqlQuery(db);
  89         _get_tracks_by_pattern_query->prepare("SELECT id, title, artist, album, source, count, length, year FROM "
  90                                               "entire WHERE "
  91                                               "utitle LIKE (SELECT '%' || :ptitle || '%') "
  92                                               "ORDER BY artist_uname, year");
  93
  94         _get_track_id_by_source_query = new QSqlQuery(db);
  95         _get_track_id_by_source_query->prepare("SELECT id FROM tracks WHERE source = :source");
  96
  97         _get_directories_query = new QSqlQuery(db);
  98         _get_directories_query->prepare("SELECT id, path FROM directories");
  99
 100         _get_artists_count_query = new QSqlQuery(db);
 101         _get_artists_count_query->prepare("SELECT COUNT(id) AS cnt FROM artist");
 102
 103         _get_albums_count_query = new QSqlQuery(db);
 104         _get_albums_count_query->prepare("SELECT COUNT(id) AS cnt FROM album");
 105
 106         _get_tracks_count_query = new QSqlQuery(db);
 107         _get_tracks_count_query->prepare("SELECT COUNT(id) AS cnt FROM tracks");
 108
 109         _get_tracks_source_from_query = new QSqlQuery(db);
 110         _get_tracks_source_from_query->prepare("SELECT source FROM tracks WHERE directory = :directory_id");
 111
 112         _check_artist_query = new QSqlQuery(db);
 113         _check_artist_query->prepare("SELECT id FROM artist WHERE uname = :uname");
 114
 115         _check_album_query = new QSqlQuery(db);
 116         _check_album_query->prepare("SELECT id FROM album WHERE uname = :uname AND artist_id = :artist_id");
 117
 118         _check_directory_query = new QSqlQuery(db);
 119         _check_directory_query->prepare("SELECT id from directories WHERE path = :path");
 120
 121         _insert_artist_query = new QSqlQuery(db);
 122         _insert_artist_query->prepare("INSERT INTO artist (name, uname) values (:name, :uname)");
 123
 124         _insert_album_query = new QSqlQuery(db);
 125         _insert_album_query->prepare("INSERT INTO album (name, uname, artist_id, year) values (:name, :uname, :artist_id, :year)");
 126
 127         _insert_track_query = new QSqlQuery(db);
 128         _insert_track_query->prepare("INSERT INTO tracks (title, utitle, artist_id, album_id, source, directory, length) values (:title, :utitle, :artist_id, :album_id, :source, :directory_id, :length)");
 129
 130         _insert_date_query = new QSqlQuery(db);
 131         _insert_date_query->prepare("INSERT INTO adding_date (track_id, date) values (:track_id, strftime('%s', 'now'))");
 132
 133         _insert_favorites_query = new QSqlQuery(db);
 134         _insert_favorites_query->prepare("INSERT INTO favorites (track_id) values (:track_id)");
 135
 136         _insert_directory_query = new QSqlQuery(db);
 137         _insert_directory_query->prepare("INSERT INTO directories (path) values (:path)");
 138
 139         _update_track_count_query = new QSqlQuery(db);
 140         _update_track_count_query->prepare("UPDATE tracks SET count = :count where id = :id");
 141
 142         _remove_track_query = new QSqlQuery(db);
 143         _remove_track_query->prepare("DELETE FROM tracks WHERE id = :id");
 144
 145         _remove_empty_albums_query = new QSqlQuery(db);
 146         _remove_empty_albums_query->prepare("DELETE FROM album WHERE album.id IN "
 147                                             "(SELECT id FROM "
 148                                             "(SELECT COUNT(tracks.id) AS cnt, album.id FROM "
 149                                             "album LEFT OUTER JOIN tracks ON album.id = tracks.album_id "
 150                                             "GROUP BY album.id) WHERE cnt = 0)");
 151
 152         _remove_empty_artists_query = new QSqlQuery(db);
 153         _remove_empty_artists_query->prepare("DELETE FROM artist WHERE artist.id IN "
 154                                              "(SELECT id FROM "
 155                                              "(SELECT COUNT(tracks.id) AS cnt, artist.id FROM "
 156                                              "artist LEFT OUTER JOIN tracks ON artist.id = tracks.artist_id "
 157                                              "GROUP BY artist.id) WHERE cnt = 0)");
 158
 159         _remove_tracks_from_query = new QSqlQuery(db);
 160         _remove_tracks_from_query->prepare("DELETE FROM tracks WHERE directory = :directory_id");
 161
 162         _remove_directory_query = new QSqlQuery(db);
 163         _remove_directory_query->prepare("DELETE FROM directories WHERE path = :path");
 164 }
 165
 166 void DbStorage::_create_database_structure() {
 167         QSqlQuery *query = new QSqlQuery(db);
 168         query->exec("create table artist (id integer primary key, "
 169                                                                 "name text, "
 170                                                                 "uname text "
 171                                                                 ");");
 172         query->exec("create table album (id integer primary key, "
 173                                                                 "artist_id integer, "
 174                                                                 "name text, "
 175                                                                 "uname text, "
 176                                                                 "year int, "
 177                                                                 "foreign key(artist_id) references arist(id) "
 178                                                                 ");");
 179         query->exec("create table tracks (id integer primary key, "
 180                                                                 "artist_id integer, "
 181                                                                 "album_id integer, "
 182                                                                 "title text, "
 183                                                                 "utitle text, "
 184                                                                 "source text, "
 185                                                                 "directory integer, "
 186                                                                 "count integer default 0, "
 187                                                                 "length integer default 0, "
 188                                                                 "foreign key(artist_id) references artist(id), "
 189                                                                 "foreign key(album_id) references album(id) "
 190                                                                 ");");
 191         query->exec("create table favorites (track_id integer, "
 192                                                                 "foreign key(track_id) references tracks(id) "
 193                                                                 ");");
 194         query->exec("create table adding_date (track_id integer, "
 195                                                                 "date integer, "
 196                                                                 "foreign key(track_id) references tracks(id) "
 197                                                                 ");");
 198         query->exec("create view entire as "
 199                     "select id, title, artist_name as artist, album_name as album, source, count, length, album_year as year, utitle, artist_uname, album_uname from "
 200                         "tracks left join "
 201                                 "(select artist.id as aartist_id, "
 202                                 "artist.uname as artist_uname, "
 203                                 "artist.name as artist_name, "
 204                                 "album.uname as album_uname, "
 205                                 "album.year as album_year, "
 206                                 "album.id as aalbum_id, "
 207                                 "album.name as album_name from "
 208                                         "artist "
 209                                         "join album "
 210                                         "on album.artist_id = artist.id) "
 211                                 "on aartist_id = tracks.artist_id "
 212                                 "and aalbum_id = tracks.album_id");
 213
 214         query->exec("create table directories (id integer primary key, path text)");
 215 }
 216
 217 DbStorage::~DbStorage() {
 218         delete _get_albums_for_artist_sort_name_query;
 219         delete _get_albums_for_artist_sort_year_query;
 220         delete _get_artists_query;
 221         delete _get_favorites_query;
 222         delete _get_most_played_query;
 223         delete _get_never_played_query;
 224         delete _get_recently_added_query;
 225         delete _get_tracks_for_album_query;
 226         delete _get_tracks_by_pattern_query;
 227         delete _get_directories_query;
 228         delete _get_artists_count_query;
 229         delete _get_albums_count_query;
 230         delete _get_tracks_count_query;
 231         delete _get_tracks_source_from_query;
 232         delete _check_album_query;
 233         delete _check_artist_query;
 234         delete _check_directory_query;
 235         delete _get_track_id_by_source_query;
 236         delete _insert_album_query;
 237         delete _insert_artist_query;
 238         delete _insert_date_query;
 239         delete _insert_track_query;
 240         delete _insert_favorites_query;
 241         delete _insert_directory_query;
 242         delete _update_track_count_query;
 243         delete _remove_track_query;
 244         delete _remove_directory_query;
 245         delete _remove_tracks_from_query;
 246         db.close();
 247 }
 248
 249 QList<QString> DbStorage::getArtists() {
 250         QList<QString> artists;
 251         QSqlQuery *query = _get_artists_query;
 252         query->exec();
 253         while (query->next()) {
 254                 QString name = query->value(0).toString();
 255                 artists.append(name);
 256         }
 257         return artists;
 258 }
 259
 260 QMap<QString, int> DbStorage::getAlbumsForArtist(QString artist) {
 261         QMap<QString, int> albums;
 262         Config config;
 263         QString sort = config.getValue("ui/albumsorting").toString();
 264         QSqlQuery *query = NULL;
 265         if (sort == "date") {
 266                 query = _get_albums_for_artist_sort_year_query;
 267         } else {
 268                 query = _get_albums_for_artist_sort_name_query;
 269         }
 270         query->bindValue(":uname", artist.toUpper());
 271         query->exec();
 272         while (query->next()) {
 273                 QString name = query->value(0).toString();
 274                 albums[name] = query->value(1).toInt();
 275         }
 276         return albums;
 277 }
 278
 279 QList<Track> DbStorage::getTracksForAlbum(QString album, QString artist) {
 280         QList<Track> tracks;
 281         QSqlQuery *query = _get_tracks_for_album_query;
 282         query->bindValue(":artist_uname", artist.toUpper());
 283         query->bindValue(":album_uname", album.toUpper());
 284         query->exec();
 285
 286         while (query->next()) {
 287                 QString title = query->value(1).toString();
 288                 QString source = query->value(2).toString();
 289                 int count = query->value(3).toInt();
 290                 int length = query->value(4).toInt();
 291                 TrackMetadata meta (title, artist, album, length);
 292                 Track track(meta, source);
 293                 track.setCount(count);
 294                 tracks.append(track);
 295         }
 296
 297         return tracks;
 298 }
 299
 300 Playlist DbStorage::getFavorites() {
 301         Playlist playlist;
 302         QSqlQuery *query = _get_favorites_query;
 303         query->exec();
 304         while(query->next()) {
 305                 QString title = query->value(1).toString();
 306                 QString artist = query->value(2).toString();
 307                 QString album = query->value(3).toString();
 308                 QString source = query->value(4).toString();
 309                 int count = query->value(5).toInt();
 310                 int length = query->value(6).toInt();
 311                 TrackMetadata meta(title, artist, album, length);
 312                 Track track(meta, source);
 313                 track.setCount(count);
 314                 playlist.addTrack(track);
 315                 playlist.setName("Favorites");
 316         }
 317         return playlist;
 318 }
 319
 320 Playlist DbStorage::getMostPlayed() {
 321         Playlist playlist;
 322         QSqlQuery *query = _get_most_played_query;
 323         query->bindValue(":max", _DYNAMIC_PLAYLIST_MAX_COUNT_);
 324         query->exec();
 325         while (query->next()) {
 326                 QString title = query->value(1).toString();
 327                 QString artist = query->value(2).toString();
 328                 QString album = query->value(3).toString();
 329                 QString source = query->value(4).toString();
 330                 int count = query->value(5).toInt();
 331                 int length = query->value(6).toInt();
 332                 TrackMetadata meta(title, artist, album, length);
 333                 Track track(meta, source);
 334                 track.setCount(count);
 335                 playlist.addTrack(track);
 336                 playlist.setName("Most popular");
 337         }
 338         return playlist;
 339 }
 340
 341 Playlist DbStorage::getNeverPlayed() {
 342         Playlist playlist;
 343         QSqlQuery *query = _get_never_played_query;
 344         query->bindValue(":max", _DYNAMIC_PLAYLIST_MAX_COUNT_);
 345         query->exec();
 346         while (query->next()) {
 347                 QString title = query->value(1).toString();
 348                 QString artist = query->value(2).toString();
 349                 QString album = query->value(3).toString();
 350                 QString source = query->value(4).toString();
 351                 int count = query->value(5).toInt();
 352                 int length = query->value(6).toInt();
 353                 TrackMetadata meta(title, artist, album, length);
 354                 Track track(meta, source);
 355                 track.setCount(count);
 356                 playlist.addTrack(track);
 357                 playlist.setName("Never played");
 358         }
 359         return playlist;
 360 }
 361
 362 Playlist DbStorage::getRecentlyAdded() {
 363         Playlist playlist;
 364         QSqlQuery *query = _get_recently_added_query;
 365         query->bindValue(":max", _DYNAMIC_PLAYLIST_MAX_COUNT_);
 366         query->exec();
 367         while (query->next()) {
 368                 QString title = query->value(1).toString();
 369                 QString artist = query->value(2).toString();
 370                 QString album = query->value(3).toString();
 371                 QString source = query->value(4).toString();
 372                 int count = query->value(5).toInt();
 373                 int length = query->value(6).toInt();
 374                 TrackMetadata meta(title, artist, album, length);
 375                 Track track(meta, source);
 376                 track.setCount(count);
 377                 playlist.addTrack(track);
 378                 playlist.setName("Recently added");
 379         }
 380         return playlist;
 381 }
 382
 383 void DbStorage::removeTrack(Track track) {
 384         QSqlQuery *query = _get_track_id_by_source_query;
 385         query->bindValue(":source", track.source());
 386         query->exec();
 387         if (query->next()) {
 388                 int id = query->value(0).toInt();
 389                 query = new QSqlQuery(db);
 390                 query->prepare("DELETE FROM tracks WHERE id = :id;");
 391                 query->bindValue(":id", id);
 392                 query->exec();
 393                 query->prepare("DELETE FROM favorites WHERE track_id = :id;");
 394                 query->bindValue(":id", id);
 395                 query->exec();
 396                 query->prepare("DELETE FROM adding_date WHERE id = :id;");
 397                 query->bindValue(":id", id);
 398                 query->exec();
 399         }
 400 }
 401
 402 void DbStorage::addTrack(Track track) {
 403         QString title = track.metadata().title();
 404         QString artist = track.metadata().artist();
 405         QString album = track.metadata().album();
 406         QString source = track.source();
 407         QFileInfo info(source);
 408         QString path = info.canonicalPath();
 409         int year = track.metadata().year();
 410         int artist_id = _check_add_artist(artist);
 411         int album_id = _check_add_album(album, artist_id, year);
 412         if (artist_id == -1 || album_id == -1) {
 413                 //big bang
 414                 return;
 415         }
 416         QSqlQuery *query = _get_track_id_by_source_query;
 417         query->bindValue(":source", source);
 418         query->exec();
 419         if (query->next()) {
 420                 // already in datebase, skip
 421                 return;
 422         }
 423         query = _insert_track_query;
 424         query->bindValue(":title", title);
 425         query->bindValue(":utitle", title.toUpper());
 426         query->bindValue(":artist_id", artist_id);
 427         query->bindValue(":album_id", album_id);
 428         query->bindValue(":source", source);
 429         query->bindValue(":directory", _check_add_directory(path));
 430         query->bindValue(":length", track.metadata().length());
 431         if (query->exec()) {
 432                 //ok
 433                 query = _get_track_id_by_source_query;
 434                 query->bindValue(":source", source);
 435                 query->exec();
 436                 if (query->next()) {
 437                         int id = query->value(0).toInt();
 438                         query = _insert_date_query;
 439                         query->bindValue(":track_id", id);
 440                         if (query->exec()) {
 441                                 // ok
 442                         } else {
 443                                 // big bang
 444                         }
 445                 } else {
 446                         // big bang
 447                 }
 448         } else {
 449                 // big bang
 450         }
 451 }
 452
 453 void DbStorage::addToFavorites(Track track) {
 454         QSqlQuery *query = _get_track_id_by_source_query;
 455         query->bindValue(":source", track.source());
 456         query->exec();
 457         if (query->next()) {
 458                 int id = query->value(0).toInt();
 459                 query = _insert_favorites_query;
 460                 query->bindValue(":track_id", id);
 461                 query->exec();
 462         }
 463 }
 464
 465 void DbStorage::updateTrackCount(Track track) {
 466         QSqlQuery *query = _get_track_id_by_source_query;
 467         query->bindValue(":source", track.source());
 468         query->exec();
 469         if (query->next()) {
 470                 int id = query->value(0).toInt();
 471                 query = _get_track_count_query;
 472                 query->bindValue(":id", id);
 473                 query->exec();
 474                 if (query->next()) {
 475                         int count = query->value(0).toInt();
 476                         query = _update_track_count_query;
 477                         query->bindValue(":count", count+1);
 478                         query->bindValue(":id", id);
 479                         query->exec();
 480                 }
 481         }
 482 }
 483
 484 Track DbStorage::updateTrack(Track track) {
 485         QSqlQuery *query = _get_track_id_by_source_query;
 486         query->bindValue(":source", track.source());
 487         query->exec();
 488         if (query->next()) { // found track in library
 489                 int id = query->value(0).toInt();
 490                 query = _remove_track_query;
 491                 query->bindValue(":id", id);
 492                 query->exec();
 493                 addTrack(track);
 494                 _cleanup();
 495         }
 496         return track;
 497 }
 498
 499 int DbStorage::_check_add_artist(QString artist) {
 500         QSqlQuery *query = _check_artist_query;
 501         query->bindValue(":uname", artist.toUpper());
 502         query->exec();
 503         if (query->next()) {
 504                 int id = query->value(0).toInt();
 505                 return id;
 506         } else {
 507                 query = _insert_artist_query;
 508                 query->bindValue(":name", artist);
 509                 query->bindValue(":uname", artist.toUpper());
 510                 if (query->exec()) {
 511                         return _check_add_artist(artist);
 512                 } else {
 513                         // big bang
 514                         return -1;
 515                 }
 516         }
 517 }
 518
 519 int DbStorage::_check_add_album(QString album, int artist_id, int year) {
 520         QSqlQuery *query = _check_album_query;
 521         query->bindValue(":uname", album.toUpper());
 522         query->bindValue(":artist_id", artist_id);
 523         query->exec();
 524         if (query->next()) {
 525                 int id = query->value(0).toInt();
 526                 return id;
 527         } else {
 528                 query = _insert_album_query;
 529                 query->bindValue(":name", album);
 530                 query->bindValue(":uname", album.toUpper());
 531                 query->bindValue(":artist_id", artist_id);
 532                 query->bindValue(":year", year);
 533                 if (query->exec()) {
 534                         return _check_add_album(album, artist_id, year);
 535                 } else {
 536                         // big bang
 537                         return -1;
 538                 }
 539         }
 540 }
 541
 542 QList<Track> DbStorage::searchTracks(QString pattern) {
 543         QList <Track> found;
 544         QSqlQuery *query = _get_tracks_by_pattern_query;
 545         query->bindValue(":ptitle", pattern.toUpper()); // with :pattern only doesn't work
 546         query->exec();
 547         // id, title, artist, album, source, count, length, year
 548         while (query->next()) {
 549                 QString title = query->value(1).toString();
 550                 QString artist = query->value(2).toString();
 551                 QString album = query->value(3).toString();
 552                 QString source = query->value(4).toString();
 553                 int count = query->value(5).toInt();
 554                 int length = query->value(6).toInt();
 555                 int year = query->value(7).toInt();
 556                 TrackMetadata meta(title, artist, album, length);
 557                 meta.setYear(year);
 558                 Track track(meta, source);
 559                 track.setCount(count);
 560                 found.append(track);
 561         }
 562         return found;
 563 }
 564
 565 void DbStorage::_cleanup() {
 566         _remove_empty_albums_query->exec();
 567         _remove_empty_artists_query->exec();
 568 }
 569
 570 int DbStorage::_check_add_directory(QString path) {
 571         QSqlQuery *query = _check_directory_query;
 572         query->bindValue(":path", path);
 573         query->exec();
 574         if (query->next()) {
 575                 return query->value(0).toInt();
 576         } else {
 577                 query = _insert_directory_query;
 578                 query->bindValue(":path", path);
 579                 query->exec();
 580                 return _check_add_directory(path);
 581         }
 582 }
 583
 584 QList<QString> DbStorage::getDirectories() {
 585         QSqlQuery *query = _get_directories_query;
 586         query->exec();
 587         QList<QString> directories;
 588         while (query->next()) {
 589                 directories.append(query->value(1).toString());
 590         }
 591         return directories;
 592 }
 593
 594 int DbStorage::getArtistsCount() {
 595         QSqlQuery *query = _get_artists_count_query;
 596         query->exec();
 597         if (query->next()) {
 598                 return query->value(0).toInt();
 599         }
 600         return 0;
 601 }
 602
 603 int DbStorage::getAlbumsCount() {
 604         QSqlQuery *query = _get_albums_count_query;
 605         query->exec();
 606         if (query->next()) {
 607                 return query->value(0).toInt();
 608         }
 609         return 0;
 610 }
 611
 612 int DbStorage::getTracksCount() {
 613         QSqlQuery *query = _get_tracks_count_query;
 614         query->exec();
 615         if (query->next()) {
 616                 return query->value(0).toInt();
 617         }
 618         return 0;
 619 }
 620
 621 void DbStorage::deleteTracksFrom(QString path) {
 622         QSqlQuery *query = _check_directory_query;
 623         query->bindValue(":path", path);
 624         query->exec();
 625         if (query->next()) {
 626                 int id = query->value(0).toInt();
 627                 query = _remove_tracks_from_query;
 628                 query->bindValue(":directory_id", id);
 629                 query->exec();
 630                 query = _remove_directory_query;
 631                 query->bindValue(":path", path);
 632                 query->exec();
 633                 _cleanup();
 634         }
 635 }
 636
 637 void DbStorage::checkTracksFrom(QString path) {
 638         QSqlQuery *query = _check_directory_query;
 639         query->bindValue(":path", path);
 640         query->exec();
 641         if (query->next()) {
 642                 int id = query->value(0).toInt();
 643                 query = _get_tracks_source_from_query;
 644                 query->bindValue(":directory_id", id);
 645                 query->exec();
 646                 while (query->next()) {
 647                         QString source = query->value(0).toString();
 648                         if (!QFile::exists(source)) {
 649                                 Track track(TrackMetadata(), source);   // removeTrack uses only source field, so
 650                                 removeTrack(track);                     // we can use this method
 651                         }
 652                 }
 653                 _cleanup();
 654         }
 655 }