using sql backends

src/Business/PdnsSlave.cpp

         return res;
     std::string sql;
     for (auto a : _actions)
-        sql += a->getSqlQuery();
+        sql += a->getSql(sqlDb);
     res = sqlDb->override(sql);
     delete sqlDb;
     return res;

src/DBO/Actions/Action.cpp

     _domain = domain;
 }
 
-const std::string Action::getSqlQuery() const
-{
-    return "SET @domain_id=(SELECT id FROM domains WHERE name=\"" + _domain + "\");\n" + getSql();
-}
-
 const std::string Action::getDhcpConf() const
 {
     return getDhcp();

src/DBO/Actions/Action.h

 #ifndef PDNS_SLAVE_ACTION_H
 #define PDNS_SLAVE_ACTION_H
 
-# include <string>
-# include <memory>
-# include <vector>
+#include <string>
+#include <memory>
+#include <vector>
+
+class AbstractSql;
 
 class Action
 {
 
     const std::string getDhcpConf() const;
 
-    const std::string getSqlQuery() const;
+    virtual const std::string getSql(AbstractSql* sqlDb) const = 0;
 
     const std::string &getDomain() const;
 
     void setDomain(const std::string &domain);
 
 protected:
-    virtual const std::string getSql() const = 0;
 
     virtual const std::string getDhcp() const;
 

src/DBO/Actions/ActionAddDomain.cpp

 //
 
 #include "ActionAddDomain.h"
+#include "../../DataAccess/AbstractSql.h"
 
 ActionAddDomain::ActionAddDomain()
 {
     _ttl = ttl;
 }
 
-const std::string ActionAddDomain::getSql() const
+const std::string ActionAddDomain::getSql(AbstractSql* sqlDb) const
 {
-    auto soa = _soaNs + " " + _soaMail + " " + std::to_string(time(nullptr)) + " " + std::to_string(_soaRefresh)
-             + " " + std::to_string(_soaRetry)+ " " + std::to_string(_soaExpire) + " " + std::to_string(_soaTtl);
-
-    return "INSERT INTO domains (name, type) VALUES (\"" + _domain + "\", \"MASTER\");\n"
-            "SET @domain_id=(SELECT id FROM domains WHERE name=\"" + _domain + "\");\n"
-            "INSERT INTO zones (domain_id, owner, zone_templ_id) VALUES (@domain_id, "
-            "(SELECT id FROM users ORDER BY id LIMIT 1), 0);\n"
-            "INSERT INTO records (domain_id, name, type, content, ttl, prio, change_date)\n"
-            "    VALUES(@domain_id, \"" + _domain + "\", \"SOA\","
-            " \"" + soa + "\", " + std::to_string(_ttl) + ", 0, " + std::to_string(time(nullptr)) + ");\n";
+    return sqlDb->getAddDomainQuery(*this);
 }

src/DBO/Actions/ActionAddDomain.h

     void setSoaMail(const std::string &soaMail);
 
 protected:
-    const std::string getSql() const override;
+    const std::string getSql(AbstractSql* sqlDb) const override;
 
 private:
     std::string _soaNs;

src/DBO/Actions/ActionAddHost.cpp

 #include <sstream>
 #include <vector>
 #include "ActionAddHost.h"
+#include "../../DataAccess/AbstractSql.h"
 
 std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems) {
     std::stringstream ss(s);
 {
 }
 
-const std::string ActionAddHost::getSql() const
+const std::string ActionAddHost::getSql(AbstractSql* sqlDb) const
 {
-    auto host = _host.empty() ? _domain : _host + "." + _domain;
-    auto query = "INSERT INTO records (domain_id, name, type, content, ttl, prio, change_date)\n"
-            "    VALUES(@domain_id, \"" + host + "\", \"" + _recordType + "\","
-            " \"" + _recordValue + "\", " + std::to_string(_ttl) + ", 0, " + std::to_string(time(nullptr)) + ");\n";
-
-    if (_reverseEnabled && _recordType == "A")
-    {
-        auto reversedValue = getReversedValue();
-        auto reverseDomain = _reverseDomain.empty() ? "in-addr.arpa" : _reverseDomain + ".in-addr.arpa";
-
-        query += "INSERT INTO records (domain_id, name, type, content, ttl, prio, change_date)\n"
-                 "    VALUES((SELECT id FROM domains WHERE name=\"" + reverseDomain + "\"), \""
-                 + reversedValue + "." + reverseDomain + "\", \"PTR\","
-                 " \"" + _host + "." + _domain + "\", 84600, 0, " + std::to_string(time(nullptr)) + ");\n";
-    }
-
-    return query;
+    return sqlDb->getAddHostQuery(*this);
 }
 
 const std::string &ActionAddHost::getHost() const

src/DBO/Actions/ActionAddHost.h

 
     void setTtl(int ttl);
 
+    const std::string getReversedValue() const;
+
 protected:
-    const std::string getSql() const override;
+    const std::string getSql(AbstractSql* sqlDb) const override;
 
     const std::string getDhcp() const override;
 
 private:
-    const std::string getReversedValue() const;
 
     std::string _host;
 

src/DBO/Actions/ActionDelDomain.cpp

 //
 
 #include "ActionDelDomain.h"
+#include "../../DataAccess/AbstractSql.h"
 
 ActionDelDomain::ActionDelDomain()
 {
 }
 
-const std::string ActionDelDomain::getSql() const
+const std::string ActionDelDomain::getSql(AbstractSql* sqlDb) const
 {
-    return "DELETE FROM records WHERE domain_id=@domain_id;\n"
-            "DELETE FROM comments WHERE domain_id=@domain_id;\n"
-            "DELETE FROM zones WHERE domain_id=@domain_id;\n"
-            "DELETE FROM cryptokeys WHERE domain_id=@domain_id;\n"
-            "DELETE FROM domainmetadata WHERE domain_id=@domain_id;\n"
-            "DELETE FROM domains WHERE id=@domain_id;\n";
+    return sqlDb->getDelDomainQuery(*this);
 }

src/DBO/Actions/ActionDelDomain.h

     ActionDelDomain();
 
 protected:
-    const std::string getSql() const override;
+    const std::string getSql(AbstractSql* sqlDb) const override;
 };
 
 

src/DBO/Actions/ActionDelHost.cpp

 //
 
 #include "ActionDelHost.h"
+#include "../../DataAccess/AbstractSql.h"
 
 ActionDelHost::ActionDelHost()
 {
 }
 
-const std::string ActionDelHost::getSql() const
+const std::string ActionDelHost::getSql(AbstractSql* sqlDb) const
 {
-    return "DELETE FROM records WHERE name=\"" + _host + "." + _domain + "\" AND "
-           "domain_id=@domain_id;";
+    return sqlDb->getDelHostQuery(*this);
 }
 
 const std::string &ActionDelHost::getHost() const

src/DBO/Actions/ActionDelHost.h

     void setHost(const std::string &host);
 
 protected:
-    const std::string getSql() const override;
+    const std::string getSql(AbstractSql* sqlDb) const override;
 
 private:
     std::string _host;

src/DataAccess/AbstractSql.h

 
 #include <DBO/Result.h>
 #include <DBO/SqlConfiguration.h>
+#include <DBO/Actions/ActionAddDomain.h>
+#include <DBO/Actions/ActionAddHost.h>
+#include <DBO/Actions/ActionDelDomain.h>
+#include <DBO/Actions/ActionDelHost.h>
 #include "DBO/Result.h"
 
 class AbstractSql
 
     virtual BResult override(const std::string& sql) = 0;
 
+    virtual std::string getAddDomainQuery(const ActionAddDomain& action) = 0;
+
+    virtual std::string getAddHostQuery(const ActionAddHost& action) = 0;
+
+    virtual std::string getDelDomainQuery(const ActionDelDomain& action) = 0;
+
+    virtual std::string getDelHostQuery(const ActionDelHost& action) = 0;
+
 protected:
     SqlConfiguration _masterConfig;
 

src/DataAccess/MySql.cpp

         return res.ok(true);
     return res.error("mysql exited with code " + std::to_string(status));
 }
