Code clean up

src/database/AlbumRepository.cpp

@@ -7,12 +7,13 @@
 #include <string>
 #include <cstring>
 
-database::AlbumRepository::AlbumRepository(const model::BinaryPath& bConf)
+namespace database {
+AlbumRepository::AlbumRepository(const model::BinaryPath& bConf)
     : BaseRepository(bConf)
 { }
 
 
-std::vector<model::Album> database::AlbumRepository::retrieveRecords()
+std::vector<model::Album> AlbumRepository::retrieveRecords()
 {
     auto conn = setupMysqlConnection();
     auto stmt = mysql_stmt_init(conn);
@@ -30,7 +31,7 @@ std::vector<model::Album> database::AlbumRepository::retrieveRecords()
 }
 
 
-std::pair<model::Album, int> database::AlbumRepository::retrieveRecordWithSongCount(model::Album& album, type::AlbumFilter filter = type::AlbumFilter::id)
+std::pair<model::Album, int> AlbumRepository::retrieveRecordWithSongCount(model::Album& album, type::AlbumFilter filter = type::AlbumFilter::id)
 {
     std::cout << "retrieving album with song count" << std::endl;
     std::stringstream qry;
@@ -71,7 +72,7 @@ std::pair<model::Album, int> database::AlbumRepository::retrieveRecordWithSongCo
     return albWSC;
 }
 
-model::Album database::AlbumRepository::retrieveRecord(model::Album& album, type::AlbumFilter filter)
+model::Album AlbumRepository::retrieveRecord(model::Album& album, type::AlbumFilter filter)
 {
     std::cout << "retrieving album record" << std::endl;
     std::stringstream qry;
@@ -122,7 +123,7 @@ model::Album database::AlbumRepository::retrieveRecord(model::Album& album, type
     return album;
 }
 
-bool database::AlbumRepository::doesAlbumExists(const model::Album& album, type::AlbumFilter filter)
+bool AlbumRepository::doesAlbumExists(const model::Album& album, type::AlbumFilter filter)
 {
     auto conn = setupMysqlConnection();
     auto stmt = mysql_stmt_init(conn);
@@ -173,7 +174,7 @@ bool database::AlbumRepository::doesAlbumExists(const model::Album& album, type:
     return (rowCount > 0) ? true : false;
 }
 
-void database::AlbumRepository::saveAlbum(const model::Album& album)
+void AlbumRepository::saveAlbum(const model::Album& album)
 {
     std::cout << "beginning to insert album record" << std::endl;
 
@@ -207,7 +208,7 @@ void database::AlbumRepository::saveAlbum(const model::Album& album)
     std::cout << "done inserting album record" << std::endl;
 }
 
-void database::AlbumRepository::deleteAlbum(const model::Album& album, type::AlbumFilter filter = type::AlbumFilter::id)
+void AlbumRepository::deleteAlbum(const model::Album& album, type::AlbumFilter filter = type::AlbumFilter::id)
 {
     std::cout << "deleting album record" << std::endl;
 
@@ -243,7 +244,7 @@ void database::AlbumRepository::deleteAlbum(const model::Album& album, type::Alb
 }
 
 
-std::vector<model::Album> database::AlbumRepository::parseRecords(MYSQL_STMT* stmt)
+std::vector<model::Album> AlbumRepository::parseRecords(MYSQL_STMT* stmt)
 {
     std::cout << "parsing album record" << std::endl;
     mysql_stmt_store_result(stmt);
@@ -304,7 +305,7 @@ std::vector<model::Album> database::AlbumRepository::parseRecords(MYSQL_STMT* st
 }
 
 // TODO: check to see if this is not used, if not then remove it
-model::Album database::AlbumRepository::parseRecord(MYSQL_RES* results)
+model::Album AlbumRepository::parseRecord(MYSQL_RES* results)
 {
     std::cout << "parsing album record" << std::endl;
     model::Album album;
@@ -329,7 +330,7 @@ model::Album database::AlbumRepository::parseRecord(MYSQL_RES* results)
     return album;
 }
 
-std::pair<model::Album, int> database::AlbumRepository::parseRecordWithSongCount(MYSQL_STMT *stmt)
+std::pair<model::Album, int> AlbumRepository::parseRecordWithSongCount(MYSQL_STMT *stmt)
 {
     std::cout << "parsing album record with song count" << std::endl;
     mysql_stmt_store_result(stmt);
@@ -392,7 +393,7 @@ std::pair<model::Album, int> database::AlbumRepository::parseRecordWithSongCount
     return albWSC;
 }
 
-model::Album database::AlbumRepository::parseRecord(MYSQL_STMT *stmt)
+model::Album AlbumRepository::parseRecord(MYSQL_STMT *stmt)
 {
     std::cout << "parsing album record" << std::endl;
     mysql_stmt_store_result(stmt);
@@ -447,3 +448,4 @@ model::Album database::AlbumRepository::parseRecord(MYSQL_STMT *stmt)
 
     return album;
 }
+}

src/database/ArtistRepository.cpp

@@ -6,13 +6,14 @@
 #include <string>
 #include <cstring>
 
-database::ArtistRepository::ArtistRepository(const model::BinaryPath& binConf)
+namespace database {
+ArtistRepository::ArtistRepository(const model::BinaryPath& binConf)
     : BaseRepository(binConf)
 {
 }
 
 
-std::vector<model::Artist> database::ArtistRepository::retrieveRecords()
+std::vector<model::Artist> ArtistRepository::retrieveRecords()
 {
     auto conn = setupMysqlConnection();
     auto stmt = mysql_stmt_init(conn);
@@ -29,7 +30,7 @@ std::vector<model::Artist> database::ArtistRepository::retrieveRecords()
     return artists;
 }
 
-std::pair<model::Artist, int> database::ArtistRepository::retrieveRecordWithSongCount(model::Artist& artist, type::ArtistFilter filter = type::ArtistFilter::id)
+std::pair<model::Artist, int> ArtistRepository::retrieveRecordWithSongCount(model::Artist& artist, type::ArtistFilter filter = type::ArtistFilter::id)
 {
     std::cout << "retrieving artist record with song count" << std::endl;
     std::stringstream qry;
@@ -73,7 +74,7 @@ std::pair<model::Artist, int> database::ArtistRepository::retrieveRecordWithSong
     return artWSC;
 }
 
-model::Artist database::ArtistRepository::retrieveRecord(model::Artist& artist, type::ArtistFilter filter)
+model::Artist ArtistRepository::retrieveRecord(model::Artist& artist, type::ArtistFilter filter)
 {
     std::cout << "retrieving artist record" << std::endl;
     std::stringstream qry;
@@ -123,7 +124,7 @@ model::Artist database::ArtistRepository::retrieveRecord(model::Artist& artist,
     return artist;
 }
 
-bool database::ArtistRepository::doesArtistExist(const model::Artist& artist, type::ArtistFilter filter)
+bool ArtistRepository::doesArtistExist(const model::Artist& artist, type::ArtistFilter filter)
 {
     auto conn = setupMysqlConnection();
     auto stmt = mysql_stmt_init(conn);
@@ -174,7 +175,7 @@ bool database::ArtistRepository::doesArtistExist(const model::Artist& artist, ty
     return (rowCount > 0) ? true : false;
 }
 
-void database::ArtistRepository::saveRecord(const model::Artist& artist)
+void ArtistRepository::saveRecord(const model::Artist& artist)
 {
     std::cout << "inserting artist record" << std::endl;
 
@@ -203,8 +204,7 @@ void database::ArtistRepository::saveRecord(const model::Artist& artist)
     std::cout<< "inserted artist record" << std::endl;
 }
 
-void database::ArtistRepository::deleteArtist(const model::Artist& artist, type::ArtistFilter filter = type::ArtistFilter::id) {
-    // TODO: implement this
+void ArtistRepository::deleteArtist(const model::Artist& artist, type::ArtistFilter filter = type::ArtistFilter::id) {
     std::cout << "delete Artist record" << std::endl;
     std::stringstream qry;
     auto conn = setupMysqlConnection();
@@ -240,7 +240,7 @@ void database::ArtistRepository::deleteArtist(const model::Artist& artist, type:
     std::cout << "deleted artist record" << std::endl;
 }
 
-std::vector<model::Artist> database::ArtistRepository::parseRecords(MYSQL_STMT *stmt)
+std::vector<model::Artist> ArtistRepository::parseRecords(MYSQL_STMT *stmt)
 {
     mysql_stmt_store_result(stmt);
 
@@ -291,7 +291,7 @@ std::vector<model::Artist> database::ArtistRepository::parseRecords(MYSQL_STMT *
 }
 
 
-model::Artist database::ArtistRepository::parseRecord(MYSQL_RES* results)
+model::Artist ArtistRepository::parseRecord(MYSQL_RES* results)
 {
     std::cout << "parsing artist record" << std::endl;
     model::Artist artist;
@@ -315,7 +315,7 @@ model::Artist database::ArtistRepository::parseRecord(MYSQL_RES* results)
     return artist;
 }
 
-std::pair<model::Artist, int> database::ArtistRepository::parseRecordWithSongCount(MYSQL_STMT *stmt)
+std::pair<model::Artist, int> ArtistRepository::parseRecordWithSongCount(MYSQL_STMT *stmt)
 {
     std::cout << "parsing artist record with song count" << std::endl;
     mysql_stmt_store_result(stmt);
@@ -364,7 +364,7 @@ std::pair<model::Artist, int> database::ArtistRepository::parseRecordWithSongCou
     return std::make_pair(artist, songCount);
 }
 
-model::Artist database::ArtistRepository::parseRecord(MYSQL_STMT *stmt)
+model::Artist ArtistRepository::parseRecord(MYSQL_STMT *stmt)
 {
     std::cout << "parsing artist record" << std::endl;
     mysql_stmt_store_result(stmt);
@@ -413,3 +413,4 @@ model::Artist database::ArtistRepository::parseRecord(MYSQL_STMT *stmt)
 
     return art;
 }
+}

src/database/BaseRepository.cpp

@@ -6,21 +6,22 @@
 
 #include "manager/DirectoryManager.h"
 
-database::BaseRepository::BaseRepository() 
+namespace database {
+BaseRepository::BaseRepository() 
 { }
 
-database::BaseRepository::BaseRepository(const std::string& path) : path(path)
+BaseRepository::BaseRepository(const std::string& path) : path(path)
 { 
     intitalizeDetails();
 }
 
-database::BaseRepository::BaseRepository(const model::BinaryPath& bConf)
+BaseRepository::BaseRepository(const model::BinaryPath& bConf)
 {
     initializeDetails(bConf);
 }
 
 
-bool database::BaseRepository::testConnection()
+bool BaseRepository::testConnection()
 {
     auto conn = mysql_init(nullptr);
     if (!mysql_real_connect(conn, details.server.c_str(), details.username.c_str(), 
@@ -36,7 +37,7 @@ bool database::BaseRepository::testConnection()
 }
 
 
-MYSQL* database::BaseRepository::setupMysqlConnection()
+MYSQL* BaseRepository::setupMysqlConnection()
 {
     MYSQL *conn = mysql_init(nullptr);
 
@@ -48,7 +49,7 @@ MYSQL* database::BaseRepository::setupMysqlConnection()
     return conn;
 }
 
-MYSQL* database::BaseRepository::setupMysqlConnection(model::DatabaseConnection details)
+MYSQL* BaseRepository::setupMysqlConnection(model::DatabaseConnection details)
 {
     MYSQL *connection = mysql_init(NULL);
 
@@ -61,7 +62,7 @@ MYSQL* database::BaseRepository::setupMysqlConnection(model::DatabaseConnection
 }
 
 
-MYSQL_RES* database::BaseRepository::performMysqlQuery(MYSQL *conn, const std::string& query)
+MYSQL_RES* BaseRepository::performMysqlQuery(MYSQL *conn, const std::string& query)
 {
    // send the query to the database
    if (mysql_query(conn, query.c_str()))
@@ -74,7 +75,7 @@ MYSQL_RES* database::BaseRepository::performMysqlQuery(MYSQL *conn, const std::s
 }
 
 
-void database::BaseRepository::intitalizeDetails()
+void BaseRepository::intitalizeDetails()
 {
     auto databaseConfig = manager::DirectoryManager::databaseConfigContent(path);
     
@@ -83,7 +84,7 @@ void database::BaseRepository::intitalizeDetails()
     details.server = databaseConfig["server"].get<std::string>();
     details.username = databaseConfig["username"].get<std::string>();
 }
-void database::BaseRepository::initializeDetails(const model::BinaryPath& bConf)
+void BaseRepository::initializeDetails(const model::BinaryPath& bConf)
 {
     auto databaseConfig = manager::DirectoryManager::databaseConfigContent(bConf);
 
@@ -94,3 +95,4 @@ void database::BaseRepository::initializeDetails(const model::BinaryPath& bConf)
 
     std::cout << "retrieved database details" << std::endl;
 }
+}

src/database/CoverArtRepository.cpp

@@ -6,14 +6,15 @@
 #include <string>
 #include <cstring>
 
-database::CoverArtRepository::CoverArtRepository(const std::string& path) : BaseRepository(path)
+namespace database {
+CoverArtRepository::CoverArtRepository(const std::string& path) : BaseRepository(path)
 { }
 
-database::CoverArtRepository::CoverArtRepository(const model::BinaryPath& bConf) : BaseRepository(bConf)
+CoverArtRepository::CoverArtRepository(const model::BinaryPath& bConf) : BaseRepository(bConf)
 { }
 
 
-std::vector<model::Cover> database::CoverArtRepository::retrieveRecords()
+std::vector<model::Cover> CoverArtRepository::retrieveRecords()
 {
     auto conn = setupMysqlConnection();
     auto stmt = mysql_stmt_init(conn);
@@ -30,7 +31,7 @@ std::vector<model::Cover> database::CoverArtRepository::retrieveRecords()
     return coverArts;
 }
 
-model::Cover database::CoverArtRepository::retrieveRecord(model::Cover& cov, type::CoverFilter filter = type::CoverFilter::id)
+model::Cover CoverArtRepository::retrieveRecord(model::Cover& cov, type::CoverFilter filter = type::CoverFilter::id)
 {
     std::stringstream qry;
     auto conn = setupMysqlConnection();
@@ -80,7 +81,7 @@ model::Cover database::CoverArtRepository::retrieveRecord(model::Cover& cov, typ
 }
 
 
-bool database::CoverArtRepository::doesCoverArtExist(const model::Cover& cover, type::CoverFilter filter)
+bool CoverArtRepository::doesCoverArtExist(const model::Cover& cover, type::CoverFilter filter)
 {
     auto conn = setupMysqlConnection();
     auto stmt = mysql_stmt_init(conn);
@@ -133,7 +134,7 @@ bool database::CoverArtRepository::doesCoverArtExist(const model::Cover& cover,
 
 
 // TODO: change to prepared statement
-void database::CoverArtRepository::deleteRecord(const model::Cover& cov)
+void CoverArtRepository::deleteRecord(const model::Cover& cov)
 {
     auto conn = setupMysqlConnection();
     const std::string query("DELETE FROM CoverArt WHERE CoverArtId = " + std::to_string(cov.id));
@@ -143,7 +144,7 @@ void database::CoverArtRepository::deleteRecord(const model::Cover& cov)
     mysql_close(conn);
 }
 
-void database::CoverArtRepository::saveRecord(const model::Cover& cov)
+void CoverArtRepository::saveRecord(const model::Cover& cov)
 {
     std::cout << "saving cover art record";
     auto conn = setupMysqlConnection();
@@ -178,7 +179,7 @@ void database::CoverArtRepository::saveRecord(const model::Cover& cov)
     std::cout << "saved cover art record" << std::endl;
 }
 
-void database::CoverArtRepository::updateRecord(const model::Cover& cover)
+void CoverArtRepository::updateRecord(const model::Cover& cover)
 {
     std::stringstream qry;
     auto conn = setupMysqlConnection();
@@ -222,7 +223,7 @@ void database::CoverArtRepository::updateRecord(const model::Cover& cover)
 }
 
 
-std::vector<model::Cover> database::CoverArtRepository::parseRecords(MYSQL_STMT *stmt)
+std::vector<model::Cover> CoverArtRepository::parseRecords(MYSQL_STMT *stmt)
 {
     mysql_stmt_store_result(stmt);
     auto rowCount = mysql_stmt_num_rows(stmt);
@@ -288,7 +289,7 @@ std::vector<model::Cover> database::CoverArtRepository::parseRecords(MYSQL_STMT
 }
 
 
-model::Cover database::CoverArtRepository::parseRecord(MYSQL_RES *results)
+model::Cover CoverArtRepository::parseRecord(MYSQL_RES *results)
 {
     std::cout << "parsing record" << std::endl;
     model::Cover cov;
@@ -314,7 +315,7 @@ model::Cover database::CoverArtRepository::parseRecord(MYSQL_RES *results)
     return cov;
 }
 
-model::Cover database::CoverArtRepository::parseRecord(MYSQL_STMT *stmt)
+model::Cover CoverArtRepository::parseRecord(MYSQL_STMT *stmt)
 {
     std::cout << "parsing cover art record" << std::endl;
 
@@ -372,3 +373,4 @@ model::Cover database::CoverArtRepository::parseRecord(MYSQL_STMT *stmt)
 
     return cover;
 }
+}

src/database/GenreRepository.cpp

@@ -5,12 +5,14 @@
 #include <sstream>
 #include <cstring>
 
-database::GenreRepository::GenreRepository(const model::BinaryPath& bConf)
+namespace database {
+
+GenreRepository::GenreRepository(const model::BinaryPath& bConf)
     : BaseRepository(bConf)
 { }
 
 
-std::vector<model::Genre> database::GenreRepository::retrieveRecords()
+std::vector<model::Genre> GenreRepository::retrieveRecords()
 {
     auto conn = setupMysqlConnection();
     auto stmt = mysql_stmt_init(conn);
@@ -27,7 +29,7 @@ std::vector<model::Genre> database::GenreRepository::retrieveRecords()
     return genres;
 }
 
-std::pair<model::Genre, int> database::GenreRepository::retrieveRecordWithSongCount(model::Genre& genre, type::GenreFilter filter = type::GenreFilter::id)
+std::pair<model::Genre, int> GenreRepository::retrieveRecordWithSongCount(model::Genre& genre, type::GenreFilter filter = type::GenreFilter::id)
 {
     std::cout << "retrieving genre record with song count" << std::endl;
     std::stringstream qry;
@@ -71,7 +73,7 @@ std::pair<model::Genre, int> database::GenreRepository::retrieveRecordWithSongCo
     return gnrWSC;
 }
 
-model::Genre database::GenreRepository::retrieveRecord(model::Genre& genre, type::GenreFilter filter)
+model::Genre GenreRepository::retrieveRecord(model::Genre& genre, type::GenreFilter filter)
 {
     // TODO: change to prepared statement
     
@@ -108,7 +110,7 @@ model::Genre database::GenreRepository::retrieveRecord(model::Genre& genre, type
     return genre;
 }
 
-bool database::GenreRepository::doesGenreExist(const model::Genre& genre, type::GenreFilter filter)
+bool GenreRepository::doesGenreExist(const model::Genre& genre, type::GenreFilter filter)
 {
     auto conn = setupMysqlConnection();
     auto stmt = mysql_stmt_init(conn);
@@ -159,7 +161,7 @@ bool database::GenreRepository::doesGenreExist(const model::Genre& genre, type::
     return (rowCount > 0) ? true : false;
 }
 
-void database::GenreRepository::saveRecord(const model::Genre& genre)
+void GenreRepository::saveRecord(const model::Genre& genre)
 {
     std::cout << "inserting genre record" << std::endl;
 
@@ -188,7 +190,7 @@ void database::GenreRepository::saveRecord(const model::Genre& genre)
     std::cout << "inserted record" << std::endl;
 }
 
-void database::GenreRepository::deleteRecord(const model::Genre& genre, type::GenreFilter filter = type::GenreFilter::id)
+void GenreRepository::deleteRecord(const model::Genre& genre, type::GenreFilter filter = type::GenreFilter::id)
 {
     // TODO: implement this
     std::cout << "deleting genre record" << std::endl;
@@ -227,7 +229,7 @@ void database::GenreRepository::deleteRecord(const model::Genre& genre, type::Ge
 }
 
 
-std::vector<model::Genre> database::GenreRepository::parseRecords(MYSQL_STMT *stmt)
+std::vector<model::Genre> GenreRepository::parseRecords(MYSQL_STMT *stmt)
 {
     mysql_stmt_store_result(stmt);
 
@@ -277,7 +279,7 @@ std::vector<model::Genre> database::GenreRepository::parseRecords(MYSQL_STMT *st
     return genres;
 }
 
-std::pair<model::Genre, int> database::GenreRepository::parseRecordWithSongCount(MYSQL_STMT *stmt)
+std::pair<model::Genre, int> GenreRepository::parseRecordWithSongCount(MYSQL_STMT *stmt)
 {
     std::cout << "parsing genre record with song count" << std::endl;
     mysql_stmt_store_result(stmt);
@@ -326,7 +328,7 @@ std::pair<model::Genre, int> database::GenreRepository::parseRecordWithSongCount
     return std::make_pair(genre, songCount);
 }
 
-model::Genre database::GenreRepository::parseRecord(MYSQL_RES* results)
+model::Genre GenreRepository::parseRecord(MYSQL_RES* results)
 {
     std::cout << "parsing genre record" << std::endl;
     model::Genre genre;
@@ -349,7 +351,7 @@ model::Genre database::GenreRepository::parseRecord(MYSQL_RES* results)
 
     return genre;
 }
-model::Genre database::GenreRepository::parseRecord(MYSQL_STMT *stmt)
+model::Genre GenreRepository::parseRecord(MYSQL_STMT *stmt)
 {
     // TODO: implement this
     
@@ -357,3 +359,4 @@ model::Genre database::GenreRepository::parseRecord(MYSQL_STMT *stmt)
 
     return genre;
 }
+}

src/database/SongRepository.cpp

@@ -7,14 +7,16 @@
 
 #include "type/SongFilter.h"
 
-database::SongRepository::SongRepository(const std::string& path) : BaseRepository(path)
+namespace database {
+
+SongRepository::SongRepository(const std::string& path) : BaseRepository(path)
 { }
 
-database::SongRepository::SongRepository(const model::BinaryPath& bConf) : BaseRepository(bConf)
+SongRepository::SongRepository(const model::BinaryPath& bConf) : BaseRepository(bConf)
 { }
 
 
-std::vector<model::Song> database::SongRepository::retrieveRecords()
+std::vector<model::Song> SongRepository::retrieveRecords()
 {
     auto conn = setupMysqlConnection();
     auto stmt = mysql_stmt_init(conn);
@@ -32,18 +34,28 @@ std::vector<model::Song> database::SongRepository::retrieveRecords()
 }
 
 
-model::Song database::SongRepository::retrieveRecord(model::Song& song, type::SongFilter filter)
+model::Song SongRepository::retrieveRecord(model::Song& song, type::SongFilter filter)
 {
     std::stringstream qry;
     auto conn = setupMysqlConnection();
     auto stmt = mysql_stmt_init(conn);
 
-    MYSQL_BIND params[1];
+    auto valueFilterCount = 1;
+    switch (filter) {
+        case type::SongFilter::titleAndArtist:
+            valueFilterCount = 2;
+            break;
+        default:
+        break;
+    }
+
+    MYSQL_BIND params[valueFilterCount];
     memset(params, 0, sizeof(params));
 
     qry << "SELECT * FROM Song WHERE ";
 
     auto titleLength = song.title.size();
+    auto artistLength = song.artist.size();
     switch (filter) {
         case type::SongFilter::id:
             qry << "SongId = ?";
@@ -61,6 +73,19 @@ model::Song database::SongRepository::retrieveRecord(model::Song& song, type::So
             params[0].length = &titleLength;
             params[0].is_null = 0;
             break;
+        case type::SongFilter::titleAndArtist:
+            qry << "Title = ? AND Artist = ?";
+
+            params[0].buffer_type = MYSQL_TYPE_STRING;
+            params[0].buffer = (char*)song.title.c_str();
+            params[0].length = &titleLength;
+            params[0].is_null = 0;
+
+            params[1].buffer_type = MYSQL_TYPE_STRING;
+            params[1].buffer = (char*)song.artist.c_str();
+            params[1].length = &artistLength;
+            params[1].is_null = 0;
+            break;
         default:
             break;
     }
@@ -84,19 +109,29 @@ model::Song database::SongRepository::retrieveRecord(model::Song& song, type::So
 }
 
 
-bool database::SongRepository::doesSongExist(const model::Song& song, type::SongFilter filter)
+bool SongRepository::doesSongExist(const model::Song& song, type::SongFilter filter)
 {
     std::cout << "checking to see if song exists" << std::endl;
     std::stringstream qry;
     auto conn = setupMysqlConnection();
     auto stmt = mysql_stmt_init(conn);
+    auto valueFilterCount = 1;
+    switch (filter) {
+        case type::SongFilter::titleAndArtist:
+            valueFilterCount = 2;
+            break;
+        default:
+            break;
+    }
 
-    MYSQL_BIND params[1];
+
+    MYSQL_BIND params[valueFilterCount];
     memset(params, 0, sizeof(params));
 
     qry << "SELECT * FROM Song WHERE ";
 
     auto titleLength = song.title.size();
+    auto artistLength = song.artist.size();
     switch (filter) {
         case type::SongFilter::id:
             qry << "SongId = ?";
@@ -114,6 +149,19 @@ bool database::SongRepository::doesSongExist(const model::Song& song, type::Song
             params[0].length = &titleLength;
             params[0].is_null = 0;
             break;
+        case type::SongFilter::titleAndArtist:
+            qry << "Title = ? AND Artist = ?";
+
+            params[0].buffer_type = MYSQL_TYPE_STRING;
+            params[0].buffer = (char*)song.title.c_str();
+            params[0].length = &titleLength;
+            params[0].is_null = 0;
+
+            params[1].buffer_type = MYSQL_TYPE_STRING;
+            params[1].buffer = (char*)song.artist.c_str();
+            params[1].length = &artistLength;
+            params[1].is_null = 0;
+            break;
         default:
             break;
     }
@@ -137,7 +185,7 @@ bool database::SongRepository::doesSongExist(const model::Song& song, type::Song
     return (rowCount > 0) ? true : false;
 }
 
-bool database::SongRepository::deleteRecord(const model::Song& song)
+bool SongRepository::deleteRecord(const model::Song& song)
 {
     auto conn = setupMysqlConnection();
     auto status = 0;
@@ -151,7 +199,7 @@ bool database::SongRepository::deleteRecord(const model::Song& song)
     return (result == 0) ? true : false;
 }
 
-void database::SongRepository::saveRecord(const model::Song& song)
+void SongRepository::saveRecord(const model::Song& song)
 {
     std::cout << "beginning to insert song record" << std::endl;
     auto conn = setupMysqlConnection();
@@ -252,7 +300,7 @@ void database::SongRepository::saveRecord(const model::Song& song)
     std::cout << "done inserting song record" << std::endl;
 }
 
-void database::SongRepository::updateRecord(const model::Song& song)
+void SongRepository::updateRecord(const model::Song& song)
 {
     std::cout << "executing query to update record" << std::endl;
     auto conn = setupMysqlConnection();
@@ -344,116 +392,84 @@ void database::SongRepository::updateRecord(const model::Song& song)
 }
 
 
-// TODO: delete this, not being used
-std::vector<model::Song> database::SongRepository::parseRecords(MYSQL_RES* results)
+std::shared_ptr<MYSQL_BIND> SongRepository::valueBind(model::Song& song,
+    std::tuple<char*, char*, char*, char*, char*>& metadata)
 {
-    auto fieldNum = mysql_num_fields(results);
-    auto numRows = mysql_num_rows(results);
+    constexpr auto strLen = 1024;
+    constexpr auto valueCount = 15;
+    std::shared_ptr<MYSQL_BIND> values((MYSQL_BIND*) std::calloc(valueCount, sizeof(MYSQL_BIND)));
+    unsigned long len[valueCount];
+    my_bool nullRes[valueCount];
 
-    std::vector<model::Song> songs;
-    songs.reserve(numRows);
 
-    for (MYSQL_ROW row = nullptr; (row = mysql_fetch_row(results)) != nullptr; ) {
-        model::Song song;
+    values.get()[0].buffer_type = MYSQL_TYPE_LONG;
+    values.get()[0].buffer = (char*)&song.id;
 
-        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;
+    values.get()[1].buffer_type = MYSQL_TYPE_STRING;
+    values.get()[1].buffer = (char*)std::get<0>(metadata);
+    values.get()[1].buffer_length = strLen;
 
-            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]);
-                    break;
-                case 1:
-                    song.title = row[i];
-                    break;
-                case 2:
-                    song.artist= row[i];
-                    break;
-                case 3:
-                    song.album = row[i];
-                    break;
-                case 4:
-                    song.genre = row[i];
-                    break;
-                case 5:
-                    song.year = std::stoi(row[i]);
-                    break;
-                case 6:
-                    song.duration = std::stoi(row[i]);
-                    break;
-                case 7:
-                    song.track = std::stoi(row[i]);
-                    break;
-                case 8:
-                    song.disc = std::stoi(row[i]);
-                    break;
-                case 9:
-                    song.songPath = row[i];
-                    break;
-                case 10:
-                    song.coverArtId = std::stoi(row[i]);
-                    break;
-            }
-        }
+    values.get()[2].buffer_type = MYSQL_TYPE_STRING;
+    values.get()[2].buffer = (char*)std::get<1>(metadata);
+    values.get()[2].buffer_length = strLen;
 
-        songs.push_back(song);
-    }
+    values.get()[3].buffer_type = MYSQL_TYPE_STRING;
+    values.get()[3].buffer = (char*)std::get<2>(metadata);
+    values.get()[3].buffer_length = strLen;
 
-    return songs;
+    values.get()[4].buffer_type = MYSQL_TYPE_STRING;
+    values.get()[4].buffer = (char*)std::get<3>(metadata);
+    values.get()[4].buffer_length = strLen;
+
+    values.get()[5].buffer_type = MYSQL_TYPE_LONG;
+    values.get()[5].buffer = (char*)&song.year;
+
+    values.get()[6].buffer_type = MYSQL_TYPE_LONG;
+    values.get()[6].buffer = (char*)&song.duration;
+
+    values.get()[7].buffer_type = MYSQL_TYPE_LONG;
+    values.get()[7].buffer = (char*)&song.track;
+
+    values.get()[8].buffer_type = MYSQL_TYPE_LONG;
+    values.get()[8].buffer = (char*)&song.disc;
+
+    values.get()[9].buffer_type = MYSQL_TYPE_STRING;
+    values.get()[9].buffer = (char*)std::get<4>(metadata);
+    values.get()[9].buffer_length = strLen;
+
+    values.get()[10].buffer_type = MYSQL_TYPE_LONG;
+    values.get()[10].buffer = (char*)&song.coverArtId;
+
+    values.get()[11].buffer_type = MYSQL_TYPE_LONG;
+    values.get()[11].buffer = (char*)&song.artistId;
+
+    values.get()[12].buffer_type = MYSQL_TYPE_LONG;
+    values.get()[12].buffer = (char*)&song.albumId;;
+
+    values.get()[13].buffer_type = MYSQL_TYPE_LONG;
+    values.get()[13].buffer = (char*)&song.genreId;
+
+    values.get()[14].buffer_type = MYSQL_TYPE_LONG;
+    values.get()[14].buffer = (char*)&song.yearId;
+
+    return values;
 }
 
-std::vector<model::Song> database::SongRepository::parseRecords(MYSQL_STMT *stmt)
+
+std::tuple<char*, char*, char*, char*, char*> SongRepository::metadataBuffer()
+{
+    constexpr auto length = 1024;
+    char title[length];
+    char artist[length];
+    char album[length];
+    char genre[length];
+    char path[length];
+
+    return std::make_tuple(title, artist, album, genre, path);
+}
+
+
+std::vector<model::Song> SongRepository::parseRecords(MYSQL_STMT *stmt)
 {
     ::mysql_stmt_store_result(stmt);
     auto c = ::mysql_stmt_num_rows(stmt);
@@ -463,110 +479,14 @@ std::vector<model::Song> database::SongRepository::parseRecords(MYSQL_STMT *stmt
 
     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));
+            auto metaBuff = metadataBuffer();
+            auto val = valueBind(song, metaBuff);
 
-            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);
+            status = ::mysql_stmt_bind_result(stmt, val.get());
 
             while (1) {
                 std::cout << "fetching statement result" << std::endl;
@@ -575,11 +495,12 @@ std::vector<model::Song> database::SongRepository::parseRecords(MYSQL_STMT *stmt
                 if (status == 1 || status == MYSQL_NO_DATA) {
                     break;
                 }
-                song.title = title;
-                song.album = album;
-                song.artist = artist;
-                song.genre = genre;
-                song.songPath = path;
+                
+                song.title = std::get<0>(metaBuff);
+                song.artist = std::get<1>(metaBuff);
+                song.album = std::get<2>(metaBuff);
+                song.genre = std::get<3>(metaBuff);
+                song.songPath = std::get<4>(metaBuff);
 
                 songs.push_back(song);
             }
@@ -592,177 +513,22 @@ std::vector<model::Song> database::SongRepository::parseRecords(MYSQL_STMT *stmt
 }
 
 
-// TODO: delete this, not being used anymore
-model::Song database::SongRepository::parseRecord(MYSQL_RES* results)
+model::Song SongRepository::parseRecord(MYSQL_STMT *stmt)
 {
     model::Song song;
+    auto metaBuff = metadataBuffer();
+    auto bindedValues = valueBind(song, metaBuff);
+    auto status = mysql_stmt_bind_result(stmt, bindedValues.get());
+    status = mysql_stmt_fetch(stmt);
 
-    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]);
-                break;
-            case 1:
-                song.title = row[i];
-                break;
-            case 2:
-                song.artist= row[i];
-                break;
-            case 3:
-                song.album = row[i];
-                break;
-            case 4:
-                song.genre = row[i];
-                break;
-            case 5:
-                song.year = std::stoi(row[i]);
-                break;
-            case 6:
-                song.duration = std::stoi(row[i]);
-                break;
-            case 7:
-                song.track = std::stoi(row[i]);
-                break;
-            case 8:
-                song.disc = std::stoi(row[i]);
-                break;
-            case 9:
-                song.songPath = row[i];
-                break;
-            case 10:
-                song.coverArtId = std::stoi(row[i]);
-                break;
-        }
-    }
+    song.title = std::get<0>(metaBuff);
+    song.artist = std::get<1>(metaBuff);
+    song.album = std::get<2>(metaBuff);
+    song.genre = std::get<3>(metaBuff);
+    song.songPath = std::get<4>(metaBuff);
+    
     std::cout << "done parsing record" << std::endl;
 
     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 << "done parsing record" << std::endl;
-
-    return song;
 }

src/database/UserRepository.cpp

@@ -25,6 +25,13 @@ model::User UserRepository::retrieveUserRecord(model::User& user,
     auto userLength = user.username.size();
     switch (filter) {
         case type::UserFilter::id:
+            qry << "UserId = ?";
+
+            params[0].buffer_type = MYSQL_TYPE_LONG;
+            params[0].buffer = (char*)&user.id;
+            params[0].length = nullptr;
+            params[0].is_null = 0;
+
             break;
         case type::UserFilter::username:
             qry << "Username = ?";

src/database/YearRepository.cpp

@@ -6,13 +6,11 @@
 #include <string>
 #include <cstring>
 
-
-database::YearRepository::YearRepository(const model::BinaryPath& bConf)
-    : BaseRepository(bConf)
-{ }
+namespace database {
+YearRepository::YearRepository(const model::BinaryPath& bConf) : BaseRepository(bConf) { }
 
 
-std::vector<model::Year> database::YearRepository::retrieveRecords()
+std::vector<model::Year> YearRepository::retrieveRecords()
 {
     auto conn = setupMysqlConnection();
     auto stmt = mysql_stmt_init(conn);
@@ -29,7 +27,7 @@ std::vector<model::Year> database::YearRepository::retrieveRecords()
     return yearRecs;
 }
 
-std::pair<model::Year, int> database::YearRepository::retrieveRecordWithSongCount(model::Year& year, type::YearFilter filter = type::YearFilter::id)
+std::pair<model::Year, int> YearRepository::retrieveRecordWithSongCount(model::Year& year, type::YearFilter filter = type::YearFilter::id)
 {
     std::cout << "retrieving year record with song count" << std::endl;
     std::stringstream qry;
@@ -73,7 +71,7 @@ std::pair<model::Year, int> database::YearRepository::retrieveRecordWithSongCoun
     return yearWSC;
 }
 
-model::Year database::YearRepository::retrieveRecord(model::Year& year, type::YearFilter filter)
+model::Year YearRepository::retrieveRecord(model::Year& year, type::YearFilter filter)
 {
     // TODO: switch to prepared statements
     std::cout << "retrieving year record" << std::endl;
@@ -106,7 +104,7 @@ model::Year database::YearRepository::retrieveRecord(model::Year& year, type::Ye
     return year;
 }
 
-bool database::YearRepository::doesYearExist(const model::Year& year, type::YearFilter filter)
+bool YearRepository::doesYearExist(const model::Year& year, type::YearFilter filter)
 {
     auto conn = setupMysqlConnection();
     auto stmt = mysql_stmt_init(conn);
@@ -156,7 +154,7 @@ bool database::YearRepository::doesYearExist(const model::Year& year, type::Year
     return (rowCount > 0) ? true : false;
 }
 
-void database::YearRepository::saveRecord(const model::Year& year)
+void YearRepository::saveRecord(const model::Year& year)
 {
     std::cout << "saving year record" << std::endl;
 
@@ -184,7 +182,7 @@ void database::YearRepository::saveRecord(const model::Year& year)
     std::cout << "saved record" << std::endl;
 }
 
-void database::YearRepository::deleteYear(const model::Year& year, type::YearFilter filter = type::YearFilter::id)
+void YearRepository::deleteYear(const model::Year& year, type::YearFilter filter = type::YearFilter::id)
 {
     std::cout << "deleting year record"  << std::endl;
     std::stringstream qry;
@@ -221,7 +219,7 @@ void database::YearRepository::deleteYear(const model::Year& year, type::YearFil
     std::cout << "deleted year record" << std::endl;
 }
 
-std::vector<model::Year> database::YearRepository::parseRecords(MYSQL_STMT *stmt)
+std::vector<model::Year> YearRepository::parseRecords(MYSQL_STMT *stmt)
 {
     mysql_stmt_store_result(stmt);
 
@@ -265,7 +263,7 @@ std::vector<model::Year> database::YearRepository::parseRecords(MYSQL_STMT *stmt
     return yearRecs;
 }
 
-std::pair<model::Year, int> database::YearRepository::parseRecordWithSongCount(MYSQL_STMT *stmt)
+std::pair<model::Year, int> YearRepository::parseRecordWithSongCount(MYSQL_STMT *stmt)
 {
     std::cout << "parsing year record" << std::endl;
     mysql_stmt_store_result(stmt);
@@ -308,7 +306,7 @@ std::pair<model::Year, int> database::YearRepository::parseRecordWithSongCount(M
     return std::make_pair(year, songCount);
 }
 
-model::Year database::YearRepository::parseRecord(MYSQL_RES *results)
+model::Year YearRepository::parseRecord(MYSQL_RES *results)
 {
     std::cout << "parsing year record" << std::endl;
     model::Year year;
@@ -331,7 +329,7 @@ model::Year database::YearRepository::parseRecord(MYSQL_RES *results)
 
     return year;
 }
-model::Year database::YearRepository::parseRecord(MYSQL_STMT *stmt)
+model::Year YearRepository::parseRecord(MYSQL_STMT *stmt)
 {
     // TODO: imeplement this
     // I really thought that I had already done this
@@ -340,3 +338,4 @@ model::Year database::YearRepository::parseRecord(MYSQL_STMT *stmt)
 
     return year;
 }
+}