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                 int bloblength=sqlite3_column_bytes(m_statement,column);\r
 233                 if(bloblength>length)\r
 234                 {\r
 235                         bloblength=length;\r
 236                 }\r
 237                 if(bloblength<length)\r
 238                 {\r
 239                         length=bloblength;\r
 240                 }\r
 241                 const void *blobptr=sqlite3_column_blob(m_statement,column);\r
 242                 if(blobptr)\r
 243                 {\r
 244                         std::copy((unsigned char *)blobptr,(unsigned char *)blobptr+bloblength,(unsigned char *)data);\r
 245                 }\r
 246                 else\r
 247                 {\r
 248                         length=0;\r
 249                 }\r
 250                 return true;\r
 251         }\r
 252         else\r
 253         {\r
 254                 return false;\r
 255         }\r
 256 }\r
 257 \r
 258 const bool Statement::ResultDouble(const int column, double &result)\r
 259 {\r
 260         if(Valid() && column>=0 && column<m_resultcolumncount)\r
 261         {\r
 262                 //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
 263                 //PThread::Guard g(DB::Instance()->m_mutex);\r
 264                 result=sqlite3_column_double(m_statement,column);\r
 265                 return true;\r
 266         }\r
 267         else\r
 268         {\r
 269                 return false;\r
 270         }\r
 271 }\r
 272 \r
 273 const bool Statement::ResultInt(const int column, int &result)\r
 274 {\r
 275         if(Valid() && column>=0 && column<m_resultcolumncount)\r
 276         {\r
 277                 //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
 278                 //PThread::Guard g(DB::Instance()->m_mutex);\r
 279                 result=sqlite3_column_int(m_statement,column);\r
 280                 return true;\r
 281         }\r
 282         else\r
 283         {\r
 284                 return false;\r
 285         }\r
 286 }\r
 287 \r
 288 const bool Statement::ResultNull(const int column)\r
 289 {\r
 290         if(Valid() && column>=0 && column<m_resultcolumncount)\r
 291         {\r
 292                 //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
 293                 //PThread::Guard g(DB::Instance()->m_mutex);\r
 294                 if(sqlite3_column_type(m_statement,column)==SQLITE_NULL)\r
 295                 {\r
 296                         return true;\r
 297                 }\r
 298                 else\r
 299                 {\r
 300                         return false;\r
 301                 }\r
 302         }\r
 303         else\r
 304         {\r
 305                 return false;\r
 306         }\r
 307 }\r
 308 \r
 309 const bool Statement::ResultText(const int column, std::string &result)\r
 310 {\r
 311         if(Valid() && column>=0 && column<m_resultcolumncount)\r
 312         {\r
 313                 //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
 314                 //PThread::Guard g(DB::Instance()->m_mutex);\r
 315                 const unsigned char *cresult=sqlite3_column_text(m_statement,column);\r
 316                 if(cresult)\r
 317                 {\r
 318                         result=(char *)cresult;\r
 319                 }\r
 320                 else\r
 321                 {\r
 322                         result="";\r
 323                 }\r
 324                 return true;\r
 325         }\r
 326         else\r
 327         {\r
 328                 return false;\r
 329         }\r
 330 }\r
 331 \r
 332 const bool Statement::Step(const bool saveinsertrowid)\r
 333 {\r
 334         m_rowreturned=false;\r
 335         if(Valid())\r
 336         {\r
 337                 //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
 338                 PThread::Guard g(DB::Instance()->m_mutex);\r
 339                 int result=sqlite3_step(m_statement);\r
 340                 if(result==SQLITE_OK || result==SQLITE_ROW || result==SQLITE_DONE)\r
 341                 {\r
 342                         if(result==SQLITE_ROW)\r
 343                         {\r
 344                                 m_rowreturned=true;\r
 345                         }\r
 346                         if(saveinsertrowid)\r
 347                         {\r
 348                                 m_lastinsertrowid=sqlite3_last_insert_rowid(DB::Instance()->GetDB());\r
 349                         }\r
 350                         return true;\r
 351                 }\r
 352                 else\r
 353                 {\r
 354                         return false;\r
 355                 }\r
 356         }\r
 357         else\r
 358         {\r
 359                 return false;\r
 360         }\r
 361 }\r
 362 \r
 363 const bool Statement::Valid()\r
 364 {\r
 365         //ZThread::Guard<ZThread::Mutex> g(DB::instance()->m_mutex);\r
 366         PThread::Guard g(DB::Instance()->m_mutex);\r
 367         return m_statement ? true : false ;\r
 368 }\r
 369 \r
 370 }       // namespace\r