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

#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"));
      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_ZoneLastChangeQuery_stmt = d_db->prepare(d_ZoneLastChangeQuery, 1);
      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_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);
      d_IsOurDomainQuery_stmt = d_db->prepare(d_IsOurDomainQuery, 2);
    }
  }

  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_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);
    release(&d_IsOurDomainQuery_stmt);
  }

  void lookup(const QType &, const DNSName &qdomain, DNSPacket *p=0, int zoneId=-1);
  bool list(const DNSName &target, int domain_id, bool include_disabled=false);
  bool get(DNSResourceRecord &r);
  void getAllDomains(vector<DomainInfo> *domains, bool include_disabled=false);
  bool isMaster(const DNSName &domain, const string &ip);
  void alsoNotifies(const DNSName &domain, set<string> *ips);
  bool startTransaction(const DNSName &domain, int domain_id=-1);
  bool commitTransaction();
  bool abortTransaction();
  bool feedRecord(const DNSResourceRecord &r, string *ordername=0);
  bool feedEnts(int domain_id, map<DNSName,bool>& nonterm);
  bool feedEnts3(int domain_id, const DNSName &domain, map<DNSName,bool> &nonterm, const NSEC3PARAMRecordContent& ns3prc, bool narrow);
  bool createDomain(const DNSName &domain, const string &type, const string &masters, const string &account);
  bool createDomain(const DNSName &domain) {
    return createDomain(domain, "NATIVE", "", "");
  };
  bool createSlaveDomain(const string &ip, const DNSName &domain, const string &nameserver, const string &account);
  bool deleteDomain(const DNSName &domain);
  bool superMasterBackend(const string &ip, const DNSName &domain, const vector<DNSResourceRecord>&nsset, string *nameserver, string *account, DNSBackend **db);
  void setFresh(uint32_t domain_id);
  void getUnfreshSlaveInfos(vector<DomainInfo> *domains);
  void getUpdatedMasters(vector<DomainInfo> *updatedDomains);
  bool getDomainInfo(const DNSName &domain, DomainInfo &di);
  void setNotified(uint32_t domain_id, uint32_t serial);
  bool setMaster(const DNSName &domain, const string &ip);
  bool setKind(const DNSName &domain, const DomainInfo::DomainKind kind);
  bool setAccount(const DNSName &domain, const string &account);

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

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

  virtual bool calculateSOASerial(const DNSName& domain, const SOAData& sd, time_t& serial);

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

  bool listComments(const uint32_t domain_id);
  bool getComment(Comment& comment);
  void feedComment(const Comment& comment);
  bool replaceComments(const uint32_t domain_id, const DNSName& qname, const QType& qt, const vector<Comment>& comments);
  bool replaceComments(const uint32_t domain_id, const string& qname, const QType& qt, const vector<Comment>& comments);
  string directBackendCmd(const string &query);
  bool searchRecords(const string &pattern, int maxResults, vector<DNSResourceRecord>& result);
  bool searchComments(const string &pattern, int maxResults, vector<Comment>& result);
  bool isOurDomain(const DNSName &zone, int domain_id=-1);
protected:
  string pattern2SQLPattern(const string& pattern);
  void extractRecord(const SSqlStatement::row_t& row, DNSResourceRecord& rr);
  void extractComment(const SSqlStatement::row_t& row, Comment& c);

private:
  string d_query_name;
  DNSName d_qname;
  SSql *d_db;
  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_ZoneLastChangeQuery;

  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_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;

  string d_IsOurDomainQuery;

  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_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;
  SSqlStatement* d_IsOurDomainQuery_stmt;
protected:
  bool d_dnssecQueries;
};

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