diff --git a/Controllers/Managers/SongManager.cs b/Controllers/Managers/SongManager.cs
index 09ebb18..02d40dd 100644
--- a/Controllers/Managers/SongManager.cs
+++ b/Controllers/Managers/SongManager.cs
@@ -112,10 +112,10 @@ namespace Icarus.Controllers.Managers
 
 				// TODO: Add the following methods
 				UpdateAlbumInDatabase(oldSongRecord, updatedSong, albumStore);
-				// UpdateArtistInDatabase(oldSongRecord, newSongRecord, artistStore
-				// UpdateeGenreInDatabase(oldSongRecord, newSongRecord, genreStore)
-				// UpdateYearInDatabase(oldSongRecord, newSongRecord, yearStore)
-				// UpdateSongInDatabase(oldSongRecord, newSongRecord, songStore)
+				UpdateArtistInDatabase(oldSongRecord, updatedSong, artistStore);
+				UpdateGenreInDatabase(oldSongRecord, updatedSong, genreStore);
+				UpdateYearInDatabase(oldSongRecord, updatedSong, yearStore);
+				UpdateSongInDatabase(oldSongRecord, updatedSong, songStore);
 			}
 			catch (Exception ex)
 			{
@@ -563,6 +563,24 @@ namespace Icarus.Controllers.Managers
 	    		}
 		}
 
