zypp/cache/sqlite3x/sqlite3x_connection.cpp

   1 /*\r
   2         Copyright (C) 2004-2005 Cory Nelson\r
   3 \r
   4         This software is provided 'as-is', without any express or implied\r
   5         warranty.  In no event will the authors be held liable for any damages\r
   6         arising from the use of this software.\r
   7 \r
   8         Permission is granted to anyone to use this software for any purpose,\r
   9         including commercial applications, and to alter it and redistribute it\r
  10         freely, subject to the following restrictions:\r
  11 \r
  12         1. The origin of this software must not be misrepresented; you must not\r
  13                 claim that you wrote the original software. If you use this software\r
  14                 in a product, an acknowledgment in the product documentation would be\r
  15                 appreciated but is not required.\r
  16         2. Altered source versions must be plainly marked as such, and must not be\r
  17                 misrepresented as being the original software.\r
  18         3. This notice may not be removed or altered from any source distribution.\r
  19 \r
  20         CVS Info :\r
  21                 $Author: phrostbyte $\r
  22                 $Date: 2005/06/16 20:46:40 $\r
  23                 $Revision: 1.1 $\r
  24 */\r
  25 \r
  26 /*\r
  27   this source contains modifications by Novell Inc.\r
  28 \r
  29   Changes:\r
  30 \r
  31   * dmacvicar@novell.com\r
  32     Wrap sqlite3_exec\r
  33 \r
  34 */\r
  35 \r
  36 #include <sqlite3.h>\r
  37 #include "sqlite3x.hpp"\r
  38 \r
  39 static int global_progress_handler(void* ptr)\r
  40 {\r
  41   //RepoImpl *r = dynamic_cast<RepoImpl *>(ptr);\r
  42   sqlite3x::sqlite3_connection *r = (sqlite3x::sqlite3_connection *)(ptr);\r
  43   if ( r )\r
  44     return r->_progress_handler_accessor(ptr);\r
  45   return 0;\r
  46 }\r
  47 \r
  48 namespace sqlite3x\r
  49 {\r
  50 \r
  51 int sqlite3_connection::_progress_handler_accessor(void* ptr)\r
  52 {\r
  53   if ( _ticks.tick() )\r
  54     return 0;\r
  55   return 1;\r
  56 }\r
  57  \r
  58 sqlite3_connection::sqlite3_connection() : db(NULL)\r
  59 {}\r
  60 \r
  61 sqlite3_connection::sqlite3_connection(const char *db) : db(NULL)\r
  62 {\r
  63   this->open(db);\r
  64 }\r
  65 \r
  66 sqlite3_connection::sqlite3_connection(const wchar_t *db) : db(NULL)\r
  67 {\r
  68   this->open(db);\r
  69 }\r
  70 \r
  71 sqlite3_connection::~sqlite3_connection()\r
  72 {\r
  73   _ticks = zypp::ProgressData();\r
  74   resetprogresshandler();\r
  75   if (this->db) sqlite3_close(this->db);\r
  76 }\r
  77 \r
  78 void sqlite3_connection::setprogresshandler( const zypp::ProgressData::ReceiverFnc &fnc,\r
  79                                              int n)\r
  80 {\r
  81   _ticks.sendTo(fnc);\r
  82   if ( fnc )\r
  83     sqlite3_progress_handler(db, n, global_progress_handler, (void*)this);\r
  84   else\r
  85     sqlite3_progress_handler(db, n, NULL, (void*)this);\r
  86 }\r
  87 \r
  88 void sqlite3_connection::resetprogresshandler()\r
  89 {\r
  90   _ticks = zypp::ProgressData();\r
  91   sqlite3_progress_handler(db, 0, NULL, (void*)this);\r
  92 }\r
  93 \r
  94 void sqlite3_connection::open(const char *db)\r
  95 {\r
  96   if (sqlite3_open(db, &this->db)!=SQLITE_OK)\r
  97   {\r
  98     std::string msg( "unable to open database at " );\r
  99     msg += ( db ? db : "NULL" );\r
 100     SQLITE3X_THROW(database_error(msg));\r
 101   }\r
 102 }\r
 103 \r
 104 void sqlite3_connection::open(const wchar_t *db)\r
 105 {\r
 106   if (sqlite3_open16(db, &this->db)!=SQLITE_OK)\r
 107     SQLITE3X_THROW(database_error("unable to open database"));\r
 108 }\r
 109 \r
 110 void sqlite3_connection::close()\r
 111 {\r
 112   if (this->db)\r
 113   {\r
 114     if (sqlite3_close(this->db)!=SQLITE_OK)\r
 115       SQLITE3X_THROW(database_error(*this));\r
 116     this->db=NULL;\r
 117   }\r
 118 }\r
 119 \r
 120 long long sqlite3_connection::insertid()\r
 121 {\r
 122   if (!this->db) throw database_error("database is not open");\r
 123   return sqlite3_last_insert_rowid(this->db);\r
 124 }\r
 125 \r
 126 void sqlite3_connection::setbusytimeout(int ms)\r
 127 {\r
 128   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 129 \r
 130   if (sqlite3_busy_timeout(this->db, ms)!=SQLITE_OK)\r
 131     SQLITE3X_THROW(database_error(*this));\r
 132 }\r
 133 \r
 134 void sqlite3_connection::executenonquery(const char *sql)\r
 135 {\r
 136   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 137   sqlite3_command(*this, sql).executenonquery();\r
 138 }\r
 139 \r
 140 void sqlite3_connection::executenonquery(const wchar_t *sql)\r
 141 {\r
 142   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 143   sqlite3_command(*this, sql).executenonquery();\r
 144 }\r
 145 \r
 146 void sqlite3_connection::executenonquery(const std::string &sql)\r
 147 {\r
 148   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 149   sqlite3_command(*this, sql).executenonquery();\r
 150 }\r
 151 \r
 152 void sqlite3_connection::executenonquery(const std::wstring &sql)\r
 153 {\r
 154   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 155   sqlite3_command(*this, sql).executenonquery();\r
 156 }\r
 157 \r
 158 int sqlite3_connection::executeint(const char *sql)\r
 159 {\r
 160   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 161   return sqlite3_command(*this, sql).executeint();\r
 162 }\r
 163 \r
 164 int sqlite3_connection::executeint(const wchar_t *sql)\r
 165 {\r
 166   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 167   return sqlite3_command(*this, sql).executeint();\r
 168 }\r
 169 \r
 170 int sqlite3_connection::executeint(const std::string &sql)\r
 171 {\r
 172   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 173   return sqlite3_command(*this, sql).executeint();\r
 174 }\r
 175 \r
 176 int sqlite3_connection::executeint(const std::wstring &sql)\r
 177 {\r
 178   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 179   return sqlite3_command(*this, sql).executeint();\r
 180 }\r
 181 \r
 182 long long sqlite3_connection::executeint64(const char *sql)\r
 183 {\r
 184   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 185   return sqlite3_command(*this, sql).executeint64();\r
 186 }\r
 187 \r
 188 long long sqlite3_connection::executeint64(const wchar_t *sql)\r
 189 {\r
 190   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 191   return sqlite3_command(*this, sql).executeint64();\r
 192 }\r
 193 \r
 194 long long sqlite3_connection::executeint64(const std::string &sql)\r
 195 {\r
 196   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 197   return sqlite3_command(*this, sql).executeint64();\r
 198 }\r
 199 \r
 200 long long sqlite3_connection::executeint64(const std::wstring &sql)\r
 201 {\r
 202   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 203   return sqlite3_command(*this, sql).executeint64();\r
 204 }\r
 205 \r
 206 double sqlite3_connection::executedouble(const char *sql)\r
 207 {\r
 208   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 209   return sqlite3_command(*this, sql).executedouble();\r
 210 }\r
 211 \r
 212 double sqlite3_connection::executedouble(const wchar_t *sql)\r
 213 {\r
 214   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 215   return sqlite3_command(*this, sql).executedouble();\r
 216 }\r
 217 \r
 218 double sqlite3_connection::executedouble(const std::string &sql)\r
 219 {\r
 220   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 221   return sqlite3_command(*this, sql).executedouble();\r
 222 }\r
 223 \r
 224 double sqlite3_connection::executedouble(const std::wstring &sql)\r
 225 {\r
 226   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 227   return sqlite3_command(*this, sql).executedouble();\r
 228 }\r
 229 \r
 230 std::string sqlite3_connection::executestring(const char *sql)\r
 231 {\r
 232   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 233   return sqlite3_command(*this, sql).executestring();\r
 234 }\r
 235 \r
 236 std::string sqlite3_connection::executestring(const wchar_t *sql)\r
 237 {\r
 238   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 239   return sqlite3_command(*this, sql).executestring();\r
 240 }\r
 241 \r
 242 std::string sqlite3_connection::executestring(const std::string &sql)\r
 243 {\r
 244   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 245   return sqlite3_command(*this, sql).executestring();\r
 246 }\r
 247 \r
 248 std::string sqlite3_connection::executestring(const std::wstring &sql)\r
 249 {\r
 250   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 251   return sqlite3_command(*this, sql).executestring();\r
 252 }\r
 253 \r
 254 std::wstring sqlite3_connection::executestring16(const char *sql)\r
 255 {\r
 256   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 257   return sqlite3_command(*this, sql).executestring16();\r
 258 }\r
 259 \r
 260 std::wstring sqlite3_connection::executestring16(const wchar_t *sql)\r
 261 {\r
 262   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 263   return sqlite3_command(*this, sql).executestring16();\r
 264 }\r
 265 \r
 266 std::wstring sqlite3_connection::executestring16(const std::string &sql)\r
 267 {\r
 268   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 269   return sqlite3_command(*this, sql).executestring16();\r
 270 }\r
 271 \r
 272 std::wstring sqlite3_connection::executestring16(const std::wstring &sql)\r
 273 {\r
 274   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 275   return sqlite3_command(*this, sql).executestring16();\r
 276 }\r
 277 \r
 278 std::string sqlite3_connection::executeblob(const char *sql)\r
 279 {\r
 280   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 281   return sqlite3_command(*this, sql).executeblob();\r
 282 }\r
 283 \r
 284 std::string sqlite3_connection::executeblob(const wchar_t *sql)\r
 285 {\r
 286   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 287   return sqlite3_command(*this, sql).executeblob();\r
 288 }\r
 289 \r
 290 std::string sqlite3_connection::executeblob(const std::string &sql)\r
 291 {\r
 292   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 293   return sqlite3_command(*this, sql).executeblob();\r
 294 }\r
 295 \r
 296 std::string sqlite3_connection::executeblob(const std::wstring &sql)\r
 297 {\r
 298   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 299   return sqlite3_command(*this, sql).executeblob();\r
 300 }\r
 301 \r
 302 void sqlite3_connection::execute(const std::string &sql)\r
 303 {\r
 304   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 305 \r
 306   char *err_msg;\r
 307 \r
 308   if ( sqlite3_exec( this->db, sql.c_str(), NULL, NULL, &err_msg ) != SQLITE_OK )\r
 309   {\r
 310     std::string err(err_msg);\r
 311     sqlite3_free(err_msg);\r
 312     SQLITE3X_THROW(database_error(err.c_str()));\r
 313   }\r
 314 }\r
 315 \r
 316 }\r