[thirdparty/pdns.git] / pdns / backends / gsql / gsqlbackend.hh

/*
 * This file is part of PowerDNS or dnsdist.
 * Copyright -- PowerDNS.COM B.V. and its contributors
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * In addition, for the avoidance of any doubt, permission is granted to
 * link this program with OpenSSL and to (re)distribute the binaries
 * produced as the result of such linking.
 *
 * 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 Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
#ifndef PDNS_GSQLBACKEND_HH
#define PDNS_GSQLBACKEND_HH

#include <string>
#include <map>
#include "ssql.hh"
#include "pdns/arguments.hh"

#include "pdns/namespaces.hh"

bool isDnssecDomainMetadata (const string& name);

/* 
GSQLBackend is a generic backend used by other sql backends
*/
class GSQLBackend : public DNSBackend
{
public:
  GSQLBackend(const string &mode, const string &suffix); //!< Makes our connection to the database. Throws an exception if it fails.
  virtual ~GSQLBackend()
  {
    freeStatements();
    if(d_db)
      delete d_db;    
  }
  
  void setDB(SSql *db)
  {
    freeStatements();
    delete d_db;
    d_db=db;
    if (d_db) {
      d_db->setLog(::arg().mustDo("query-logging"));
      allocateStatements();
    }
  }

  void allocateStatements()
  {
    if (d_db) {
      d_NoIdQuery_stmt = d_db->prepare(d_NoIdQuery, 2);
      d_IdQuery_stmt = d_db->prepare(d_IdQuery, 3);
      d_ANYNoIdQuery_stmt = d_db->prepare(d_ANYNoIdQuery, 1);
      d_ANYIdQuery_stmt = d_db->prepare(d_ANYIdQuery, 2);
      d_listQuery_stmt = d_db->prepare(d_listQuery, 2);
      d_listSubZoneQuery_stmt = d_db->prepare(d_listSubZoneQuery, 3);
      d_MasterOfDomainsZoneQuery_stmt = d_db->prepare(d_MasterOfDomainsZoneQuery, 1);
      d_InfoOfDomainsZoneQuery_stmt = d_db->prepare(d_InfoOfDomainsZoneQuery, 1);
      d_InfoOfAllSlaveDomainsQuery_stmt = d_db->prepare(d_InfoOfAllSlaveDomainsQuery, 0);
      d_SuperMasterInfoQuery_stmt = d_db->prepare(d_SuperMasterInfoQuery, 2);
      d_GetSuperMasterIPs_stmt = d_db->prepare(d_GetSuperMasterIPs, 2);
      d_InsertZoneQuery_stmt = d_db->prepare(d_InsertZoneQuery, 4);
      d_InsertRecordQuery_stmt = d_db->prepare(d_InsertRecordQuery, 9);
      d_InsertEmptyNonTerminalOrderQuery_stmt = d_db->prepare(d_InsertEmptyNonTerminalOrderQuery, 4);
      d_UpdateMasterOfZoneQuery_stmt = d_db->prepare(d_UpdateMasterOfZoneQuery, 2);
      d_UpdateKindOfZoneQuery_stmt = d_db->prepare(d_UpdateKindOfZoneQuery, 2);
      d_UpdateAccountOfZoneQuery_stmt = d_db->prepare(d_UpdateAccountOfZoneQuery, 2);
      d_UpdateSerialOfZoneQuery_stmt = d_db->prepare(d_UpdateSerialOfZoneQuery, 2);
      d_UpdateLastCheckofZoneQuery_stmt = d_db->prepare(d_UpdateLastCheckofZoneQuery, 2);
      d_InfoOfAllMasterDomainsQuery_stmt = d_db->prepare(d_InfoOfAllMasterDomainsQuery, 0);
      d_DeleteDomainQuery_stmt = d_db->prepare(d_DeleteDomainQuery, 1);
      d_DeleteZoneQuery_stmt = d_db->prepare(d_DeleteZoneQuery, 1);
      d_DeleteRRSetQuery_stmt = d_db->prepare(d_DeleteRRSetQuery, 3);
      d_DeleteNamesQuery_stmt = d_db->prepare(d_DeleteNamesQuery, 2);
      d_firstOrderQuery_stmt = d_db->prepare(d_firstOrderQuery, 1);
      d_beforeOrderQuery_stmt = d_db->prepare(d_beforeOrderQuery, 2);
      d_afterOrderQuery_stmt = d_db->prepare(d_afterOrderQuery, 2);
      d_lastOrderQuery_stmt = d_db->prepare(d_lastOrderQuery, 1);
      d_updateOrderNameAndAuthQuery_stmt = d_db->prepare(d_updateOrderNameAndAuthQuery, 4);
      d_updateOrderNameAndAuthTypeQuery_stmt = d_db->prepare(d_updateOrderNameAndAuthTypeQuery, 5);
      d_nullifyOrderNameAndUpdateAuthQuery_stmt = d_db->prepare(d_nullifyOrderNameAndUpdateAuthQuery, 3);
      d_nullifyOrderNameAndUpdateAuthTypeQuery_stmt = d_db->prepare(d_nullifyOrderNameAndUpdateAuthTypeQuery, 4);
      d_RemoveEmptyNonTerminalsFromZoneQuery_stmt = d_db->prepare(d_RemoveEmptyNonTerminalsFromZoneQuery, 1);
      d_DeleteEmptyNonTerminalQuery_stmt = d_db->prepare(d_DeleteEmptyNonTerminalQuery, 2);
      d_AddDomainKeyQuery_stmt = d_db->prepare(d_AddDomainKeyQuery, 4);
      d_GetLastInsertedKeyIdQuery_stmt = d_db->prepare(d_GetLastInsertedKeyIdQuery, 0);
      d_ListDomainKeysQuery_stmt = d_db->prepare(d_ListDomainKeysQuery, 1);
      d_GetAllDomainMetadataQuery_stmt = d_db->prepare(d_GetAllDomainMetadataQuery, 1);
      d_GetDomainMetadataQuery_stmt = d_db->prepare(d_GetDomainMetadataQuery, 2);
      d_ClearDomainMetadataQuery_stmt = d_db->prepare(d_ClearDomainMetadataQuery, 2);
      d_ClearDomainAllMetadataQuery_stmt = d_db->prepare(d_ClearDomainAllMetadataQuery, 1);
      d_SetDomainMetadataQuery_stmt = d_db->prepare(d_SetDomainMetadataQuery, 3);
      d_RemoveDomainKeyQuery_stmt = d_db->prepare(d_RemoveDomainKeyQuery, 2);
      d_ActivateDomainKeyQuery_stmt = d_db->prepare(d_ActivateDomainKeyQuery, 2);
      d_DeactivateDomainKeyQuery_stmt = d_db->prepare(d_DeactivateDomainKeyQuery, 2);
      d_ClearDomainAllKeysQuery_stmt = d_db->prepare(d_ClearDomainAllKeysQuery, 1);
      d_getTSIGKeyQuery_stmt = d_db->prepare(d_getTSIGKeyQuery, 1);
      d_setTSIGKeyQuery_stmt = d_db->prepare(d_setTSIGKeyQuery, 3);
      d_deleteTSIGKeyQuery_stmt = d_db->prepare(d_deleteTSIGKeyQuery, 1);
      d_getTSIGKeysQuery_stmt = d_db->prepare(d_getTSIGKeysQuery, 0);
      d_getAllDomainsQuery_stmt = d_db->prepare(d_getAllDomainsQuery, 1);
      d_ListCommentsQuery_stmt = d_db->prepare(d_ListCommentsQuery, 1);
      d_InsertCommentQuery_stmt = d_db->prepare(d_InsertCommentQuery, 6);
      d_DeleteCommentRRsetQuery_stmt = d_db->prepare(d_DeleteCommentRRsetQuery, 3);
      d_DeleteCommentsQuery_stmt = d_db->prepare(d_DeleteCommentsQuery, 1);
      d_SearchRecordsQuery_stmt = d_db->prepare(d_SearchRecordsQuery, 3);
      d_SearchCommentsQuery_stmt = d_db->prepare(d_SearchCommentsQuery, 3);
    }
  }