+		private bool SongRecordChanged(Song currentSong, Song songUpdates)
+		{
+			var currentTitle = currentSong.Title;
+			var currentArtist = currentSong.Artist;
+			var currentAlbum = currentSong.AlbumTitle;
+			var currentGenre = currentSong.Genre;
+			var currentYear = currentSong.Year;
+
+			if (!currentTitle.Equals(songUpdates.Title) || !currentArtist.Equals(songUpdates.Artist) ||
+					!currentAlbum.Equals(songUpdates.AlbumTitle) ||
+					!currentGenre.Equals(songUpdates.Genre) || currentYear != songUpdates.Year)
+			{
+				return true;
+			}
+
+			return false;
+		}
+
 		private void Initialize()
 		{
 	    		try
@@ -724,22 +742,254 @@ namespace Icarus.Controllers.Managers
 		{
 			var albumRecord = albumStore.GetAlbum(oldSongRecord);
 			var oldAlbumTitle = oldSongRecord.AlbumTitle;
+			var oldAlbumArtist = oldSongRecord.Artist;
 			var newAlbumTitle = newSongRecord.AlbumTitle;
+			var newAlbumArtist = newSongRecord.Artist;
 
 			var info = string.Empty;
 
-			Console.WriteLine($"{oldAlbumTitle}\n{newAlbumTitle}");
-
-			if (!oldAlbumTitle.Equals(newAlbumTitle))
+			if ((string.IsNullOrEmpty(newAlbumTitle) || string.IsNullOrEmpty(newAlbumArtist) || 
+						oldAlbumTitle.Equals(newAlbumTitle) || oldAlbumArtist.Equals(newAlbumArtist)))
 			{
-				info = "Change to the song's album";
-				_logger.Info(info);
+				_logger.Info("No change to the song's album");
+				return;
+			}
+
+			info = "Change to the song's album";
+			_logger.Info(info);
+
+			if (albumRecord.SongCount > 1)
+			{
+				_logger.Info("Decrementing existing album's song count");
+
+				albumRecord.SongCount -= 1;
+				albumStore.UpdateAlbum(albumRecord);
 			}
 			else
 			{
-				info = "No change to the song's album";
-				_logger.Info(info);
+				_logger.Info("Deleting existing album record that no longer has any songs");
+
+				albumStore.DeleteAlbum(albumRecord);
 			}
+
+			if (!albumStore.DoesAlbumExist(newSongRecord))
+			{
+				_logger.Info("Creating new album record");
+
+				var newAlbumRecord = new Album
+				{
+					Title = newAlbumTitle,
+					AlbumArtist = newAlbumArtist,
+					SongCount = 1
+				};
+
+				albumStore.SaveAlbum(newAlbumRecord);
+			}
+			else
+			{
+				_logger.Info("Updating existing album record");
+
+				var existingAlbumRecord = albumStore.GetAlbum(newSongRecord);
+				existingAlbumRecord.AlbumArtist = newAlbumArtist;
+				existingAlbumRecord.SongCount += 1;
+
+				albumStore.UpdateAlbum(existingAlbumRecord);
+			}
+		}
+		private void UpdateArtistInDatabase(Song oldSongRecord, Song newSongRecord, ArtistStoreContext artistStore)
+		{
+			var oldArtistRecord = artistStore.GetArtist(oldSongRecord);
+			var oldArtistName = oldArtistRecord.Name;
+			var newArtistName = newSongRecord.Artist;
+
+			if (string.IsNullOrEmpty(newArtistName) || oldArtistName.Equals(newArtistName))
+			{
+				_logger.Info("No change to the song's Artist");
+				return;
+			}
+
+			_logger.Info("Change to the song's record found");
+
+			if (oldArtistRecord.SongCount > 1)
+			{
+				_logger.Info("Decrementing existing artist's song count");
+
+				oldArtistRecord.SongCount -= 1;
+				artistStore.UpdateArtist(oldArtistRecord);
+			}
+			else
+			{
+				_logger.Info("Deleting artist record that no longer has any songs");
+
+				artistStore.DeleteArtist(oldArtistRecord);
+			}
+
+			if (!artistStore.DoesArtistExist(newSongRecord))
+			{
+				_logger.Info("Creating new artist record");
+
+				var newArtistRecord = new Artist
+				{
+					Name = newArtistName,
+					SongCount = 1
+				};
+
+				artistStore.SaveArtist(newArtistRecord);
+			}
+			else
+			{
+				_logger.Info("Updating existing artist record");
+
+				var existingArtistRecord = artistStore.GetArtist(newSongRecord);
+				existingArtistRecord.SongCount += 1;
+
+				artistStore.UpdateArtist(existingArtistRecord);
+			}
+		}
+		private void UpdateGenreInDatabase(Song oldSongRecord, Song newSongRecord, GenreStoreContext genreStore)
+		{
+			var oldGenreRecord = genreStore.GetGenre(oldSongRecord);
+			var oldGenreName = oldGenreRecord.GenreName;
+			var newGenreName = newSongRecord.Genre;
+
+			if (string.IsNullOrEmpty(newGenreName) || oldGenreName.Equals(newGenreName))
+			{
+				_logger.Info("No change to the song's Genre");
+				return;
+			}
+
+			_logger.Info("Change to the song's genre found");
+
+			if (oldGenreRecord.SongCount > 1)
+			{
+				_logger.Info("Decrementing exisiting genre song count");
+
+				oldGenreRecord.SongCount -= 1;
+				genreStore.UpdateGenre(oldGenreRecord);
+			}
+			else
+			{
+				_logger.Info("Deleting genre record");
+
+				genreStore.DeleteGenre(oldGenreRecord);
+			}
+
+			if (!genreStore.DoesGenreExist(newSongRecord))
+			{
+				_logger.Info("Creating new genre record");
+
+				var newGenreRecord = new Genre
+				{
+					GenreName = newGenreName,
+					SongCount = 1
+				};
+
+				genreStore.SaveGenre(newGenreRecord);
+			}
+			else
+			{
+				_logger.Info("Updating existing genre record");
+
+				var existingGenreRecord = genreStore.GetGenre(newSongRecord);
+				existingGenreRecord.SongCount += 1;
+
+				genreStore.UpdateGenre(existingGenreRecord);
+			}
+
+		}
+		private void UpdateYearInDatabase(Song oldSongRecord, Song newSongRecord, YearStoreContext yearStore)
+		{
+			var oldYearRecord = yearStore.GetSongYear(oldSongRecord);
+			var oldYearValue = oldYearRecord.YearValue;
+			var newYearValue = newSongRecord.Year;
+
+			if (oldYearValue == newYearValue || newYearValue == 0 || newYearValue == null)
+			{
+				_logger.Info("No change to the song's Year");
+				return;
+			}
+
+			_logger.Info("Change to the song's year found");
+
+			if (oldYearRecord.SongCount > 1)
+			{
+				_logger.Info("Decrementing song count of year record");
+
+				oldYearRecord.SongCount -= 1;
+				yearStore.UpdateYear(oldYearRecord);
+			}
+			else
+			{
+				_logger.Info("Deleting year record");
+
+				yearStore.DeleteYear(oldYearRecord);
+			}
+
+			if(!yearStore.DoesYearExist(newSongRecord))
+			{
+				_logger.Info("Creating new year record");
+
+				var newYearRecord = new Year
+				{
+					YearValue = newYearValue.Value,
+					SongCount = 1
+				};
+
+				yearStore.SaveYear(newYearRecord);
+			}
+			else
+			{
+				_logger.Info("Updating existing year record");
+
+				var existingYearRecord = yearStore.GetSongYear(newSongRecord);
+				existingYearRecord.SongCount += 1;
+
+				yearStore.UpdateYear(existingYearRecord);
+			}
+		}
+		private void UpdateSongInDatabase(Song oldSongRecord, Song newSongRecord, MusicStoreContext songStore)
+		{
+			var updatedSongRecord = oldSongRecord;
+
+			if (!SongRecordChanged(updatedSongRecord, newSongRecord))
+			{
+				_logger.Info("No change to the song record");
+				return;
+			}
+
+			_logger.Info("Changes to song record found");
+			Console.WriteLine($"Song id {updatedSongRecord.Id}");
+			Console.WriteLine("Before updated song values");
+
+			MetadataRetriever.PrintMetadata(updatedSongRecord);
+
+			if (!string.IsNullOrEmpty(newSongRecord.Title))
+			{
+				updatedSongRecord.Title = newSongRecord.Title;
+			}
+			if (!string.IsNullOrEmpty(newSongRecord.AlbumTitle))
+			{
+				updatedSongRecord.AlbumTitle = newSongRecord.AlbumTitle;
+			}
+			if (!string.IsNullOrEmpty(newSongRecord.Artist))
+			{
+				updatedSongRecord.Artist = newSongRecord.Artist;
+			}
+			if (!string.IsNullOrEmpty(newSongRecord.Genre))
+			{
+				updatedSongRecord.Genre = newSongRecord.Genre;
+			}
+			if (newSongRecord.Year != null || newSongRecord.Year > 0)
+			{
+				updatedSongRecord.Year = newSongRecord.Year;
+			}
+
+			_logger.Info("Applied changes to song record");
+
+			Console.WriteLine("Updated song values\n");
+			MetadataRetriever.PrintMetadata(updatedSongRecord);
+
+			songStore.UpdateSong(updatedSongRecord);
 		}
 
         	private async Task PopulateSongDetails()
diff --git a/Controllers/SongController.cs b/Controllers/SongController.cs
index d7e32eb..1ec7418 100644
--- a/Controllers/SongController.cs
+++ b/Controllers/SongController.cs
@@ -127,23 +127,6 @@ namespace Icarus.Controllers
 					yearStore);
 
 			return Ok("song exists");
