mysql_connection.h

Go to the documentation of this file.

// Copyright (C) 2012-2018 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef MYSQL_CONNECTION_H
#define MYSQL_CONNECTION_H
 
#include <database/database_connection.h>
#include <database/db_exceptions.h>
#include <database/db_log.h>
#include <exceptions/exceptions.h>
#include <mysql/mysql_binding.h>
#include <mysql/mysql_constants.h>
#include <boost/scoped_ptr.hpp>
#include <mysql.h>
#include <mysqld_error.h>
#include <errmsg.h>
#include <functional>
#include <vector>
#include <stdint.h>
 
namespace isc {
namespace db {
 
 
 
class MySqlFreeResult {
public:
 
    MySqlFreeResult(MYSQL_STMT* statement) : statement_(statement)
    {}
 
    ~MySqlFreeResult() {
        (void) mysql_stmt_free_result(statement_);
    }
 
private:
    MYSQL_STMT*     statement_;     
};
 
 
struct TaggedStatement {
    uint32_t index;
    const char* text;
};
 
class MySqlHolder : public boost::noncopyable {
public:
 
    MySqlHolder() : mysql_(mysql_init(NULL)) {
        if (mysql_ == NULL) {
            isc_throw(db::DbOpenError, "unable to initialize MySQL");
        }
    }
 
    ~MySqlHolder() {
        if (mysql_ != NULL) {
            mysql_close(mysql_);
        }
        // The library itself shouldn't be needed anymore
        mysql_library_end();
    }
 
    operator MYSQL*() const {
        return (mysql_);
    }
 
private:
    MYSQL* mysql_;      
};
 
class MySqlConnection;
 
class MySqlTransaction : public boost::noncopyable {
public:
 
    MySqlTransaction(MySqlConnection& conn);
 
    ~MySqlTransaction();
 
    void commit();
 
private:
 
    MySqlConnection& conn_;
 
    bool committed_;
};
 
 
class MySqlConnection : public db::DatabaseConnection {
public:
 
    typedef std::function<void(MySqlBindingCollection&)> ConsumeResultFun;
 
    MySqlConnection(const ParameterMap& parameters)
        : DatabaseConnection(parameters) {
    }
 
    virtual ~MySqlConnection();
 
    void prepareStatement(uint32_t index, const char* text);
 
    void prepareStatements(const TaggedStatement* start_statement,
                           const TaggedStatement* end_statement);
 
    void clearStatements();
 
    void openDatabase();
 
 
    static
    void convertToDatabaseTime(const time_t input_time, MYSQL_TIME& output_time);
 
    static
    void convertToDatabaseTime(const time_t cltt, const uint32_t valid_lifetime,
            MYSQL_TIME& expire);
 
    static
    void convertFromDatabaseTime(const MYSQL_TIME& expire,
            uint32_t valid_lifetime, time_t& cltt);
 
    void startTransaction();
 
    template<typename StatementIndex>
    void selectQuery(const StatementIndex& index,
                     const MySqlBindingCollection& in_bindings,
                     MySqlBindingCollection& out_bindings,
                     ConsumeResultFun process_result) {
        // Extract native input bindings.
        std::vector<MYSQL_BIND> in_bind_vec;
        for (MySqlBindingPtr in_binding : in_bindings) {
            in_bind_vec.push_back(in_binding->getMySqlBinding());
        }
 
        int status = 0;
        if (!in_bind_vec.empty()) {
            // Bind parameters to the prepared statement.
            status = mysql_stmt_bind_param(statements_[index], &in_bind_vec[0]);
            checkError(status, index, "unable to bind parameters for select");
        }
 
        // Bind variables that will receive results as well.
        std::vector<MYSQL_BIND> out_bind_vec;
        for (MySqlBindingPtr out_binding : out_bindings) {
            out_bind_vec.push_back(out_binding->getMySqlBinding());
        }
        if (!out_bind_vec.empty()) {
            status = mysql_stmt_bind_result(statements_[index], &out_bind_vec[0]);
            checkError(status, index, "unable to bind result parameters for select");
        }
 
        // Execute query.
        status = mysql_stmt_execute(statements_[index]);
        checkError(status, index, "unable to execute");
 
        status = mysql_stmt_store_result(statements_[index]);
        checkError(status, index, "unable to set up for storing all results");
 
        // Fetch results.
        MySqlFreeResult fetch_release(statements_[index]);
        while ((status = mysql_stmt_fetch(statements_[index])) ==
               MLM_MYSQL_FETCH_SUCCESS) {
            try {
                // For each returned row call user function which should
                // consume the row and copy the data to a safe place.
                process_result(out_bindings);
 
            } catch (const std::exception& ex) {
                // Rethrow the exception with a bit more data.
                isc_throw(BadValue, ex.what() << ". Statement is <" <<
                          text_statements_[index] << ">");
            }
        }
 
        // How did the fetch end?
        // If mysql_stmt_fetch return value is equal to 1 an error occurred.
        if (status == MLM_MYSQL_FETCH_FAILURE) {
            // Error - unable to fetch results
            checkError(status, index, "unable to fetch results");
 
        } else if (status == MYSQL_DATA_TRUNCATED) {
            // Data truncated - throw an exception indicating what was at fault
            isc_throw(DataTruncated, text_statements_[index]
                      << " returned truncated data");
        }
    }
 
