Changeset 129 for trunk/src/sql_Query.cpp

Timestamp:

11/18/09 04:40:30 (3 years ago)

Author:

mercyful

Message:

$ Build 438/Sql Alpha
+ Removed all SQLite Code and References.
+ Updated the SQL Wrapper, and all Automake files to now link in and also Detect MySql? in the configure scripts.
+ Added detection for OpenSSL, not in use yet, but will add encryption for passwords.

and anything else of intertest once everything is moved over to the SQL Backend.

This is still an interm develop update release, the MySql? backend
is still a WIP, and the Husky SMAPI Library will be removed shortly.

Files:

• trunk/src/sql_Query.cpp (modified) (11 diffs)

trunk/src/sql_Query.cpp

@@ -1 @@
-/*
+/**
  **     Query.cpp
  **
- **     Published / author: 2005-08-12 / grymse@alhem.net
+ **     Published / author: 2001-02-15 / grymse@alhem.net
  **/
 
 /*
-Copyright (C) 2001-2006  Anders Hedstrom
+Copyright (C) 2001  Anders Hedstrom
 
 This program is made available under the terms of the GNU GPL.
@@ -36 +36 @@
 #include <string>
 #include <map>
+#ifdef WIN32
+#include <config-win.h>
+#include <mysql.h>
+#else
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <sqlite3.h>
+#include <mysql/mysql.h>
+#endif
 
 #include "sql_Database.h"
@@ -45 +50 @@
 
 
-#ifdef SQLITEW_NAMESPACE
-namespace SQLITEW_NAMESPACE {
+#ifdef MYSQLW_NAMESPACE
+namespace MYSQLW_NAMESPACE {
 #endif
 
 
-Query::Query(Database& dbin) 
-: m_db(dbin)
-,odb(dbin.grabdb())
+Query::Query(Database *dbin)
+:m_db(*dbin)
+,odb(dbin ? dbin -> grabdb() : NULL)
 ,res(NULL)
-,row(false)
-,cache_rc(0)
-,cache_rc_valid(false)
-,m_row_count(0)
+,row(NULL)
 ,m_num_cols(0)
 {
@@ -63 +65 @@
 
 
-Query::Query(Database& dbin,const std::string& sql) 
-: m_db(dbin)
-,odb(dbin.grabdb())
-,res(NULL)
-,row(false)
-,cache_rc(0)
-,cache_rc_valid(false)
-,m_row_count(0)
+Query::Query(Database& dbin) : m_db(dbin),odb(dbin.grabdb()),res(NULL),row(NULL)
 ,m_num_cols(0)
 {
+}
+
+
+Query::Query(Database *dbin,const std::string& sql) : m_db(*dbin)
+,odb(dbin ? dbin -> grabdb() : NULL),res(NULL),row(NULL)
+,m_num_cols(0)
+{
         execute(sql);
 }
 
 
+Query::Query(Database& dbin,const std::string& sql) : m_db(dbin),odb(dbin.grabdb()),res(NULL),row(NULL)
+,m_num_cols(0)
+{
+        execute(sql); // returns 0 if fail
+}
+
+
 Query::~Query()
 {
         if (res)
         {
-                GetDatabase().error(*this, "sqlite3_finalize in destructor");
-                sqlite3_finalize(res);
+                GetDatabase().error(*this, "mysql_free_result in destructor");
+                mysql_free_result(res);
         }
         if (odb)
@@ -97 +106 @@
 
 
-/*
-The sqlite3_finalize() routine deallocates a prepared SQL statement. 
-All prepared statements must be finalized before the database can be closed.
-*/
 bool Query::execute(const std::string& sql)
