SSql: Use unique_ptr for statements

diff --git a/modules/bindbackend/bindbackend2.hh b/modules/bindbackend/bindbackend2.hh
index 468d46f861d3fe62217a863fdcab30146f0519c6..68c5257fb89bbbc508bdeed0b25bb14a3aea4dfa 100644 (file)
--- a/modules/bindbackend/bindbackend2.hh
+++ b/modules/bindbackend/bindbackend2.hh
@@ -286,20 +286,20 @@ private:
     handle(const handle &);
   };
 
-  SSqlStatement* d_getAllDomainMetadataQuery_stmt;
-  SSqlStatement* d_getDomainMetadataQuery_stmt;
-  SSqlStatement* d_deleteDomainMetadataQuery_stmt;
-  SSqlStatement* d_insertDomainMetadataQuery_stmt;
-  SSqlStatement* d_getDomainKeysQuery_stmt;
-  SSqlStatement* d_deleteDomainKeyQuery_stmt;
-  SSqlStatement* d_insertDomainKeyQuery_stmt;
-  SSqlStatement* d_GetLastInsertedKeyIdQuery_stmt;
-  SSqlStatement* d_activateDomainKeyQuery_stmt;
-  SSqlStatement* d_deactivateDomainKeyQuery_stmt;
-  SSqlStatement* d_getTSIGKeyQuery_stmt;
-  SSqlStatement* d_setTSIGKeyQuery_stmt;
-  SSqlStatement* d_deleteTSIGKeyQuery_stmt;
-  SSqlStatement* d_getTSIGKeysQuery_stmt;
+  unique_ptr<SSqlStatement> d_getAllDomainMetadataQuery_stmt;
+  unique_ptr<SSqlStatement> d_getDomainMetadataQuery_stmt;
+  unique_ptr<SSqlStatement> d_deleteDomainMetadataQuery_stmt;
+  unique_ptr<SSqlStatement> d_insertDomainMetadataQuery_stmt;
+  unique_ptr<SSqlStatement> d_getDomainKeysQuery_stmt;
+  unique_ptr<SSqlStatement> d_deleteDomainKeyQuery_stmt;
+  unique_ptr<SSqlStatement> d_insertDomainKeyQuery_stmt;
+  unique_ptr<SSqlStatement> d_GetLastInsertedKeyIdQuery_stmt;
+  unique_ptr<SSqlStatement> d_activateDomainKeyQuery_stmt;
+  unique_ptr<SSqlStatement> d_deactivateDomainKeyQuery_stmt;
+  unique_ptr<SSqlStatement> d_getTSIGKeyQuery_stmt;
+  unique_ptr<SSqlStatement> d_setTSIGKeyQuery_stmt;
+  unique_ptr<SSqlStatement> d_deleteTSIGKeyQuery_stmt;
+  unique_ptr<SSqlStatement> d_getTSIGKeysQuery_stmt;
 
   string d_transaction_tmpname;
   string d_logprefix;

diff --git a/modules/bindbackend/binddnssec.cc b/modules/bindbackend/binddnssec.cc
index 8079faa8f2801a97e711b6a26ed683696de1a79a..ead39ccd69c39ac1477271f07ec9f7e333004055 100644 (file)
--- a/modules/bindbackend/binddnssec.cc
+++ b/modules/bindbackend/binddnssec.cc
@@ -132,20 +132,20 @@ void Bind2Backend::release(SSqlStatement** stmt) {
 
 void Bind2Backend::freeStatements()
 {
-  release(&d_getAllDomainMetadataQuery_stmt);
-  release(&d_getDomainMetadataQuery_stmt);
-  release(&d_deleteDomainMetadataQuery_stmt);
-  release(&d_insertDomainMetadataQuery_stmt);
-  release(&d_getDomainKeysQuery_stmt);
-  release(&d_deleteDomainKeyQuery_stmt);
-  release(&d_insertDomainKeyQuery_stmt);
-  release(&d_GetLastInsertedKeyIdQuery_stmt);
-  release(&d_activateDomainKeyQuery_stmt);
-  release(&d_deactivateDomainKeyQuery_stmt);
-  release(&d_getTSIGKeyQuery_stmt);
-  release(&d_setTSIGKeyQuery_stmt);
-  release(&d_deleteTSIGKeyQuery_stmt);
-  release(&d_getTSIGKeysQuery_stmt);
+  d_getAllDomainMetadataQuery_stmt.reset();
+  d_getDomainMetadataQuery_stmt.reset();
+  d_deleteDomainMetadataQuery_stmt.reset();
+  d_insertDomainMetadataQuery_stmt.reset();
+  d_getDomainKeysQuery_stmt.reset();
+  d_deleteDomainKeyQuery_stmt.reset();
+  d_insertDomainKeyQuery_stmt.reset();
+  d_GetLastInsertedKeyIdQuery_stmt.reset();
+  d_activateDomainKeyQuery_stmt.reset();
+  d_deactivateDomainKeyQuery_stmt.reset();
+  d_getTSIGKeyQuery_stmt.reset();
+  d_setTSIGKeyQuery_stmt.reset();
+  d_deleteTSIGKeyQuery_stmt.reset();
+  d_getTSIGKeysQuery_stmt.reset();
 }
 
 bool Bind2Backend::doesDNSSEC()

diff --git a/modules/gmysqlbackend/smysql.cc b/modules/gmysqlbackend/smysql.cc
index 0309aca95df88b43892de3a7a61c69693f8a8858..5e9354254a4e7123dec3e756d641baef1552ef63 100644 (file)
--- a/modules/gmysqlbackend/smysql.cc
+++ b/modules/gmysqlbackend/smysql.cc
@@ -467,9 +467,9 @@ SSqlException SMySQL::sPerrorException(const string &reason)
   return SSqlException(reason+string(": ")+mysql_error(&d_db));
 }
 
