nortega/menu-helper
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Put database in class and use throw exceptions.

Browse Source
This commit is contained in:
Nicolás A. Ortega Froysa 2024-10-11 17:43:28 +02:00
parent ba7f930231
commit d30f8df5c1
4 changed files with 272 additions and 267 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
src/cmd.cpp
View File

@ -19,13 +19,14 @@
#include "db.hpp" #include "db.hpp"
#include "util.hpp" #include "util.hpp"
#include <iostream>
#include <cstdlib> #include <cstdlib>
#include <iostream>
#include <string> #include <string>
#include <vector>
#include <unistd.h> #include <unistd.h>
#include <vector>
int cmd_add(void) { int cmd_add(void) {
db db;
std::string name, description, ingredients, tags; std::string name, description, ingredients, tags;
int recipe_id, ingredient_id, tag_id; int recipe_id, ingredient_id, tag_id;
@ -41,36 +42,34 @@ int cmd_add(void) {
std::cout << "Tags (comma separated): "; std::cout << "Tags (comma separated): ";
getline(std::cin, tags); getline(std::cin, tags);
if(not db_open()) { db.open();
std::cerr << "Failed to open database. Cannot add new entry." << std::endl;
return EXIT_FAILURE;
}
if((recipe_id = db_get_recipe_id(name)) <= 0) if((recipe_id = db.get_recipe_id(name)) <= 0)
recipe_id = db_add_recipe(name, description); recipe_id = db.add_recipe(name, description);
for(auto &ingredient : split(ingredients, ",")) { for(auto &ingredient : split(ingredients, ",")) {
trim(ingredient); trim(ingredient);
if((ingredient_id = db_get_ingredient_id(ingredient)) <= 0) if((ingredient_id = db.get_ingredient_id(ingredient)) <= 0)
ingredient_id = db_add_ingredient(ingredient); ingredient_id = db.add_ingredient(ingredient);
db_conn_recipe_ingredient(recipe_id, ingredient_id); db.conn_recipe_ingredient(recipe_id, ingredient_id);
} }
for(auto &tag : split(tags, ",")) { for(auto &tag : split(tags, ",")) {
trim(tag); trim(tag);
if((tag_id = db_get_tag_id(tag)) <= 0) if((tag_id = db.get_tag_id(tag)) <= 0)
tag_id = db_add_tag(tag); tag_id = db.add_tag(tag);
db_conn_recipe_tag(recipe_id, tag_id); db.conn_recipe_tag(recipe_id, tag_id);
} }
db_close(); db.close();
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }
int cmd_list(int argc, char *argv[]) { int cmd_list(int argc, char *argv[]) {
db db;
std::vector<std::string> ingredients, tags; std::vector<std::string> ingredients, tags;
int opt; int opt;
@ -93,21 +92,18 @@ int cmd_list(int argc, char *argv[]) {
} }
} }
if(not db_open()) { db.open();
std::cerr << "Failed to open database. Cannot add new entry." << std::endl;
return EXIT_FAILURE;
}
for(const auto &recipe : db_get_recipes(ingredients, tags)) for(const auto &recipe : db.get_recipes(ingredients, tags))
std::cout << recipe.id << " | " << recipe.name << " | " << recipe.description << std::endl; std::cout << recipe.id << " | " << recipe.name << " | " << recipe.description << std::endl;
db_close(); db.close();
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }
int cmd_delete(int argc, char *argv[]) { int cmd_delete(int argc, char *argv[]) {
int ret = EXIT_SUCCESS; db db;
std::vector<int> recipe_ids; std::vector<int> recipe_ids;
if(argc < 1) { if(argc < 1) {
@ -115,15 +111,12 @@ int cmd_delete(int argc, char *argv[]) {
return EXIT_FAILURE; return EXIT_FAILURE;
} }
if(not db_open()) { db.open();
std::cerr << "Failed to open database. Cannot add new entry." << std::endl;
return EXIT_FAILURE;
}
for(int i = 0; i < argc; ++i) { for(int i = 0; i < argc; ++i) {
const int id = std::stoi(argv[i]); const int id = std::stoi(argv[i]);
if(not db_recipe_exists(id)) { if(not db.recipe_exists(id)) {
std::cerr << "No recipe exists with ID " << id << "." << std::endl; std::cerr << "No recipe exists with ID " << id << "." << std::endl;
return EXIT_FAILURE; return EXIT_FAILURE;
} else { } else {
@ -131,33 +124,30 @@ int cmd_delete(int argc, char *argv[]) {
} }
} }
ret = (db_del_recipes(recipe_ids)) ? EXIT_SUCCESS : EXIT_FAILURE; db.del_recipes(recipe_ids);
db.close();
db_close(); return EXIT_SUCCESS;
return ret;
} }
int cmd_info(const int id) { int cmd_info(const int id) {
db db;
struct recipe recipe; struct recipe recipe;
std::vector<std::string> ingredients, tags; std::vector<std::string> ingredients, tags;
int ret = EXIT_SUCCESS; int ret = EXIT_SUCCESS;
if(not db_open()) { db.open();
std::cerr << "Failed to open database. Cannot add new entry." << std::endl;
return EXIT_FAILURE;
}
if(not db_recipe_exists(id)) { if(not db.recipe_exists(id)) {
std::cerr << "No recipe with ID '" << id << "'"; std::cerr << "No recipe with ID '" << id << "'";
return EXIT_FAILURE; return EXIT_FAILURE;
} }
recipe = db_get_recipe(id); recipe = db.get_recipe(id);
ingredients = db_get_recipe_ingredients(id); ingredients = db.get_recipe_ingredients(id);
tags = db_get_recipe_tags(id); tags = db.get_recipe_tags(id);
db_close(); db.close();
std::cout << "Name: " << recipe.name << "\n" std::cout << "Name: " << recipe.name << "\n"
<< "Description: " << recipe.description << "\n" << "Description: " << recipe.description << "\n"

266
src/db.cpp
View File

@ -17,28 +17,22 @@
*/ */
#include "db.hpp" #include "db.hpp"
#include <sqlite3.h>
#include <cstdlib> #include <cstdlib>
#include <iostream>
#include <filesystem> #include <filesystem>
#include <format> #include <format>
#include <string> #include <iostream>
#include <vector> #include <sqlite3.h>
#include <stdexcept>
#define DB_VERSION 1 #define DB_VERSION 1
static sqlite3 *db = nullptr;
int db_open(void) { void db::open(void) {
std::string xdg_data_home; std::string xdg_data_home;
std::string db_path; std::string db_path;
bool new_db = false; bool new_db = false;
int rc;
if((xdg_data_home = std::getenv("XDG_DATA_HOME")).empty()) { if((xdg_data_home = std::getenv("XDG_DATA_HOME")).empty())
std::cerr << "Cannot find environment variable XDG_DATA_HOME. Please define it before continuing. E.g.:\n" throw std::runtime_error("Cannot find environment variable XDG_DATA_HOME. Please define it before continuing.");
"export XDG_DATA_HOME=\"$HOME/.local/share\"" << std::endl;
return 0;
}
db_path = xdg_data_home + "/menu-helper"; db_path = xdg_data_home + "/menu-helper";
@ -52,26 +46,26 @@ int db_open(void) {
new_db = true; new_db = true;
} }
rc = sqlite3_open(db_path.c_str(), &db); if(sqlite3_open(db_path.c_str(), &sqlite_db) not_eq SQLITE_OK)
throw std::runtime_error("Failed to open database file " + db_path);
if(rc == SQLITE_OK and new_db) { if(new_db) {
sqlite3_exec(db, "CREATE TABLE db_version(version INTEGER UNIQUE NOT nullptr);", nullptr, nullptr, nullptr); sqlite3_exec(sqlite_db, "CREATE TABLE db_version(version INTEGER UNIQUE NOT nullptr);", nullptr, nullptr, nullptr);
sqlite3_exec(db, std::format("INSERT INTO db_version VALUES({});", DB_VERSION).c_str(), nullptr, nullptr, nullptr); sqlite3_exec(sqlite_db, std::format("INSERT INTO db_version VALUES({});", DB_VERSION).c_str(), nullptr, nullptr, nullptr);
sqlite3_exec(db, "CREATE TABLE tags(id INTEGER PRIMARY KEY AUTOINCREMENT, name STRING UNIQUE);", nullptr, nullptr, nullptr); sqlite3_exec(sqlite_db, "CREATE TABLE tags(id INTEGER PRIMARY KEY AUTOINCREMENT, name STRING UNIQUE);", nullptr, nullptr, nullptr);
sqlite3_exec(db, "CREATE TABLE ingredients(id INTEGER PRIMARY KEY AUTOINCREMENT, name STRING UNIQUE);", nullptr, nullptr, nullptr); sqlite3_exec(sqlite_db, "CREATE TABLE ingredients(id INTEGER PRIMARY KEY AUTOINCREMENT, name STRING UNIQUE);", nullptr, nullptr, nullptr);
sqlite3_exec(db, "CREATE TABLE recipes(id INTEGER PRIMARY KEY AUTOINCREMENT, name STRING UNIQUE, description STRING);", nullptr, nullptr, nullptr); sqlite3_exec(sqlite_db, "CREATE TABLE recipes(id INTEGER PRIMARY KEY AUTOINCREMENT, name STRING UNIQUE, description STRING);", nullptr, nullptr, nullptr);
sqlite3_exec(db, "CREATE TABLE recipe_tag(recipe_id INTEGER REFERENCES recipes(id) ON DELETE CASCADE, tag_id INTEGER REFERENCES tags(id) ON DELETE CASCADE);", nullptr, nullptr, nullptr); sqlite3_exec(sqlite_db, "CREATE TABLE recipe_tag(recipe_id INTEGER REFERENCES recipes(id) ON DELETE CASCADE, tag_id INTEGER REFERENCES tags(id) ON DELETE CASCADE);", nullptr, nullptr, nullptr);
sqlite3_exec(db, "CREATE TABLE recipe_ingredient(recipe_id INTEGER REFERENCES recipes(id) ON DELETE CASCADE, ingredient_id INTEGER REFERENCES ingredients(id) ON DELETE CASCADE);", nullptr, nullptr, nullptr); sqlite3_exec(sqlite_db, "CREATE TABLE recipe_ingredient(recipe_id INTEGER REFERENCES recipes(id) ON DELETE CASCADE, ingredient_id INTEGER REFERENCES ingredients(id) ON DELETE CASCADE);", nullptr, nullptr, nullptr);
}
} }
return rc == SQLITE_OK; void db::close(void) {
} if(not sqlite_db)
void db_close(void) {
if(not db)
return; return;
sqlite3_close(db); sqlite3_close(sqlite_db);
sqlite_db = nullptr;
} }
int query_id_cb(void *recipe_id_var, int col_num, char **col_data, char **col_name) { int query_id_cb(void *recipe_id_var, int col_num, char **col_data, char **col_name) {
@ -89,43 +83,47 @@ int query_id_cb(void *recipe_id_var, int col_num, char **col_data, char **col_na
return ret; return ret;
} }
int table_get_id_by_name(const std::string &table, const std::string &name) { int db::table_get_id_by_name(const std::string &table, const std::string &name) {
int id = 0; int id = 0;
if(sqlite3_exec(db, std::format("SELECT id FROM {} WHERE lower(name)=lower('{}');", table, name).c_str(), if(not sqlite_db)
query_id_cb, &id, nullptr) not_eq SQLITE_OK) throw std::runtime_error(std::format("{}: Database not open! Please contact a developer.", __PRETTY_FUNCTION__));
return -2;
if(sqlite3_exec(sqlite_db, std::format("SELECT id FROM {} WHERE lower(name)=lower('{}');", table, name).c_str(),
query_id_cb, &id, nullptr) not_eq SQLITE_OK) {
throw std::runtime_error(std::format("Failed to get ID of '{}' from table '{}'.", name, table));
}
return id; return id;
} }
int db_add_recipe(const std::string &name, const std::string &description) { int db::add_recipe(const std::string &name, const std::string &description) {
if(not db) if(not sqlite_db)
return -1; throw std::runtime_error(std::format("{}: Database not open! Please contact a developer.", __PRETTY_FUNCTION__));
if(sqlite3_exec(db, std::format("INSERT INTO recipes(name,description) VALUES('{}','{}');", name, description).c_str(), if(sqlite3_exec(sqlite_db, std::format("INSERT INTO recipes(name,description) VALUES('{}','{}');", name, description).c_str(),
nullptr, nullptr, nullptr) not_eq SQLITE_OK) nullptr, nullptr, nullptr) not_eq SQLITE_OK) {
return -2; throw std::runtime_error("Failed to insert new recipe into database.");
return db_get_recipe_id(name);
} }
bool db_del_recipe(const int id) { return get_recipe_id(name);
if(not db)
return false;
if(sqlite3_exec(db, std::format("DELETE FROM recipes WHERE id={}", id).c_str(),
nullptr, nullptr, nullptr) not_eq SQLITE_OK)
return false;
return true;
} }
bool db_del_recipes(const std::vector<int> &ids) { void db::del_recipe(const int id) {
if(not sqlite_db)
throw std::runtime_error(std::format("{}: Database not open! Please contact a developer.", __PRETTY_FUNCTION__));
if(sqlite3_exec(sqlite_db, std::format("DELETE FROM recipes WHERE id={}", id).c_str(),
nullptr, nullptr, nullptr) not_eq SQLITE_OK) {
throw std::runtime_error(std::format("Failed to delete recipe with ID {} from database.", id));
}
}
void db::del_recipes(const std::vector<int> &ids) {
std::string stmt = "DELETE FROM recipes WHERE id IN ("; std::string stmt = "DELETE FROM recipes WHERE id IN (";
if(not db) if(not sqlite_db)
return false; throw std::runtime_error(std::format("{}: Database not open! Please contact a developer.", __PRETTY_FUNCTION__));
bool first = true; bool first = true;
for(auto id : ids) { for(auto id : ids) {
@ -139,53 +137,54 @@ bool db_del_recipes(const std::vector<int> &ids) {
stmt += ");"; stmt += ");";
if(sqlite3_exec(db, stmt.c_str(), nullptr, nullptr, nullptr) not_eq SQLITE_OK) if(sqlite3_exec(sqlite_db, stmt.c_str(), nullptr, nullptr, nullptr) not_eq SQLITE_OK)
return false; throw std::runtime_error("Failed to delete recipes from database.");
return true;
} }
bool db_recipe_exists(const int id) { bool db::recipe_exists(const int id) {
bool exists = false; bool exists = false;
if(not db) if(not sqlite_db)
return false; throw std::runtime_error(std::format("{}: Database not open! Please contact a developer.", __PRETTY_FUNCTION__));
sqlite3_exec(db, std::format("SELECT id FROM recipes WHERE id={}", id).c_str(), if(sqlite3_exec(sqlite_db, std::format("SELECT id FROM recipes WHERE id={}", id).c_str(),
[](void *found,int,char**,char**) { [](void *found,int,char**,char**) {
*static_cast<bool*>(found) = true; *static_cast<bool*>(found) = true;
return 0; return 0;
}, &exists, nullptr); }, &exists, nullptr) not_eq SQLITE_OK) {
throw std::runtime_error("Failed to select from database.");
}
return exists; return exists;
} }
int db_get_recipe_id(const std::string &name) { struct recipe db::get_recipe(const int id) {
if(not db)
return -1;
return table_get_id_by_name("recipes", name);
}
struct recipe db_get_recipe(const int id) {
struct recipe recipe; struct recipe recipe;
sqlite3_exec(db, std::format("SELECT * FROM recipes WHERE id={};", id).c_str(), if(not sqlite_db)
throw std::runtime_error(std::format("{}: Database not open! Please contact a developer.", __PRETTY_FUNCTION__));
if(sqlite3_exec(sqlite_db, std::format("SELECT * FROM recipes WHERE id={};", id).c_str(),
[](void *recipe, int, char **col_data, char**) { [](void *recipe, int, char **col_data, char**) {
*static_cast<struct recipe*>(recipe) = { std::atoi(col_data[0]), col_data[1], col_data[2] }; *static_cast<struct recipe*>(recipe) = { std::atoi(col_data[0]), col_data[1], col_data[2] };
return 0; return 0;
}, &recipe, nullptr); }, &recipe, nullptr) not_eq SQLITE_OK) {
throw std::runtime_error("Failed to select from database.");
}
return recipe; return recipe;
} }
std::vector<struct recipe> db_get_recipes(const std::vector<std::string> &ingredients, std::vector<struct recipe> db::get_recipes(const std::vector<std::string> &ingredients,
const std::vector<std::string> &tags) const std::vector<std::string> &tags)
{ {
std::vector<struct recipe> recipes; std::vector<struct recipe> recipes;
std::string stmt = "SELECT id,name,description FROM recipes"; std::string stmt = "SELECT id,name,description FROM recipes";
std::string filters; std::string filters;
if(not sqlite_db)
throw std::runtime_error(std::format("{}: Database not open! Please contact a developer.", __PRETTY_FUNCTION__));
if(not ingredients.empty() or not tags.empty()) if(not ingredients.empty() or not tags.empty())
filters += " WHERE"; filters += " WHERE";
@ -201,14 +200,10 @@ std::vector<struct recipe> db_get_recipes(const std::vector<std::string> &ingred
filters += " id IN (SELECT recipe_id FROM recipe_ingredient WHERE ingredient_id="; filters += " id IN (SELECT recipe_id FROM recipe_ingredient WHERE ingredient_id=";
// TODO: use throw? if((id = get_ingredient_id(i)) <= 0)
if((id = db_get_ingredient_id(i)) < 0) { throw std::runtime_error(std::format("Failed to find ingredient '{}'", i));
std::cerr << "Failed to find ingredient '" << i << "'" << std::endl;
return std::vector<struct recipe>();
} else {
filters += std::to_string(id);
}
filters += std::to_string(id);
filters += ")"; filters += ")";
} }
} }
@ -228,111 +223,106 @@ std::vector<struct recipe> db_get_recipes(const std::vector<std::string> &ingred
filters += " id IN (SELECT recipe_id FROM recipe_tag WHERE tag_id="; filters += " id IN (SELECT recipe_id FROM recipe_tag WHERE tag_id=";
// TODO: use throw? if((id = get_tag_id(i)) <= 0)
if((id = db_get_tag_id(i)) < 0) { throw std::runtime_error("Failed to find tag '{}'");
std::cerr << "Failed to find tag '" << i << "'" << std::endl;
return std::vector<struct recipe>();
} else {
filters += std::to_string(id);
}
filters += std::to_string(id);
filters += ")"; filters += ")";
} }
} }
stmt += filters + ";"; stmt += filters + ";";
sqlite3_exec(db, stmt.c_str(), if(sqlite3_exec(sqlite_db, stmt.c_str(),
[](void *recipe_list, int, char **col_data, char**) { [](void *recipe_list, int, char **col_data, char**) {
auto recipe_vec = static_cast<std::vector<struct recipe>*>(recipe_list); static_cast<std::vector<struct recipe>*>(recipe_list)->push_back({
recipe_vec->push_back({
std::atoi(col_data[0]), std::atoi(col_data[0]),
col_data[1], col_data[1],
col_data[2] }); col_data[2] });
return 0; return 0;
}, &recipes, nullptr); }, &recipes, nullptr) not_eq SQLITE_OK) {
throw std::runtime_error("Failed to select recipes.");
}
return recipes; return recipes;
} }
int db_add_ingredient(const std::string &name) { int db::add_ingredient(const std::string &name) {
if(not db) if(not sqlite_db)
return -1; throw std::runtime_error(std::format("{}: Database not open! Please contact a developer.", __PRETTY_FUNCTION__));
if(sqlite3_exec(db, std::format("INSERT INTO ingredients(name) VALUES(lower('{}'));", name).c_str(), if(sqlite3_exec(sqlite_db, std::format("INSERT INTO ingredients(name) VALUES(lower('{}'));", name).c_str(),
nullptr, nullptr, nullptr) not_eq SQLITE_OK) nullptr, nullptr, nullptr) not_eq SQLITE_OK) {
return -2; throw std::runtime_error(std::format("Failed to instert ingredient '{}'.", name));
return db_get_ingredient_id(name);
} }
std::vector<std::string> db_get_recipe_ingredients(const int id) { return get_ingredient_id(name);
}
std::vector<std::string> db::get_recipe_ingredients(const int id) {
std::vector<std::string> ingredients; std::vector<std::string> ingredients;
sqlite3_exec(db, std::format("SELECT name FROM ingredients WHERE id IN (SELECT ingredient_id FROM recipe_ingredient WHERE recipe_id={});", id).c_str(), if(not sqlite_db)
throw std::runtime_error(std::format("{}: Database not open! Please contact a developer.", __PRETTY_FUNCTION__));
if(sqlite3_exec(sqlite_db, std::format("SELECT name FROM ingredients WHERE id IN (SELECT ingredient_id FROM recipe_ingredient WHERE recipe_id={});", id).c_str(),
[](void *ingredients, int, char **col_data, char**) { [](void *ingredients, int, char **col_data, char**) {
static_cast<std::vector<std::string>*>(ingredients)->push_back(col_data[0]); static_cast<std::vector<std::string>*>(ingredients)->push_back(col_data[0]);
return 0; return 0;
}, &ingredients, nullptr); }, &ingredients, nullptr) not_eq SQLITE_OK) {
throw std::runtime_error(std::format("Failed to select ingredients from recipe with ID {}", id));
}
return ingredients; return ingredients;
} }
int db_get_ingredient_id(const std::string &name) { int db::add_tag(const std::string &name) {
if(not db) if(not sqlite_db)
return -1; throw std::runtime_error(std::format("{}: Database not open! Please contact a developer.", __PRETTY_FUNCTION__));
return table_get_id_by_name("ingredients", name); if(sqlite3_exec(sqlite_db, std::format("INSERT INTO tags(name) VALUES('{}');", name).c_str(),
nullptr, nullptr, nullptr) not_eq SQLITE_OK) {
throw std::runtime_error(std::format("Failed to insert tag '{}'", name));
} }
int db_add_tag(const std::string &name) { return get_tag_id(name);
if(not db)
return -1;
if(sqlite3_exec(db, std::format("INSERT INTO tags(name) VALUES('{}');", name).c_str(),
nullptr, nullptr, nullptr) not_eq SQLITE_OK)
return -2;
return db_get_tag_id(name);
} }
std::vector<std::string> db_get_recipe_tags(const int id) { std::vector<std::string> db::get_recipe_tags(const int id) {
std::vector<std::string> tags; std::vector<std::string> tags;
sqlite3_exec(db, std::format("SELECT name FROM tags WHERE id IN (SELECT tag_id FROM recipe_tag WHERE recipe_id={});", id).c_str(), if(not sqlite_db)
throw std::runtime_error(std::format("{}: Database not open! Please contact a developer.", __PRETTY_FUNCTION__));
if(sqlite3_exec(sqlite_db, std::format("SELECT name FROM tags WHERE id IN (SELECT tag_id FROM recipe_tag WHERE recipe_id={});", id).c_str(),
[](void *tags, int, char **col_data, char**) { [](void *tags, int, char **col_data, char**) {
static_cast<std::vector<std::string>*>(tags)->push_back(col_data[0]); static_cast<std::vector<std::string>*>(tags)->push_back(col_data[0]);
return 0; return 0;
}, &tags, nullptr); }, &tags, nullptr) not_eq SQLITE_OK) {
throw std::runtime_error(std::format("Failed to select tags for recipe with ID {}", id));
}
return tags; return tags;
} }
int db_get_tag_id(const std::string &name) { void db::conn_recipe_ingredient(int recipe_id, int ingredient_id) {
if(not db) if(not sqlite_db)
return -1; throw std::runtime_error(std::format("{}: Database not open! Please contact a developer.", __PRETTY_FUNCTION__));
return table_get_id_by_name("tags", name); if(sqlite3_exec(sqlite_db, std::format("INSERT INTO recipe_ingredient(recipe_id, ingredient_id) VALUES({},{});", recipe_id, ingredient_id).c_str(),
nullptr, nullptr, nullptr) not_eq SQLITE_OK) {
throw std::runtime_error(std::format("Failed to connect recipe with ID {} to ingredient with ID {}",
recipe_id, ingredient_id));
}
} }
int db_conn_recipe_ingredient(int recipe_id, int ingredient_id) { void db::conn_recipe_tag(int recipe_id, int tag_id) {
if(not db) if(not sqlite_db)
return -1; throw std::runtime_error(std::format("{}: Database not open! Please contact a developer.", __PRETTY_FUNCTION__));
if(sqlite3_exec(db, std::format("INSERT INTO recipe_ingredient(recipe_id, ingredient_id) VALUES({},{});", recipe_id, ingredient_id).c_str(), if(sqlite3_exec(sqlite_db, std::format("INSERT INTO recipe_tag(recipe_id, tag_id) VALUES({},{});", recipe_id, tag_id).c_str(),
nullptr, nullptr, nullptr) not_eq SQLITE_OK) nullptr, nullptr, nullptr) not_eq SQLITE_OK) {
return -2; throw std::runtime_error(std::format("Failed to connect recipe with ID {} to tag with ID {}",
recipe_id, tag_id));
return 1;
} }
int db_conn_recipe_tag(int recipe_id, int tag_id) {
if(not db)
return -1;
if(sqlite3_exec(db, std::format("INSERT INTO recipe_tag(recipe_id, tag_id) VALUES({},{});", recipe_id, tag_id).c_str(),
nullptr, nullptr, nullptr) not_eq SQLITE_OK)
return -2;
return 1;
} }

68
src/db.hpp
View File

@ -17,6 +17,7 @@
*/ */
#pragma once #pragma once
#include <sqlite3.h>
#include <string> #include <string>
#include <vector> #include <vector>
@ -26,8 +27,18 @@ struct recipe {
std::string description; std::string description;
}; };
int db_open(void); class db {
void db_close(void); private:
sqlite3 *sqlite_db;
int table_get_id_by_name(const std::string &table, const std::string &name);
public:
db() : sqlite_db(nullptr) {}
~db() {
sqlite3_close(sqlite_db);
}
void open(void);
void close(void);
/** /**
* @brief Add a new recipe to the database. * @brief Add a new recipe to the database.
@ -35,18 +46,20 @@ void db_close(void);
* @param name Name of the new recipe. * @param name Name of the new recipe.
* @param description Short description. * @param description Short description.
* *
* @return ID of newly created recipe, -1 if DB isn't open, -2 on other failure. * @return ID of newly created recipe.
*/ */
int db_add_recipe(const std::string &name, const std::string &description); int add_recipe(const std::string &name, const std::string &description);
bool db_del_recipe(const int id); void del_recipe(const int id);
bool db_del_recipes(const std::vector<int> &ids); void del_recipes(const std::vector<int> &ids);
int db_get_recipe_id(const std::string &name); inline int get_recipe_id(const std::string &name) {
bool db_recipe_exists(const int id); return table_get_id_by_name("recipes", name);
static inline bool db_recipe_exists(const std::string &name) {
return (db_get_recipe_id(name) > 0);
} }
struct recipe db_get_recipe(const int id); inline bool db_recipe_exists(const std::string &name) {
std::vector<struct recipe> db_get_recipes(const std::vector<std::string> &ingredients, return (get_recipe_id(name) > 0);
}
bool recipe_exists(const int id);
struct recipe get_recipe(const int id);
std::vector<struct recipe> get_recipes(const std::vector<std::string> &ingredients,
const std::vector<std::string> &tags); const std::vector<std::string> &tags);
/** /**
@ -54,13 +67,15 @@ std::vector<struct recipe> db_get_recipes(const std::vector<std::string> &ingred
* *
* @param name Name of the new ingredient. * @param name Name of the new ingredient.
* *
* @return ID of newly created ingredient, -1 if DB isn't open, -2 on other failure. * @return ID of newly created ingredient.
*/ */
int db_add_ingredient(const std::string &name); int add_ingredient(const std::string &name);
std::vector<std::string> db_get_recipe_ingredients(const int id); std::vector<std::string> get_recipe_ingredients(const int id);
int db_get_ingredient_id(const std::string &name); inline int get_ingredient_id(const std::string &name) {
static inline bool db_ingredient_exists(const std::string &name) { return table_get_id_by_name("ingredients", name);
return (db_get_ingredient_id(name) > 0); }
inline bool db_ingredient_exists(const std::string &name) {
return (get_ingredient_id(name) > 0);
} }
/** /**
@ -70,12 +85,15 @@ static inline bool db_ingredient_exists(const std::string &name) {
* *
* @return ID of newly created tag, -1 if DB isn't open, -2 on other failure. * @return ID of newly created tag, -1 if DB isn't open, -2 on other failure.
*/ */
int db_add_tag(const std::string &name); int add_tag(const std::string &name);
std::vector<std::string> db_get_recipe_tags(const int id); std::vector<std::string> get_recipe_tags(const int id);
int db_get_tag_id(const std::string &name); inline int get_tag_id(const std::string &name) {
static inline bool db_tag_exists(const std::string &name) { return table_get_id_by_name("tags", name);
return (db_get_tag_id(name) > 0); }
inline bool tag_exists(const std::string &name) {
return (get_tag_id(name) > 0);
} }
int db_conn_recipe_ingredient(int recipe_id, int ingredient_id); void conn_recipe_ingredient(int recipe_id, int ingredient_id);
int db_conn_recipe_tag(int recipe_id, int tag_id); void conn_recipe_tag(int recipe_id, int tag_id);
};

11
src/main.cpp
View File

@ -16,8 +16,9 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include <iostream>
#include <cstdlib> #include <cstdlib>
#include <exception>
#include <iostream>
#include <string> #include <string>
#include "arg_parse.hpp" #include "arg_parse.hpp"
@ -35,6 +36,7 @@ int main(int argc, char *argv[]) {
id = parse_args(argv[1]); id = parse_args(argv[1]);
try {
switch(id) { switch(id) {
case CMD_ADD: case CMD_ADD:
ret = cmd_add(); ret = cmd_add();
@ -57,7 +59,12 @@ int main(int argc, char *argv[]) {
default: default:
std::cerr << "No such command '" << argv[1] << "'. Use 'help' sub-command." << std::endl; std::cerr << "No such command '" << argv[1] << "'. Use 'help' sub-command." << std::endl;
print_usage(); print_usage();
return EXIT_FAILURE; ret = EXIT_FAILURE;
break;
}
} catch(const std::exception &e) {
std::cerr << e.what() << std::endl;
ret = EXIT_FAILURE;
} }
return ret; return ret;