-{
-        // query, no result
+{               // query, no result
         m_last_query = sql;
         if (odb && res)
@@ -111 +115 @@
         if (odb && !res)
         {
-                const char *s = NULL;
-                int rc = sqlite3_prepare(odb -> db, sql.c_str(), sql.size(), &res, &s);
-                if (rc != SQLITE_OK)
-                {
-                        GetDatabase().error(*this, "execute: prepare query failed");
-                        return false;
-                }
-                if (!res)
-                {
-                        GetDatabase().error(*this, "execute: query failed");
-                        return false;
-                }
-                rc = sqlite3_step(res); // execute
-                sqlite3_finalize(res); // deallocate statement
+                if (mysql_query(&odb -> mysql,sql.c_str()))
+                {
+                        GetDatabase().error(*this,"query failed");
+                }
+                else
+                {
+                        return true;
+                }
+        }
+        return false;
+}
+
+
+
+// methods using db specific api calls
+
+MYSQL_RES *Query::get_result(const std::string& sql)
+{       // query, result
+        if (odb && res)
+        {
+                GetDatabase().error(*this, "get_result: query busy");
+        }
+        if (odb && !res)
+        {
+                if (execute(sql))
+                {
+                        res = mysql_store_result(&odb -> mysql);
+                        if (res)
+                        {
+                                MYSQL_FIELD *f = mysql_fetch_field(res);
+                                int i = 1;
+                                while (f)
+                                {
+                                        if (f -> name)
+                                                m_nmap[f -> name] = i;
+                                        f = mysql_fetch_field(res);
+                                        i++;
+                                }
+                                m_num_cols = i - 1;
+                        }
+                }
+        }
+        return res;
+}
+
+
+void Query::free_result()
+{
+        if (odb && res)
+        {
+                mysql_free_result(res);
                 res = NULL;
-                switch (rc)
-                {
-                case SQLITE_BUSY:
-                        GetDatabase().error(*this, "execute: database busy");
-                        return false;
-                case SQLITE_DONE:
-                case SQLITE_ROW:
-                        return true;
-                case SQLITE_ERROR:
-                        GetDatabase().error(*this, sqlite3_errmsg(odb -> db));
-                        return false;
-                case SQLITE_MISUSE:
-                        GetDatabase().error(*this, "execute: database misuse");
-                        return false;
-                }
-                GetDatabase().error(*this, "execute: unknown result code");
-        }
-        return false;
-}
-
-
-
-// methods using db specific api calls
-
-sqlite3_stmt *Query::get_result(const std::string& sql)
-{
-        // query, result
-        m_last_query = sql;
-        if (odb && res)
-        {
-                GetDatabase().error(*this, "get_result: query busy");
-        }
-        if (odb && !res)
-        {
-                const char *s = NULL;
-                int rc = sqlite3_prepare(odb -> db, sql.c_str(), sql.size(), &res, &s);
-                if (rc != SQLITE_OK)
-                {
-                        GetDatabase().error(*this, "get_result: prepare query failed");
-                        return NULL;
-                }
-                if (!res)
-                {
-                        GetDatabase().error(*this, "get_result: query failed");
-                        return NULL;
-                }
-                // get column names from result
-                {
-                        int i = 0;
-                        do
-                        {
-                                const char *p = sqlite3_column_name(res, i);
-                                if (!p)
-                                        break;
-                                m_nmap[p] = ++i;
-                        } while (true);
-                        m_num_cols = i;
-                }
-                cache_rc = sqlite3_step(res);
-                cache_rc_valid = true;
-                m_row_count = (cache_rc == SQLITE_ROW) ? 1 : 0;
-        }
-        return res;
-}
-
-
-void Query::free_result()
-{
-        if (odb && res)
-        {
-                sqlite3_finalize(res);
-                res = NULL;
-                row = false;
-                cache_rc_valid = false;
-        }
-        // clear column names
+                row = NULL;
+        }
         while (m_nmap.size())
         {
@@ -207 +174 @@
                 m_nmap.erase(it);
         }
-}
-
-
-bool Query::fetch_row()
+        m_num_cols = 0;
+}
+
+
+MYSQL_ROW Query::fetch_row()
 {
         rowcount = 0;
-        row = false;
-        if (odb && res)
-        {
-                int rc = cache_rc_valid ? cache_rc : sqlite3_step(res); // execute
-                cache_rc_valid = false;
-                switch (rc)
-                {
-                case SQLITE_BUSY:
-                        GetDatabase().error(*this, "execute: database busy");
-                        return false;
-                case SQLITE_DONE:
-                        return false;
-                case SQLITE_ROW:
-                        row = true;
-                        return true;
-                case SQLITE_ERROR:
-                        GetDatabase().error(*this, sqlite3_errmsg(odb -> db));
-                        return false;
-                case SQLITE_MISUSE:
-                        GetDatabase().error(*this, "execute: database misuse");
-                        return false;
-                }
-                GetDatabase().error(*this, "execute: unknown result code");
-        }
+        return odb && res ? row = mysql_fetch_row(res) : NULL;
+}
+
+
+my_ulonglong Query::insert_id()
+{
+        if (odb)
+        {
+                return mysql_insert_id(&odb -> mysql);
+        }
+        else
+        {
+                return 0;
+        }
+}
+
+
+long Query::num_rows()
+{
+        return odb && res ? mysql_num_rows(res) : 0;
+}
+
+
+int Query::num_cols()
+{
+        return m_num_cols;
+}
+
+
+bool Query::is_null(int x)
+{
+        if (odb && res && row)
+        {
+                return row[x] ? false : true;
+        }
+        return false; // ...
+}
+
+
+bool Query::is_null(const std::string& x)
+{
+        int index = m_nmap[x] - 1;
+        if (index >= 0)
+                return is_null(index);
+        error("Column name lookup failure: " + x);
         return false;
 }
 
 