-SSqlStatement* SMySQL::prepare(const string& query, int nparams)
+std::unique_ptr<SSqlStatement> SMySQL::prepare(const string& query, int nparams)
 {
-  return new SMySQLStatement(query, s_dolog, nparams, &d_db);
+  return std::unique_ptr<SSqlStatement>(new SMySQLStatement(query, s_dolog, nparams, &d_db));
 }
 
 void SMySQL::execute(const string& query)

diff --git a/modules/gmysqlbackend/smysql.hh b/modules/gmysqlbackend/smysql.hh
index f79af781383b47d67ceceb9cbd13f4e8526ebce5..7e31d7b5644f1da8d405318253abe22e08f6d305 100644 (file)
--- a/modules/gmysqlbackend/smysql.hh
+++ b/modules/gmysqlbackend/smysql.hh
@@ -38,7 +38,7 @@ public:
 
   SSqlException sPerrorException(const string &reason) override;
   void setLog(bool state) override;
-  SSqlStatement* prepare(const string& query, int nparams) override;
+  std::unique_ptr<SSqlStatement> prepare(const string& query, int nparams) override;
   void execute(const string& query) override;
 
   void startTransaction() override;

diff --git a/modules/godbcbackend/sodbc.cc b/modules/godbcbackend/sodbc.cc
index 2ba6cb3b18fa562a0335e820063812de2a0183b2..db1dfccb00b08b156eb1f2a448a39cf69acb3bef 100644 (file)
--- a/modules/godbcbackend/sodbc.cc
+++ b/modules/godbcbackend/sodbc.cc
@@ -446,9 +446,9 @@ SSqlException SODBC::sPerrorException( const std::string & reason )
   return SSqlException( reason );
 }
 
-SSqlStatement* SODBC::prepare(const string& query, int nparams)
+std::unique_ptr<SSqlStatement> SODBC::prepare(const string& query, int nparams)
 {
-  return new SODBCStatement(query, m_log, nparams, m_connection);
+  return std::unique_ptr<SSqlStatement>(new SODBCStatement(query, m_log, nparams, m_connection));
 }
 
 

diff --git a/modules/godbcbackend/sodbc.hh b/modules/godbcbackend/sodbc.hh
index d01377a4cd960c46a9cb2eb48aa99e69cc743ef6..947d6e1cde0651239693c4fd5c367eae278eadf8 100644 (file)
--- a/modules/godbcbackend/sodbc.hh
+++ b/modules/godbcbackend/sodbc.hh
@@ -65,7 +65,7 @@ public:
   //! Sets the logging state.
   void setLog( bool state );
 
-  SSqlStatement* prepare(const string& query, int nparams);
+  std::unique_ptr<SSqlStatement> prepare(const string& query, int nparams);
   void execute(const string& query);
   void startTransaction() override;
   void rollback() override;

diff --git a/modules/goraclebackend/soracle.cc b/modules/goraclebackend/soracle.cc
index 8be0870cf50587e51efb187e48fa193dd62581d2..e5f4a8b93e0d28e83c1f5bc33a7a02aaa623dfc9 100644 (file)
--- a/modules/goraclebackend/soracle.cc
+++ b/modules/goraclebackend/soracle.cc
@@ -524,8 +524,8 @@ SSqlException SOracle::sPerrorException(const string &reason)
   return SSqlException(reason);
 }
 
-SSqlStatement* SOracle::prepare(const string& query, int nparams) {
-  return new SOracleStatement(query, s_dolog, nparams, d_environmentHandle, d_serviceContextHandle, d_release_stmt);
+std::unique_ptr<SSqlStatement> SOracle::prepare(const string& query, int nparams) {
+  return std::unique_ptr<SSqlStatement>(new SOracleStatement(query, s_dolog, nparams, d_environmentHandle, d_serviceContextHandle, d_release_stmt));
 }
 
 void SOracle::execute(const string& query) {

diff --git a/modules/goraclebackend/soracle.hh b/modules/goraclebackend/soracle.hh
index 221e294fadcc2bd0f5f10963c8bfc5211819414b..2abae2b1c49c7826e32cf433697a389a77c3986a 100644 (file)
--- a/modules/goraclebackend/soracle.hh
+++ b/modules/goraclebackend/soracle.hh
@@ -45,7 +45,7 @@ public:
 
   SSqlException sPerrorException(const string &reason);
   void setLog(bool state);
-  SSqlStatement* prepare(const string& query, int nparams);
+  std::unique_ptr<SSqlStatement> prepare(const string& query, int nparams);
   void execute(const string& query);
 
   void startTransaction();

diff --git a/modules/gpgsqlbackend/spgsql.cc b/modules/gpgsqlbackend/spgsql.cc
index cfb0ca27c7f95dc62b77c4e6294af90df3f8dfbc..f02d87e9dd2c7e1942b4b897f954af67b03046b1 100644 (file)
--- a/modules/gpgsqlbackend/spgsql.cc
+++ b/modules/gpgsqlbackend/spgsql.cc
@@ -326,10 +326,10 @@ void SPgSQL::execute(const string& query)
   }
 }
 
