src/db/sqlite3statement.cpp

   1 #include "../../include/db/sqlite3db/sqlite3statement.h"\r
   2 \r
   3 #ifdef XMEM\r
   4         #include <xmem.h>\r
   5 #endif\r
   6 \r
   7 namespace SQLite3DB\r
   8 {\r
   9 \r
  10 std::map<sqlite3_stmt *, long> Statement::m_statementcount;\r
  11 \r
  12 Statement::Statement()\r
  13 {\r
  14         m_statement=NULL;\r
  15         m_parametercount=0;\r
  16         m_resultcolumncount=0;\r
  17         m_rowreturned=false;\r
  18 }\r
  19 \r
  20 Statement::Statement(sqlite3_stmt *statement)\r
  21 {\r
  22         m_statement=statement;\r
  23         m_parametercount=sqlite3_bind_parameter_count(m_statement);\r
  24         m_resultcolumncount=sqlite3_column_count(m_statement);\r
  25         m_rowreturned=false;\r
  26         \r
  27         if(m_statement)\r
  28         {\r
  29                 m_statementcount[m_statement]++;\r
  30         }\r
  31 }\r
  32 \r
  33 Statement::Statement(const Statement &rhs)\r
  34 {\r
  35         m_statement=NULL;\r
  36         m_parametercount=0;\r
  37         m_resultcolumncount=0;\r
  38         m_rowreturned=false;\r
  39         *this=rhs;\r
  40 }\r
  41 \r
  42 Statement::~Statement()\r
  43 {\r
  44         \r
  45         Finalize();\r
  46         \r
  47         std::vector<char *>::iterator i;\r
  48         for(i=textptrs.begin(); i!=textptrs.end(); i++)\r
  49         {\r
  50                 if((*i))\r
  51                 {\r
  52                         delete [] (*i);\r
  53                 }\r
  54         }\r
  55 }\r
  56 \r
  57 const bool Statement::Bind(const int column)\r
  58 {\r
  59         if(Valid() && column>=0 && column<m_parametercount)\r
  60         {\r
  61                 //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
  62                 PThread::Guard g(DB::Instance()->m_mutex);\r
  63                 if(sqlite3_bind_null(m_statement,column+1)==SQLITE_OK)\r
  64                 {\r
  65                         return true;\r
  66                 }\r
  67                 else\r
  68                 {\r
  69                         return false;\r
  70                 }\r
  71         }\r
  72         else\r
  73         {\r
  74                 return false;\r
  75         }\r
  76 }\r
  77 \r
  78 const bool Statement::Bind(const int column, const int value)\r
  79 {\r
  80         if(Valid() && column>=0 && column<m_parametercount)\r
  81         {\r
  82                 //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
  83                 PThread::Guard g(DB::Instance()->m_mutex);\r
  84                 if(sqlite3_bind_int(m_statement,column+1,value)==SQLITE_OK)\r
  85                 {\r
  86                         return true;\r
  87                 }\r
  88                 else\r
  89                 {\r
  90                         return false;\r
  91                 }\r
  92         }\r
  93         else\r
  94         {\r
  95                 return false;\r
  96         }\r
  97 }\r
  98 \r
  99 const bool Statement::Bind(const int column, const double value)\r
 100 {\r
 101         if(Valid() && column>=0 && column<m_parametercount)\r
 102         {\r
 103                 //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
 104                 PThread::Guard g(DB::Instance()->m_mutex);\r
 105                 if(sqlite3_bind_double(m_statement,column+1,value)==SQLITE_OK)\r
 106                 {\r
 107                         return true;\r
 108                 }\r
 109                 else\r
 110                 {\r
 111                         return false;\r
 112                 }\r
 113         }\r
 114         else\r
 115         {\r
 116                 return false;\r
 117         }       \r
 118 }\r
 119 \r
 120 const bool Statement::Bind(const int column, const std::string &value)\r
 121 {\r
 122         if(Valid() && column>=0 && column<m_parametercount)\r
 123         {\r
 124                 char *text=new char[value.size()+1];\r
 125                 strncpy(text,value.c_str(),value.size());\r
 126                 text[value.size()]=NULL;\r
 127                 textptrs.push_back(text);\r
 128                 //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
 129                 PThread::Guard g(DB::Instance()->m_mutex);\r
 130                 if(sqlite3_bind_text(m_statement,column+1,text,value.size(),NULL)==SQLITE_OK)\r
 131                 {\r
 132                         return true;\r
 133                 }\r
 134                 else\r
 135                 {\r
 136                         return false;\r
 137                 }\r
 138         }\r
 139         else\r
 140         {\r
 141                 return false;\r
 142         }       \r
 143 }\r
 144 \r
 145 const bool Statement::Bind(const int column, const void *data, const int length)\r
 146 {\r
 147         if(Valid() && column>=0 && column<m_parametercount)\r
 148         {\r
 149                 //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
 150                 PThread::Guard g(DB::Instance()->m_mutex);\r
 151                 if(sqlite3_bind_blob(m_statement,column+1,data,length,NULL)==SQLITE_OK)\r
 152                 {\r
 153                         return true;\r
 154                 }\r
 155                 else\r
 156                 {\r
 157                         return false;\r
 158                 }\r
 159         }\r
 160         else\r
 161         {\r
 162                 return false;\r
 163         }\r
 164 }\r
 165 \r
 166 void Statement::Finalize()\r
 167 {\r
 168         if(m_statement)\r
 169         {\r
 170                 //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
 171                 PThread::Guard g(DB::Instance()->m_mutex);\r
 172                 m_statementcount[m_statement]--;\r
 173                 if(m_statementcount[m_statement]<=0)\r
 174                 {\r
 175                         m_statementcount.erase(m_statement);\r
 176                         sqlite3_finalize(m_statement);\r
 177                 }\r
 178                 m_statement=NULL;\r
 179         }\r
 180 }\r
 181 \r
 182 Statement &Statement::operator=(const Statement &rhs)\r
 183 {\r
 184         if(&rhs!=this)\r
 185         {\r
 186                 Finalize();\r
 187 \r
 188                 m_statement=rhs.m_statement;\r
 189                 m_parametercount=rhs.m_parametercount;\r
 190                 m_resultcolumncount=rhs.m_resultcolumncount;\r
 191                 m_rowreturned=rhs.m_rowreturned;\r
 192 \r
 193                 if(m_statement)\r
 194                 {\r
 195                         //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
 196                         PThread::Guard g(DB::Instance()->m_mutex);\r
 197                         m_statementcount[m_statement]++;\r
 198                 }\r
 199         }\r
 200         return *this;\r
 201 }\r
 202 \r
 203 const bool Statement::Reset()\r
 204 {\r
 205         if(Valid())\r
 206         {\r
 207                 //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
 208                 PThread::Guard g(DB::Instance()->m_mutex);\r
 209                 if(sqlite3_reset(m_statement)==SQLITE_OK)\r
 210                 {\r
 211                         return true;\r
 212                 }\r
 213                 else\r
 214                 {\r
 215                         return false;\r
 216                 }\r
 217         }\r
 218         else\r
 219         {\r
 220                 return false;\r
 221         }\r
 222 }\r
 223 \r
 224 const bool Statement::ResultBlob(const int column, void *data, int &length)\r
 225 {\r
 226         if(Valid() && column>=0 && column<m_resultcolumncount)\r
 227         {\r
 228                 //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
 229                 PThread::Guard g(DB::Instance()->m_mutex);\r
 230                 data=(void *)sqlite3_column_blob(m_statement,column);\r
 231                 length=sqlite3_column_bytes(m_statement,column);\r
 232                 return true;\r
 233         }\r
 234         else\r
 235         {\r
 236                 return false;\r
 237         }\r
 238 }\r
 239 \r
 240 const bool Statement::ResultDouble(const int column, double &result)\r
 241 {\r
 242         if(Valid() && column>=0 && column<m_resultcolumncount)\r
 243         {\r
 244                 //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
 245                 PThread::Guard g(DB::Instance()->m_mutex);\r
 246                 result=sqlite3_column_double(m_statement,column);\r
 247                 return true;\r
 248         }\r
 249         else\r
 250         {\r
 251                 return false;\r
 252         }\r
 253 }\r
 254 \r
 255 const bool Statement::ResultInt(const int column, int &result)\r
 256 {\r
 257         if(Valid() && column>=0 && column<m_resultcolumncount)\r
 258         {\r
 259                 //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
 260                 PThread::Guard g(DB::Instance()->m_mutex);\r
 261                 result=sqlite3_column_int(m_statement,column);\r
 262                 return true;\r
 263         }\r
 264         else\r
 265         {\r
 266                 return false;\r
 267         }\r
 268 }\r
 269 \r
 270 const bool Statement::ResultNull(const int column)\r
 271 {\r
 272         if(Valid() && column>=0 && column<m_resultcolumncount)\r
 273         {\r
 274                 //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
 275                 PThread::Guard g(DB::Instance()->m_mutex);\r
 276                 if(sqlite3_column_type(m_statement,column)==SQLITE_NULL)\r
 277                 {\r
 278                         return true;\r
 279                 }\r
 280                 else\r
 281                 {\r
 282                         return false;\r
 283                 }\r
 284         }\r
 285         else\r
 286         {\r
 287                 return false;\r
 288         }\r
 289 }\r
 290 \r
 291 const bool Statement::ResultText(const int column, std::string &result)\r
 292 {\r
 293         if(Valid() && column>=0 && column<m_resultcolumncount)\r
 294         {\r
 295                 //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
 296                 PThread::Guard g(DB::Instance()->m_mutex);\r
 297                 const unsigned char *cresult=sqlite3_column_text(m_statement,column);\r
 298                 if(cresult)\r
 299                 {\r
 300                         result=(char *)cresult;\r
 301                 }\r
 302                 else\r
 303                 {\r
 304                         result="";\r
 305                 }\r
 306                 return true;\r
 307         }\r
 308         else\r
 309         {\r
 310                 return false;\r
 311         }\r
 312 }\r
 313 \r
 314 const bool Statement::Step(const bool saveinsertrowid)\r
 315 {\r
 316         m_rowreturned=false;\r
 317         if(Valid())\r
 318         {\r
 319                 //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
 320                 PThread::Guard g(DB::Instance()->m_mutex);\r
 321                 int result=sqlite3_step(m_statement);\r
 322                 if(result==SQLITE_OK || result==SQLITE_ROW || result==SQLITE_DONE)\r
 323                 {\r
 324                         if(result==SQLITE_ROW)\r
 325                         {\r
 326                                 m_rowreturned=true;\r
 327                         }\r
 328                         if(saveinsertrowid)\r
 329                         {\r
 330                                 m_lastinsertrowid=sqlite3_last_insert_rowid(DB::Instance()->GetDB());\r
 331                         }\r
 332                         return true;\r
 333                 }\r
 334                 else\r
 335                 {\r
 336                         return false;\r
 337                 }\r
 338         }\r
 339         else\r
 340         {\r
 341                 return false;\r
 342         }\r
 343 }\r
 344 \r
 345 const bool Statement::Valid()\r
 346 {\r
 347         //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
 348         PThread::Guard g(DB::Instance()->m_mutex);\r
 349         return m_statement ? true : false ;\r
 350 }\r
 351 \r
 352 }       // namespace\r