phoenix/icarus
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 33 Wiki Activity

Able to save and retrieve records (Artist, Album, Genre, etc.)

Browse Source
This commit is contained in:
kdeng00
2019-09-02 13:59:49 -04:00
parent fafb39326b
commit 4306c174b3
26 changed files with 522 additions and 34 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/database/albumRepository.cpp
+8 -8
View File
@@ -21,6 +21,7 @@ std::vector<Model::Album> Database::albumRepository::retrieveRecords()
Model::Album Database::albumRepository::retrieveRecord(Model::Album& album, Type::albumFilter filter)
{
std::cout << "retrieving album record" << std::endl;
std::stringstream qry;
auto conn = setup_mysql_connection();
qry << "SELECT alb.* FROM Album alb WHERE ";
@@ -35,12 +36,12 @@ Model::Album Database::albumRepository::retrieveRecord(Model::Album& album, Type
mysql_real_escape_string(conn, *param, album.title.c_str(), album.title.size());
qry << "alb.Title = '" << *param << "'";
break;
case Type::albumFilter::year:
break;
default:
break;
}
qry << " ORDER BY AlbumId DESC LIMIT 1";
const std::string query = qry.str();
auto results = perform_mysql_query(conn, query);
@@ -57,13 +58,11 @@ void Database::albumRepository::saveAlbum(const Model::Album& album)
std::cout << "beginning to insert album record" << std::endl;
auto conn = setup_mysql_connection();
auto status = 0;
MYSQL_STMT *stmt = mysql_stmt_init(conn);
std::string query = "INSERT INTO Album(Title, Year) VALUES(?, ?)";
const std::string query = "INSERT INTO Album(Title, Year) VALUES(?, ?)";
status = mysql_stmt_prepare(stmt, query.c_str(), query.size());
auto status = mysql_stmt_prepare(stmt, query.c_str(), query.size());
MYSQL_BIND params[2];
memset(params, 0, sizeof(params));
@@ -71,7 +70,7 @@ void Database::albumRepository::saveAlbum(const Model::Album& album)
params[0].buffer_type = MYSQL_TYPE_STRING;
params[0].buffer = (char*)album.title.c_str();
auto titleLength = album.title.size();
params[0].buffer = &titleLength;
params[0].length= &titleLength;
params[0].is_null = 0;
params[1].buffer_type = MYSQL_TYPE_LONG;
@@ -99,9 +98,10 @@ std::vector<Model::Album> Database::albumRepository::parseRecords(MYSQL_RES* res
Model::Album Database::albumRepository::parseRecord(MYSQL_RES* results)
{
std::cout << "parsing album record" << std::endl;
Model::Album album;
auto fieldNum = mysql_num_fields(results);
auto fieldNum = mysql_num_fields(results);
auto row = mysql_fetch_row(results);
for (auto i = 0; i != fieldNum; ++i) {
src/database/artistRepository.cpp
+96
View File
@@ -1,6 +1,102 @@
#include "database/artistRepository.h"
#include <iostream>
#include <memory>
#include <sstream>
#include <string>
#include <cstring>
Database::artistRepository::artistRepository(const Model::BinaryPath& binConf)
: base_repository(binConf)
{
}
Model::Artist Database::artistRepository::retrieveRecord(Model::Artist& artist, Type::artistFilter filter)
{
std::cout << "retrieving artist record" << std::endl;
std::stringstream qry;
auto conn = setup_mysql_connection();
qry << "SELECT art.* FROM Artist art WHERE ";
std::unique_ptr<char*> param;
switch (filter) {
case Type::artistFilter::id:
qry << "art.ArtistId = " << artist.id;
break;
case Type::artistFilter::artist:
param = std::make_unique<char*>(new char[artist.artist.size()]);
mysql_real_escape_string(conn, *param, artist.artist.c_str(), artist.artist.size());
qry << "art.Artist ='" << *param << "'";
break;
default:
break;
}
qry << " ORDER BY ArtistId DESC LIMIT 1";
const auto query = qry.str();
auto results = perform_mysql_query(conn, query);
artist = parseRecord(results);
mysql_close(conn);
std::cout << "retrieved record" << std::endl;
return artist;
}
void Database::artistRepository::saveRecord(const Model::Artist& artist)
{
std::cout << "inserting artist record" << std::endl;
auto conn = setup_mysql_connection();
MYSQL_STMT *stmt = mysql_stmt_init(conn);
const std::string query = "INSERT INTO Artist(Artist) VALUES(?)";
auto status = mysql_stmt_prepare(stmt, query.c_str(), query.size());
MYSQL_BIND params[1];
memset(params, 0, sizeof(params));
params[0].buffer_type = MYSQL_TYPE_STRING;
params[0].buffer = (char*)artist.artist.c_str();
auto artistLength = artist.artist.size();
params[0].length = &artistLength;
params[0].is_null = 0;
status = mysql_stmt_bind_param(stmt, params);
status = mysql_stmt_execute(stmt);
mysql_stmt_close(stmt);
mysql_close(conn);
std::cout<< "inserted artist record" << std::endl;
}
Model::Artist Database::artistRepository::parseRecord(MYSQL_RES* results)
{
std::cout << "parsing artist record" << std::endl;
Model::Artist artist;
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);
if (field.compare("ArtistId") == 0) {
artist.id = std::stoi(row[i]);
}
if (field.compare("Artist") == 0) {
artist.artist = row[i];
}
}
std::cout << "parsed artist record" << std::endl;
return artist;
}
src/database/coverArtRepository.cpp
-2
View File
@@ -25,13 +25,11 @@ Model::Cover Database::coverArtRepository::retrieveRecord(Model::Cover& cov, Typ
case Type::coverFilter::songTitle:
param = std::make_unique<char*>(new char[cov.songTitle.size()]);
mysql_real_escape_string(conn, *param, cov.songTitle.c_str(), cov.songTitle.size());
std::cout << *param << std::endl;
qry << "SongTitle = '" << *param << "'";
break;
case Type::coverFilter::imagePath:
param = std::make_unique<char*>(new char[cov.imagePath.size()]);
mysql_real_escape_string(conn, *param, cov.imagePath.c_str(), cov.imagePath.size());
std::cout << *param << std::endl;
qry << "ImagePath = '" << *param << "'";
break;
}
src/database/genreRepository.cpp
+94
View File
@@ -1,5 +1,99 @@
#include "database/genreRepository.h"
#include <iostream>
#include <memory>
#include <sstream>
#include <cstring>
Database::genreRepository::genreRepository(const Model::BinaryPath& bConf)
: base_repository(bConf)
{ }
Model::Genre Database::genreRepository::retrieveRecord(Model::Genre& genre, Type::genreFilter filter)
{
std::cout << "retrieving genre record" << std::endl;
std::stringstream qry;
auto conn = setup_mysql_connection();
qry << "SELECT gnr.* FROM Genre gnr WHERE ";
std::unique_ptr<char*> param;
switch (filter) {
case Type::genreFilter::id:
qry << "gnr.GenreId = " << genre.id;
break;
case Type::genreFilter::category:
param = std::make_unique<char*>(new char[genre.category.size()]);
mysql_real_escape_string(conn, *param, genre.category.c_str(), genre.category.size());
qry << "gnr.Category ='" << *param << "'";
break;
default:
break;
}
qry << " ORDER BY GenreId DESC LIMIT 1";
const auto query = qry.str();
auto results = perform_mysql_query(conn, query);
genre = parseRecord(results);
mysql_close(conn);
std::cout << "retrieved record" << std::endl;
return genre;
}
void Database::genreRepository::saveRecord(const Model::Genre& genre)
{
std::cout << "inserting genre record" << std::endl;
auto conn = setup_mysql_connection();
MYSQL_STMT *stmt = mysql_stmt_init(conn);
const std::string query("INSERT INTO Genre(Category) VALUES(?)");
auto status = mysql_stmt_prepare(stmt, query.c_str(), query.size());
MYSQL_BIND params[1];
memset(params, 0, sizeof(params));
params[0].buffer_type = MYSQL_TYPE_STRING;
params[0].buffer = (char*)genre.category.c_str();
auto categoryLength = genre.category.size();
params[0].length = &categoryLength;
params[0].is_null = 0;
status = mysql_stmt_bind_param(stmt, params);
status = mysql_stmt_execute(stmt);
mysql_stmt_close(stmt);
mysql_close(conn);
std::cout << "inserted record" << std::endl;
}
Model::Genre Database::genreRepository::parseRecord(MYSQL_RES* results)
{
std::cout << "parsing genre record" << std::endl;
Model::Genre genre;
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);
if (field.compare("GenreId") == 0) {
genre.id = std::stoi(row[i]);
}
if (field.compare("Category") == 0) {
genre.category = row[i];
}
}
std::cout << "parsed genre record" << std::endl;
return genre;
}
src/database/songRepository.cpp
+23 -3
View File
@@ -41,7 +41,6 @@ Model::Song Database::songRepository::retrieveRecord(Model::Song& song, Type::so
case Type::songFilter::title:
param = std::make_unique<char*>(new char[song.title.size()]);
mysql_real_escape_string(conn, *param, song.title.c_str(), song.title.size());
std::cout << *param << std::endl;
qry << "Title = '" << *param << "'";
break;
default:
@@ -81,11 +80,12 @@ void Database::songRepository::saveRecord(const Model::Song& song)
MYSQL_STMT *stmt = mysql_stmt_init(conn);
std::string query = "INSERT INTO Song(Title, Artist, Album, Genre, ";
query.append("Year, Duration, Track, Disc, SongPath, CoverArtId) VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
query.append("Year, Duration, Track, Disc, SongPath, CoverArtId, ArtistId, ");
query.append("AlbumId, GenreId, YearId) VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
status = mysql_stmt_prepare(stmt, query.c_str(), query.size());
MYSQL_BIND params[10];
MYSQL_BIND params[14];
memset(params, 0, sizeof(params));
params[0].buffer_type = MYSQL_TYPE_STRING;
@@ -142,7 +142,27 @@ void Database::songRepository::saveRecord(const Model::Song& song)
params[9].buffer = (char*)&song.coverArtId;
params[9].length = 0;
params[9].is_null = 0;
params[10].buffer_type = MYSQL_TYPE_LONG;
params[10].buffer = (char*)&song.artistId;
params[10].length = 0;
params[10].is_null = 0;
params[11].buffer_type = MYSQL_TYPE_LONG;
params[11].buffer = (char*)&song.albumId;
params[11].length = 0;
params[11].is_null = 0;
params[12].buffer_type = MYSQL_TYPE_LONG;
params[12].buffer = (char*)&song.genreId;
params[12].length = 0;
params[12].is_null = 0;
params[13].buffer_type = MYSQL_TYPE_LONG;
params[13].buffer = (char*)&song.yearId;
params[13].length = 0;
params[13].is_null = 0;
status = mysql_stmt_bind_param(stmt, params);
status = mysql_stmt_execute(stmt);
src/database/yearRepository.cpp
+92
View File
@@ -1,5 +1,97 @@
#include "database/yearRepository.h"
#include <iostream>
#include <memory>
#include <sstream>
#include <string>
#include <cstring>
Database::yearRepository::yearRepository(const Model::BinaryPath& bConf)
: base_repository(bConf)
{ }
Model::Year Database::yearRepository::retrieveRecord(Model::Year& year, Type::yearFilter filter)
{
std::cout << "retrieving year record" << std::endl;
std::stringstream qry;
auto conn = setup_mysql_connection();
qry << "SELECT yr.* FROM Year yr WHERE ";
switch (filter) {
case Type::yearFilter::id:
qry << "yr.YearId = " << year.id;
break;
case Type::yearFilter::year:
qry << "yr.Year = " << year.year;
break;
default:
break;
}
qry << " ORDER BY yr.YearId DESC LIMIT 1";
const auto query = qry.str();
auto results = perform_mysql_query(conn, query);
year = parseRecord(results);
mysql_close(conn);
std::cout << "retrieved record" << std::endl;
return year;
}
void Database::yearRepository::saveRecord(const Model::Year& year)
{
std::cout << "saving year record" << std::endl;
auto conn = setup_mysql_connection();
MYSQL_STMT *stmt = mysql_stmt_init(conn);
const std::string query("INSERT INTO Year(Year) VALUES(?)");
auto status = mysql_stmt_prepare(stmt, query.c_str(), query.size());
MYSQL_BIND params[1];
memset(params, 0 , sizeof(params));
params[0].buffer_type = MYSQL_TYPE_LONG;
params[0].buffer = (char*)&year.year;
params[0].length = 0;
params[0].is_null = 0;
status = mysql_stmt_bind_param(stmt, params);
status = mysql_stmt_execute(stmt);
mysql_stmt_close(stmt);
mysql_close(conn);
std::cout << "saved record" << std::endl;
}
Model::Year Database::yearRepository::parseRecord(MYSQL_RES *results)
{
std::cout << "parsing year record" << std::endl;
Model::Year year;
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);
if (field.compare("YearId") == 0) {
year.id= std::stoi(row[i]);
}
if (field.compare("Year") == 0) {
year.year = std::stoi(row[i]);
}
}
std::cout << "parse year record" << std::endl;
return year;
}