8470012545

Committed 28 Mar 2024 03:51PM UTC coverage: 59.453% (+0.04%) from 59.413%

Build # 8470012545

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #13999 from rgacogne/ddist-inc-http1-counter-alpn

dnsdist: Fix DNS over HTTP connections/queries counters with `nghttp2`

Run Details

32534 of 87212 branches covered (37.3%)

Branch coverage included in aggregate %.

7 of 7 new or added lines in 1 file covered. (100.0%)

22 existing lines in 7 files now uncovered.

113913 of 159111 relevant lines covered (71.59%)

3214991.63 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

66.77

/pdns/ssqlite3.cc

/*  SQLite backend for PowerDNS
 *  Copyright (C) 2003, Michel Stol <michel@powerdns.com>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2
 *  as published by the Free Software Foundation.
 *
 *  Additionally, the license of this program contains a special
 *  exception which allows to distribute the program in binary form when
 *  it is linked against OpenSSL.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <string>
#include <sstream>
#include "ssqlite3.hh"
#include <iostream>
#include <fstream>
#include <utility>
#include "pdns/logger.hh"
#include "misc.hh"
#include "utility.hh"
#include <unistd.h>

/*
** Set all the parameters in the compiled SQL statement to NULL.
*
* copied from sqlite 3.3.6 // cmouse
*/
#if SQLITE_VERSION_NUMBER < 3003009
static int pdns_sqlite3_clear_bindings(sqlite3_stmt* pStmt)
{
  int i;
  int rc = SQLITE_OK;
  for (i = 1; rc == SQLITE_OK && i <= sqlite3_bind_parameter_count(pStmt); i++) {
    rc = sqlite3_bind_null(pStmt, i);
  }
  return rc;
}
#endif

static string SSQLite3ErrorString(sqlite3* database)
{
  return string(sqlite3_errmsg(database) + string(" (") + std::to_string(sqlite3_extended_errcode(database)) + string(")"));
}

class SSQLite3Statement : public SSqlStatement
{
public:
  SSQLite3Statement(SSQLite3* database, bool dolog, string query) :
    d_query(std::move(query)),
    d_db(database),
    d_dolog(dolog)
  {
  }

  SSQLite3Statement(const SSQLite3Statement&) = delete;
  SSQLite3Statement(SSQLite3Statement&&) = delete;
  SSQLite3Statement& operator=(const SSQLite3Statement&) = delete;
  SSQLite3Statement& operator=(SSQLite3Statement&&) = delete;

  int name2idx(const string& name)
  {
    string zName = string(":") + name;
    prepareStatement();
    return sqlite3_bind_parameter_index(d_stmt, zName.c_str());
    // XXX: support @ and $?
  }

  SSqlStatement* bind(const string& name, bool value) override
  {
    int idx = name2idx(name);
    if (idx > 0) {
      sqlite3_bind_int(d_stmt, idx, value ? 1 : 0);
    };
    return this;
  }

  SSqlStatement* bind(const string& name, int value) override
  {
    int idx = name2idx(name);
    if (idx > 0) {
      sqlite3_bind_int(d_stmt, idx, value);
    };
    return this;
  }

  SSqlStatement* bind(const string& name, uint32_t value) override
  {
    int idx = name2idx(name);
    if (idx > 0) {
      sqlite3_bind_int64(d_stmt, idx, value);
    };
    return this;
  }

  SSqlStatement* bind(const string& name, long value) override
  {
    int idx = name2idx(name);
    if (idx > 0) {
      sqlite3_bind_int64(d_stmt, idx, value);
    };
    return this;
  }

  SSqlStatement* bind(const string& name, unsigned long value) override
  {
    int idx = name2idx(name);
    if (idx > 0) {
      sqlite3_bind_int64(d_stmt, idx, static_cast<sqlite3_int64>(value));
    };
    return this;
  }