-
-			var oldSongRecord = context.GetSong(id);
-			song.SongPath = oldSongRecord.SongPath;
-
-			MetadataRetriever updateMetadata = new MetadataRetriever();
-			updateMetadata.UpdateMetadata(song, oldSongRecord);
-
-			var updatedSong = updateMetadata.UpdatedSongRecord;
-			context.UpdateSong(updatedSong);
-
-			SongResult songResult = new SongResult
-			{
-				Message = updateMetadata.Message,
-				SongTitle = updatedSong.Title
-			};
-
-			return Ok(songResult);
         	}
     	}
 }
diff --git a/Controllers/Utilities/MetadataRetriever.cs b/Controllers/Utilities/MetadataRetriever.cs
index a6f28b4..148eb12 100644
--- a/Controllers/Utilities/MetadataRetriever.cs
+++ b/Controllers/Utilities/MetadataRetriever.cs
@@ -43,6 +43,29 @@ namespace Icarus.Controllers.Utilities
 
 
 		#region Methods
+		public static void PrintMetadata(Song song)
+		{
+			Console.WriteLine("\n\nMetadata of the song:");
+			Console.WriteLine($"Title: {song.Title}");
+			Console.WriteLine($"Artist: {song.Artist}");
+			Console.WriteLine($"Album: {song.AlbumTitle}");
+			Console.WriteLine($"Genre: {song.Genre}");
+			Console.WriteLine($"Year: {song.Year}");
+			Console.WriteLine($"Duration: {song.Duration}");
+			Console.WriteLine($"AlbumId: {song.AlbumId}");
+			Console.WriteLine($"ArtistId: {song.ArtistId}");
+			Console.WriteLine($"GenreId: {song.GenreId}");
+			Console.WriteLine($"YearId: {song.YearId}");
+			Console.WriteLine("\n");
+
+			_logger.Info("Metadata of the song");
+			_logger.Info($"Title: {song.Title}");
+			_logger.Info($"Artist: {song.Artist}");
+			_logger.Info($"Album: {song.AlbumTitle}");
+			_logger.Info($"Genre: {song.Genre}");
+			_logger.Info($"Year: {song.Year}");
+			_logger.Info($"Duration: {song.Duration}");
+		}
 		public Song RetrieveMetaData(string filePath)
 		{
 			Song song = new Song();
diff --git a/Models/Context/AlbumStoreContext.cs b/Models/Context/AlbumStoreContext.cs
index b202b84..41f5cbb 100644
--- a/Models/Context/AlbumStoreContext.cs
+++ b/Models/Context/AlbumStoreContext.cs
@@ -119,7 +119,7 @@ namespace Icarus.Models.Context
 				{
 					conn.Open();
 					var query = "SELECT * FROM Album WHERE Title=@Title";
-					_logger.Info($"Song title to rerieve album:\n{song.AlbumTitle}");
+					
 					using (MySqlCommand cmd = new MySqlCommand(query, conn))
 					{
 						cmd.Parameters.AddWithValue("@Title", song.AlbumTitle);
@@ -280,7 +280,7 @@ namespace Icarus.Models.Context
 				using (var conn = GetConnection())
 				{
 					conn.Open();
-					var query = "DELETE Album WHERE AlbumId=@AlbumId";
+					var query = "DELETE FROM Album WHERE AlbumId=@AlbumId";
 
 					using (var cmd = new MySqlCommand(query, conn))
 					{
diff --git a/Models/Context/ArtistStoreContext.cs b/Models/Context/ArtistStoreContext.cs
index 93245a3..b6d6b3f 100644
--- a/Models/Context/ArtistStoreContext.cs
+++ b/Models/Context/ArtistStoreContext.cs
@@ -202,7 +202,7 @@ namespace Icarus.Models.Context
 				{
 					conn.Open();
 
-					var query = "DELETE Artist WHERE ArtistId=@ArtistId";
+					var query = "DELETE FROM Artist WHERE ArtistId=@ArtistId";
 
 					using (var cmd = new MySqlCommand(query, conn))
 					{
diff --git a/Models/Context/GenreStoreContext.cs b/Models/Context/GenreStoreContext.cs
index 9abf5c4..f33e626 100644
--- a/Models/Context/GenreStoreContext.cs
+++ b/Models/Context/GenreStoreContext.cs
@@ -275,7 +275,7 @@ namespace Icarus.Models.Context
 				{
 					conn.Open();
 
-					var query = "DELETE Genre WHERE GenreId=@GenreId";
+					var query = "DELETE FROM Genre WHERE GenreId=@GenreId";
 
 					using (var cmd = new MySqlCommand(query, conn))
 					{
diff --git a/Models/Context/YearStoreContext.cs b/Models/Context/YearStoreContext.cs
index 282f3e1..c99c433 100644
--- a/Models/Context/YearStoreContext.cs
+++ b/Models/Context/YearStoreContext.cs
@@ -273,7 +273,7 @@ namespace Icarus.Models.Context
 				{
 					conn.Open();
 
-					var query = "DELETE Year WHERE YearId=@YearId";
+					var query = "DELETE FROM Year WHERE YearId=@YearId";
 
 					using (var cmd = new MySqlCommand(query, conn))
 					{