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