-SSqlStatement* SPgSQL::prepare(const string& query, int nparams)
+std::unique_ptr<SSqlStatement> SPgSQL::prepare(const string& query, int nparams)
 {
   d_nstatement++;
-  return new SPgSQLStatement(query, s_dolog, nparams, this, d_nstatement);
+  return std::unique_ptr<SSqlStatement>(new SPgSQLStatement(query, s_dolog, nparams, this, d_nstatement));
 }
 
 void SPgSQL::startTransaction() {

diff --git a/modules/gpgsqlbackend/spgsql.hh b/modules/gpgsqlbackend/spgsql.hh
index 6654e4f872a66dd53ed2279e9306c299dd923424..35631e45df4d013ced7b89fb0d5b5531e9f8b4f1 100644 (file)
--- a/modules/gpgsqlbackend/spgsql.hh
+++ b/modules/gpgsqlbackend/spgsql.hh
@@ -36,7 +36,7 @@ public:
   
   SSqlException sPerrorException(const string &reason) override;
   void setLog(bool state) override;
-  SSqlStatement* prepare(const string& query, int nparams) override;
+  unique_ptr<SSqlStatement> prepare(const string& query, int nparams) override;
   void execute(const string& query) override;
 
   void startTransaction() override;

diff --git a/modules/mydnsbackend/mydnsbackend.cc b/modules/mydnsbackend/mydnsbackend.cc
index db4751c46972584126aedfcca665f8194da56162..0bf7a52eaad0f2399e1f03d4d8d23b135946b277 100644 (file)
--- a/modules/mydnsbackend/mydnsbackend.cc
+++ b/modules/mydnsbackend/mydnsbackend.cc
@@ -65,15 +65,6 @@ static string backendName="[MyDNSbackend]";
 MyDNSBackend::MyDNSBackend(const string &suffix) {
   setArgPrefix("mydns"+suffix);
  
-  d_domainIdQuery_stmt = NULL;
-  d_domainNoIdQuery_stmt = NULL;
-  d_listQuery_stmt = NULL;
-  d_soaQuery_stmt = NULL;
-  d_basicQuery_stmt = NULL;
-  d_anyQuery_stmt = NULL;
-  d_query_stmt = NULL;
-  d_allDomainsQuery_stmt = NULL;
-
   try {
     d_db = new SMySQL(getArg("dbname"),
       getArg("host"),
@@ -150,20 +141,13 @@ MyDNSBackend::MyDNSBackend(const string &suffix) {
 }
 
 MyDNSBackend::~MyDNSBackend() {
-  delete d_domainIdQuery_stmt;
-  d_domainIdQuery_stmt = NULL;
-  delete d_domainNoIdQuery_stmt;
-  d_domainNoIdQuery_stmt = NULL;
-  delete d_listQuery_stmt;
-  d_listQuery_stmt = NULL;
-  delete d_soaQuery_stmt;
-  d_soaQuery_stmt = NULL;
-  delete d_basicQuery_stmt;
-  d_basicQuery_stmt = NULL;
-  delete d_anyQuery_stmt;
-  d_anyQuery_stmt = NULL;
-  delete d_allDomainsQuery_stmt;
-  d_allDomainsQuery_stmt = NULL;
+  d_domainIdQuery_stmt.release();
+  d_domainNoIdQuery_stmt.release();
+  d_listQuery_stmt.release();
+  d_soaQuery_stmt.release();
+  d_basicQuery_stmt.release();
+  d_anyQuery_stmt.release();
+  d_allDomainsQuery_stmt.release();
   delete(d_db);
 }
 
@@ -197,8 +181,8 @@ bool MyDNSBackend::list(const DNSName &target, int zoneId, bool include_disabled
   };
 
   try {
-    d_query_stmt = d_listQuery_stmt;
-    d_query_stmt->
+    d_query_stmt = &d_listQuery_stmt;
+    (*d_query_stmt)->
       bind("domain_id", zoneId)->
       execute();
   }
@@ -336,8 +320,8 @@ void MyDNSBackend::lookup(const QType &qtype, const DNSName &qname, DNSPacket *p
 
       if (qtype.getCode()==QType::ANY) {
         DLOG(L<<Logger::Debug<<"Running d_anyQuery_stmt with " << zoneId << ", " << host << ", " << sdom  << ", " << zoneId <<" , "<< qname << ", " << qtype.getName() << endl);
-        d_query_stmt = d_anyQuery_stmt;
-        d_query_stmt->
+        d_query_stmt = &d_anyQuery_stmt;
+        (*d_query_stmt)->
           bind("domain_id", zoneId)->
           bind("host", host)->
           bind("qname", qname.toString())->
@@ -346,8 +330,8 @@ void MyDNSBackend::lookup(const QType &qtype, const DNSName &qname, DNSPacket *p
           execute();
       } else {
         DLOG(L<<Logger::Debug<<"Running d_basicQuery_stmt with " << zoneId << ", " << host << ", " << qname << ", " << qtype.getName() << endl);
-        d_query_stmt = d_basicQuery_stmt;
-        d_query_stmt->
+        d_query_stmt = &d_basicQuery_stmt;
+        (*d_query_stmt)->
           bind("domain_id", zoneId)->
           bind("host", host)->
           bind("qname", qname.toString())->
@@ -368,7 +352,7 @@ bool MyDNSBackend::get(DNSResourceRecord &rr) {
   if (d_origin.empty()) {
     if (d_query_stmt) {
       try {
-        d_query_stmt->reset();
+        (*d_query_stmt)->reset();
       } catch (SSqlException &e) {
         throw PDNSException("MyDNSBackend unable to lookup "+d_qname+": "+e.txtReason());
       }
@@ -380,9 +364,9 @@ bool MyDNSBackend::get(DNSResourceRecord &rr) {
 
   SSqlStatement::row_t rrow;
 
-  if (d_query_stmt->hasNextRow()) {
+  if ((*d_query_stmt)->hasNextRow()) {
     try {
-      d_query_stmt->nextRow(rrow);
+      (*d_query_stmt)->nextRow(rrow);
     } catch (SSqlException &e) {
       throw PDNSException("MyDNSBackend unable to lookup "+d_qname+": "+e.txtReason());
     }
@@ -433,7 +417,7 @@ bool MyDNSBackend::get(DNSResourceRecord &rr) {
   }
 
   try {
-    d_query_stmt->reset();
+    (*d_query_stmt)->reset();
   } catch (SSqlException &e) {
     throw PDNSException("MyDNSBackend unable to lookup "+d_qname+": "+e.txtReason());
   }

diff --git a/modules/mydnsbackend/mydnsbackend.hh b/modules/mydnsbackend/mydnsbackend.hh
index 52aaf9fcdd19d065991178fbfda4b15172d98d30..6bd1e13d3401e6a59cebb4a25e7ba6e5d28ab8ed 100644 (file)
--- a/modules/mydnsbackend/mydnsbackend.hh
+++ b/modules/mydnsbackend/mydnsbackend.hh
@@ -51,14 +51,14 @@ private:
 
   SSqlStatement::result_t d_result;
 
-  SSqlStatement* d_query_stmt;
-  SSqlStatement* d_domainIdQuery_stmt;
-  SSqlStatement* d_domainNoIdQuery_stmt;
-  SSqlStatement* d_listQuery_stmt;
-  SSqlStatement* d_soaQuery_stmt;
-  SSqlStatement* d_basicQuery_stmt;
-  SSqlStatement* d_anyQuery_stmt;
-  SSqlStatement* d_allDomainsQuery_stmt;
+  std::unique_ptr<SSqlStatement>* d_query_stmt;
+  std::unique_ptr<SSqlStatement> d_domainIdQuery_stmt;
+  std::unique_ptr<SSqlStatement> d_domainNoIdQuery_stmt;
+  std::unique_ptr<SSqlStatement> d_listQuery_stmt;
+  std::unique_ptr<SSqlStatement> d_soaQuery_stmt;
+  std::unique_ptr<SSqlStatement> d_basicQuery_stmt;
+  std::unique_ptr<SSqlStatement> d_anyQuery_stmt;
+  std::unique_ptr<SSqlStatement> d_allDomainsQuery_stmt;
 };
 
 #endif /* MYDNSBACKEND_HH */

diff --git a/pdns/backends/gsql/gsqlbackend.cc b/pdns/backends/gsql/gsqlbackend.cc
index efc9b5def61e765b2ac88516860c9fb6203306a5..848fb260e180a6c040b596d4e63fe6e2bb60b273 100644 (file)
--- a/pdns/backends/gsql/gsqlbackend.cc
+++ b/pdns/backends/gsql/gsqlbackend.cc
@@ -1030,14 +1030,14 @@ void GSQLBackend::lookup(const QType &qtype,const DNSName &qname, DNSPacket *pkt
     if(qtype.getCode()!=QType::ANY) {
       if(domain_id < 0) {
         d_query_name = "basic-query";
-        d_query_stmt = d_NoIdQuery_stmt;
-        d_query_stmt->
+        d_query_stmt = &d_NoIdQuery_stmt;
+        (*d_query_stmt)->
           bind("qtype", qtype.getName())->
           bind("qname", qname);
       } else {
         d_query_name = "id-query";
-        d_query_stmt = d_IdQuery_stmt;
-        d_query_stmt->
+        d_query_stmt = &d_IdQuery_stmt;
+        (*d_query_stmt)->
           bind("qtype", qtype.getName())->
           bind("qname", qname)->
           bind("domain_id", domain_id);
@@ -1046,19 +1046,19 @@ void GSQLBackend::lookup(const QType &qtype,const DNSName &qname, DNSPacket *pkt
       // qtype==ANY
       if(domain_id < 0) {
         d_query_name = "any-query";
-        d_query_stmt = d_ANYNoIdQuery_stmt;
-        d_query_stmt->
+        d_query_stmt = &d_ANYNoIdQuery_stmt;
+        (*d_query_stmt)->
           bind("qname", qname);
       } else {
         d_query_name = "any-id-query";
-        d_query_stmt = d_ANYIdQuery_stmt;
-        d_query_stmt->
+        d_query_stmt = &d_ANYIdQuery_stmt;
+        (*d_query_stmt)->
           bind("qname", qname)->
           bind("domain_id", domain_id);
       }
     }
 
-    d_query_stmt->
+    (*d_query_stmt)->
       execute();
   }
   catch(SSqlException &e) {
@@ -1076,8 +1076,8 @@ bool GSQLBackend::list(const DNSName &target, int domain_id, bool include_disabl
     reconnectIfNeeded();
 
     d_query_name = "list-query";
-    d_query_stmt = d_listQuery_stmt;
-    d_query_stmt->
+    d_query_stmt = &d_listQuery_stmt;
+    (*d_query_stmt)->
       bind("include_disabled", (int)include_disabled)->
       bind("domain_id", domain_id)->
       execute();
@@ -1098,8 +1098,8 @@ bool GSQLBackend::listSubZone(const DNSName &zone, int domain_id) {
     reconnectIfNeeded();
 
     d_query_name = "list-subzone-query";
-    d_query_stmt = d_listSubZoneQuery_stmt;
-    d_query_stmt->
+    d_query_stmt = &d_listSubZoneQuery_stmt;
+    (*d_query_stmt)->
       bind("zone", zone)->
       bind("wildzone", wildzone)->
       bind("domain_id", domain_id)->
@@ -1118,9 +1118,9 @@ bool GSQLBackend::get(DNSResourceRecord &r)
   SSqlStatement::row_t row;
 
 skiprow:
-  if(d_query_stmt->hasNextRow()) {
+  if((*d_query_stmt)->hasNextRow()) {
     try {
-      d_query_stmt->nextRow(row);
+      (*d_query_stmt)->nextRow(row);
       ASSERT_ROW_COLUMNS(d_query_name, row, 8);
     } catch (SSqlException &e) {
       throw PDNSException("GSQLBackend get: "+e.txtReason());
@@ -1134,7 +1134,7 @@ skiprow:
   }
 
   try {
-    d_query_stmt->reset();
+    (*d_query_stmt)->reset();
   } catch (SSqlException &e) {
       throw PDNSException("GSQLBackend get: "+e.txtReason());
   }
@@ -1542,8 +1542,8 @@ bool GSQLBackend::listComments(const uint32_t domain_id)
     reconnectIfNeeded();
 
     d_query_name = "list-comments-query";
-    d_query_stmt = d_ListCommentsQuery_stmt;
-    d_query_stmt->
+    d_query_stmt = &d_ListCommentsQuery_stmt;
+    (*d_query_stmt)->
       bind("domain_id", domain_id)->
       execute();
   }
@@ -1559,9 +1559,9 @@ bool GSQLBackend::getComment(Comment& comment)
   SSqlStatement::row_t row;
 
   for(;;) {
-    if (!d_query_stmt->hasNextRow()) {
+    if (!(*d_query_stmt)->hasNextRow()) {
       try {
-        d_query_stmt->reset();
+        (*d_query_stmt)->reset();
       } catch(SSqlException &e) {
         throw PDNSException("GSQLBackend comment get: "+e.txtReason());
       }
@@ -1570,7 +1570,7 @@ bool GSQLBackend::getComment(Comment& comment)
     }
 
     try {
-      d_query_stmt->nextRow(row);
+      (*d_query_stmt)->nextRow(row);
       ASSERT_ROW_COLUMNS(d_query_name, row, 6);
     } catch(SSqlException &e) {
       throw PDNSException("GSQLBackend comment get: "+e.txtReason());
@@ -1632,7 +1632,7 @@ string GSQLBackend::directBackendCmd(const string &query)
  try {
    ostringstream out;
 
-   unique_ptr<SSqlStatement> stmt(d_db->prepare(query,0));
+   auto stmt = d_db->prepare(query,0);
 
    reconnectIfNeeded();
 

diff --git a/pdns/backends/gsql/gsqlbackend.hh b/pdns/backends/gsql/gsqlbackend.hh
index dfe2e221d68198c26c3d6768f701d104e534e3ec..7a6fcff9091655e080fe1b19abc27193c7e37cbd 100644 (file)
--- a/pdns/backends/gsql/gsqlbackend.hh
+++ b/pdns/backends/gsql/gsqlbackend.hh
@@ -113,70 +113,65 @@ public:
     }
   }
 
-  void release(SSqlStatement **stmt) {
-    delete *stmt;
-    *stmt = NULL;
-  }
-  
   void freeStatements() {
-    release(&d_NoIdQuery_stmt);
-    release(&d_IdQuery_stmt);
-    release(&d_ANYNoIdQuery_stmt);
-    release(&d_ANYIdQuery_stmt);
-    release(&d_listQuery_stmt);
-    release(&d_listSubZoneQuery_stmt);
-    release(&d_MasterOfDomainsZoneQuery_stmt);
-    release(&d_InfoOfDomainsZoneQuery_stmt);
-    release(&d_InfoOfAllSlaveDomainsQuery_stmt);
-    release(&d_SuperMasterInfoQuery_stmt);
-    release(&d_GetSuperMasterIPs_stmt);
-    release(&d_InsertZoneQuery_stmt);
-    release(&d_InsertRecordQuery_stmt);
-    release(&d_InsertEmptyNonTerminalOrderQuery_stmt);
-    release(&d_UpdateMasterOfZoneQuery_stmt);
-    release(&d_UpdateKindOfZoneQuery_stmt);
-    release(&d_UpdateAccountOfZoneQuery_stmt);
-    release(&d_UpdateSerialOfZoneQuery_stmt);
-    release(&d_UpdateLastCheckofZoneQuery_stmt);
-    release(&d_InfoOfAllMasterDomainsQuery_stmt);
-    release(&d_DeleteDomainQuery_stmt);
-    release(&d_DeleteZoneQuery_stmt);
-    release(&d_DeleteRRSetQuery_stmt);
-    release(&d_DeleteNamesQuery_stmt);
-    release(&d_ZoneLastChangeQuery_stmt);
-    release(&d_firstOrderQuery_stmt);
-    release(&d_beforeOrderQuery_stmt);
-    release(&d_afterOrderQuery_stmt);
-    release(&d_lastOrderQuery_stmt);
-    release(&d_updateOrderNameAndAuthQuery_stmt);
-    release(&d_updateOrderNameAndAuthTypeQuery_stmt);
-    release(&d_nullifyOrderNameAndUpdateAuthQuery_stmt);
-    release(&d_nullifyOrderNameAndUpdateAuthTypeQuery_stmt);
-    release(&d_RemoveEmptyNonTerminalsFromZoneQuery_stmt);
-    release(&d_DeleteEmptyNonTerminalQuery_stmt);
-    release(&d_AddDomainKeyQuery_stmt);
-    release(&d_GetLastInsertedKeyIdQuery_stmt);
-    release(&d_ListDomainKeysQuery_stmt);
-    release(&d_GetAllDomainMetadataQuery_stmt);
-    release(&d_GetDomainMetadataQuery_stmt);
-    release(&d_ClearDomainMetadataQuery_stmt);
-    release(&d_ClearDomainAllMetadataQuery_stmt);
-    release(&d_SetDomainMetadataQuery_stmt);
-    release(&d_RemoveDomainKeyQuery_stmt);
-    release(&d_ActivateDomainKeyQuery_stmt);
-    release(&d_DeactivateDomainKeyQuery_stmt);
-    release(&d_ClearDomainAllKeysQuery_stmt);
-    release(&d_getTSIGKeyQuery_stmt);
-    release(&d_setTSIGKeyQuery_stmt);
-    release(&d_deleteTSIGKeyQuery_stmt);
-    release(&d_getTSIGKeysQuery_stmt);
-    release(&d_getAllDomainsQuery_stmt);
-    release(&d_ListCommentsQuery_stmt);
-    release(&d_InsertCommentQuery_stmt);
-    release(&d_DeleteCommentRRsetQuery_stmt);
-    release(&d_DeleteCommentsQuery_stmt);
-    release(&d_SearchRecordsQuery_stmt);
-    release(&d_SearchCommentsQuery_stmt);
+    d_NoIdQuery_stmt.reset();
+    d_IdQuery_stmt.reset();
+    d_ANYNoIdQuery_stmt.reset();
+    d_ANYIdQuery_stmt.reset();
+    d_listQuery_stmt.reset();
+    d_listSubZoneQuery_stmt.reset();
+    d_MasterOfDomainsZoneQuery_stmt.reset();
+    d_InfoOfDomainsZoneQuery_stmt.reset();
+    d_InfoOfAllSlaveDomainsQuery_stmt.reset();
+    d_SuperMasterInfoQuery_stmt.reset();
+    d_GetSuperMasterIPs_stmt.reset();
+    d_InsertZoneQuery_stmt.reset();
+    d_InsertRecordQuery_stmt.reset();
+    d_InsertEmptyNonTerminalOrderQuery_stmt.reset();
+    d_UpdateMasterOfZoneQuery_stmt.reset();
+    d_UpdateKindOfZoneQuery_stmt.reset();
+    d_UpdateAccountOfZoneQuery_stmt.reset();
+    d_UpdateSerialOfZoneQuery_stmt.reset();
+    d_UpdateLastCheckofZoneQuery_stmt.reset();
+    d_InfoOfAllMasterDomainsQuery_stmt.reset();
+    d_DeleteDomainQuery_stmt.reset();
+    d_DeleteZoneQuery_stmt.reset();
+    d_DeleteRRSetQuery_stmt.reset();
+    d_DeleteNamesQuery_stmt.reset();
+    d_ZoneLastChangeQuery_stmt.reset();
+    d_firstOrderQuery_stmt.reset();
+    d_beforeOrderQuery_stmt.reset();
+    d_afterOrderQuery_stmt.reset();
+    d_lastOrderQuery_stmt.reset();
+    d_updateOrderNameAndAuthQuery_stmt.reset();
+    d_updateOrderNameAndAuthTypeQuery_stmt.reset();
+    d_nullifyOrderNameAndUpdateAuthQuery_stmt.reset();
+    d_nullifyOrderNameAndUpdateAuthTypeQuery_stmt.reset();
+    d_RemoveEmptyNonTerminalsFromZoneQuery_stmt.reset();
+    d_DeleteEmptyNonTerminalQuery_stmt.reset();
+    d_AddDomainKeyQuery_stmt.reset();
+    d_GetLastInsertedKeyIdQuery_stmt.reset();
+    d_ListDomainKeysQuery_stmt.reset();
+    d_GetAllDomainMetadataQuery_stmt.reset();
+    d_GetDomainMetadataQuery_stmt.reset();
+    d_ClearDomainMetadataQuery_stmt.reset();
+    d_ClearDomainAllMetadataQuery_stmt.reset();
+    d_SetDomainMetadataQuery_stmt.reset();
+    d_RemoveDomainKeyQuery_stmt.reset();
+    d_ActivateDomainKeyQuery_stmt.reset();
+    d_DeactivateDomainKeyQuery_stmt.reset();
+    d_ClearDomainAllKeysQuery_stmt.reset();
+    d_getTSIGKeyQuery_stmt.reset();
+    d_setTSIGKeyQuery_stmt.reset();
+    d_deleteTSIGKeyQuery_stmt.reset();
+    d_getTSIGKeysQuery_stmt.reset();
+    d_getAllDomainsQuery_stmt.reset();
+    d_ListCommentsQuery_stmt.reset();
+    d_InsertCommentQuery_stmt.reset();
+    d_DeleteCommentRRsetQuery_stmt.reset();
+    d_DeleteCommentsQuery_stmt.reset();
+    d_SearchRecordsQuery_stmt.reset();
+    d_SearchCommentsQuery_stmt.reset();
   }
 
   void lookup(const QType &, const DNSName &qdomain, DNSPacket *p=0, int zoneId=-1) override;
@@ -342,66 +337,66 @@ private:
   string d_SearchRecordsQuery;
   string d_SearchCommentsQuery;
 
-  SSqlStatement* d_query_stmt;
+  unique_ptr<SSqlStatement>* d_query_stmt;
 
-  SSqlStatement* d_NoIdQuery_stmt;
-  SSqlStatement* d_IdQuery_stmt;
-  SSqlStatement* d_ANYNoIdQuery_stmt;
-  SSqlStatement* d_ANYIdQuery_stmt;
-  SSqlStatement* d_listQuery_stmt;
-  SSqlStatement* d_listSubZoneQuery_stmt;
-  SSqlStatement* d_MasterOfDomainsZoneQuery_stmt;
-  SSqlStatement* d_InfoOfDomainsZoneQuery_stmt;
-  SSqlStatement* d_InfoOfAllSlaveDomainsQuery_stmt;
-  SSqlStatement* d_SuperMasterInfoQuery_stmt;
-  SSqlStatement* d_GetSuperMasterIPs_stmt;
-  SSqlStatement* d_InsertZoneQuery_stmt;
-  SSqlStatement* d_InsertRecordQuery_stmt;
-  SSqlStatement* d_InsertEmptyNonTerminalOrderQuery_stmt;
-  SSqlStatement* d_UpdateMasterOfZoneQuery_stmt;
-  SSqlStatement* d_UpdateKindOfZoneQuery_stmt;
-  SSqlStatement* d_UpdateAccountOfZoneQuery_stmt;
-  SSqlStatement* d_UpdateSerialOfZoneQuery_stmt;
-  SSqlStatement* d_UpdateLastCheckofZoneQuery_stmt;
-  SSqlStatement* d_InfoOfAllMasterDomainsQuery_stmt;
-  SSqlStatement* d_DeleteDomainQuery_stmt;
-  SSqlStatement* d_DeleteZoneQuery_stmt;
-  SSqlStatement* d_DeleteRRSetQuery_stmt;
-  SSqlStatement* d_DeleteNamesQuery_stmt;
-  SSqlStatement* d_ZoneLastChangeQuery_stmt;
-  SSqlStatement* d_firstOrderQuery_stmt;
-  SSqlStatement* d_beforeOrderQuery_stmt;
-  SSqlStatement* d_afterOrderQuery_stmt;
-  SSqlStatement* d_lastOrderQuery_stmt;
-  SSqlStatement* d_updateOrderNameAndAuthQuery_stmt;
-  SSqlStatement* d_updateOrderNameAndAuthTypeQuery_stmt;
-  SSqlStatement* d_nullifyOrderNameAndUpdateAuthQuery_stmt;
-  SSqlStatement* d_nullifyOrderNameAndUpdateAuthTypeQuery_stmt;
-  SSqlStatement* d_RemoveEmptyNonTerminalsFromZoneQuery_stmt;
-  SSqlStatement* d_DeleteEmptyNonTerminalQuery_stmt;
-  SSqlStatement* d_AddDomainKeyQuery_stmt;
-  SSqlStatement* d_GetLastInsertedKeyIdQuery_stmt;
-  SSqlStatement* d_ListDomainKeysQuery_stmt;
-  SSqlStatement* d_GetAllDomainMetadataQuery_stmt;
-  SSqlStatement* d_GetDomainMetadataQuery_stmt;
-  SSqlStatement* d_ClearDomainMetadataQuery_stmt;
-  SSqlStatement* d_ClearDomainAllMetadataQuery_stmt;
-  SSqlStatement* d_SetDomainMetadataQuery_stmt;
-  SSqlStatement* d_RemoveDomainKeyQuery_stmt;
-  SSqlStatement* d_ActivateDomainKeyQuery_stmt;
-  SSqlStatement* d_DeactivateDomainKeyQuery_stmt;
-  SSqlStatement* d_ClearDomainAllKeysQuery_stmt;
-  SSqlStatement* d_getTSIGKeyQuery_stmt;
-  SSqlStatement* d_setTSIGKeyQuery_stmt;
-  SSqlStatement* d_deleteTSIGKeyQuery_stmt;
-  SSqlStatement* d_getTSIGKeysQuery_stmt;
-  SSqlStatement* d_getAllDomainsQuery_stmt;
-  SSqlStatement* d_ListCommentsQuery_stmt;
-  SSqlStatement* d_InsertCommentQuery_stmt;
-  SSqlStatement* d_DeleteCommentRRsetQuery_stmt;
-  SSqlStatement* d_DeleteCommentsQuery_stmt;
-  SSqlStatement* d_SearchRecordsQuery_stmt;
-  SSqlStatement* d_SearchCommentsQuery_stmt;
+  unique_ptr<SSqlStatement> d_NoIdQuery_stmt;
+  unique_ptr<SSqlStatement> d_IdQuery_stmt;
+  unique_ptr<SSqlStatement> d_ANYNoIdQuery_stmt;
+  unique_ptr<SSqlStatement> d_ANYIdQuery_stmt;
+  unique_ptr<SSqlStatement> d_listQuery_stmt;
+  unique_ptr<SSqlStatement> d_listSubZoneQuery_stmt;
+  unique_ptr<SSqlStatement> d_MasterOfDomainsZoneQuery_stmt;
+  unique_ptr<SSqlStatement> d_InfoOfDomainsZoneQuery_stmt;
+  unique_ptr<SSqlStatement> d_InfoOfAllSlaveDomainsQuery_stmt;
+  unique_ptr<SSqlStatement> d_SuperMasterInfoQuery_stmt;
+  unique_ptr<SSqlStatement> d_GetSuperMasterIPs_stmt;
+  unique_ptr<SSqlStatement> d_InsertZoneQuery_stmt;
+  unique_ptr<SSqlStatement> d_InsertRecordQuery_stmt;
+  unique_ptr<SSqlStatement> d_InsertEmptyNonTerminalOrderQuery_stmt;
+  unique_ptr<SSqlStatement> d_UpdateMasterOfZoneQuery_stmt;
+  unique_ptr<SSqlStatement> d_UpdateKindOfZoneQuery_stmt;
+  unique_ptr<SSqlStatement> d_UpdateAccountOfZoneQuery_stmt;
+  unique_ptr<SSqlStatement> d_UpdateSerialOfZoneQuery_stmt;
+  unique_ptr<SSqlStatement> d_UpdateLastCheckofZoneQuery_stmt;
+  unique_ptr<SSqlStatement> d_InfoOfAllMasterDomainsQuery_stmt;
+  unique_ptr<SSqlStatement> d_DeleteDomainQuery_stmt;
+  unique_ptr<SSqlStatement> d_DeleteZoneQuery_stmt;
+  unique_ptr<SSqlStatement> d_DeleteRRSetQuery_stmt;
+  unique_ptr<SSqlStatement> d_DeleteNamesQuery_stmt;
+  unique_ptr<SSqlStatement> d_ZoneLastChangeQuery_stmt;
+  unique_ptr<SSqlStatement> d_firstOrderQuery_stmt;
+  unique_ptr<SSqlStatement> d_beforeOrderQuery_stmt;
+  unique_ptr<SSqlStatement> d_afterOrderQuery_stmt;
+  unique_ptr<SSqlStatement> d_lastOrderQuery_stmt;
+  unique_ptr<SSqlStatement> d_updateOrderNameAndAuthQuery_stmt;
+  unique_ptr<SSqlStatement> d_updateOrderNameAndAuthTypeQuery_stmt;
+  unique_ptr<SSqlStatement> d_nullifyOrderNameAndUpdateAuthQuery_stmt;
+  unique_ptr<SSqlStatement> d_nullifyOrderNameAndUpdateAuthTypeQuery_stmt;
+  unique_ptr<SSqlStatement> d_RemoveEmptyNonTerminalsFromZoneQuery_stmt;
+  unique_ptr<SSqlStatement> d_DeleteEmptyNonTerminalQuery_stmt;
+  unique_ptr<SSqlStatement> d_AddDomainKeyQuery_stmt;
+  unique_ptr<SSqlStatement> d_GetLastInsertedKeyIdQuery_stmt;
+  unique_ptr<SSqlStatement> d_ListDomainKeysQuery_stmt;
+  unique_ptr<SSqlStatement> d_GetAllDomainMetadataQuery_stmt;
+  unique_ptr<SSqlStatement> d_GetDomainMetadataQuery_stmt;
+  unique_ptr<SSqlStatement> d_ClearDomainMetadataQuery_stmt;
+  unique_ptr<SSqlStatement> d_ClearDomainAllMetadataQuery_stmt;
+  unique_ptr<SSqlStatement> d_SetDomainMetadataQuery_stmt;
+  unique_ptr<SSqlStatement> d_RemoveDomainKeyQuery_stmt;
+  unique_ptr<SSqlStatement> d_ActivateDomainKeyQuery_stmt;
+  unique_ptr<SSqlStatement> d_DeactivateDomainKeyQuery_stmt;
+  unique_ptr<SSqlStatement> d_ClearDomainAllKeysQuery_stmt;
+  unique_ptr<SSqlStatement> d_getTSIGKeyQuery_stmt;
+  unique_ptr<SSqlStatement> d_setTSIGKeyQuery_stmt;
+  unique_ptr<SSqlStatement> d_deleteTSIGKeyQuery_stmt;
+  unique_ptr<SSqlStatement> d_getTSIGKeysQuery_stmt;
+  unique_ptr<SSqlStatement> d_getAllDomainsQuery_stmt;
+  unique_ptr<SSqlStatement> d_ListCommentsQuery_stmt;
+  unique_ptr<SSqlStatement> d_InsertCommentQuery_stmt;
+  unique_ptr<SSqlStatement> d_DeleteCommentRRsetQuery_stmt;
+  unique_ptr<SSqlStatement> d_DeleteCommentsQuery_stmt;
+  unique_ptr<SSqlStatement> d_SearchRecordsQuery_stmt;
+  unique_ptr<SSqlStatement> d_SearchCommentsQuery_stmt;
 
 protected:
   SSql *d_db{nullptr};

diff --git a/pdns/backends/gsql/ssql.hh b/pdns/backends/gsql/ssql.hh
index 642b4a662855b73572b85202aa8c2a6dea659d19..661b23f9145a6902153735999113bd0f0b6a6cab 100644 (file)
--- a/pdns/backends/gsql/ssql.hh
+++ b/pdns/backends/gsql/ssql.hh
@@ -76,7 +76,7 @@ class SSql
 {
 public:
   virtual SSqlException sPerrorException(const string &reason)=0;
-  virtual SSqlStatement* prepare(const string& query, int nparams)=0;
+  virtual std::unique_ptr<SSqlStatement> prepare(const string& query, int nparams)=0;
   virtual void execute(const string& query)=0;
   virtual void startTransaction()=0;
   virtual void rollback()=0;

diff --git a/pdns/ssqlite3.cc b/pdns/ssqlite3.cc
index 9c275688fd86cd4d33b61e2a4783b9d5526340d4..037aa259a75acb3fd1745db9d02ea67987deae25 100644 (file)
--- a/pdns/ssqlite3.cc
+++ b/pdns/ssqlite3.cc
@@ -210,8 +210,8 @@ SSQLite3::~SSQLite3()
   }
 }
 
-SSqlStatement* SSQLite3::prepare(const string& query, int nparams __attribute__((unused))) {
-  return new SSQLite3Statement(this, m_dolog, query);
+std::unique_ptr<SSqlStatement> SSQLite3::prepare(const string& query, int nparams __attribute__((unused))) {
+  return std::unique_ptr<SSqlStatement>(new SSQLite3Statement(this, m_dolog, query));
 }
 
 void SSQLite3::execute(const string& query) {

diff --git a/pdns/ssqlite3.hh b/pdns/ssqlite3.hh
index 85436a4b78ef58d386b47931417562db5355dd33..affc36a652cc3e374e7c0493d6317601f67a0adc 100644 (file)
--- a/pdns/ssqlite3.hh
+++ b/pdns/ssqlite3.hh
@@ -42,7 +42,7 @@ public:
   //! Destructor.
   ~SSQLite3();
 
-  SSqlStatement* prepare(const string& query, int nparams);
+  std::unique_ptr<SSqlStatement> prepare(const string& query, int nparams) override;
   void execute(const string& query);
   void setLog(bool state);