  void freeStatements() {
    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_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;
  bool list(const DNSName &target, int domain_id, bool include_disabled=false) override;
  bool get(DNSResourceRecord &r) override;
  void getAllDomains(vector<DomainInfo> *domains, bool include_disabled=false) override;
  void alsoNotifies(const DNSName &domain, set<string> *ips) override;
  bool startTransaction(const DNSName &domain, int domain_id=-1) override;
  bool commitTransaction() override;
  bool abortTransaction() override;
  bool feedRecord(const DNSResourceRecord &r, const DNSName &ordername) override;
  bool feedEnts(int domain_id, map<DNSName,bool>& nonterm) override;
  bool feedEnts3(int domain_id, const DNSName &domain, map<DNSName,bool> &nonterm, const NSEC3PARAMRecordContent& ns3prc, bool narrow) override;
  bool createDomain(const DNSName &domain) override {
    return createDomain(domain, "NATIVE", "", "");
  };
  bool createSlaveDomain(const string &ip, const DNSName &domain, const string &nameserver, const string &account) override;
  bool deleteDomain(const DNSName &domain) override;
  bool superMasterBackend(const string &ip, const DNSName &domain, const vector<DNSResourceRecord>&nsset, string *nameserver, string *account, DNSBackend **db) override;
  void setFresh(uint32_t domain_id) override;
  void getUnfreshSlaveInfos(vector<DomainInfo> *domains) override;
  void getUpdatedMasters(vector<DomainInfo> *updatedDomains) override;
  bool getDomainInfo(const DNSName &domain, DomainInfo &di, bool getSerial=true) override;
  void setNotified(uint32_t domain_id, uint32_t serial) override;
  bool setMaster(const DNSName &domain, const string &ip) override;
  bool setKind(const DNSName &domain, const DomainInfo::DomainKind kind) override;
  bool setAccount(const DNSName &domain, const string &account) override;

  bool getBeforeAndAfterNamesAbsolute(uint32_t id, const DNSName& qname, DNSName& unhashed, DNSName& before, DNSName& after) override;
  bool updateDNSSECOrderNameAndAuth(uint32_t domain_id, const DNSName& qname, const DNSName& ordername, bool auth, const uint16_t=QType::ANY) override;

  bool updateEmptyNonTerminals(uint32_t domain_id, set<DNSName>& insert ,set<DNSName>& erase, bool remove) override;
  bool doesDNSSEC() override;

  bool replaceRRSet(uint32_t domain_id, const DNSName& qname, const QType& qt, const vector<DNSResourceRecord>& rrset) override;
  bool listSubZone(const DNSName &zone, int domain_id) override;
  bool addDomainKey(const DNSName& name, const KeyData& key, int64_t& id) override;
  bool getDomainKeys(const DNSName& name, std::vector<KeyData>& keys) override;
  bool getAllDomainMetadata(const DNSName& name, std::map<std::string, std::vector<std::string> >& meta) override;
  bool getDomainMetadata(const DNSName& name, const std::string& kind, std::vector<std::string>& meta) override;
  bool setDomainMetadata(const DNSName& name, const std::string& kind, const std::vector<std::string>& meta) override;
  
  bool removeDomainKey(const DNSName& name, unsigned int id) override;
  bool activateDomainKey(const DNSName& name, unsigned int id) override;
  bool deactivateDomainKey(const DNSName& name, unsigned int id) override;
  
  bool getTSIGKey(const DNSName& name, DNSName* algorithm, string* content) override;
  bool setTSIGKey(const DNSName& name, const DNSName& algorithm, const string& content) override;
  bool deleteTSIGKey(const DNSName& name) override;
  bool getTSIGKeys(std::vector< struct TSIGKey > &keys) override;

  bool listComments(const uint32_t domain_id) override;
  bool getComment(Comment& comment) override;
  void feedComment(const Comment& comment) override;
  bool replaceComments(const uint32_t domain_id, const DNSName& qname, const QType& qt, const vector<Comment>& comments) override;
  string directBackendCmd(const string &query) override;
  bool searchRecords(const string &pattern, int maxResults, vector<DNSResourceRecord>& result) override;
  bool searchComments(const string &pattern, int maxResults, vector<Comment>& result) override;

protected:
  bool createDomain(const DNSName &domain, const string &type, const string &masters, const string &account);
  string pattern2SQLPattern(const string& pattern);
  void extractRecord(const SSqlStatement::row_t& row, DNSResourceRecord& rr);
  void extractComment(const SSqlStatement::row_t& row, Comment& c);
  bool isConnectionUsable() {
    if (d_db) {
      return d_db->isConnectionUsable();
    }
    return false;
  }
  void reconnectIfNeeded()
  {
    if (inTransaction() || isConnectionUsable()) {
      return;
    }

    reconnect();
  }
  virtual void reconnect() { }
  virtual bool inTransaction()
  {
    return d_inTransaction;
  }

private:
  string d_query_name;
  DNSName d_qname;
  SSqlStatement::result_t d_result;

  string d_NoIdQuery;
  string d_IdQuery;
  string d_ANYNoIdQuery;
  string d_ANYIdQuery;

  string d_listQuery;
  string d_listSubZoneQuery;
  string d_logprefix;

  string d_MasterOfDomainsZoneQuery;
  string d_InfoOfDomainsZoneQuery;
  string d_InfoOfAllSlaveDomainsQuery;
  string d_SuperMasterInfoQuery;
  string d_GetSuperMasterName;
  string d_GetSuperMasterIPs;

  string d_InsertZoneQuery;
  string d_InsertRecordQuery;
  string d_InsertEmptyNonTerminalOrderQuery;
  string d_UpdateMasterOfZoneQuery;
  string d_UpdateKindOfZoneQuery;
  string d_UpdateAccountOfZoneQuery;
  string d_UpdateSerialOfZoneQuery;
  string d_UpdateLastCheckofZoneQuery;
  string d_InfoOfAllMasterDomainsQuery;
  string d_DeleteDomainQuery;
  string d_DeleteZoneQuery;
  string d_DeleteRRSetQuery;
  string d_DeleteNamesQuery;

  string d_firstOrderQuery;
  string d_beforeOrderQuery;
  string d_afterOrderQuery;
  string d_lastOrderQuery;

  string d_updateOrderNameAndAuthQuery;
  string d_updateOrderNameAndAuthTypeQuery;
  string d_nullifyOrderNameAndUpdateAuthQuery;
  string d_nullifyOrderNameAndUpdateAuthTypeQuery;

  string d_RemoveEmptyNonTerminalsFromZoneQuery;
  string d_DeleteEmptyNonTerminalQuery;

  string d_AddDomainKeyQuery;
  string d_GetLastInsertedKeyIdQuery;
  string d_ListDomainKeysQuery;
  string d_GetAllDomainMetadataQuery;
  string d_GetDomainMetadataQuery;
  string d_ClearDomainMetadataQuery;
  string d_ClearDomainAllMetadataQuery;
  string d_SetDomainMetadataQuery;

  string d_RemoveDomainKeyQuery;
  string d_ActivateDomainKeyQuery;
  string d_DeactivateDomainKeyQuery;
  string d_ClearDomainAllKeysQuery;

  string d_getTSIGKeyQuery;
  string d_setTSIGKeyQuery;
  string d_deleteTSIGKeyQuery;
  string d_getTSIGKeysQuery;

  string d_getAllDomainsQuery;

  string d_ListCommentsQuery;
  string d_InsertCommentQuery;
  string d_DeleteCommentRRsetQuery;
  string d_DeleteCommentsQuery;

  string d_SearchRecordsQuery;
  string d_SearchCommentsQuery;

  unique_ptr<SSqlStatement>* d_query_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_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};
  bool d_dnssecQueries;
  bool d_inTransaction{false};
};

