c++-mysql-crud.cpp

#include <iostream>
#include <string>
#include <stdexcept>
#include <mysql_connection.h>
#include <cppconn/driver.h>
#include <cppconn/exception.h>
#include <cppconn/statement.h>
#include <cppconn/prepared_statement.h>

/**
 * Namespace GGlink
 * 
 * @author Mokter Hossain
 * @email mo@gglink.uk
 * @website www.gglink.uk
 * @github https://github.com/moktermd08
 * @linkedin https://www.linkedin.com/in/mr-mokter/
 * @twitter https://twitter.com/moGGLink
 */
namespace GGlink {

/**
 * Class Database
 *
 * Provides functionalities for database interactions.
 */
class Database {
private:
    const std::string host = "tcp://localhost:3306";
    const std::string user = "user";
    const std::string password = "password";
    const std::string database = "database";
    sql::Driver* driver;
    std::unique_ptr<sql::Connection> connection;

public:
    /**
     * Establishes a database connection.
     *
     * @throws std::runtime_error If connection to the database fails
     */
    void connect() {
        try {
            driver = get_driver_instance();
            connection.reset(driver->connect(host, user, password));
            connection->setSchema(database);
        } catch (sql::SQLException &e) {
            throw std::runtime_error("Failed to connect to the database: " + std::string(e.what()));
        }
    }

    /**
     * Closes the database connection.
     */
    void disconnect() {
        connection.reset(nullptr);
    }

    /**
     * Executes a simple query (e.g., INSERT, UPDATE, DELETE).
     *
     * @param query The SQL query to execute.
     */
    void execute(const std::string& query) {
        try {
            std::unique_ptr<sql::Statement> stmt(connection->createStatement());
            stmt->execute(query);
        } catch (sql::SQLException &e) {
            throw std::runtime_error("Failed to execute query: " + std::string(e.what()));
        }
    }

    /**
     * Sanitize user input.
     *
     * @param data The user input data.
     * @return The sanitized data.
     */
    std::string sanitizeInput(const std::string& data) {
        std::string sanitized;
        sanitized.reserve(data.size());
        for (char c : data) {
            switch (c) {
                case '\'': sanitized += "\\'"; break;
                case '\"': sanitized += "\\\""; break;
                case '\n': sanitized += "\\n"; break;
                case '\r': sanitized += "\\r"; break;
                case '\\': sanitized += "\\\\"; break;
                default: sanitized += c; break;
            }
        }
        return sanitized;
    }
    
    /**
     * Sanitize output.
     *
     * @param data The data to be sent to the client.
     * @return The sanitized data.
     */
    std::string sanitizeOutput(const std::string& data) {
        return data; // In this example, we assume the output is safe and does not require additional sanitization
    }
};

} // namespace GGlink

// Usage Example:
int main() {
    GGlink::Database db;
    
    try {
        db.connect();
        std::string safeInput = db.sanitizeInput("user' OR '1'='1");
        std::cout << "Sanitized Input: " << safeInput << std::endl;
        db.execute("INSERT INTO users (name) VALUES ('" + safeInput + "')");
        db.disconnect();
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
    
    return 0;
}