[2342] getVersion() is now working

This change adds the code for prepared statement creation and the
template for retrieving information from the database.

src/lib/dhcp/mysql_lease_mgr.cc

@@ -76,32 +76,88 @@ MySqlLeaseMgr::openDatabase() {
     }
 }
 
+void
+MySqlLeaseMgr::prepareStatement(StatementIndex index, const char* text) {
+    // Validate that there is space for the statement in the statements array
+    // and that nothing has been placed there before.
+    if ((index >= statements_.size()) || (statements_[index] != NULL)) {
+        isc_throw(InvalidParameter, "invalid prepared statement index or "
+                  "statement index not null");
+    }
+
+    // All OK, so prepare the statement
+    raw_statements_[index] = std::string(text);
+
+    statements_[index] = mysql_stmt_init(mysql_);
+    if (statements_[index] == NULL) {
+        isc_throw(DbOperationError, "unable to allocate MySQL prepared "
+                  "statement structure" << mysql_error(mysql_));
+    }
+
+    int status = mysql_stmt_prepare(statements_[index], text, strlen(text));
+    if (status != 0) {
+        isc_throw(DbOperationError, "unable to prepare MySQL statement <" <<
+                  text << ">, reason: " << mysql_error(mysql_));
+    }
+}
+
+void
+MySqlLeaseMgr::prepareStatements() {
+    // Allocate space for all statements
+    statements_.clear();
+    statements_.resize(NUM_STATEMENTS, NULL);
+    
+    raw_statements_.clear();
+    raw_statements_.resize(NUM_STATEMENTS, std::string(""));
+
+    // Now allocate the statements
+    prepareStatement(SELECT_VERSION,
+                     "SELECT version, minor FROM schema_version");
+}
+
 
 MySqlLeaseMgr::MySqlLeaseMgr(const LeaseMgr::ParameterMap& parameters) 
-    : LeaseMgr(parameters), mysql_(NULL), major_(0), minor_(0) {
+    : LeaseMgr(parameters), mysql_(NULL) {
 
     // Allocate context for MySQL - it is destroyed in the destructor.
     mysql_ = mysql_init(NULL);
-    std::cerr << "cerr: mysql_ is " << long(mysql_) << std::endl;
-    std::cout << "cout: mysql_ is " << long(mysql_) << std::endl;
 
     // Open the database
     openDatabase();
-    
+
+    // Disable autocommit
+    my_bool result = mysql_autocommit(mysql_, 0);
+    if (result != 0) {
+        isc_throw(DbOperationError, mysql_error(mysql_));
+    }
+
+    // Prepare all statements likely to be used.
+    prepareStatements();
 }
 
 MySqlLeaseMgr::~MySqlLeaseMgr() {
+    // Free up the prepared statements, ignoring errors. (What would we do
+    // about them - we're destroying this object and are not really concerned
+    // with errors on a database connection that it about to go away.)
+    for (int i = 0; i < statements_.size(); ++i) {
+        if (statements_[i] != NULL) {
+            (void) mysql_stmt_close(statements_[i]);
+            statements_[i] = NULL;
+        }
+    }
+
+    // Close the database
     mysql_close(mysql_);
     mysql_ = NULL;
 }
 
 bool
-MySqlLeaseMgr::addLease(isc::dhcp::Lease4Ptr /* lease */) {
+MySqlLeaseMgr::addLease(Lease4Ptr /* lease */) {
     return (false);
 }
 
 bool
-MySqlLeaseMgr::addLease(isc::dhcp::Lease6Ptr /* lease */) {
+MySqlLeaseMgr::addLease(Lease6Ptr /* lease */) {
     return (false);
 }
 
@@ -184,7 +240,45 @@ MySqlLeaseMgr::getDescription() const {
 
 std::pair<uint32_t, uint32_t>
 MySqlLeaseMgr::getVersion() const {
-    return (std::make_pair(major_, minor_));
+    uint32_t    major;      // Major version number
+    uint32_t    minor;      // Minor version number
+
+    // Execute the prepared statement
+    int status = mysql_stmt_execute(statements_[SELECT_VERSION]);
+    if (status != 0) {
+        isc_throw(DbOperationError, "unable to execute <"
+                  << raw_statements_[SELECT_VERSION] << "> - reason: " <<
+                  mysql_error(mysql_));
+    }
+
+    // Bind the output of the statement to the appropriate variables.
+    MYSQL_BIND bind[2];
+    memset(bind, 0, sizeof(bind));
+
+    bind[0].buffer_type = MYSQL_TYPE_LONG;
+    bind[0].is_unsigned = 1;
+    bind[0].buffer = &major;
+    bind[0].buffer_length = sizeof(major);
+
+    bind[1].buffer_type = MYSQL_TYPE_LONG;
+    bind[1].is_unsigned = 1;
+    bind[1].buffer = &minor;
+    bind[1].buffer_length = sizeof(minor);
+
+    status = mysql_stmt_bind_result(statements_[SELECT_VERSION], bind);
+    if (status != 0) {
+        isc_throw(DbOperationError, "unable to bind result set: " <<
+                  mysql_error(mysql_));
+    }
+
+    // Get the result
+    status = mysql_stmt_fetch(statements_[SELECT_VERSION]);
+    if (status != 0) {
+        isc_throw(DbOperationError, "unable to obtain result set: " <<
+                  mysql_error(mysql_));
+    }
+
+    return (std::make_pair(major, minor));
 }
 
 }; // end of isc::dhcp namespace