  SSqlStatement* bind(const string& name, long long value) override
  {
    int idx = name2idx(name);
    if (idx > 0) {
      sqlite3_bind_int64(d_stmt, idx, value);
    };
    return this;
  };

  SSqlStatement* bind(const string& name, unsigned long long value) override
  {
    int idx = name2idx(name);
    if (idx > 0) {
      sqlite3_bind_int64(d_stmt, idx, static_cast<sqlite3_int64>(value));
    };
    return this;
  }

  SSqlStatement* bind(const string& name, const std::string& value) override
  {
    int idx = name2idx(name);
    if (idx > 0) {
      sqlite3_bind_text(d_stmt, idx, value.c_str(), static_cast<int>(value.size()), SQLITE_TRANSIENT);
    };
    return this;
  }

  SSqlStatement* bindNull(const string& name) override
  {
    int idx = name2idx(name);
    if (idx > 0) {
      sqlite3_bind_null(d_stmt, idx);
    };
    return this;
  }

  SSqlStatement* execute() override
  {
    prepareStatement();
    if (d_dolog) {
      g_log << Logger::Warning << "Query " << this << ": " << d_query << endl;
      d_dtime.set();
    }

    int attempts = d_db->inTransaction() ? 1 : 0; // try only once
    while (attempts < 2 && (d_rc = sqlite3_step(d_stmt)) == SQLITE_BUSY) {
      attempts++;
    }

    if (d_rc != SQLITE_ROW && d_rc != SQLITE_DONE) {
      // failed.
      releaseStatement();
      if (d_rc == SQLITE_CANTOPEN) {
        throw SSqlException(string("CANTOPEN error in sqlite3, often caused by unwritable sqlite3 db *directory*: ") + SSQLite3ErrorString(d_db->db()));
      }
      throw SSqlException(string("Error while retrieving SQLite query results: ") + SSQLite3ErrorString(d_db->db()));
    }
    if (d_dolog) {
      g_log << Logger::Warning << "Query " << this << ": " << d_dtime.udiffNoReset() << " us to execute" << endl;
    }
    return this;
  }

  bool hasNextRow() override
  {
    if (d_dolog && d_rc != SQLITE_ROW) {
      g_log << Logger::Warning << "Query " << this << ": " << d_dtime.udiffNoReset() << " us total to last row" << endl;
    }
    return d_rc == SQLITE_ROW;
  }

  SSqlStatement* nextRow(row_t& row) override
  {
    row.clear();
    int numCols = sqlite3_column_count(d_stmt);
    row.reserve(numCols); // preallocate memory
    // Another row received, process it.
    for (int i = 0; i < numCols; i++) {
      if (sqlite3_column_type(d_stmt, i) == SQLITE_NULL) {
        row.emplace_back("");
      }
      else {
        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-cstyle-cast): SQLite API returns unsigned char strings and std::strings are signed char.
        const char* pData = (const char*)sqlite3_column_text(d_stmt, i);
        row.emplace_back(pData, sqlite3_column_bytes(d_stmt, i));
      }
    }
    d_rc = sqlite3_step(d_stmt);
    return this;
  }

  SSqlStatement* getResult(result_t& result) override
  {
    result.clear();
    while (hasNextRow()) {
      row_t row;
      nextRow(row);
      result.push_back(std::move(row));
    }
    return this;
  }

  SSqlStatement* reset() override
  {
    sqlite3_reset(d_stmt);
#if SQLITE_VERSION_NUMBER >= 3003009
    sqlite3_clear_bindings(d_stmt);
#else
    pdns_sqlite3_clear_bindings(d_stmt);
#endif
    return this;
  }

  ~SSQLite3Statement() override
  {
    // deallocate if necessary
    releaseStatement();
  }

  const string& getQuery() override { return d_query; };

