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                 //char *text=new char[value.size()+1];\r
 131                 //strncpy(text,value.c_str(),value.size());\r
 132                 //text[value.size()]=NULL;\r
 133                 //textptrs.push_back(text);\r
 134                 \r
 135                 //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
 136                 PThread::Guard g(DB::Instance()->m_mutex);\r
 137                 //m_boundtext.push_back(std::vector<char>(value.begin(),value.end()));\r
 138                 //if(sqlite3_bind_text(m_statement,column+1,text,value.size(),NULL)==SQLITE_OK)\r
 139                 //if(sqlite3_bind_text(m_statement,column+1,&(m_boundtext[m_boundtext.size()-1][0]),(m_boundtext[m_boundtext.size()-1]).size(),NULL)==SQLITE_OK)                \r
 140                 if(sqlite3_bind_text(m_statement,column+1,value.c_str(),value.size(),SQLITE_TRANSIENT)==SQLITE_OK)\r
 141                 {\r
 142                         return true;\r
 143                 }\r
 144                 else\r
 145                 {\r
 146                         return false;\r
 147                 }\r
 148         }\r
 149         else\r
 150         {\r
 151                 return false;\r
 152         }       \r
 153 }\r
 154 \r
 155 const bool Statement::Bind(const int column, const void *data, const int length)\r
 156 {\r
 157         if(Valid() && column>=0 && column<m_parametercount)\r
 158         {\r
 159                 //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
 160                 PThread::Guard g(DB::Instance()->m_mutex);\r
 161                 if(sqlite3_bind_blob(m_statement,column+1,data,length,SQLITE_TRANSIENT)==SQLITE_OK)\r
 162                 {\r
 163                         return true;\r
 164                 }\r
 165                 else\r
 166                 {\r
 167                         return false;\r
 168                 }\r
 169         }\r
 170         else\r
 171         {\r
 172                 return false;\r
 173         }\r
 174 }\r
 175 \r
 176 void Statement::Finalize()\r
 177 {\r
 178         if(m_statement)\r
 179         {\r
 180                 //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
 181                 PThread::Guard g(DB::Instance()->m_mutex);\r
 182                 m_statementcount[m_statement]--;\r
 183                 if(m_statementcount[m_statement]<=0)\r
 184                 {\r
 185                         m_statementcount.erase(m_statement);\r
 186                         sqlite3_finalize(m_statement);\r
 187                 }\r
 188                 m_statement=NULL;\r
 189         }\r
 190 }\r
 191 \r
 192 Statement &Statement::operator=(const Statement &rhs)\r
 193 {\r
 194         if(&rhs!=this)\r
 195         {\r
 196                 Finalize();\r
 197 \r
 198                 m_statement=rhs.m_statement;\r
 199                 m_parametercount=rhs.m_parametercount;\r
 200                 m_resultcolumncount=rhs.m_resultcolumncount;\r
 201                 m_rowreturned=rhs.m_rowreturned;\r
 202 \r
 203                 if(m_statement)\r
 204                 {\r
 205                         //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
 206                         PThread::Guard g(DB::Instance()->m_mutex);\r
 207                         m_statementcount[m_statement]++;\r
 208                 }\r
 209         }\r
 210         return *this;\r
 211 }\r
 212 \r
 213 const bool Statement::Reset()\r
 214 {\r
 215         if(Valid())\r
 216         {\r
 217                 //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
 218                 PThread::Guard g(DB::Instance()->m_mutex);\r
 219                 if(sqlite3_reset(m_statement)==SQLITE_OK)\r
 220                 {\r
 221                         return true;\r
 222                 }\r
 223                 else\r
 224                 {\r
 225                         return false;\r
 226                 }\r
 227         }\r
 228         else\r
 229         {\r
 230                 return false;\r
 231         }\r
 232 }\r
 233 \r
 234 const bool Statement::ResultBlob(const int column, void *data, int &length)\r
 235 {\r
 236         if(Valid() && column>=0 && column<m_resultcolumncount)\r
 237         {\r
 238                 //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
 239                 PThread::Guard g(DB::Instance()->m_mutex);\r
 240                 data=(void *)sqlite3_column_blob(m_statement,column);\r
 241                 length=sqlite3_column_bytes(m_statement,column);\r
 242                 return true;\r
 243         }\r
 244         else\r
 245         {\r
 246                 return false;\r
 247         }\r
 248 }\r
 249 \r
 250 const bool Statement::ResultDouble(const int column, double &result)\r
 251 {\r
 252         if(Valid() && column>=0 && column<m_resultcolumncount)\r
 253         {\r
 254                 //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
 255                 PThread::Guard g(DB::Instance()->m_mutex);\r
 256                 result=sqlite3_column_double(m_statement,column);\r
 257                 return true;\r
 258         }\r
 259         else\r
 260         {\r
 261                 return false;\r
 262         }\r
 263 }\r
 264 \r
 265 const bool Statement::ResultInt(const int column, int &result)\r
 266 {\r
 267         if(Valid() && column>=0 && column<m_resultcolumncount)\r
 268         {\r
 269                 //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
 270                 PThread::Guard g(DB::Instance()->m_mutex);\r
 271                 result=sqlite3_column_int(m_statement,column);\r
 272                 return true;\r
 273         }\r
 274         else\r
 275         {\r
 276                 return false;\r
 277         }\r
 278 }\r
 279 \r
 280 const bool Statement::ResultNull(const int column)\r
 281 {\r
 282         if(Valid() && column>=0 && column<m_resultcolumncount)\r
 283         {\r
 284                 //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
 285                 PThread::Guard g(DB::Instance()->m_mutex);\r
 286                 if(sqlite3_column_type(m_statement,column)==SQLITE_NULL)\r
 287                 {\r
 288                         return true;\r
 289                 }\r
 290                 else\r
 291                 {\r
 292                         return false;\r
 293                 }\r
 294         }\r
 295         else\r
 296         {\r
 297                 return false;\r
 298         }\r
 299 }\r
 300 \r
 301 const bool Statement::ResultText(const int column, std::string &result)\r
 302 {\r
 303         if(Valid() && column>=0 && column<m_resultcolumncount)\r
 304         {\r
 305                 //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
 306                 PThread::Guard g(DB::Instance()->m_mutex);\r
 307                 const unsigned char *cresult=sqlite3_column_text(m_statement,column);\r
 308                 if(cresult)\r
 309                 {\r
 310                         result=(char *)cresult;\r
 311                 }\r
 312                 else\r
 313                 {\r
 314                         result="";\r
 315                 }\r
 316                 return true;\r
 317         }\r
 318         else\r
 319         {\r
 320                 return false;\r
 321         }\r
 322 }\r
 323 \r
 324 const bool Statement::Step(const bool saveinsertrowid)\r
 325 {\r
 326         m_rowreturned=false;\r
 327         if(Valid())\r
 328         {\r
 329                 //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
 330                 PThread::Guard g(DB::Instance()->m_mutex);\r
 331                 int result=sqlite3_step(m_statement);\r
 332                 if(result==SQLITE_OK || result==SQLITE_ROW || result==SQLITE_DONE)\r
 333                 {\r
 334                         if(result==SQLITE_ROW)\r
 335                         {\r
 336                                 m_rowreturned=true;\r
 337                         }\r
 338                         if(saveinsertrowid)\r
 339                         {\r
 340                                 m_lastinsertrowid=sqlite3_last_insert_rowid(DB::Instance()->GetDB());\r
 341                         }\r
 342                         return true;\r
 343                 }\r
 344                 else\r
 345                 {\r
 346                         return false;\r
 347                 }\r
 348         }\r
 349         else\r
 350         {\r
 351                 return false;\r
 352         }\r
 353 }\r
 354 \r
 355 const bool Statement::Valid()\r
 356 {\r
 357         //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
 358         PThread::Guard g(DB::Instance()->m_mutex);\r
 359         return m_statement ? true : false ;\r
 360 }\r
 361 \r
 362 }       // namespace\r