#endif /* PDNS_GSQLBACKEND_HH */
Commit	Line	Data
12471842 PL	1	/*
	2	* This file is part of PowerDNS or dnsdist.
	3	* Copyright -- PowerDNS.COM B.V. and its contributors
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of version 2 of the GNU General Public License as
	7	* published by the Free Software Foundation.
	8	*
	9	* In addition, for the avoidance of any doubt, permission is granted to
	10	* link this program with OpenSSL and to (re)distribute the binaries
	11	* produced as the result of such linking.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program; if not, write to the Free Software
	20	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
	21	*/
680f25f8 RK	22	#ifndef PDNS_GSQLBACKEND_HH
	23	#define PDNS_GSQLBACKEND_HH
	24
b4ce8b4e BH	25	#include <string>
	26	#include <map>
	27	#include "ssql.hh"
eb743bba	28	#include "pdns/arguments.hh"
b4ce8b4e	29
9ad7641b	30	#include "pdns/namespaces.hh"
b4ce8b4e	31
ad34750d KM	32	bool isDnssecDomainMetadata (const string& name);
ad34750d KM	33
1325e8a2 PD	34	/*
	35	GSQLBackend is a generic backend used by other sql backends
	36	*/
b4ce8b4e BH	37	class GSQLBackend : public DNSBackend
	38	{
	39	public:
	40	GSQLBackend(const string &mode, const string &suffix); //!< Makes our connection to the database. Throws an exception if it fails.
	41	virtual ~GSQLBackend()
	42	{
0f310932	43	freeStatements();
b4ce8b4e	44	if(d_db)
0f310932	45	delete d_db;
b4ce8b4e BH	46	}
	47
	48	void setDB(SSql *db)
	49	{
0f310932 AT	50	freeStatements();
0f310932 AT	51	delete d_db;
b4ce8b4e	52	d_db=db;
eb743bba CH	53	if (d_db) {
eb743bba CH	54	d_db->setLog(::arg().mustDo("query-logging"));
db737018 RG	55	allocateStatements();
	56	}
	57	}
	58
	59	void allocateStatements()
	60	{
	61	if (d_db) {
0f310932 AT	62	d_NoIdQuery_stmt = d_db->prepare(d_NoIdQuery, 2);
	63	d_IdQuery_stmt = d_db->prepare(d_IdQuery, 3);
	64	d_ANYNoIdQuery_stmt = d_db->prepare(d_ANYNoIdQuery, 1);
	65	d_ANYIdQuery_stmt = d_db->prepare(d_ANYIdQuery, 2);
	66	d_listQuery_stmt = d_db->prepare(d_listQuery, 2);
	67	d_listSubZoneQuery_stmt = d_db->prepare(d_listSubZoneQuery, 3);
	68	d_MasterOfDomainsZoneQuery_stmt = d_db->prepare(d_MasterOfDomainsZoneQuery, 1);
	69	d_InfoOfDomainsZoneQuery_stmt = d_db->prepare(d_InfoOfDomainsZoneQuery, 1);
	70	d_InfoOfAllSlaveDomainsQuery_stmt = d_db->prepare(d_InfoOfAllSlaveDomainsQuery, 0);
	71	d_SuperMasterInfoQuery_stmt = d_db->prepare(d_SuperMasterInfoQuery, 2);
	72	d_GetSuperMasterIPs_stmt = d_db->prepare(d_GetSuperMasterIPs, 2);
aa09fa3b	73	d_InsertZoneQuery_stmt = d_db->prepare(d_InsertZoneQuery, 4);
08536840	74	d_InsertRecordQuery_stmt = d_db->prepare(d_InsertRecordQuery, 9);
09070ce7	75	d_InsertEmptyNonTerminalOrderQuery_stmt = d_db->prepare(d_InsertEmptyNonTerminalOrderQuery, 4);
0f310932 AT	76	d_UpdateMasterOfZoneQuery_stmt = d_db->prepare(d_UpdateMasterOfZoneQuery, 2);
0f310932 AT	77	d_UpdateKindOfZoneQuery_stmt = d_db->prepare(d_UpdateKindOfZoneQuery, 2);
79532aa7	78	d_UpdateAccountOfZoneQuery_stmt = d_db->prepare(d_UpdateAccountOfZoneQuery, 2);
0f310932 AT	79	d_UpdateSerialOfZoneQuery_stmt = d_db->prepare(d_UpdateSerialOfZoneQuery, 2);
	80	d_UpdateLastCheckofZoneQuery_stmt = d_db->prepare(d_UpdateLastCheckofZoneQuery, 2);
	81	d_InfoOfAllMasterDomainsQuery_stmt = d_db->prepare(d_InfoOfAllMasterDomainsQuery, 0);
	82	d_DeleteDomainQuery_stmt = d_db->prepare(d_DeleteDomainQuery, 1);
	83	d_DeleteZoneQuery_stmt = d_db->prepare(d_DeleteZoneQuery, 1);
	84	d_DeleteRRSetQuery_stmt = d_db->prepare(d_DeleteRRSetQuery, 3);
	85	d_DeleteNamesQuery_stmt = d_db->prepare(d_DeleteNamesQuery, 2);
0f310932 AT	86	d_firstOrderQuery_stmt = d_db->prepare(d_firstOrderQuery, 1);
	87	d_beforeOrderQuery_stmt = d_db->prepare(d_beforeOrderQuery, 2);
	88	d_afterOrderQuery_stmt = d_db->prepare(d_afterOrderQuery, 2);
	89	d_lastOrderQuery_stmt = d_db->prepare(d_lastOrderQuery, 1);
79de0a80 KM	90	d_updateOrderNameAndAuthQuery_stmt = d_db->prepare(d_updateOrderNameAndAuthQuery, 4);
79de0a80 KM	91	d_updateOrderNameAndAuthTypeQuery_stmt = d_db->prepare(d_updateOrderNameAndAuthTypeQuery, 5);
0f310932	92	d_nullifyOrderNameAndUpdateAuthQuery_stmt = d_db->prepare(d_nullifyOrderNameAndUpdateAuthQuery, 3);
79de0a80	93	d_nullifyOrderNameAndUpdateAuthTypeQuery_stmt = d_db->prepare(d_nullifyOrderNameAndUpdateAuthTypeQuery, 4);
09070ce7 PL	94	d_RemoveEmptyNonTerminalsFromZoneQuery_stmt = d_db->prepare(d_RemoveEmptyNonTerminalsFromZoneQuery, 1);
09070ce7 PL	95	d_DeleteEmptyNonTerminalQuery_stmt = d_db->prepare(d_DeleteEmptyNonTerminalQuery, 2);
0f310932	96	d_AddDomainKeyQuery_stmt = d_db->prepare(d_AddDomainKeyQuery, 4);
63de5311	97	d_GetLastInsertedKeyIdQuery_stmt = d_db->prepare(d_GetLastInsertedKeyIdQuery, 0);
0f310932 AT	98	d_ListDomainKeysQuery_stmt = d_db->prepare(d_ListDomainKeysQuery, 1);
	99	d_GetAllDomainMetadataQuery_stmt = d_db->prepare(d_GetAllDomainMetadataQuery, 1);
	100	d_GetDomainMetadataQuery_stmt = d_db->prepare(d_GetDomainMetadataQuery, 2);
	101	d_ClearDomainMetadataQuery_stmt = d_db->prepare(d_ClearDomainMetadataQuery, 2);
	102	d_ClearDomainAllMetadataQuery_stmt = d_db->prepare(d_ClearDomainAllMetadataQuery, 1);
	103	d_SetDomainMetadataQuery_stmt = d_db->prepare(d_SetDomainMetadataQuery, 3);
	104	d_RemoveDomainKeyQuery_stmt = d_db->prepare(d_RemoveDomainKeyQuery, 2);
	105	d_ActivateDomainKeyQuery_stmt = d_db->prepare(d_ActivateDomainKeyQuery, 2);
	106	d_DeactivateDomainKeyQuery_stmt = d_db->prepare(d_DeactivateDomainKeyQuery, 2);
	107	d_ClearDomainAllKeysQuery_stmt = d_db->prepare(d_ClearDomainAllKeysQuery, 1);
	108	d_getTSIGKeyQuery_stmt = d_db->prepare(d_getTSIGKeyQuery, 1);
	109	d_setTSIGKeyQuery_stmt = d_db->prepare(d_setTSIGKeyQuery, 3);
	110	d_deleteTSIGKeyQuery_stmt = d_db->prepare(d_deleteTSIGKeyQuery, 1);
	111	d_getTSIGKeysQuery_stmt = d_db->prepare(d_getTSIGKeysQuery, 0);
	112	d_getAllDomainsQuery_stmt = d_db->prepare(d_getAllDomainsQuery, 1);
	113	d_ListCommentsQuery_stmt = d_db->prepare(d_ListCommentsQuery, 1);
	114	d_InsertCommentQuery_stmt = d_db->prepare(d_InsertCommentQuery, 6);
	115	d_DeleteCommentRRsetQuery_stmt = d_db->prepare(d_DeleteCommentRRsetQuery, 3);
	116	d_DeleteCommentsQuery_stmt = d_db->prepare(d_DeleteCommentsQuery, 1);
474cacfa AT	117	d_SearchRecordsQuery_stmt = d_db->prepare(d_SearchRecordsQuery, 3);
474cacfa AT	118	d_SearchCommentsQuery_stmt = d_db->prepare(d_SearchCommentsQuery, 3);
eb743bba	119	}
b4ce8b4e	120	}
0f310932	121
0f310932	122	void freeStatements() {
a59a9c23 AT	123	d_NoIdQuery_stmt.reset();
	124	d_IdQuery_stmt.reset();
	125	d_ANYNoIdQuery_stmt.reset();
	126	d_ANYIdQuery_stmt.reset();
	127	d_listQuery_stmt.reset();
	128	d_listSubZoneQuery_stmt.reset();
	129	d_MasterOfDomainsZoneQuery_stmt.reset();
	130	d_InfoOfDomainsZoneQuery_stmt.reset();
	131	d_InfoOfAllSlaveDomainsQuery_stmt.reset();
	132	d_SuperMasterInfoQuery_stmt.reset();
	133	d_GetSuperMasterIPs_stmt.reset();
	134	d_InsertZoneQuery_stmt.reset();
	135	d_InsertRecordQuery_stmt.reset();
	136	d_InsertEmptyNonTerminalOrderQuery_stmt.reset();
	137	d_UpdateMasterOfZoneQuery_stmt.reset();
	138	d_UpdateKindOfZoneQuery_stmt.reset();
	139	d_UpdateAccountOfZoneQuery_stmt.reset();
	140	d_UpdateSerialOfZoneQuery_stmt.reset();
	141	d_UpdateLastCheckofZoneQuery_stmt.reset();
	142	d_InfoOfAllMasterDomainsQuery_stmt.reset();
	143	d_DeleteDomainQuery_stmt.reset();
	144	d_DeleteZoneQuery_stmt.reset();
	145	d_DeleteRRSetQuery_stmt.reset();
	146	d_DeleteNamesQuery_stmt.reset();
a59a9c23 AT	147	d_firstOrderQuery_stmt.reset();
	148	d_beforeOrderQuery_stmt.reset();
	149	d_afterOrderQuery_stmt.reset();
	150	d_lastOrderQuery_stmt.reset();
	151	d_updateOrderNameAndAuthQuery_stmt.reset();
	152	d_updateOrderNameAndAuthTypeQuery_stmt.reset();
	153	d_nullifyOrderNameAndUpdateAuthQuery_stmt.reset();
	154	d_nullifyOrderNameAndUpdateAuthTypeQuery_stmt.reset();
	155	d_RemoveEmptyNonTerminalsFromZoneQuery_stmt.reset();
	156	d_DeleteEmptyNonTerminalQuery_stmt.reset();
	157	d_AddDomainKeyQuery_stmt.reset();
	158	d_GetLastInsertedKeyIdQuery_stmt.reset();
	159	d_ListDomainKeysQuery_stmt.reset();
	160	d_GetAllDomainMetadataQuery_stmt.reset();
	161	d_GetDomainMetadataQuery_stmt.reset();
	162	d_ClearDomainMetadataQuery_stmt.reset();
	163	d_ClearDomainAllMetadataQuery_stmt.reset();
	164	d_SetDomainMetadataQuery_stmt.reset();
	165	d_RemoveDomainKeyQuery_stmt.reset();
	166	d_ActivateDomainKeyQuery_stmt.reset();
	167	d_DeactivateDomainKeyQuery_stmt.reset();
	168	d_ClearDomainAllKeysQuery_stmt.reset();
	169	d_getTSIGKeyQuery_stmt.reset();
	170	d_setTSIGKeyQuery_stmt.reset();
	171	d_deleteTSIGKeyQuery_stmt.reset();
	172	d_getTSIGKeysQuery_stmt.reset();
	173	d_getAllDomainsQuery_stmt.reset();
	174	d_ListCommentsQuery_stmt.reset();
	175	d_InsertCommentQuery_stmt.reset();
	176	d_DeleteCommentRRsetQuery_stmt.reset();
	177	d_DeleteCommentsQuery_stmt.reset();
	178	d_SearchRecordsQuery_stmt.reset();
	179	d_SearchCommentsQuery_stmt.reset();
0f310932 AT	180	}
0f310932 AT	181
d57d7155 KM	182	void lookup(const QType &, const DNSName &qdomain, DNSPacket *p=0, int zoneId=-1) override;
	183	bool list(const DNSName &target, int domain_id, bool include_disabled=false) override;
	184	bool get(DNSResourceRecord &r) override;
	185	void getAllDomains(vector<DomainInfo> *domains, bool include_disabled=false) override;
d57d7155 KM	186	void alsoNotifies(const DNSName &domain, set<string> *ips) override;
	187	bool startTransaction(const DNSName &domain, int domain_id=-1) override;
	188	bool commitTransaction() override;
	189	bool abortTransaction() override;
	190	bool feedRecord(const DNSResourceRecord &r, const DNSName &ordername) override;
	191	bool feedEnts(int domain_id, map<DNSName,bool>& nonterm) override;
	192	bool feedEnts3(int domain_id, const DNSName &domain, map<DNSName,bool> &nonterm, const NSEC3PARAMRecordContent& ns3prc, bool narrow) override;
	193	bool createDomain(const DNSName &domain) override {
aa09fa3b PL	194	return createDomain(domain, "NATIVE", "", "");
aa09fa3b PL	195	};
d57d7155 KM	196	bool createSlaveDomain(const string &ip, const DNSName &domain, const string &nameserver, const string &account) override;
	197	bool deleteDomain(const DNSName &domain) override;
	198	bool superMasterBackend(const string &ip, const DNSName &domain, const vector<DNSResourceRecord>&nsset, string nameserver, string account, DNSBackend **db) override;
	199	void setFresh(uint32_t domain_id) override;
	200	void getUnfreshSlaveInfos(vector<DomainInfo> *domains) override;
	201	void getUpdatedMasters(vector<DomainInfo> *updatedDomains) override;
47bddbb7	202	bool getDomainInfo(const DNSName &domain, DomainInfo &di, bool getSerial=true) override;
d57d7155 KM	203	void setNotified(uint32_t domain_id, uint32_t serial) override;
	204	bool setMaster(const DNSName &domain, const string &ip) override;
	205	bool setKind(const DNSName &domain, const DomainInfo::DomainKind kind) override;
	206	bool setAccount(const DNSName &domain, const string &account) override;
c02f13ef	207
d57d7155 KM	208	bool getBeforeAndAfterNamesAbsolute(uint32_t id, const DNSName& qname, DNSName& unhashed, DNSName& before, DNSName& after) override;
d57d7155 KM	209	bool updateDNSSECOrderNameAndAuth(uint32_t domain_id, const DNSName& qname, const DNSName& ordername, bool auth, const uint16_t=QType::ANY) override;
79de0a80	210
d57d7155 KM	211	bool updateEmptyNonTerminals(uint32_t domain_id, set<DNSName>& insert ,set<DNSName>& erase, bool remove) override;
d57d7155 KM	212	bool doesDNSSEC() override;
5c3bf2db	213
d57d7155 KM	214	bool replaceRRSet(uint32_t domain_id, const DNSName& qname, const QType& qt, const vector<DNSResourceRecord>& rrset) override;
	215	bool listSubZone(const DNSName &zone, int domain_id) override;
	216	bool addDomainKey(const DNSName& name, const KeyData& key, int64_t& id) override;
	217	bool getDomainKeys(const DNSName& name, std::vector<KeyData>& keys) override;
	218	bool getAllDomainMetadata(const DNSName& name, std::map<std::string, std::vector<std::string> >& meta) override;
	219	bool getDomainMetadata(const DNSName& name, const std::string& kind, std::vector<std::string>& meta) override;
	220	bool setDomainMetadata(const DNSName& name, const std::string& kind, const std::vector<std::string>& meta) override;
4496f66f	221
d57d7155 KM	222	bool removeDomainKey(const DNSName& name, unsigned int id) override;
	223	bool activateDomainKey(const DNSName& name, unsigned int id) override;
	224	bool deactivateDomainKey(const DNSName& name, unsigned int id) override;
4496f66f	225
d57d7155 KM	226	bool getTSIGKey(const DNSName& name, DNSName* algorithm, string* content) override;
	227	bool setTSIGKey(const DNSName& name, const DNSName& algorithm, const string& content) override;
	228	bool deleteTSIGKey(const DNSName& name) override;
	229	bool getTSIGKeys(std::vector< struct TSIGKey > &keys) override;
9a72349d	230
d57d7155 KM	231	bool listComments(const uint32_t domain_id) override;
	232	bool getComment(Comment& comment) override;
	233	void feedComment(const Comment& comment) override;
	234	bool replaceComments(const uint32_t domain_id, const DNSName& qname, const QType& qt, const vector<Comment>& comments) override;
	235	string directBackendCmd(const string &query) override;
	236	bool searchRecords(const string &pattern, int maxResults, vector<DNSResourceRecord>& result) override;
	237	bool searchComments(const string &pattern, int maxResults, vector<Comment>& result) override;
512eafef	238
474cacfa	239	protected:
d57d7155	240	bool createDomain(const DNSName &domain, const string &type, const string &masters, const string &account);
474cacfa AT	241	string pattern2SQLPattern(const string& pattern);
474cacfa AT	242	void extractRecord(const SSqlStatement::row_t& row, DNSResourceRecord& rr);
512ad04f	243	void extractComment(const SSqlStatement::row_t& row, Comment& c);
45d36933 RG	244	bool isConnectionUsable() {
	245	if (d_db) {
	246	return d_db->isConnectionUsable();
	247	}
	248	return false;
	249	}
bfa196c0	250	void reconnectIfNeeded()
45d36933	251	{
8fc3a46d	252	if (inTransaction() \|\| isConnectionUsable()) {
aacd07ce RG	253	return;
	254	}
	255
bfa196c0 RG	256	reconnect();
	257	}
	258	virtual void reconnect() { }
	259	virtual bool inTransaction()
	260	{
	261	return d_inTransaction;
45d36933	262	}
6cc98ddf	263
b4ce8b4e	264	private:
7c779a31	265	string d_query_name;
f1d06abf	266	DNSName d_qname;
0f310932	267	SSqlStatement::result_t d_result;
b4ce8b4e	268
75f02b56 KM	269	string d_NoIdQuery;
	270	string d_IdQuery;
	271	string d_ANYNoIdQuery;
	272	string d_ANYIdQuery;
	273
b4ce8b4e	274	string d_listQuery;
c69120f2	275	string d_listSubZoneQuery;
b4ce8b4e	276	string d_logprefix;
770e6a9c	277
36d772ab BH	278	string d_MasterOfDomainsZoneQuery;
	279	string d_InfoOfDomainsZoneQuery;
	280	string d_InfoOfAllSlaveDomainsQuery;
	281	string d_SuperMasterInfoQuery;
5805615b AT	282	string d_GetSuperMasterName;
	283	string d_GetSuperMasterIPs;
	284
487cf033	285	string d_InsertZoneQuery;
36d772ab	286	string d_InsertRecordQuery;
09070ce7	287	string d_InsertEmptyNonTerminalOrderQuery;
c02f13ef CH	288	string d_UpdateMasterOfZoneQuery;
c02f13ef CH	289	string d_UpdateKindOfZoneQuery;
79532aa7	290	string d_UpdateAccountOfZoneQuery;
36d772ab BH	291	string d_UpdateSerialOfZoneQuery;
	292	string d_UpdateLastCheckofZoneQuery;
	293	string d_InfoOfAllMasterDomainsQuery;
09d6667a CH	294	string d_DeleteDomainQuery;
09d6667a CH	295	string d_DeleteZoneQuery;
98d47e2e CH	296	string d_DeleteRRSetQuery;
98d47e2e CH	297	string d_DeleteNamesQuery;
770e6a9c	298
5697411b	299	string d_firstOrderQuery;
136efa2f BH	300	string d_beforeOrderQuery;
136efa2f BH	301	string d_afterOrderQuery;
bc74a078	302	string d_lastOrderQuery;
79de0a80 KM	303
	304	string d_updateOrderNameAndAuthQuery;
	305	string d_updateOrderNameAndAuthTypeQuery;
c2df797e	306	string d_nullifyOrderNameAndUpdateAuthQuery;
79de0a80 KM	307	string d_nullifyOrderNameAndUpdateAuthTypeQuery;
79de0a80 KM	308
09070ce7 PL	309	string d_RemoveEmptyNonTerminalsFromZoneQuery;
09070ce7 PL	310	string d_DeleteEmptyNonTerminalQuery;
136efa2f	311
c0273500	312	string d_AddDomainKeyQuery;
63de5311	313	string d_GetLastInsertedKeyIdQuery;
c0273500	314	string d_ListDomainKeysQuery;
df0cc941	315	string d_GetAllDomainMetadataQuery;
c0273500	316	string d_GetDomainMetadataQuery;
f7bcc763	317	string d_ClearDomainMetadataQuery;
09d6667a	318	string d_ClearDomainAllMetadataQuery;
c0273500	319	string d_SetDomainMetadataQuery;
4496f66f BH	320
	321	string d_RemoveDomainKeyQuery;
	322	string d_ActivateDomainKeyQuery;
	323	string d_DeactivateDomainKeyQuery;
09d6667a	324	string d_ClearDomainAllKeysQuery;
770e6a9c	325
78bcb858	326	string d_getTSIGKeyQuery;
9a72349d AT	327	string d_setTSIGKeyQuery;
	328	string d_deleteTSIGKeyQuery;
	329	string d_getTSIGKeysQuery;
1325e8a2 PD	330
	331	string d_getAllDomainsQuery;
	332
6cc98ddf CH	333	string d_ListCommentsQuery;
	334	string d_InsertCommentQuery;
	335	string d_DeleteCommentRRsetQuery;
	336	string d_DeleteCommentsQuery;
	337
474cacfa AT	338	string d_SearchRecordsQuery;
	339	string d_SearchCommentsQuery;
	340
a59a9c23	341	unique_ptr<SSqlStatement>* d_query_stmt;
0f310932	342
a59a9c23 AT	343	unique_ptr<SSqlStatement> d_NoIdQuery_stmt;
	344	unique_ptr<SSqlStatement> d_IdQuery_stmt;
	345	unique_ptr<SSqlStatement> d_ANYNoIdQuery_stmt;
	346	unique_ptr<SSqlStatement> d_ANYIdQuery_stmt;
	347	unique_ptr<SSqlStatement> d_listQuery_stmt;
	348	unique_ptr<SSqlStatement> d_listSubZoneQuery_stmt;
	349	unique_ptr<SSqlStatement> d_MasterOfDomainsZoneQuery_stmt;
	350	unique_ptr<SSqlStatement> d_InfoOfDomainsZoneQuery_stmt;
	351	unique_ptr<SSqlStatement> d_InfoOfAllSlaveDomainsQuery_stmt;
	352	unique_ptr<SSqlStatement> d_SuperMasterInfoQuery_stmt;
	353	unique_ptr<SSqlStatement> d_GetSuperMasterIPs_stmt;
	354	unique_ptr<SSqlStatement> d_InsertZoneQuery_stmt;
	355	unique_ptr<SSqlStatement> d_InsertRecordQuery_stmt;
	356	unique_ptr<SSqlStatement> d_InsertEmptyNonTerminalOrderQuery_stmt;
	357	unique_ptr<SSqlStatement> d_UpdateMasterOfZoneQuery_stmt;
	358	unique_ptr<SSqlStatement> d_UpdateKindOfZoneQuery_stmt;
	359	unique_ptr<SSqlStatement> d_UpdateAccountOfZoneQuery_stmt;
	360	unique_ptr<SSqlStatement> d_UpdateSerialOfZoneQuery_stmt;
	361	unique_ptr<SSqlStatement> d_UpdateLastCheckofZoneQuery_stmt;
	362	unique_ptr<SSqlStatement> d_InfoOfAllMasterDomainsQuery_stmt;
	363	unique_ptr<SSqlStatement> d_DeleteDomainQuery_stmt;
	364	unique_ptr<SSqlStatement> d_DeleteZoneQuery_stmt;
	365	unique_ptr<SSqlStatement> d_DeleteRRSetQuery_stmt;
	366	unique_ptr<SSqlStatement> d_DeleteNamesQuery_stmt;
a59a9c23 AT	367	unique_ptr<SSqlStatement> d_firstOrderQuery_stmt;
	368	unique_ptr<SSqlStatement> d_beforeOrderQuery_stmt;
	369	unique_ptr<SSqlStatement> d_afterOrderQuery_stmt;
	370	unique_ptr<SSqlStatement> d_lastOrderQuery_stmt;
	371	unique_ptr<SSqlStatement> d_updateOrderNameAndAuthQuery_stmt;
	372	unique_ptr<SSqlStatement> d_updateOrderNameAndAuthTypeQuery_stmt;
	373	unique_ptr<SSqlStatement> d_nullifyOrderNameAndUpdateAuthQuery_stmt;
	374	unique_ptr<SSqlStatement> d_nullifyOrderNameAndUpdateAuthTypeQuery_stmt;
	375	unique_ptr<SSqlStatement> d_RemoveEmptyNonTerminalsFromZoneQuery_stmt;
	376	unique_ptr<SSqlStatement> d_DeleteEmptyNonTerminalQuery_stmt;
	377	unique_ptr<SSqlStatement> d_AddDomainKeyQuery_stmt;
	378	unique_ptr<SSqlStatement> d_GetLastInsertedKeyIdQuery_stmt;
	379	unique_ptr<SSqlStatement> d_ListDomainKeysQuery_stmt;
	380	unique_ptr<SSqlStatement> d_GetAllDomainMetadataQuery_stmt;
	381	unique_ptr<SSqlStatement> d_GetDomainMetadataQuery_stmt;
	382	unique_ptr<SSqlStatement> d_ClearDomainMetadataQuery_stmt;
	383	unique_ptr<SSqlStatement> d_ClearDomainAllMetadataQuery_stmt;
	384	unique_ptr<SSqlStatement> d_SetDomainMetadataQuery_stmt;
	385	unique_ptr<SSqlStatement> d_RemoveDomainKeyQuery_stmt;
	386	unique_ptr<SSqlStatement> d_ActivateDomainKeyQuery_stmt;
	387	unique_ptr<SSqlStatement> d_DeactivateDomainKeyQuery_stmt;
	388	unique_ptr<SSqlStatement> d_ClearDomainAllKeysQuery_stmt;
	389	unique_ptr<SSqlStatement> d_getTSIGKeyQuery_stmt;
	390	unique_ptr<SSqlStatement> d_setTSIGKeyQuery_stmt;
	391	unique_ptr<SSqlStatement> d_deleteTSIGKeyQuery_stmt;
	392	unique_ptr<SSqlStatement> d_getTSIGKeysQuery_stmt;
	393	unique_ptr<SSqlStatement> d_getAllDomainsQuery_stmt;
	394	unique_ptr<SSqlStatement> d_ListCommentsQuery_stmt;
	395	unique_ptr<SSqlStatement> d_InsertCommentQuery_stmt;
	396	unique_ptr<SSqlStatement> d_DeleteCommentRRsetQuery_stmt;
	397	unique_ptr<SSqlStatement> d_DeleteCommentsQuery_stmt;
	398	unique_ptr<SSqlStatement> d_SearchRecordsQuery_stmt;
	399	unique_ptr<SSqlStatement> d_SearchCommentsQuery_stmt;
512eafef	400
770e6a9c	401	protected:
bfa196c0	402	SSql *d_db{nullptr};
136efa2f	403	bool d_dnssecQueries;
bfa196c0	404	bool d_inTransaction{false};
b4ce8b4e	405	};
680f25f8 RK	406
680f25f8 RK	407	#endif /* PDNS_GSQLBACKEND_HH */