private:
  string d_query;
  DTime d_dtime;
  sqlite3_stmt* d_stmt{nullptr};
  SSQLite3* d_db{nullptr};
  int d_rc{0};
  bool d_dolog;
  bool d_prepared{false};

  void prepareStatement()
  {
    const char* pTail = nullptr;

    if (d_prepared) {
      return;
    }
#if SQLITE_VERSION_NUMBER >= 3003009
    if (sqlite3_prepare_v2(d_db->db(), d_query.c_str(), -1, &d_stmt, &pTail) != SQLITE_OK)
#else
    if (sqlite3_prepare(d_db->db(), d_query.c_str(), -1, &d_stmt, &pTail) != SQLITE_OK)
#endif
    {
      releaseStatement();
      throw SSqlException(string("Unable to compile SQLite statement : '") + d_query + "': " + SSQLite3ErrorString(d_db->db()));
    }
    if ((pTail != nullptr) && strlen(pTail) > 0) {
      g_log << Logger::Warning << "Sqlite3 command partially processed. Unprocessed part: " << pTail << endl;
    }
    d_prepared = true;
  }

  void releaseStatement()
  {
    if (d_stmt != nullptr) {
      sqlite3_finalize(d_stmt);
    }
    d_stmt = nullptr;
    d_prepared = false;
  }
};

// Constructor.
SSQLite3::SSQLite3(const std::string& database, const std::string& journalmode, bool creat)
{
  if (access(database.c_str(), F_OK) == -1) {
    if (!creat) {
      throw SSqlException("SQLite database '" + database + "' does not exist yet");
    }
  }
  else {
    if (creat) {
      throw SSqlException("SQLite database '" + database + "' already exists");
    }
  }

  if (sqlite3_open(database.c_str(), &m_pDB) != SQLITE_OK) {
    throw SSqlException("Could not connect to the SQLite database '" + database + "'");
  }
  m_dolog = false;
  m_in_transaction = false;
  sqlite3_busy_handler(m_pDB, busyHandler, nullptr);

  if (journalmode.length() != 0) {
    executeImpl("PRAGMA journal_mode=" + journalmode);
  }
}

void SSQLite3::setLog(bool state)
{
  m_dolog = state;
}

// Destructor.
SSQLite3::~SSQLite3()
{
  for (int tried = 0;; ++tried) {
    int ret = sqlite3_close(m_pDB);
    if (ret == SQLITE_OK) {
      break;
    }
    cerr << "SQLite3 error state while tearing down database: " << SSQLite3ErrorString(m_pDB) << endl;
    if (tried == 0 && ret == SQLITE_BUSY) {
      continue;
    }
    cerr << "Unable to close down sqlite connection: " << ret << endl;
    abort();
  }
}

std::unique_ptr<SSqlStatement> SSQLite3::prepare(const string& query, int nparams __attribute__((unused)))
{
  return std::make_unique<SSQLite3Statement>(this, m_dolog, query);
}

void SSQLite3::executeImpl(const string& query)
{
  char* errmsg = nullptr;
  std::string errstr1;
  int execRet = sqlite3_exec(m_pDB, query.c_str(), nullptr, nullptr, &errmsg);
  if (execRet != SQLITE_OK) {
    errstr1 = errmsg;
    sqlite3_free(errmsg);
  }
  if (execRet == SQLITE_BUSY) {
    if (m_in_transaction) {
      throw SSqlException("Failed to execute query: " + errstr1);
    }
    execRet = sqlite3_exec(m_pDB, query.c_str(), nullptr, nullptr, &errmsg);
    std::string errstr2;
    if (execRet != SQLITE_OK) {
      errstr2 = errmsg;
      sqlite3_free(errmsg);
      throw SSqlException("Failed to execute query: " + errstr2);
    }
  }
  else if (execRet != SQLITE_OK) {
    throw SSqlException("Failed to execute query: " + errstr1);
  }
}

void SSQLite3::execute(const string& query)
{
  executeImpl(query);
}

int SSQLite3::busyHandler([[maybe_unused]] void* userData, [[maybe_unused]] int invocationsSoFar)
{
  Utility::usleep(1000);
  return 1;
}

