Added some TODO's. Need to switch to prepared statements for album, artist, genre, and year repositories

database.json

@@ -1,7 +1,7 @@
 
 {
-  "server": "server",
+  "server": "localhost",
-  "database": "database",
+  "database": "Icarus",
-  "username": "username",
+  "username": "icarus-admin",
-  "password": "password"
+  "password": "dreamofpeace"
 }

include/controller/songController.hpp

@@ -117,6 +117,9 @@ namespace Controller
             Model::Song songDb;
             songDb.id = id;
 
+            OATPP_ASSERT_HTTP(songRepo.doesSongExist(songDb, Type::songFilter::id) , Status::CODE_403, "song does not exist");
+
+            std::cout << "song exists" << std::endl;
             songDb = songRepo.retrieveRecord(songDb, Type::songFilter::id);
 
             auto song = Dto::songDto::createShared();

include/database/albumRepository.h

@@ -23,7 +23,11 @@ namespace Database
         void saveAlbum(const Model::Album&);
     private:
         std::vector<Model::Album> parseRecords(MYSQL_RES*);
+
+        // TODO: after parseRecord(MYSQL_STMT*) is implemented remove
+        // parseRecord(MYSQL_RES*)
         Model::Album parseRecord(MYSQL_RES*);
+        Model::Album parseRecord(MYSQL_STMT*);
     };
 }
 

include/database/artistRepository.h

@@ -14,9 +14,14 @@ namespace Database
 
         Model::Artist retrieveRecord(Model::Artist&, Type::artistFilter);
 
+        bool doesArtistExist(const Model::Artist&, Type::artistFilter);
+
         void saveRecord(const Model::Artist&);
     private:
+        // TODO: After parseRecord(MYSQL_STMT*) is implemented
+        // remove parseRecord(MYSQL_RES*)
         Model::Artist parseRecord(MYSQL_RES*);
+        Model::Artist parseRecord(MYSQL_STMT*);
     };
 }
 

include/database/coverArtRepository.h

@@ -17,10 +17,15 @@ namespace Database
 
         Model::Cover retrieveRecord(Model::Cover&, Type::coverFilter);
         
+        bool doesCoverArtExist(const Model::Cover&, Type::coverFilter);
+
         void deleteRecord(const Model::Cover&);
         void saveRecord(const Model::Cover&);
     private:
+        // TODO: After parseRecord(MYSQL_STMT*) is implemented
+        // remove parseRecord(MYSQL_RES*)
         Model::Cover parseRecord(MYSQL_RES*);
+        Model::Cover parseRecord(MYSQL_STMT*);
     };
 }
 

include/database/genreRepository.h

@@ -14,9 +14,14 @@ namespace Database
 
         Model::Genre retrieveRecord(Model::Genre&, Type::genreFilter);
 
+        bool doesGenreExist(const Model::Genre&, Type::genreFilter);
+
         void saveRecord(const Model::Genre&);
     private:
+        // TODO: After parseRecord(MYSQL_STMT*) is implemented
+        // remove parseRecord(MYSQL_RES*)
         Model::Genre parseRecord(MYSQL_RES*);
+        Model::Genre parseRecord(MYSQL_STMT*);
     };
 }
 

include/database/songRepository.h

@@ -20,14 +20,18 @@ namespace Database
 
         std::vector<Model::Song> retrieveRecords();
 
+        bool doesSongExist(const Model::Song&, Type::songFilter);
+
         Model::Song retrieveRecord(Model::Song&, Type::songFilter);
 
         void deleteRecord(const Model::Song&);
         void saveRecord(const Model::Song&);
     private:
-        std::vector<Model::Song> parseRecords(MYSQL_RES*);
+        std::vector<Model::Song> parseRecords(MYSQL_RES*); // TODO: to be removed
+        std::vector<Model::Song> parseRecords(MYSQL_STMT*);
 
-        Model::Song parseRecord(MYSQL_RES*);
+        Model::Song parseRecord(MYSQL_RES*); // TODO: to be removed
+        Model::Song parseRecord(MYSQL_STMT*);
     };
 }
 

include/database/yearRepository.h

@@ -14,9 +14,14 @@ namespace Database
 
         Model::Year retrieveRecord(Model::Year&, Type::yearFilter);
 
+        bool doesYearExist(const Model::Year&, Type::yearFilter);
+
         void saveRecord(const Model::Year&);
     private:
+        // TODO: After parseRecord(MYSQL_STMT*) is implemented
+        // remove parseRecord(MYSQL_RES*)
         Model::Year parseRecord(MYSQL_RES*);
+        Model::Year parseRecord(MYSQL_STMT*);
     };
 }
 

src/database/albumRepository.cpp

@@ -63,7 +63,53 @@ bool Database::albumRepository::doesAlbumExists(const Model::Album& album, Type:
     // record for songs on the same album. After fixing this, do the
     // same for Artist, Genre, and Year records
 
-    return false;
+    auto conn = setup_mysql_connection();
+    auto stmt = mysql_stmt_init(conn);
+
+    MYSQL_BIND params[1];
+    memset(params, 0, sizeof(params));
+
+    std::stringstream qry;
+    qry << "SELECT * FROM Album WHERE ";
+
+    auto titleLength = album.title.size();
+    switch (filter) {
+        case Type::albumFilter::id:
+            qry << "AlbumId = ?";
+
+            params[0].buffer_type = MYSQL_TYPE_LONG;
+            params[0].buffer = (char*)&album.id;
+            params[0].length = 0;
+            params[0].is_null = 0;
+            break;
+        case Type::albumFilter::title:
+            qry << "Title = ?";
+
+            params[0].buffer_type = MYSQL_TYPE_STRING;
+            params[0].buffer = (char*)album.title.c_str();
+            params[0].length = &titleLength;
+            params[0].is_null = 0;
+            break;
+        default:
+            break;
+    }
+
+    qry << " LIMIT 1";
+
+    const auto query = qry.str();
+    auto status = mysql_stmt_prepare(stmt, query.c_str(), query.size());
+    status = mysql_stmt_bind_param(stmt, params);
+    status = mysql_stmt_execute(stmt);
+
+    std::cout << "the query has been performed" << std::endl;
+
+    ::mysql_stmt_store_result(stmt);
+    auto rowCount = ::mysql_stmt_num_rows(stmt);
+
+    ::mysql_stmt_close(stmt);
+    ::mysql_close(conn);
+
+    return (rowCount > 0) ? true : false;
 }
 
 void Database::albumRepository::saveAlbum(const Model::Album& album)
@@ -133,3 +179,11 @@ Model::Album Database::albumRepository::parseRecord(MYSQL_RES* results)
 
     return album;
 }
+
+Model::Album Database::albumRepository::parseRecord(MYSQL_STMT *stmt)
+{
+    // TODO: implement this
+    Model::Album album;
+
+    return album;
+}

src/database/artistRepository.cpp

@@ -47,6 +47,13 @@ Model::Artist Database::artistRepository::retrieveRecord(Model::Artist& artist,
     return artist;
 }
 
+bool Database::artistRepository::doesArtistExist(const Model::Artist& artist, Type::artistFilter filter)
+{
+    // TODO: implement this
+    
+    return false;
+}
+
 void Database::artistRepository::saveRecord(const Model::Artist& artist)
 {
     std::cout << "inserting artist record" << std::endl;
@@ -100,3 +107,11 @@ Model::Artist Database::artistRepository::parseRecord(MYSQL_RES* results)
 
     return artist;
 }
+
+Model::Artist Database::artistRepository::parseRecord(MYSQL_STMT *stmt)
+{
+    // TODO: implement this
+    Model::Artist art;
+
+    return art;
+}

src/database/coverArtRepository.cpp

@@ -46,6 +46,12 @@ Model::Cover Database::coverArtRepository::retrieveRecord(Model::Cover& cov, Typ
     return covDb;
 }
 
+bool Database::coverArtRepository::doesCoverArtExist(const Model::Cover& cover, Type::coverFilter filter)
+{
+    // TODO: implement this
+    return false;
+}
+
 void Database::coverArtRepository::deleteRecord(const Model::Cover& cov)
 {
     auto conn = setup_mysql_connection();
@@ -119,3 +125,12 @@ Model::Cover Database::coverArtRepository::parseRecord(MYSQL_RES *results)
 
     return cov;
 }
+
+Model::Cover Database::coverArtRepository::parseRecord(MYSQL_STMT *stmt)
+{
+    // TODO: implement this
+    
+    Model::Cover cover;
+
+    return cover;
+}

src/database/genreRepository.cpp

@@ -45,6 +45,13 @@ Model::Genre Database::genreRepository::retrieveRecord(Model::Genre& genre, Type
     return genre;
 }
 
