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