void SSQLite3::startTransaction()
{
  execute("begin");
  m_in_transaction = true;
}

void SSQLite3::rollback()
{
  execute("rollback");
  m_in_transaction = false;
}

void SSQLite3::commit()
{
  execute("commit");
  m_in_transaction = false;
}

// Constructs a SSqlException object.
SSqlException SSQLite3::sPerrorException(const std::string& reason)
{
  return {reason};
}

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 <utility>
31	#include "pdns/logger.hh"
32	#include "misc.hh"
33	#include "utility.hh"
34	#include <unistd.h>
35
36	/*
37	** Set all the parameters in the compiled SQL statement to NULL.
38	*
39	* copied from sqlite 3.3.6 // cmouse
40	*/
41	#if SQLITE_VERSION_NUMBER < 3003009
42	static int pdns_sqlite3_clear_bindings(sqlite3_stmt* pStmt)
43	{
44	int i;
45	int rc = SQLITE_OK;
46	for (i = 1; rc == SQLITE_OK && i <= sqlite3_bind_parameter_count(pStmt); i++) {
47	rc = sqlite3_bind_null(pStmt, i);
48	}
49	return rc;
50	}
51	#endif
52
53	static string SSQLite3ErrorString(sqlite3* database)
54	{	×
55	return string(sqlite3_errmsg(database) + string(" (") + std::to_string(sqlite3_extended_errcode(database)) + string(")"));	×
56	}	×
57
58	class SSQLite3Statement : public SSqlStatement
59	{
60	public:
61	SSQLite3Statement(SSQLite3* database, bool dolog, string query) :
62	d_query(std::move(query)),
63	d_db(database),
64	d_dolog(dolog)
65	{	131,475✔
66	}	131,475✔
67
68	SSQLite3Statement(const SSQLite3Statement&) = delete;
69	SSQLite3Statement(SSQLite3Statement&&) = delete;
70	SSQLite3Statement& operator=(const SSQLite3Statement&) = delete;
71	SSQLite3Statement& operator=(SSQLite3Statement&&) = delete;
72
73	int name2idx(const string& name)
74	{	1,756,161✔
75	string zName = string(":") + name;	1,756,161✔
76	prepareStatement();	1,756,161✔
77	return sqlite3_bind_parameter_index(d_stmt, zName.c_str());	1,756,161✔
78	// XXX: support @ and $?
79	}	1,756,161✔
80
81	SSqlStatement* bind(const string& name, bool value) override
82	{	387,213✔
83	int idx = name2idx(name);	387,213✔
84	if (idx > 0) {	387,213!
85	sqlite3_bind_int(d_stmt, idx, value ? 1 : 0);	387,213✔
86	};	387,213✔
87	return this;	387,213✔
88	}	387,213✔
89
90	SSqlStatement* bind(const string& name, int value) override
91	{	329,477✔
92	int idx = name2idx(name);	329,477✔
93	if (idx > 0) {	329,477!
94	sqlite3_bind_int(d_stmt, idx, value);	329,477✔
95	};	329,477✔
96	return this;	329,477✔
97	}	329,477✔
98
99	SSqlStatement* bind(const string& name, uint32_t value) override
100	{	232,840✔
101	int idx = name2idx(name);	232,840✔
102	if (idx > 0) {	232,840!
103	sqlite3_bind_int64(d_stmt, idx, value);	232,840✔
104	};	232,840✔
105	return this;	232,840✔
106	}	232,840✔
107
108	SSqlStatement* bind(const string& name, long value) override
109	{	63✔
110	int idx = name2idx(name);	63✔
111	if (idx > 0) {	63!
112	sqlite3_bind_int64(d_stmt, idx, value);	63✔
113	};	63✔
114	return this;	63✔
115	}	63✔
116
117	SSqlStatement* bind(const string& name, unsigned long value) override
118	{	11✔
119	int idx = name2idx(name);	11✔
120	if (idx > 0) {	11!
121	sqlite3_bind_int64(d_stmt, idx, static_cast<sqlite3_int64>(value));	11✔
122	};	11✔
123	return this;	11✔
124	}	11✔
125
126	SSqlStatement* bind(const string& name, long long value) override
127	{	×
128	int idx = name2idx(name);	×
129	if (idx > 0) {	×
130	sqlite3_bind_int64(d_stmt, idx, value);	×
131	};	×
132	return this;	×
133	};	×
134
135	SSqlStatement* bind(const string& name, unsigned long long value) override
136	{	×
137	int idx = name2idx(name);	×
138	if (idx > 0) {	×
139	sqlite3_bind_int64(d_stmt, idx, static_cast<sqlite3_int64>(value));	×
140	};	×
141	return this;	×
142	}	×
143
144	SSqlStatement* bind(const string& name, const std::string& value) override
145	{	684,324✔
146	int idx = name2idx(name);	684,324✔
147	if (idx > 0) {	684,324!
148	sqlite3_bind_text(d_stmt, idx, value.c_str(), static_cast<int>(value.size()), SQLITE_TRANSIENT);	684,324✔
149	};	684,324✔
150	return this;	684,324✔
151	}	684,324✔
152
153	SSqlStatement* bindNull(const string& name) override
154	{	122,233✔
155	int idx = name2idx(name);	122,233✔
156	if (idx > 0) {	122,233!
157	sqlite3_bind_null(d_stmt, idx);	122,233✔
158	};	122,233✔
159	return this;	122,233✔
160	}	122,233✔
161
162	SSqlStatement* execute() override
163	{	248,996✔
164	prepareStatement();	248,996✔
165	if (d_dolog) {	248,996!
166	g_log << Logger::Warning << "Query " << this << ": " << d_query << endl;	×
167	d_dtime.set();	×
168	}	×
169
170	int attempts = d_db->inTransaction() ? 1 : 0; // try only once	248,996✔
171	while (attempts < 2 && (d_rc = sqlite3_step(d_stmt)) == SQLITE_BUSY) {	248,996!
172	attempts++;	×
173	}	×
174
175	if (d_rc != SQLITE_ROW && d_rc != SQLITE_DONE) {	248,996!
176	// failed.
177	releaseStatement();	×
178	if (d_rc == SQLITE_CANTOPEN) {	×
179	throw SSqlException(string("CANTOPEN error in sqlite3, often caused by unwritable sqlite3 db directory: ") + SSQLite3ErrorString(d_db->db()));	×
180	}	×
181	throw SSqlException(string("Error while retrieving SQLite query results: ") + SSQLite3ErrorString(d_db->db()));	×
182	}	×
183	if (d_dolog) {	248,996!
184	g_log << Logger::Warning << "Query " << this << ": " << d_dtime.udiffNoReset() << " us to execute" << endl;	×
185	}	×
186	return this;	248,996✔
187	}	248,996✔
188
189	bool hasNextRow() override
190	{	228,155✔
191	if (d_dolog && d_rc != SQLITE_ROW) {	228,155!
192	g_log << Logger::Warning << "Query " << this << ": " << d_dtime.udiffNoReset() << " us total to last row" << endl;	×
193	}	×
194	return d_rc == SQLITE_ROW;	228,155✔
195	}	228,155✔
196
197	SSqlStatement* nextRow(row_t& row) override
198	{	205,702✔
199	row.clear();	205,702✔
200	int numCols = sqlite3_column_count(d_stmt);	205,702✔
201	row.reserve(numCols); // preallocate memory	205,702✔
202	// Another row received, process it.
203	for (int i = 0; i < numCols; i++) {	1,966,383✔
204	if (sqlite3_column_type(d_stmt, i) == SQLITE_NULL) {	1,760,681✔
205	row.emplace_back("");	156,751✔
206	}	156,751✔
207	else {	1,603,930✔
208	// NOLINTNEXTLINE(cppcoreguidelines-pro-type-cstyle-cast): SQLite API returns unsigned char strings and std::strings are signed char.
209	const char* pData = (const char*)sqlite3_column_text(d_stmt, i);	1,603,930✔
210	row.emplace_back(pData, sqlite3_column_bytes(d_stmt, i));	1,603,930✔
211	}	1,603,930✔
212	}	1,760,681✔
213	d_rc = sqlite3_step(d_stmt);	205,702✔
214	return this;	205,702✔
215	}	205,702✔
216
217	SSqlStatement* getResult(result_t& result) override
218	{	1,099✔
219	result.clear();	1,099✔
220	while (hasNextRow()) {	2,068✔
221	row_t row;	969✔
222	nextRow(row);	969✔
223	result.push_back(std::move(row));	969✔
224	}	969✔
225	return this;	1,099✔
226	}	1,099✔
227
228	SSqlStatement* reset() override
229	{	248,996✔
230	sqlite3_reset(d_stmt);	248,996✔
231	#if SQLITE_VERSION_NUMBER >= 3003009	248,996✔
232	sqlite3_clear_bindings(d_stmt);	248,996✔
233	#else
234	pdns_sqlite3_clear_bindings(d_stmt);
235	#endif
236	return this;	248,996✔
237	}	248,996✔
238
239	~SSQLite3Statement() override
240	{	126,664✔
241	// deallocate if necessary
242	releaseStatement();	126,664✔
243	}	126,664✔
244
245	const string& getQuery() override { return d_query; };	×
246
247	private:
248	string d_query;
249	DTime d_dtime;
250	sqlite3_stmt* d_stmt{nullptr};
251	SSQLite3* d_db{nullptr};
252	int d_rc{0};
253	bool d_dolog;
254	bool d_prepared{false};
255
256	void prepareStatement()
257	{	2,005,156✔
258	const char* pTail = nullptr;	2,005,156✔
259
260	if (d_prepared) {	2,005,156✔
261	return;	1,997,605✔
262	}	1,997,605✔
263	#if SQLITE_VERSION_NUMBER >= 3003009	7,551✔
264	if (sqlite3_prepare_v2(d_db->db(), d_query.c_str(), -1, &d_stmt, &pTail) != SQLITE_OK)	7,551!
265	#else
266	if (sqlite3_prepare(d_db->db(), d_query.c_str(), -1, &d_stmt, &pTail) != SQLITE_OK)
267	#endif
268	{	×
269	releaseStatement();	×
270	throw SSqlException(string("Unable to compile SQLite statement : '") + d_query + "': " + SSQLite3ErrorString(d_db->db()));	×
271	}	×
272	if ((pTail != nullptr) && strlen(pTail) > 0) {	7,552!
273	g_log << Logger::Warning << "Sqlite3 command partially processed. Unprocessed part: " << pTail << endl;	×
274	}	×
275	d_prepared = true;	7,551✔
276	}	7,551✔
277
278	void releaseStatement()
279	{	126,663✔
280	if (d_stmt != nullptr) {	126,663✔
281	sqlite3_finalize(d_stmt);	7,231✔
282	}	7,231✔
283	d_stmt = nullptr;	126,663✔
284	d_prepared = false;	126,663✔
285	}	126,663✔
286	};
287
288	// Constructor.
289	SSQLite3::SSQLite3(const std::string& database, const std::string& journalmode, bool creat)
290	{	2,907✔
291	if (access(database.c_str(), F_OK) == -1) {	2,907✔
292	if (!creat) {	28!
293	throw SSqlException("SQLite database '" + database + "' does not exist yet");	×
294	}	×
295	}	28✔
296	else {	2,879✔
297	if (creat) {	2,879!
298	throw SSqlException("SQLite database '" + database + "' already exists");	×
299	}	×
300	}	2,879✔
301
302	if (sqlite3_open(database.c_str(), &m_pDB) != SQLITE_OK) {	2,907!
303	throw SSqlException("Could not connect to the SQLite database '" + database + "'");	×
304	}	×
305	m_dolog = false;	2,907✔
306	m_in_transaction = false;	2,907✔
307	sqlite3_busy_handler(m_pDB, busyHandler, nullptr);	2,907✔
308
309	if (journalmode.length() != 0) {	2,907✔
310	executeImpl("PRAGMA journal_mode=" + journalmode);	2,880✔
311	}	2,880✔
312	}	2,907✔
313
314	void SSQLite3::setLog(bool state)
315	{	2,880✔
316	m_dolog = state;	2,880✔
317	}	2,880✔
318
319	// Destructor.
320	SSQLite3::~SSQLite3()
321	{	2,801✔
322	for (int tried = 0;; ++tried) {	2,801✔
323	int ret = sqlite3_close(m_pDB);	2,801✔
324	if (ret == SQLITE_OK) {	2,801!
325	break;	2,801✔
326	}	2,801✔
UNCOV 327	cerr << "SQLite3 error state while tearing down database: " << SSQLite3ErrorString(m_pDB) << endl;	×
UNCOV 328	if (tried == 0 && ret == SQLITE_BUSY) {	×
329	continue;	×
330	}	×
UNCOV 331	cerr << "Unable to close down sqlite connection: " << ret << endl;	×
UNCOV 332	abort();	×
UNCOV 333	}	×
334	}	2,801✔
335
336	std::unique_ptr<SSqlStatement> SSQLite3::prepare(const string& query, int nparams __attribute__((unused)))
337	{	131,509✔
338	return std::make_unique<SSQLite3Statement>(this, m_dolog, query);	131,509✔
339	}	131,509✔
340
341	void SSQLite3::executeImpl(const string& query)
342	{	4,186✔
343	char* errmsg = nullptr;	4,186✔
344	std::string errstr1;	4,186✔
345	int execRet = sqlite3_exec(m_pDB, query.c_str(), nullptr, nullptr, &errmsg);	4,186✔
346	if (execRet != SQLITE_OK) {	4,186!
347	errstr1 = errmsg;	×
348	sqlite3_free(errmsg);	×
349	}	×
350	if (execRet == SQLITE_BUSY) {	4,186!
351	if (m_in_transaction) {	×
352	throw SSqlException("Failed to execute query: " + errstr1);	×
353	}	×
354	execRet = sqlite3_exec(m_pDB, query.c_str(), nullptr, nullptr, &errmsg);	×
355	std::string errstr2;	×
356	if (execRet != SQLITE_OK) {	×
357	errstr2 = errmsg;	×
358	sqlite3_free(errmsg);	×
359	throw SSqlException("Failed to execute query: " + errstr2);	×
360	}	×
361	}	×
362	else if (execRet != SQLITE_OK) {	4,186!
363	throw SSqlException("Failed to execute query: " + errstr1);	×
364	}	×
365	}	4,186✔
366
367	void SSQLite3::execute(const string& query)
368	{	1,306✔
369	executeImpl(query);	1,306✔
370	}	1,306✔
371
372	int SSQLite3::busyHandler([[maybe_unused]] void* userData, [[maybe_unused]] int invocationsSoFar)
373	{	31✔
374	Utility::usleep(1000);	31✔
375	return 1;	31✔
376	}	31✔
377
378	void SSQLite3::startTransaction()
379	{	423✔
380	execute("begin");	423✔
381	m_in_transaction = true;	423✔
382	}	423✔
383
384	void SSQLite3::rollback()
385	{	17✔
386	execute("rollback");	17✔
387	m_in_transaction = false;	17✔
388	}	17✔
389
390	void SSQLite3::commit()
391	{	403✔
392	execute("commit");	403✔
393	m_in_transaction = false;	403✔
394	}	403✔
395
396	// Constructs a SSqlException object.
397	SSqlException SSQLite3::sPerrorException(const std::string& reason)
398	{	×
399	return {reason};	×
400	}	×

PowerDNS / pdns / 8470012545

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous