impl/mysql_traits.hpp

   1 /*
   2   Mysql C++ traits for sqlgg
   3   by ygrek
   4   2014-06-08
   5
   6   This is free and unencumbered software released into the public domain.
   7
   8   Anyone is free to copy, modify, publish, use, compile, sell, or
   9   distribute this software, either in source code form or as a compiled
  10   binary, for any purpose, commercial or non-commercial, and by any
  11   means.
  12
  13   For more information, please refer to <http://unlicense.org/>
  14 */
  15
  16 #include <mysql/mysql.h>
  17 #define SQLGG_STR(x) x
  18
  19 #include <assert.h>
  20 #include <string.h>
  21 #include <stdlib.h>
  22
  23 #include <string>
  24 #include <vector>
  25
  26 #if defined(SQLGG_DEBUG)
  27 #include <stdio.h>
  28 #endif
  29
  30 struct mysql_traits
  31 {
  32   typedef int Int;
  33   typedef std::string Text;
  34   typedef Text Any;
  35
  36   struct row_t
  37   {
  38     template<class T> T* alloc(size_t const count) { return (T*)calloc(count,sizeof(T)); }
  39
  40     row_t(MYSQL_STMT* stmt, size_t count) : count(count), stmt(stmt)
  41     {
  42       bind = alloc<MYSQL_BIND>(count);
  43       error = alloc<my_bool>(count);
  44       length = alloc<unsigned long>(count);
  45       is_null = alloc<my_bool>(count);
  46     }
  47
  48     ~row_t()
  49     {
  50       free(bind);
  51       free(error);
  52       free(length);
  53       free(is_null);
  54     }
  55
  56     const size_t count;
  57     MYSQL_STMT* stmt;
  58
  59     MYSQL_BIND* bind;
  60     unsigned long* length;
  61     my_bool* error;
  62     my_bool* is_null;
  63   };
  64
  65   typedef row_t& row;
  66   typedef MYSQL* connection;
  67
  68   static void get_column_Int(row r, int index, Int& data)
  69   {
  70     // nothing
  71   }
  72
  73   static void get_column_Text(row r, int index, Text& data)
  74   {
  75     unsigned long const& length = r.length[index];
  76     MYSQL_BIND& bind = r.bind[index];
  77
  78     if (length > 0)
  79     {
  80       data.resize(length);
  81       bind.buffer = (void*)(data.c_str());
  82       bind.buffer_length = length;
  83       mysql_stmt_fetch_column(r.stmt, r.bind, index, 0);
  84     }
  85
  86     //data.resize(length);
  87   }
  88
  89   static void bind_column_Int(row r, int index, Int& data)
  90   {
  91     MYSQL_BIND& bind = r.bind[index];
  92
  93     data = 0;
  94     bind.buffer_type = MYSQL_TYPE_LONG;
  95     bind.buffer = (void*)&data;
  96     bind.is_null = &r.is_null[index];
  97     bind.length = &r.length[index];
  98     bind.error = &r.error[index];
  99   }
 100
 101   static void bind_column_Text(row r, int index, Text& data)
 102   {
 103     MYSQL_BIND& bind = r.bind[index];
 104
 105     bind.buffer_type = MYSQL_TYPE_STRING;
 106     bind.buffer = 0;
 107     bind.buffer_length = 0;
 108     bind.is_null = &r.is_null[index];
 109     bind.length = &r.length[index];
 110     bind.error = &r.error[index];
 111   }
 112
 113   static void set_param(row r, const Text& val, int index)
 114   {
 115     MYSQL_BIND& bind = r.bind[index];
 116
 117     r.length[index] = val.size();
 118     bind.length = &r.length[index];
 119     bind.buffer_length = val.size();
 120     bind.buffer_type = MYSQL_TYPE_STRING;
 121     bind.buffer = (void*)val.c_str();
 122   }
 123
 124   static void set_param(row r, const Int& val, int index)
 125   {
 126     MYSQL_BIND& bind = r.bind[index];
 127
 128     bind.buffer_type = MYSQL_TYPE_LONG;
 129     bind.buffer = (void*)&val;
 130   }
 131
 132   class mysql_stmt
 133   {
 134   public:
 135     mysql_stmt(MYSQL_STMT* stmt) : stmt(stmt)
 136     {
 137     }
 138
 139     void close()
 140     {
 141       if (stmt) mysql_stmt_close(stmt);
 142       stmt = NULL;
 143     }
 144
 145     virtual ~mysql_stmt()
 146     {
 147       close();
 148     }
 149
 150 /*
 151     mysql_stmt& operator=(MYSQL_STMT* v)
 152     {
 153       close();
 154       stmt = v;
 155     }
 156 */
 157
 158     operator MYSQL_STMT*()
 159     {
 160       return stmt;
 161     }
 162
 163   private:
 164     MYSQL_STMT* stmt;
 165   };
 166
 167   struct no_params
 168   {
 169     void set_params(row) {}
 170     enum { count = 0 };
 171   };
 172
 173   template<class T>
 174   struct no_binder
 175   {
 176     void get(row,T) {}
 177     void bind(row) {}
 178     enum { count = 0 };
 179   };
 180
 181
 182   class statement
 183   {
 184   private:
 185     connection db;
 186     char const* sql;
 187     mysql_stmt stmt;
 188     bool ready;
 189
 190   public:
 191     statement(connection aDb, char const* sql) : db(aDb), sql(sql), stmt(mysql_stmt_init(aDb))
 192     {
 193       ready = false;
 194     }
 195
 196     bool prepare()
 197     {
 198       if (ready)
 199       {
 200         return true;
 201       }
 202
 203       if (!stmt)
 204       {
 205 #if defined(SQLGG_DEBUG)
 206         fprintf(stderr, " mysql_stmt_init(), out of memory\n");
 207 #endif
 208         return false;
 209       }
 210
 211       if (mysql_stmt_prepare(stmt, sql, strlen(sql)))
 212       {
 213 #if defined(SQLGG_DEBUG)
 214         fprintf(stderr, " mysql_stmt_prepare(), failed\n");
 215         fprintf(stderr, " %s\n", mysql_stmt_error(stmt));
 216 #endif
 217         return false;
 218       }
 219
 220       ready = true;
 221       return true;
 222     }
 223
 224     template<class T, class Binder, class Params>
 225     bool select(T result, Binder binder, Params params)
 226     {
 227       prepare();
 228
 229       if (Params::count != mysql_stmt_param_count(stmt))
 230       {
 231 #if defined(SQLGG_DEBUG)
 232         fprintf(stderr, " wrong params count %u != %lu\n",Params::count,mysql_stmt_param_count(stmt));
 233 #endif
 234         return false;
 235       }
 236       if (Binder::count != mysql_stmt_field_count(stmt))
 237       {
 238 #if defined(SQLGG_DEBUG)
 239         fprintf(stderr, " wrong number of columns %u != %u\n",Binder::count,mysql_stmt_field_count(stmt));
 240 #endif
 241         return false;
 242       }
 243
 244       row_t r_params(stmt,Params::count);
 245       params.set_params(r_params);
 246
 247       if (mysql_stmt_bind_param(stmt, r_params.bind))
 248       {
 249 #if defined(SQLGG_DEBUG)
 250         fprintf(stderr, " mysql_stmt_bind_param() failed\n");
 251         fprintf(stderr, " %s\n", mysql_stmt_error(stmt));
 252 #endif
 253         return false;
 254       }
 255
 256       if (mysql_stmt_execute(stmt))
 257       {
 258 #if defined(SQLGG_DEBUG)
 259         fprintf(stderr, " mysql_stmt_execute(), failed\n");
 260         fprintf(stderr, " %s\n", mysql_stmt_error(stmt));
 261 #endif
 262         return false;
 263       }
 264
 265       row_t r(stmt,Binder::count);
 266
 267       if (0 != Binder::count)
 268       {
 269         binder.bind(r);
 270
 271         if (mysql_stmt_bind_result(stmt, r.bind))
 272         {
 273 #if defined(SQLGG_DEBUG)
 274           fprintf(stderr, " mysql_stmt_bind_result() failed\n");
 275           fprintf(stderr, " %s\n", mysql_stmt_error(stmt));
 276 #endif
 277           return false;
 278         }
 279       }
 280
 281       while (true)
 282       {
 283         int res = mysql_stmt_fetch(stmt);
 284         if (0 != res && MYSQL_DATA_TRUNCATED != res) break;
 285         binder.get(r,result);
 286       }
 287
 288       return true;
 289     }
 290
 291     template<class Params>
 292     bool execute(Params params)
 293     {
 294       int dummy = 0;
 295       return select(dummy,no_binder<int>(),params);
 296     }
 297
 298   }; // statement
 299
 300 }; // mysql_traits