+
+std::string MySql::getAddDomainQuery(const ActionAddDomain &action)
+{
+    auto soa = action.getSoaNs() + " " + action.getSoaMail() + " " + std::to_string(time(nullptr)) + " "
+               + std::to_string(action.getSoaRefresh()) + " " + std::to_string(action.getSoaRetry()) + " "
+               + std::to_string(action.getSoaExpire()) + " " + std::to_string(action.getSoaTtl());
+
+    return "SET @domain_id=(SELECT id FROM domains WHERE name=\"" + action.getDomain() + "\");\n"
+            "INSERT INTO domains (name, type) VALUES (\"" + action.getDomain() + "\", \"MASTER\");\n"
+            "SET @domain_id=(SELECT id FROM domains WHERE name=\"" + action.getDomain() + "\");\n"
+                   "INSERT INTO zones (domain_id, owner, zone_templ_id) VALUES (@domain_id, "
+                   "(SELECT id FROM users ORDER BY id LIMIT 1), 0);\n"
+                   "INSERT INTO records (domain_id, name, type, content, ttl, prio, change_date)\n"
+                   "    VALUES(@domain_id, \"" + action.getDomain() + "\", \"SOA\","
+                   " \"" + soa + "\", " + std::to_string(action.getTtl()) + ", 0, "
+           + std::to_string(time(nullptr)) + ");\n";
+}
+
+std::string MySql::getAddHostQuery(const ActionAddHost &action)
+{
+    auto host = action.getHost().empty() ? action.getDomain() : action.getHost() + "." + action.getDomain();
+    auto query = "SET @domain_id=(SELECT id FROM domains WHERE name=\"" + action.getDomain() + "\");\n"
+                         "INSERT INTO records (domain_id, name, type, content, ttl, prio, change_date)\n"
+                         "    VALUES(@domain_id, \"" + host + "\", \"" + action.getRecordType() + "\","
+                         " \"" + action.getRecordValue() + "\", " + std::to_string(action.getTtl())
+                 + ", 0, " + std::to_string(time(nullptr)) + ");\n";
+
+    if (action.isReverseEnabled() && action.getRecordType() == "A")
+    {
+        auto reversedValue = action.getReversedValue();
+        auto reverseDomain = action.getReverseDomain().empty() ? "in-addr.arpa" :
+                             action.getReverseDomain() + ".in-addr.arpa";
+
+        query += "INSERT INTO records (domain_id, name, type, content, ttl, prio, change_date)\n"
+                         "    VALUES((SELECT id FROM domains WHERE name=\"" + reverseDomain + "\"), \""
+                 + reversedValue + "." + reverseDomain + "\", \"PTR\","
+                         " \"" + action.getHost() + "." + action.getDomain() + "\", 84600, 0, "
+                 + std::to_string(time(nullptr)) + ");\n";
+    }
+
+    return query;
+}
+
+std::string MySql::getDelDomainQuery(const ActionDelDomain &action)
+{
+    return "SET @domain_id=(SELECT id FROM domains WHERE name=\"" + action.getDomain() + "\");\n"
+            "DELETE FROM records WHERE domain_id=@domain_id;\n"
+            "DELETE FROM comments WHERE domain_id=@domain_id;\n"
+            "DELETE FROM zones WHERE domain_id=@domain_id;\n"
+            "DELETE FROM cryptokeys WHERE domain_id=@domain_id;\n"
+            "DELETE FROM domainmetadata WHERE domain_id=@domain_id;\n"
+            "DELETE FROM domains WHERE id=@domain_id;\n";
+}
+
+std::string MySql::getDelHostQuery(const ActionDelHost &action)
+{
+    return "SET @domain_id=(SELECT id FROM domains WHERE name=\"" + action.getDomain() + "\");\n"
+            "DELETE FROM records WHERE name=\"" + action.getHost() + "." + action.getDomain() + "\" AND "
+            "domain_id=@domain_id;";
+}