+bool Database::genreRepository::doesGenreExist(const Model::Genre& genre, Type::genreFilter filter)
+{
+    // TODO: implement this
+
+    return false;
+}
+
 void Database::genreRepository::saveRecord(const Model::Genre& genre)
 {
     std::cout << "inserting genre record" << std::endl;
@@ -97,3 +104,11 @@ Model::Genre Database::genreRepository::parseRecord(MYSQL_RES* results)
 
     return genre;
 }
+Model::Genre Database::genreRepository::parseRecord(MYSQL_STMT *stmt)
+{
+    // TODO: implement this
+    
+    Model::Genre genre;
+
+    return genre;
+}

src/database/songRepository.cpp

@@ -16,14 +16,17 @@ Database::songRepository::songRepository(const Model::BinaryPath& bConf) : base_
 std::vector<Model::Song> Database::songRepository::retrieveRecords()
 {
     auto conn = setup_mysql_connection();
+    auto stmt = mysql_stmt_init(conn);
     const std::string query = "SELECT * FROM Song";
 
-    auto results = perform_mysql_query(conn, query);
+    ::mysql_stmt_prepare(stmt, query.c_str(), query.size());
-    auto songs = parseRecords(results);
+    ::mysql_stmt_execute(stmt);
 
+    auto songs = parseRecords(stmt);
+
+    mysql_stmt_close(stmt);
     mysql_close(conn);
 
-
     return songs;
 }
 
@@ -31,34 +34,106 @@ Model::Song Database::songRepository::retrieveRecord(Model::Song& song, Type::so
 {
     std::stringstream qry;
     auto conn = setup_mysql_connection();
+    auto stmt = mysql_stmt_init(conn);
+
+    MYSQL_BIND params[1];
+    memset(params, 0, sizeof(params));
+
     qry << "SELECT * FROM Song WHERE ";
 
-    std::unique_ptr<char*> param;
+    auto titleLength = song.title.size();
     switch (filter) {
         case Type::songFilter::id:
-            qry << "SongId = " << song.id;
+            qry << "SongId = ?";
+
+            params[0].buffer_type = MYSQL_TYPE_LONG;
+            params[0].buffer = (char*)&song.id;
+            params[0].length = 0;
+            params[0].is_null = 0;;
             break;
         case Type::songFilter::title:
-            param = std::make_unique<char*>(new char[song.title.size()]);
+            qry << "Title = ?";
-            mysql_real_escape_string(conn, *param, song.title.c_str(), song.title.size());
+
-            qry << "Title = '" << *param << "'";
+            params[0].buffer_type = MYSQL_TYPE_STRING;
+            params[0].buffer = (char*)song.title.c_str();
+            params[0].length = &titleLength;
+            params[0].is_null = 0;
             break;
         default:
             break;
     }
 
+    qry << " LIMIT 1";
+
     const std::string query = qry.str();
-    auto results = perform_mysql_query(conn, query);
+    auto status = mysql_stmt_prepare(stmt, query.c_str(), query.size());
+    status = mysql_stmt_bind_param(stmt, params);
+    status = mysql_stmt_execute(stmt);
+
     std::cout << "the query has been performed" << std::endl;
 
-    song = parseRecord(results);
+    song = parseRecord(stmt);
 
+    mysql_stmt_close(stmt);
     mysql_close(conn);
     std::cout << "done" << std::endl;
 
     return song;
 }
 
+bool Database::songRepository::doesSongExist(const Model::Song& song, Type::songFilter filter)
+{
+    std::cout << "checking to see if song exists" << std::endl;
+    std::stringstream qry;
+    auto conn = setup_mysql_connection();
+    auto stmt = mysql_stmt_init(conn);
+
+    MYSQL_BIND params[1];
+    memset(params, 0, sizeof(params));
+
+    qry << "SELECT * FROM Song WHERE ";
+
+    auto titleLength = song.title.size();
+    switch (filter) {
+        case Type::songFilter::id:
+            qry << "SongId = ?";
+
+            params[0].buffer_type = MYSQL_TYPE_LONG;
+            params[0].buffer = (char*)&song.id;
+            params[0].length = 0;
+            params[0].is_null = 0;
+            break;
+        case Type::songFilter::title:
+            qry << "Title = ?";
+
+            params[0].buffer_type = MYSQL_TYPE_STRING;
+            params[0].buffer = (char*)song.title.c_str();
+            params[0].length = &titleLength;
+            params[0].is_null = 0;
+            break;
+        default:
+            break;
+    }
+
+    qry << " LIMIT 1";
+
+    const std::string query = qry.str();
+    auto status = mysql_stmt_prepare(stmt, query.c_str(), query.size());
+    status = mysql_stmt_bind_param(stmt, params);
+    status = mysql_stmt_execute(stmt);
+
+    std::cout << "the query has been performed" << std::endl;
+
+    ::mysql_stmt_store_result(stmt);
+    auto rowCount = ::mysql_stmt_num_rows(stmt);
+
+    mysql_stmt_close(stmt);
+    mysql_close(conn);
+    std::cout << "done" << std::endl;
+
+    return (rowCount > 0) ? true : false;
+}
+
 void Database::songRepository::deleteRecord(const Model::Song& song)
 {
     auto conn = setup_mysql_connection();
@@ -172,6 +247,7 @@ void Database::songRepository::saveRecord(const Model::Song& song)
     std::cout << "done inserting song record" << std::endl;
 }
 
+// TODO: delete this, not being used
 std::vector<Model::Song> Database::songRepository::parseRecords(MYSQL_RES* results)
 {
     auto fieldNum = mysql_num_fields(results);
@@ -184,6 +260,59 @@ std::vector<Model::Song> Database::songRepository::parseRecords(MYSQL_RES* resul
         Model::Song song;
 
         for (auto i = 0; i != fieldNum; ++i) {
+            /**
+            auto field = mysql_fetch_field(results);
+            if (field->name  == NULL) {
+                std::cout << "null field" << std::endl;
+                break;
+            }
+            */
+            /**
+            std::string field;
+            if ((i + 0) == fieldNum) {
+                std::cout << "goodbye" << std::endl;
+                break;
+            } else {
+                std::cout << "still good" << std::endl;
+                field.assign(mysql_fetch_field(results)->name);
+            }
+            //const std::string field(row[i].field);
+            std::cout << field << std::endl;
+
+            if (field.compare("SongId") == 0) {
+                song.id = std::stoi(row[i]);
+            }
+            if (field.compare("Title") == 0) {
+                song.title = row[i];
+            }
+            if (field.compare("Artist") == 0) {
+                song.artist = row[i];
+            }
+            if (field.compare("Album") == 0) {
+                song.album = row[i];
+            }
+            if (field.compare("Genre") == 0) {
+                song.genre = row[i];
+            }
+            if (field.compare("Year") == 0) {
+                song.year = std::stoi(row[i]);
+            }
+            if (field.compare("Duration") == 0) {
+                song.duration = std::stoi(row[i]);
+            }
+            if (field.compare("Track") == 0) {
+                song.track = std::stoi(row[i]);
+            }
+            if (field.compare("Disc") == 0) {
+                song.disc = std::stoi(row[i]);
+            }
+            if (field.compare("SongPath") == 0) {
+                song.songPath = row[i];
+            }
+            if (field.compare("CoverArtId") == 0) {
+                song.coverArtId = std::stoi(row[i]);
+            }
+            */
             switch (i) {
                 case 0:
                     song.id = std::stoi(row[i]);
@@ -222,19 +351,163 @@ std::vector<Model::Song> Database::songRepository::parseRecords(MYSQL_RES* resul
         }
 
         songs.push_back(song);
+        //std::cout << "added" << std::endl;
+    }
+    //std::cout << "completely" << std::endl;
+
+    return songs;
+}
+
+std::vector<Model::Song> Database::songRepository::parseRecords(MYSQL_STMT *stmt)
+{
+    ::mysql_stmt_store_result(stmt);
+    auto c = ::mysql_stmt_num_rows(stmt);
+    std::cout << "number of results " << c << std::endl;
+    std::vector<Model::Song> songs;
+    songs.reserve(c);
+
+    auto status = 0;
+    auto time = 0;
+    auto valAmt = 15;
+    unsigned long len[valAmt];
+    my_bool nullRes[valAmt];
+
+    while (status == 0) {
+        std::cout << time++ << " time" << std::endl;
+        std::cout << "field count " << ::mysql_stmt_field_count(stmt) << std::endl;
+        
+        if (::mysql_stmt_field_count(stmt) > 0) {
+
+            Model::Song song;
+            auto res = ::mysql_stmt_result_metadata(stmt);
+            auto fields = ::mysql_fetch_fields(res);
+            auto strLen = 1024;
+            MYSQL_BIND val[valAmt];
+            memset(val, 0, sizeof(val));
+
+            char title[strLen];
+            char album[strLen];
+            char artist[strLen];
+            char genre[strLen];
+            char path[strLen];
+
+            val[0].buffer_type = MYSQL_TYPE_LONG;
+            val[0].buffer = (char*)&song.id;
+            val[0].length = &len[0];
+            val[0].is_null = &nullRes[0];
+
+            val[1].buffer_type = MYSQL_TYPE_STRING;
+            val[1].buffer = (char*)title;
+            val[1].buffer_length = strLen;
+            val[1].length = &len[1];
+            val[1].is_null = &nullRes[1];
+
+            val[2].buffer_type = MYSQL_TYPE_STRING;
+            val[2].buffer = (char*)artist;
+            val[2].buffer_length = strLen;
+            val[2].length = &len[2];
+            val[2].is_null = &nullRes[2];
+
+            val[3].buffer_type = MYSQL_TYPE_STRING;
+            val[3].buffer = (char*)album;
+            val[3].buffer_length = strLen;
+            val[3].length = &len[3];
+            val[3].is_null = &nullRes[3];
+
+            val[4].buffer_type = MYSQL_TYPE_STRING;
+            val[4].buffer = (char*)genre;
+            val[4].buffer_length = strLen;
+            val[4].length = &len[4];
+            val[4].is_null = &nullRes[4];
+
+            val[5].buffer_type = MYSQL_TYPE_LONG;
+            val[5].buffer = (char*)&song.year;
+            val[5].length = &len[5];
+            val[5].is_null = &nullRes[5];
+
+            val[6].buffer_type = MYSQL_TYPE_LONG;
+            val[6].buffer = (char*)&song.duration;
+            val[6].length = &len[6];
+            val[6].is_null = &nullRes[6];
+
+            val[7].buffer_type = MYSQL_TYPE_LONG;
+            val[7].buffer = (char*)&song.track;
+            val[7].length = &len[7];
+            val[7].is_null = &nullRes[7];
+
+            val[8].buffer_type = MYSQL_TYPE_LONG;
+            val[8].buffer = (char*)&song.disc;
+            val[8].length = &len[8];
+            val[8].is_null = &nullRes[8];
+
+            val[9].buffer_type = MYSQL_TYPE_STRING;
+            val[9].buffer = (char*)path;
+            val[9].buffer_length = strLen;
+            val[9].length = &len[9];
+            val[9].is_null = &nullRes[9];
+
+            val[10].buffer_type = MYSQL_TYPE_LONG;
+            val[10].buffer = (char*)&song.coverArtId;
+            val[10].length = &len[10];
+            val[10].is_null = &nullRes[10];
+
+            val[11].buffer_type = MYSQL_TYPE_LONG;
+            val[11].buffer = (char*)&song.artistId;
+            val[11].length = &len[11];
+            val[11].is_null = &nullRes[11];
+
+            val[12].buffer_type = MYSQL_TYPE_LONG;
+            val[12].buffer = (char*)&song.albumId;;
+            val[12].length = &len[12];
+            val[12].is_null = &nullRes[12];
+
+            val[13].buffer_type = MYSQL_TYPE_LONG;
+            val[13].buffer = (char*)&song.genreId;
+            val[13].length = &len[13];
+            val[13].is_null = &nullRes[13];
+
+            val[14].buffer_type = MYSQL_TYPE_LONG;
+            val[14].buffer = (char*)&song.yearId;
+            val[14].length = &len[14];
+            val[14].is_null = &nullRes[14];
+
+            status = ::mysql_stmt_bind_result(stmt, val);
+
+            while (1) {
+                std::cout << "fetching statement result" << std::endl;
+                status = ::mysql_stmt_fetch(stmt);
+
+                if (status == 1 || status == MYSQL_NO_DATA) {
+                    break;
+                }
+                song.title = title;
+                song.album = album;
+                song.artist = artist;
+                song.genre = genre;
+                song.songPath = path;
+
+                songs.push_back(song);
+            }
+        }
+        std::cout << "fetching next result" << std::endl;
+        status = ::mysql_stmt_next_result(stmt);
     }
 
     return songs;
 }
 
+
+// TODO: delete this, not being used anymore
 Model::Song Database::songRepository::parseRecord(MYSQL_RES* results)
 {
     Model::Song song;
-    auto fieldNum = mysql_num_fields(results);
 
-    MYSQL_ROW row = mysql_fetch_row(results);
+    auto fieldNum = mysql_num_fields(results);
+    auto row = mysql_fetch_row(results);
 
     for (auto i = 0; i != fieldNum; ++i) {
+        const std::string field(mysql_fetch_field(results)->name);
+
         switch (i) {
             case 0:
                 song.id = std::stoi(row[i]);
@@ -275,3 +548,127 @@ Model::Song Database::songRepository::parseRecord(MYSQL_RES* results)
 
     return song;
 }
+
+Model::Song Database::songRepository::parseRecord(MYSQL_STMT *stmt)
+{
+    Model::Song song;
+    auto status = 0;
+    auto time = 0;
+    auto valAmt = 15;
+    unsigned long len[valAmt];
+    my_bool nullRes[valAmt];
+
+    while (status == 0) {
+        if (::mysql_stmt_field_count(stmt) > 0) {
+            auto res = ::mysql_stmt_result_metadata(stmt);
+            auto fields = ::mysql_fetch_fields(res);
+            auto strLen = 1024;
+            MYSQL_BIND val[valAmt];
+            memset(val, 0, sizeof(val));
+
+            char title[strLen];
+            char album[strLen];
+            char artist[strLen];
+            char genre[strLen];
+            char path[strLen];
+
+            val[0].buffer_type = MYSQL_TYPE_LONG;
+            val[0].buffer = (char*)&song.id;
+            val[0].length = &len[0];
+            val[0].is_null = &nullRes[0];
+
+            val[1].buffer_type = MYSQL_TYPE_STRING;
+            val[1].buffer = (char*)title;
+            val[1].buffer_length = strLen;
+            val[1].length = &len[1];
+            val[1].is_null = &nullRes[1];
+
+            val[2].buffer_type = MYSQL_TYPE_STRING;
+            val[2].buffer = (char*)artist;
+            val[2].buffer_length = strLen;
+            val[2].length = &len[2];
+            val[2].is_null = &nullRes[2];
+
+            val[3].buffer_type = MYSQL_TYPE_STRING;
+            val[3].buffer = (char*)album;
+            val[3].buffer_length = strLen;
+            val[3].length = &len[3];
+            val[3].is_null = &nullRes[3];
+
+            val[4].buffer_type = MYSQL_TYPE_STRING;
+            val[4].buffer = (char*)genre;
+            val[4].buffer_length = strLen;
+            val[4].length = &len[4];
+            val[4].is_null = &nullRes[4];
+
+            val[5].buffer_type = MYSQL_TYPE_LONG;
+            val[5].buffer = (char*)&song.year;
+            val[5].length = &len[5];
+            val[5].is_null = &nullRes[5];
+
+            val[6].buffer_type = MYSQL_TYPE_LONG;
+            val[6].buffer = (char*)&song.duration;
+            val[6].length = &len[6];
+            val[6].is_null = &nullRes[6];
+
+            val[7].buffer_type = MYSQL_TYPE_LONG;
+            val[7].buffer = (char*)&song.track;
+            val[7].length = &len[7];
+            val[7].is_null = &nullRes[7];
+
+            val[8].buffer_type = MYSQL_TYPE_LONG;
+            val[8].buffer = (char*)&song.disc;
+            val[8].length = &len[8];
+            val[8].is_null = &nullRes[8];
+
+            val[9].buffer_type = MYSQL_TYPE_STRING;
+            val[9].buffer = (char*)path;
+            val[9].buffer_length = strLen;
+            val[9].length = &len[9];
+            val[9].is_null = &nullRes[9];
+
+            val[10].buffer_type = MYSQL_TYPE_LONG;
+            val[10].buffer = (char*)&song.coverArtId;
+            val[10].length = &len[10];
+            val[10].is_null = &nullRes[10];
+
+            val[11].buffer_type = MYSQL_TYPE_LONG;
+            val[11].buffer = (char*)&song.artistId;
+            val[11].length = &len[11];
+            val[11].is_null = &nullRes[11];
+
+            val[12].buffer_type = MYSQL_TYPE_LONG;
+            val[12].buffer = (char*)&song.albumId;;
+            val[12].length = &len[12];
+            val[12].is_null = &nullRes[12];
+
+            val[13].buffer_type = MYSQL_TYPE_LONG;
+            val[13].buffer = (char*)&song.genreId;
+            val[13].length = &len[13];
+            val[13].is_null = &nullRes[13];
+
+            val[14].buffer_type = MYSQL_TYPE_LONG;
+            val[14].buffer = (char*)&song.yearId;
+            val[14].length = &len[14];
+            val[14].is_null = &nullRes[14];
+
+            status = ::mysql_stmt_bind_result(stmt, val);
+            ::mysql_stmt_store_result(stmt);
+
+            status = ::mysql_stmt_fetch(stmt);
+
+            song.title = title;
+            song.album = album;
+            song.artist = artist;
+            song.genre = genre;
+            song.songPath = path;
+
+        }
+        status = ::mysql_stmt_next_result(stmt);
+    }
+
+    std::cout << "okay!!!!" << std::endl;
+    std::cout << "done parsing record" << std::endl;
+
+    return song;
+}

src/database/yearRepository.cpp

@@ -44,6 +44,13 @@ Model::Year Database::yearRepository::retrieveRecord(Model::Year& year, Type::ye
     return year;
 }
 
+bool Database::yearRepository::doesYearExist(const Model::Year& year, Type::yearFilter filter)
+{
+    // TODO: implement this
+
+    return false;
+}
+
 void Database::yearRepository::saveRecord(const Model::Year& year)
 {
     std::cout << "saving year record" << std::endl;
@@ -95,3 +102,11 @@ Model::Year Database::yearRepository::parseRecord(MYSQL_RES *results)
 
     return year;
 }
+Model::Year Database::yearRepository::parseRecord(MYSQL_STMT *stmt)
+{
+    // TODO: imeplement this
+    
+    Model::Year year;
+
+    return year;
+}

src/managers/albumManager.cpp

@@ -26,7 +26,12 @@ Model::Album Manager::albumManager::saveAlbum(const Model::Song& song)
     album.year = song.year;
     
     Database::albumRepository albRepo(m_bConf);
+    if (!albRepo.doesAlbumExists(album, Type::albumFilter::title)) {
         albRepo.saveAlbum(album);
+    } else {
+        std::cout << "album record already exists in the database" << std::endl;
+    }
+
 
     return album;
 }

src/managers/artistManager.cpp

@@ -24,8 +24,11 @@ Model::Artist Manager::artistManager::saveArtist(const Model::Song& song)
     artist.artist = song.artist;
 
     Database::artistRepository artRepo(m_bConf);
+    if (!artRepo.doesArtistExist(artist, Type::artistFilter::artist)) {
         artRepo.saveRecord(artist);
-
+    } else {
+        std::cout << "artist already exists" << std::endl;
+    }
 
     return artist;
 }

src/managers/coverArtManager.cpp

@@ -20,8 +20,13 @@ Model::Cover Manager::coverArtManager::saveCover(const Model::Song& song, std::s
     cov.songTitle = song.title;
 
     Database::coverArtRepository covRepo(m_bConf);
+    if (!covRepo.doesCoverArtExist(cov, Type::coverFilter::songTitle)) {
         std::cout << "saving image record to the database" << std::endl;
         covRepo.saveRecord(cov);
+    } else {
+        std::cout << "cover art record already exists" << std::endl;
+    }
+
     std::cout << "retrieving image record from database" << std::endl;
     cov = covRepo.retrieveRecord(cov, Type::coverFilter::songTitle);
 

src/managers/genreManager.cpp

@@ -24,7 +24,11 @@ Model::Genre Manager::genreManager::saveGenre(const Model::Song& song)
     genre.category = song.genre;
     
     Database::genreRepository gnrRepo(m_bConf);
+    if (!gnrRepo.doesGenreExist(genre, Type::genreFilter::category)) {
         gnrRepo.saveRecord(genre);
+    } else {
+        std::cout << "genre record already exists" << std::endl;
+    }
 
     return genre;
 }

src/managers/yearManager.cpp

@@ -24,7 +24,11 @@ Model::Year Manager::yearManager::saveYear(const Model::Song& song)
     year.year = song.year;
 
     Database::yearRepository yearRepo(m_bConf);
+    if (!yearRepo.doesYearExist(year, Type::yearFilter::year)) {
         yearRepo.saveRecord(year);
+    } else {
+        std::cout << "year record already exists in the database" << std::endl;
+    }
 
     return year;
 }