pdns/ssqlite3.cc

   1 /*  SQLite backend for PowerDNS
   2  *  Copyright (C) 2003, Michel Stol <michel@powerdns.com>
   3  *
   4  *  This program is free software; you can redistribute it and/or modify
   5  *  it under the terms of the GNU General Public License version 2
   6  *  as published by the Free Software Foundation.
   7  *
   8  *  Additionally, the license of this program contains a special
   9  *  exception which allows to distribute the program in binary form when
  10  *  it is linked against OpenSSL.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif
  25 #include <string>
  26 #include <sstream>
  27 #include "ssqlite3.hh"
  28 #include <iostream>
  29 #include <fstream>
  30 #include "pdns/logger.hh"
  31 #include "misc.hh"
  32 #include "utility.hh"
  33 #include <unistd.h>
  34
  35 /*
  36 ** Set all the parameters in the compiled SQL statement to NULL.
  37 *
  38 * copied from sqlite 3.3.6 // cmouse
  39 */
  40 #if SQLITE_VERSION_NUMBER < 3003009
  41 static int pdns_sqlite3_clear_bindings(sqlite3_stmt *pStmt){
  42   int i;
  43   int rc = SQLITE_OK;
  44   for(i=1; rc==SQLITE_OK && i<=sqlite3_bind_parameter_count(pStmt); i++){
  45     rc = sqlite3_bind_null(pStmt, i);
  46   }
  47   return rc;
  48 }
  49 #endif
  50
  51 static string SSQLite3ErrorString(sqlite3 *db)
  52 {
  53   return string(sqlite3_errmsg(db)+string(" (")+std::to_string(sqlite3_extended_errcode(db))+string(")"));
  54 }
  55
  56 class SSQLite3Statement: public SSqlStatement
  57 {
  58 public:
  59   SSQLite3Statement(SSQLite3 *db, bool dolog, const string& query) :
  60     d_query(query),
  61     d_db(db),
  62     d_dolog(dolog)
  63   {
  64   }
  65
  66   int name2idx(const string& name) {
  67     string zName = string(":")+name;
  68     prepareStatement();
  69     return sqlite3_bind_parameter_index(d_stmt, zName.c_str());
  70     // XXX: support @ and $?
  71   }
  72
  73   SSqlStatement* bind(const string& name, bool value) { int idx = name2idx(name); if (idx>0) { sqlite3_bind_int(d_stmt, idx, value ? 1 : 0); }; return this; }
  74   SSqlStatement* bind(const string& name, int value) { int idx = name2idx(name); if (idx>0) { sqlite3_bind_int(d_stmt, idx, value); }; return this; }
  75   SSqlStatement* bind(const string& name, uint32_t value) { int idx = name2idx(name); if (idx>0) { sqlite3_bind_int64(d_stmt, idx, value); }; return this; }
  76   SSqlStatement* bind(const string& name, long value) { int idx = name2idx(name); if (idx>0) { sqlite3_bind_int64(d_stmt, idx, value); }; return this; }
  77   SSqlStatement* bind(const string& name, unsigned long value) { int idx = name2idx(name); if (idx>0) { sqlite3_bind_int64(d_stmt, idx, value); }; return this; }
  78   SSqlStatement* bind(const string& name, long long value) { int idx = name2idx(name); if (idx>0) { sqlite3_bind_int64(d_stmt, idx, value); }; return this; };
  79   SSqlStatement* bind(const string& name, unsigned long long value) { int idx = name2idx(name); if (idx>0) { sqlite3_bind_int64(d_stmt, idx, value); }; return this; }
  80   SSqlStatement* bind(const string& name, const std::string& value) { int idx = name2idx(name); if (idx>0) { sqlite3_bind_text(d_stmt, idx, value.c_str(), value.size(), SQLITE_TRANSIENT); }; return this; }
  81   SSqlStatement* bindNull(const string& name) { int idx = name2idx(name); if (idx>0) { sqlite3_bind_null(d_stmt, idx); }; return this; }
  82
  83   SSqlStatement* execute() {
  84     prepareStatement();
  85     if (d_dolog) {
  86       g_log<<Logger::Warning<< "Query "<<((long)(void*)this)<<": " << d_query << endl;
  87       d_dtime.set();
  88     }
  89     int attempts = d_db->inTransaction(); // try only once
  90     while(attempts < 2 && (d_rc = sqlite3_step(d_stmt)) == SQLITE_BUSY) attempts++;
  91
  92     if (d_rc != SQLITE_ROW && d_rc != SQLITE_DONE) {
  93       // failed.
  94       releaseStatement();
  95       if (d_rc == SQLITE_CANTOPEN)
  96         throw SSqlException(string("CANTOPEN error in sqlite3, often caused by unwritable sqlite3 db *directory*: ")+SSQLite3ErrorString(d_db->db()));
  97       throw SSqlException(string("Error while retrieving SQLite query results: ")+SSQLite3ErrorString(d_db->db()));
  98     }
  99     if(d_dolog)
 100       g_log<<Logger::Warning<< "Query "<<((long)(void*)this)<<": "<<d_dtime.udiffNoReset()<<" usec to execute"<<endl;
 101     return this;
 102   }
 103   bool hasNextRow() {
 104     if(d_dolog && d_rc != SQLITE_ROW) {
 105       g_log<<Logger::Warning<< "Query "<<((long)(void*)this)<<": "<<d_dtime.udiffNoReset()<<" total usec to last row"<<endl;
 106     }
 107     return d_rc == SQLITE_ROW;
 108   }
 109
 110   SSqlStatement* nextRow(row_t& row) {
 111     row.clear();
 112     int numCols = sqlite3_column_count(d_stmt);
 113     row.reserve(numCols); // preallocate memory
 114     // Another row received, process it.
 115     for ( int i=0; i<numCols; i++)
 116     {
 117       if (sqlite3_column_type(d_stmt,i) == SQLITE_NULL) {
 118         row.emplace_back("");
 119       } else {
 120         const char *pData = (const char*) sqlite3_column_text(d_stmt, i);
 121         row.emplace_back(pData, sqlite3_column_bytes(d_stmt, i));
 122       }
 123     }
 124     d_rc = sqlite3_step(d_stmt);
 125     return this;
 126   }
 127
 128   SSqlStatement* getResult(result_t& result) {
 129     result.clear();
 130     while(hasNextRow()) {
 131       row_t row;
 132       nextRow(row);
 133       result.push_back(std::move(row));
 134     }
 135     return this;
 136   }
 137
 138   SSqlStatement* reset() {
 139     sqlite3_reset(d_stmt);
 140 #if SQLITE_VERSION_NUMBER >= 3003009
 141     sqlite3_clear_bindings(d_stmt);
 142 #else
 143     pdns_sqlite3_clear_bindings(d_stmt);
 144 #endif
 145     return this;
 146   }
 147
 148   ~SSQLite3Statement() {
 149     // deallocate if necessary
 150     releaseStatement();
 151   }
 152
 153   const string& getQuery() { return d_query; };
 154 private:
 155   string d_query;
 156   DTime d_dtime;
 157   sqlite3_stmt* d_stmt{nullptr};
 158   SSQLite3* d_db{nullptr};
 159   int d_rc{0};
 160   bool d_dolog;
 161   bool d_prepared{false};
 162
 163   void prepareStatement() {
 164     const char *pTail;
 165
 166     if (d_prepared) return;
 167 #if SQLITE_VERSION_NUMBER >= 3003009
 168     if (sqlite3_prepare_v2(d_db->db(), d_query.c_str(), -1, &d_stmt, &pTail ) != SQLITE_OK)
 169 #else
 170     if (sqlite3_prepare(d_db->db(), d_query.c_str(), -1, &d_stmt, &pTail ) != SQLITE_OK)
 171 #endif
 172     {
 173       releaseStatement();
 174       throw SSqlException(string("Unable to compile SQLite statement : '")+d_query+"': "+SSQLite3ErrorString(d_db->db()));
 175     }
 176     if (pTail && strlen(pTail)>0)
 177       g_log<<Logger::Warning<<"Sqlite3 command partially processed. Unprocessed part: "<<pTail<<endl;
 178     d_prepared = true;
 179   }
 180
 181   void releaseStatement() {
 182     if (d_stmt)
 183       sqlite3_finalize(d_stmt);
 184     d_stmt = nullptr;
 185     d_prepared = false;
 186   }
 187 };
 188
 189 // Constructor.
 190 SSQLite3::SSQLite3( const std::string & database, const std::string & journalmode, bool creat )
 191 {
 192   if (access( database.c_str(), F_OK ) == -1){
 193     if (!creat)
 194       throw sPerrorException( "SQLite database '"+database+"' does not exist yet" );
 195   } else {
 196     if (creat)
 197       throw sPerrorException( "SQLite database '"+database+"' already exists" );
 198   }
 199
 200   if ( sqlite3_open( database.c_str(), &m_pDB)!=SQLITE_OK )
 201     throw sPerrorException( "Could not connect to the SQLite database '" + database + "'" );
 202   m_dolog = 0;
 203   m_in_transaction = false;
 204   sqlite3_busy_handler(m_pDB, busyHandler, 0);
 205
 206   if(journalmode.length())
 207     execute("PRAGMA journal_mode="+journalmode);
 208 }
 209
 210 void SSQLite3::setLog(bool state)
 211 {
 212   m_dolog=state;
 213 }
 214
 215 // Destructor.
 216 SSQLite3::~SSQLite3()
 217 {
 218   int ret;
 219   for(int n = 0; n < 2 ; ++n) {
 220     if((ret =sqlite3_close( m_pDB )) != SQLITE_OK) {
 221       if(n || ret != SQLITE_BUSY) { // if we have SQLITE_BUSY, and a working m_Pstmt, try finalize
 222         cerr<<"Unable to close down sqlite connection: "<<ret<<endl;
 223         abort();
 224       }
 225     }
 226     else
 227       break;
 228   }
 229 }
 230
 231 std::unique_ptr<SSqlStatement> SSQLite3::prepare(const string& query, int nparams __attribute__((unused))) {
 232   return std::unique_ptr<SSqlStatement>(new SSQLite3Statement(this, m_dolog, query));
 233 }
 234
 235 void SSQLite3::execute(const string& query) {
 236   char *errmsg;
 237   std::string errstr1;
 238   int rc = sqlite3_exec(m_pDB, query.c_str(), nullptr, nullptr, &errmsg);
 239   if (rc != SQLITE_OK) {
 240     errstr1 = errmsg;
 241     sqlite3_free(errmsg);
 242   }
 243   if (rc == SQLITE_BUSY) {
 244     if (m_in_transaction) {
 245       throw SSqlException("Failed to execute query: " + errstr1);
 246     } else {
 247       rc = sqlite3_exec(m_pDB, query.c_str(), NULL, NULL, &errmsg);
 248       std::string errstr2;
 249       if (rc != SQLITE_OK)  {
 250         errstr2 = errmsg;
 251         sqlite3_free(errmsg);
 252         throw SSqlException("Failed to execute query: " + errstr2);
 253       }
 254     }
 255   } else if (rc != SQLITE_OK) {
 256     throw SSqlException("Failed to execute query: " + errstr1);
 257   }
 258 }
 259
 260 int SSQLite3::busyHandler(void*, int)
 261 {
 262   Utility::usleep(1000);
 263   return 1;
 264 }
 265
 266 void SSQLite3::startTransaction() {
 267   execute("begin");
 268   m_in_transaction = true;
 269 }
 270
 271 void SSQLite3::rollback() {
 272   execute("rollback");
 273   m_in_transaction = false;
 274 }
 275
 276 void SSQLite3::commit() {
 277   execute("commit");
 278   m_in_transaction = false;
 279 }
 280
 281 // Constructs a SSqlException object.
 282 SSqlException SSQLite3::sPerrorException( const std::string & reason )
 283 {
 284   return SSqlException( reason );
 285 }