src/DataAccess/MySql.h

 
     BResult override(const std::string& sql);
 
+    virtual std::string getAddDomainQuery(const ActionAddDomain &action) override;
+
+    virtual std::string getAddHostQuery(const ActionAddHost &action) override;
+
+    virtual std::string getDelDomainQuery(const ActionDelDomain &action) override;
+
+    virtual std::string getDelHostQuery(const ActionDelHost &action) override;
+
 private:
     const std::string getTempFile();
 

src/DataAccess/PgSql.cpp

                                + "-U '" + _masterConfig.getUser() + "' "
                                + "-w -c -x -O '" + _masterConfig.getDatabase() + "' "
                                + "> '" + _dumpFilePath + "'");
-    std::cout << command << std::endl;
     int status = system(command.c_str());
     if (status == 0)
         return res.ok(true);
                                + "psql -h '" + _slaveConfig.getHost() + "' "
                                + "-U '" + _slaveConfig.getUser() + "' "
                                + "-w -d '" + _slaveConfig.getDatabase() + "' > /dev/null");
-    std::cout << command << std::endl;
     int status = system(command.c_str());
     if (status == 0)
         return res.ok(true);
     return res.error("psql exited with code " + std::to_string(status));
-}
+}
+
+std::string PgSql::getAddDomainQuery(const ActionAddDomain &action)
+{
+    return "";
+}
+
+std::string PgSql::getAddHostQuery(const ActionAddHost &action)
+{
+    return "";
+}
+
+std::string PgSql::getDelDomainQuery(const ActionDelDomain &action)
+{
+    return "";
+}
+
+std::string PgSql::getDelHostQuery(const ActionDelHost &action)
+{
+    return "";
+}

src/DataAccess/PgSql.h

 
     BResult override(const std::string& sql);
 
+    virtual std::string getAddDomainQuery(const ActionAddDomain &action) override;
+
+    virtual std::string getAddHostQuery(const ActionAddHost &action) override;
+
+    virtual std::string getDelDomainQuery(const ActionDelDomain &action) override;
+
+    virtual std::string getDelHostQuery(const ActionDelHost &action) override;
+
+
 private:
     const std::string getTempFile();