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   if (this->db) sqlite3_close(this->db);\r
  74 }\r
  75 \r
  76 void sqlite3_connection::setprogresshandler( const zypp::ProgressData::ReceiverFnc &fnc,\r
  77                                              int n)\r
  78 {\r
  79   _ticks.sendTo(fnc);\r
  80   if ( fnc )\r
  81     sqlite3_progress_handler(db, n, global_progress_handler, (void*)this);\r
  82   else\r
  83     sqlite3_progress_handler(db, n, NULL, (void*)this);\r
  84 }\r
  85 \r
  86 void sqlite3_connection::resetprogresshandler()\r
  87 {\r
  88   sqlite3_progress_handler(db, 0, NULL, (void*)this);\r
  89 }\r
  90 \r
  91 void sqlite3_connection::open(const char *db)\r
  92 {\r
  93   if (sqlite3_open(db, &this->db)!=SQLITE_OK)\r
  94   {\r
  95     std::string msg( "unable to open database at " );\r
  96     msg += ( db ? db : "NULL" );\r
  97     SQLITE3X_THROW(database_error(msg));\r
  98   }\r
  99 }\r
 100 \r
 101 void sqlite3_connection::open(const wchar_t *db)\r
 102 {\r
 103   if (sqlite3_open16(db, &this->db)!=SQLITE_OK)\r
 104     SQLITE3X_THROW(database_error("unable to open database"));\r
 105 }\r
 106 \r
 107 void sqlite3_connection::close()\r
 108 {\r
 109   if (this->db)\r
 110   {\r
 111     if (sqlite3_close(this->db)!=SQLITE_OK)\r
 112       SQLITE3X_THROW(database_error(*this));\r
 113     this->db=NULL;\r
 114   }\r
 115 }\r
 116 \r
 117 long long sqlite3_connection::insertid()\r
 118 {\r
 119   if (!this->db) throw database_error("database is not open");\r
 120   return sqlite3_last_insert_rowid(this->db);\r
 121 }\r
 122 \r
 123 void sqlite3_connection::setbusytimeout(int ms)\r
 124 {\r
 125   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 126 \r
 127   if (sqlite3_busy_timeout(this->db, ms)!=SQLITE_OK)\r
 128     SQLITE3X_THROW(database_error(*this));\r
 129 }\r
 130 \r
 131 void sqlite3_connection::executenonquery(const char *sql)\r
 132 {\r
 133   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 134   sqlite3_command(*this, sql).executenonquery();\r
 135 }\r
 136 \r
 137 void sqlite3_connection::executenonquery(const wchar_t *sql)\r
 138 {\r
 139   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 140   sqlite3_command(*this, sql).executenonquery();\r
 141 }\r
 142 \r
 143 void sqlite3_connection::executenonquery(const std::string &sql)\r
 144 {\r
 145   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 146   sqlite3_command(*this, sql).executenonquery();\r
 147 }\r
 148 \r
 149 void sqlite3_connection::executenonquery(const std::wstring &sql)\r
 150 {\r
 151   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 152   sqlite3_command(*this, sql).executenonquery();\r
 153 }\r
 154 \r
 155 int sqlite3_connection::executeint(const char *sql)\r
 156 {\r
 157   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 158   return sqlite3_command(*this, sql).executeint();\r
 159 }\r
 160 \r
 161 int sqlite3_connection::executeint(const wchar_t *sql)\r
 162 {\r
 163   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 164   return sqlite3_command(*this, sql).executeint();\r
 165 }\r
 166 \r
 167 int sqlite3_connection::executeint(const std::string &sql)\r
 168 {\r
 169   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 170   return sqlite3_command(*this, sql).executeint();\r
 171 }\r
 172 \r
 173 int sqlite3_connection::executeint(const std::wstring &sql)\r
 174 {\r
 175   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 176   return sqlite3_command(*this, sql).executeint();\r
 177 }\r
 178 \r
 179 long long sqlite3_connection::executeint64(const char *sql)\r
 180 {\r
 181   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 182   return sqlite3_command(*this, sql).executeint64();\r
 183 }\r
 184 \r
 185 long long sqlite3_connection::executeint64(const wchar_t *sql)\r
 186 {\r
 187   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 188   return sqlite3_command(*this, sql).executeint64();\r
 189 }\r
 190 \r
 191 long long sqlite3_connection::executeint64(const std::string &sql)\r
 192 {\r
 193   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 194   return sqlite3_command(*this, sql).executeint64();\r
 195 }\r
 196 \r
 197 long long sqlite3_connection::executeint64(const std::wstring &sql)\r
 198 {\r
 199   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 200   return sqlite3_command(*this, sql).executeint64();\r
 201 }\r
 202 \r
 203 double sqlite3_connection::executedouble(const char *sql)\r
 204 {\r
 205   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 206   return sqlite3_command(*this, sql).executedouble();\r
 207 }\r
 208 \r
 209 double sqlite3_connection::executedouble(const wchar_t *sql)\r
 210 {\r
 211   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 212   return sqlite3_command(*this, sql).executedouble();\r
 213 }\r
 214 \r
 215 double sqlite3_connection::executedouble(const std::string &sql)\r
 216 {\r
 217   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 218   return sqlite3_command(*this, sql).executedouble();\r
 219 }\r
 220 \r
 221 double sqlite3_connection::executedouble(const std::wstring &sql)\r
 222 {\r
 223   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 224   return sqlite3_command(*this, sql).executedouble();\r
 225 }\r
 226 \r
 227 std::string sqlite3_connection::executestring(const char *sql)\r
 228 {\r
 229   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 230   return sqlite3_command(*this, sql).executestring();\r
 231 }\r
 232 \r
 233 std::string sqlite3_connection::executestring(const wchar_t *sql)\r
 234 {\r
 235   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 236   return sqlite3_command(*this, sql).executestring();\r
 237 }\r
 238 \r
 239 std::string sqlite3_connection::executestring(const std::string &sql)\r
 240 {\r
 241   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 242   return sqlite3_command(*this, sql).executestring();\r
 243 }\r
 244 \r
 245 std::string sqlite3_connection::executestring(const std::wstring &sql)\r
 246 {\r
 247   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 248   return sqlite3_command(*this, sql).executestring();\r
 249 }\r
 250 \r
 251 std::wstring sqlite3_connection::executestring16(const char *sql)\r
 252 {\r
 253   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 254   return sqlite3_command(*this, sql).executestring16();\r
 255 }\r
 256 \r
 257 std::wstring sqlite3_connection::executestring16(const wchar_t *sql)\r
 258 {\r
 259   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 260   return sqlite3_command(*this, sql).executestring16();\r
 261 }\r
 262 \r
 263 std::wstring sqlite3_connection::executestring16(const std::string &sql)\r
 264 {\r
 265   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 266   return sqlite3_command(*this, sql).executestring16();\r
 267 }\r
 268 \r
 269 std::wstring sqlite3_connection::executestring16(const std::wstring &sql)\r
 270 {\r
 271   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 272   return sqlite3_command(*this, sql).executestring16();\r
 273 }\r
 274 \r
 275 std::string sqlite3_connection::executeblob(const char *sql)\r
 276 {\r
 277   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 278   return sqlite3_command(*this, sql).executeblob();\r
 279 }\r
 280 \r
 281 std::string sqlite3_connection::executeblob(const wchar_t *sql)\r
 282 {\r
 283   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 284   return sqlite3_command(*this, sql).executeblob();\r
 285 }\r
 286 \r
 287 std::string sqlite3_connection::executeblob(const std::string &sql)\r
 288 {\r
 289   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 290   return sqlite3_command(*this, sql).executeblob();\r
 291 }\r
 292 \r
 293 std::string sqlite3_connection::executeblob(const std::wstring &sql)\r
 294 {\r
 295   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 296   return sqlite3_command(*this, sql).executeblob();\r
 297 }\r
 298 \r
 299 void sqlite3_connection::execute(const std::string &sql)\r
 300 {\r
 301   if (!this->db) SQLITE3X_THROW(database_error("database is not open"));\r
 302 \r
 303   char *err_msg;\r
 304 \r
 305   if ( sqlite3_exec( this->db, sql.c_str(), NULL, NULL, &err_msg ) != SQLITE_OK )\r
 306   {\r
 307     std::string err(err_msg);\r
 308     sqlite3_free(err_msg);\r
 309     SQLITE3X_THROW(database_error(err.c_str()));\r
 310   }\r
 311 }\r
 312 \r
 313 }\r