-sqlite_int64 Query::insert_id()
-{
-        if (odb)
-        {
-                return sqlite3_last_insert_rowid(odb -> db);
-        }
-        else
-        {
-                return 0;
-        }
-}
-
-
-long Query::num_rows()
-{
-        return odb && res ? m_row_count : 0;
-}
-
-
-int Query::num_cols()
-{
-        return m_num_cols;
-}
-
-
-bool Query::is_null(int x)
+bool Query::is_null()
+{
+        return is_null(rowcount++);
+}
+
+
+const char *Query::getstr(const std::string& x)
+{
+        int index = m_nmap[x] - 1;
+        if (index >= 0)
+                return getstr(index);
+        error("Column name lookup failure: " + x);
+        return NULL;
+}
+
+
+const char *Query::getstr(int x)
 {
         if (odb && res && row)
         {
-                if (sqlite3_column_type(res, x) == SQLITE_NULL)
-                        return true;
-        }
-        return false; // ...
-}
-
-
-const char *Query::getstr(const std::string& x)
-{
-        int index = m_nmap[x] - 1;
-        if (index >= 0)
-                return getstr(index);
-        error("Column name lookup failure: " + x);
-        return "";
-}
-
-
-const char *Query::getstr(int x)
-{
-        if (odb && res && row && x < sqlite3_column_count(res) )
-        {
-                const unsigned char *tmp = sqlite3_column_text(res, x);
-                return tmp ? (const char *)tmp : "";
-        }
-        return "";
+                return row[x] ? row[x] : "";
+        }
+        return NULL;
 }
 
@@ -316 +274 @@
 double Query::getnum(int x)
 {
-        if (odb && res && row)
-        {
-                return sqlite3_column_double(res, x);
-        }
+        return odb && res && row && row[x] ? atof(row[x]) : 0;
+}
+
+
+long Query::getval(const std::string& x)
+{
+        int index = m_nmap[x] - 1;
+        if (index >= 0)
+                return getval(index);
+        error("Column name lookup failure: " + x);
         return 0;
 }
 
 
