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