    template<typename StatementIndex>
    void insertQuery(const StatementIndex& index,
                     const MySqlBindingCollection& in_bindings) {
        std::vector<MYSQL_BIND> in_bind_vec;
        for (MySqlBindingPtr in_binding : in_bindings) {
            in_bind_vec.push_back(in_binding->getMySqlBinding());
        }
 
        // Bind the parameters to the statement
        int status = mysql_stmt_bind_param(statements_[index], &in_bind_vec[0]);
        checkError(status, index, "unable to bind parameters");
 
        // Execute the statement
        status = mysql_stmt_execute(statements_[index]);
 
        if (status != 0) {
            // Failure: check for the special case of duplicate entry.
            if (mysql_errno(mysql_) == ER_DUP_ENTRY) {
                isc_throw(DuplicateEntry, "Database duplicate entry error");
        }
            checkError(status, index, "unable to execute");
        }
    }
 
    template<typename StatementIndex>
    uint64_t updateDeleteQuery(const StatementIndex& index,
                               const MySqlBindingCollection& in_bindings) {
        std::vector<MYSQL_BIND> in_bind_vec;
        for (MySqlBindingPtr in_binding : in_bindings) {
            in_bind_vec.push_back(in_binding->getMySqlBinding());
        }
 
        // Bind the parameters to the statement
        int status = mysql_stmt_bind_param(statements_[index], &in_bind_vec[0]);
        checkError(status, index, "unable to bind parameters");
 
        // Execute the statement
        status = mysql_stmt_execute(statements_[index]);
 
        if (status != 0) {
            checkError(status, index, "unable to execute");
        }
 
        // Let's return how many rows were affected.
        return (static_cast<uint64_t>(mysql_stmt_affected_rows(statements_[index])));
    }
 
 
    void commit();
 
    void rollback();
 
    template<typename StatementIndex>
    void checkError(const int status, const StatementIndex& index,
                    const char* what) const {
        if (status != 0) {
            switch(mysql_errno(mysql_)) {
                // These are the ones we consider fatal. Remember this method is
                // used to check errors of API calls made subsequent to successfully
                // connecting.  Errors occurring while attempting to connect are
                // checked in the connection code. An alternative would be to call
                // mysql_ping() - assuming autoreconnect is off. If that fails
                // then we know connection is toast.
            case CR_SERVER_GONE_ERROR:
            case CR_SERVER_LOST:
            case CR_OUT_OF_MEMORY:
            case CR_CONNECTION_ERROR:
                DB_LOG_ERROR(db::MYSQL_FATAL_ERROR)
                    .arg(what)
                    .arg(text_statements_[static_cast<int>(index)])
                    .arg(mysql_error(mysql_))
                    .arg(mysql_errno(mysql_));
 
                // If there's no lost db callback or it returns false,
                // then we're not attempting to recover so we're done
                if (!invokeDbLostCallback()) {
                    exit (-1);
                }
 
                // We still need to throw so caller can error out of the current
                // processing.
                isc_throw(db::DbOperationError,
                          "fatal database errror or connectivity lost");
            default:
                // Connection is ok, so it must be an SQL error
                isc_throw(db::DbOperationError, what << " for <"
                          << text_statements_[static_cast<int>(index)]
                          << ">, reason: "
                          << mysql_error(mysql_) << " (error code "
                          << mysql_errno(mysql_) << ")");
            }
        }
    }
 
    std::vector<MYSQL_STMT*> statements_;
 
    std::vector<std::string> text_statements_;
 
    MySqlHolder mysql_;
};
 
}; // end of isc::db namespace
}; // end of isc namespace
 
#endif // MYSQL_CONNECTION_H