-long Query::getval(const std::string& x)
-{
-        int index = m_nmap[x] - 1;
-        if (index >= 0)
-                return getval(index);
+long Query::getval(int x)
+{
+        return odb && res && row && row[x] ? atol(row[x]) : 0;
+}
+
+
+double Query::getnum()
+{
+        return getnum(rowcount++);
+}
+
+
+long Query::getval()
+{
+        return getval(rowcount++);
+}
+
+
+unsigned long Query::getuval(const std::string& x)
+{
+        int index = m_nmap[x] - 1;
+        if (index >= 0)
+                return getuval(index);
         error("Column name lookup failure: " + x);
         return 0;
@@ -334 +316 @@
 
 
-long Query::getval(int x)
-{
-        if (odb && res && row)
-        {
-                return sqlite3_column_int(res, x);
-        }
+unsigned long Query::getuval(int x)
+{
+        unsigned long l = 0;
+        if (odb && res && row && row[x])
+        {
+                l = m_db.a2ubigint(row[x]);
+        }
+        return l;
+}
+
+
+unsigned long Query::getuval()
+{
+        return getuval(rowcount++);
+}
+
+
+int64_t Query::getbigint(const std::string& x)
+{
+        int index = m_nmap[x] - 1;
+        if (index >= 0)
+                return getbigint(index);
+        error("Column name lookup failure: " + x);
         return 0;
 }
 
 
-double Query::getnum()
-{
-        return getnum(rowcount++);
-}
-
-
-long Query::getval()
-{
-        return getval(rowcount++);
-}
-
-
-unsigned long Query::getuval(const std::string& x)
-{
-        int index = m_nmap[x] - 1;
-        if (index >= 0)
-                return getuval(index);
+int64_t Query::getbigint(int x)
+{
+        return odb && res && row && row[x] ? m_db.a2bigint(row[x]) : 0;
+}
+
+
+int64_t Query::getbigint()
+{
+        return getbigint(rowcount++);
+}
+
+
+uint64_t Query::getubigint(const std::string& x)
+{
+        int index = m_nmap[x] - 1;
+        if (index >= 0)
+                return getubigint(index);
         error("Column name lookup failure: " + x);
         return 0;
@@ -366 +365 @@
 
 
-unsigned long Query::getuval(int x)
-{
-        unsigned long l = 0;
-        if (odb && res && row)
-        {
-                l = sqlite3_column_int(res, x);
-        }
-        return l;
-}
-
-
-unsigned long Query::getuval()
-{
-        return getuval(rowcount++);
-}
-
-
-int64_t Query::getbigint(const std::string& x)
-{
-        int index = m_nmap[x] - 1;
-        if (index >= 0)
-                return getbigint(index);
-        error("Column name lookup failure: " + x);
-        return 0;
-}
-
-
-int64_t Query::getbigint(int x)
-{
-        if (odb && res && row)
-        {
-                return sqlite3_column_int64(res, x);
-        }
-        return 0;
-}
-
-
-int64_t Query::getbigint()
-{
-        return getbigint(rowcount++);
-}
-
-
-uint64_t Query::getubigint(const std::string& x)
-{
-        int index = m_nmap[x] - 1;
-        if (index >= 0)
-                return getubigint(index);
-        error("Column name lookup failure: " + x);
-        return 0;
-}
-
-
 uint64_t Query::getubigint(int x)
 {
-        uint64_t l = 0;
-        if (odb && res && row)
-        {
-                l = sqlite3_column_int64(res, x);
-        }
-        return l;
+        return odb && res && row && row[x] ? m_db.a2ubigint(row[x]) : 0;
 }
 
@@ -489 +430 @@
 std::string Query::GetError()
 {
+        return odb ? mysql_error(&odb -> mysql) : "";
+}
+
+
+int Query::GetErrno()
+{
+        return odb ? mysql_errno(&odb -> mysql) : 0;
+}
+
+
+bool Query::Connected()
+{
         if (odb)
-                return sqlite3_errmsg(odb -> db);
-        return "";
-}
-
-
-int Query::GetErrno()
-{
-        if (odb)
-                return sqlite3_errcode(odb -> db);
-        return 0;
-}
-
-
-bool Query::Connected()
-{
+        {
+                if (mysql_ping(&odb -> mysql))
+                {
+                        GetDatabase().error(*this, "mysql_ping() failed");
+                        return false;
+                }
+        }
         return odb ? true : false;
 }
 
 
-
-
-void Query::ViewRes()
-{
-        if (!res)
-        {
-                printf("no result stored\n");
-                return;
-        }
-        printf("result column count = %d\n", sqlite3_column_count(res));
-        for (int i = 0; i < sqlite3_column_count(res); i++)
-        {
-                printf(" %2d   type %d   name '%s'", i, sqlite3_column_type(res, i), sqlite3_column_name(res, i));
-                printf("  / '%s'", (char *)sqlite3_column_text(res, i));
-                printf("  / %d", sqlite3_column_int(res, i));
-                printf("  / %f", sqlite3_column_double(res, i));
-                printf("\n");
-        }
-}
-
-
-void Query::error(const std::string& msg)
-{
-        GetDatabase().error(*this, msg);
-}
-
-
-#ifdef SQLITEW_NAMESPACE
-} // namespace SQLITEW_NAMESPACE {
+void Query::error(const std::string& x)
+{
+        m_db.error(*this, x.c_str());
+}
+
+
+std::string Query::safestr(const std::string& x)
+{
+        return m_db.safestr(x);
+}
+
+// Added Michael Griffin 11/15/09
+// Custom 'mysql_real_escape_string()'
+char *Query::strip(char* Oldstr) 
+{
+    return m_db.strip_escape(odb,Oldstr);
+}
+
+
+#ifdef MYSQLW_NAMESPACE
+} // namespace MYSQLW_NAMESPACE {
 #endif