diff --git a/catalogue/CMakeLists.txt b/catalogue/CMakeLists.txt
index 0c790652b5d9ce15258a2d8e7dc554f03c03f0f7..48fa3cee1a5b4ef2dbdbe936905c1a13ace827fd 100644
--- a/catalogue/CMakeLists.txt
+++ b/catalogue/CMakeLists.txt
@@ -26,12 +26,19 @@ set (CATALOGUE_LIB_SRC_FILES
   ArchiveFileItorImpl.cpp
   Catalogue.cpp
   CatalogueFactory.cpp
+  CatalogueFactoryFactory.cpp
   ChecksumTypeMismatch.cpp
   ChecksumValueMismatch.cpp
   CmdLineTool.cpp
   FileSizeMismatch.cpp
   InMemoryCatalogue.cpp
+  InMemoryCatalogueFactory.cpp
+  MysqlCatalogue.cpp
+  MysqlCatalogueFactory.cpp
+  MysqlCatalogueSchema.cpp
   OracleCatalogue.cpp
+  OracleCatalogueFactory.cpp
+  PostgresqlCatalogueFactory.cpp
   SqliteCatalogueSchema.cpp
   TapeFileWritten.cpp
   TapeItemImplementation.cpp
@@ -40,8 +47,7 @@ set (CATALOGUE_LIB_SRC_FILES
   RdbmsCatalogue.cpp
   SchemaCreatingSqliteCatalogue.cpp
   SqliteCatalogue.cpp
-  MysqlCatalogue.cpp
-  MysqlCatalogueSchema.cpp
+  SqliteCatalogueFactory.cpp
   TapeForWriting.cpp
   UserSpecifiedANonEmptyTape.cpp
   UserSpecifiedANonExistentTape.cpp
@@ -123,7 +129,6 @@ add_custom_command(OUTPUT MysqlCatalogueSchema.cpp
 
 set(IN_MEMORY_CATALOGUE_UNIT_TESTS_LIB_SRC_FILES
   CatalogueTest.cpp
-  CatalogueFactoryTest.cpp
   InMemoryCatalogueTest.cpp
   InMemoryVersionOfCatalogueTest.cpp)
 
diff --git a/catalogue/CatalogueFactory.cpp b/catalogue/CatalogueFactory.cpp
index 717126cc7f1bc374d3a12dafddc32f9f252abcd0..40adf495f3eb3d1ddc44e099dbcb7653c019ce33 100644
--- a/catalogue/CatalogueFactory.cpp
+++ b/catalogue/CatalogueFactory.cpp
@@ -17,61 +17,14 @@
  */
 
 #include "catalogue/CatalogueFactory.hpp"
-#include "catalogue/CatalogueRetryWrapper.hpp"
-#include "catalogue/InMemoryCatalogue.hpp"
-#include "catalogue/OracleCatalogue.hpp"
-#include "catalogue/SqliteCatalogue.hpp"
-#include "catalogue/MysqlCatalogue.hpp"
-#include "common/exception/Exception.hpp"
-#include "common/make_unique.hpp"
 
 namespace cta {
 namespace catalogue {
 
 //------------------------------------------------------------------------------
-// create
+// destructor
 //------------------------------------------------------------------------------
-std::unique_ptr<Catalogue> CatalogueFactory::create(
-  log::Logger &log,
-  const rdbms::Login &login,
-  const uint64_t nbConns,
-  const uint64_t nbArchiveFileListingConns,
-  const uint32_t maxTriesToConnect) {
-  try {
-    switch(login.dbType) {
-    case rdbms::Login::DBTYPE_IN_MEMORY:
-      {
-        auto c = cta::make_unique<InMemoryCatalogue>(log, nbConns, nbArchiveFileListingConns);
-        return cta::make_unique<CatalogueRetryWrapper>(log, std::move(c), maxTriesToConnect);
-      }
-    case rdbms::Login::DBTYPE_ORACLE:
-      {
-        auto c = cta::make_unique<OracleCatalogue>(log, login.username, login.password, login.database, nbConns,
-          nbArchiveFileListingConns);
-        return cta::make_unique<CatalogueRetryWrapper>(log, std::move(c), maxTriesToConnect);
-      }
-    case rdbms::Login::DBTYPE_SQLITE:
-      {
-        auto c = cta::make_unique<SqliteCatalogue>(log, login.database, nbConns, nbArchiveFileListingConns);
-        return cta::make_unique<CatalogueRetryWrapper>(log, std::move(c), maxTriesToConnect);
-      }
-    case rdbms::Login::DBTYPE_MYSQL:
-      {
-        auto c = cta::make_unique<MysqlCatalogue>(log, login, nbConns, nbArchiveFileListingConns);
-        return cta::make_unique<CatalogueRetryWrapper>(log, std::move(c), maxTriesToConnect);
-      }
-    case rdbms::Login::DBTYPE_NONE:
-      throw exception::Exception("Cannot create a catalogue without a database type");
-    default:
-      {
-        exception::Exception ex;
-        ex.getMessage() << "Unknown database type: value=" << login.dbType;
-        throw ex;
-      }
-    }
-  } catch(exception::Exception &ex) {
-    throw exception::Exception(std::string(__FUNCTION__) + " failed: " + ex.getMessage().str());
-  }
+CatalogueFactory:: ~CatalogueFactory() {
 }
 
 } // namespace catalogue
diff --git a/catalogue/CatalogueFactory.hpp b/catalogue/CatalogueFactory.hpp
index 7c0cae56b3d15e3852be295900318deb5f8dc7de..1e6253f72b9e4da6ced9c169aa833e274a002280 100644
--- a/catalogue/CatalogueFactory.hpp
+++ b/catalogue/CatalogueFactory.hpp
@@ -19,48 +19,27 @@
 #pragma once
 
 #include "catalogue/Catalogue.hpp"
-#include "rdbms/Login.hpp"
 
 #include <memory>
-#include <mutex>
 
 namespace cta {
 namespace catalogue {
 
 /**
- * Factory for creating CTA catalogue objects.  This class is a singleton.
+ * Specifies the interface to a factory Catalogue objects.
  */
 class CatalogueFactory {
 public:
 
   /**
-   * Prevent objects of this class from being instantiated.
+   * Destructor.
    */
-  CatalogueFactory() = delete;
+  virtual ~CatalogueFactory();
 
   /**
-   * Creates a CTA catalogue object using the specified database login details.
-   *
-   * @param log Object representing the API to the CTA logging system.
-   * @param login The database connection details.
-   * @param nbConns The maximum number of concurrent connections to the
-   * underlying relational database for all operations accept listing archive
-   * files which can be relatively long operations.
-   * @param nbArchiveFileListingConns The maximum number of concurrent
-   * connections to the underlying relational database for the sole purpose of
-   * listing archive files.
-   * @return The newly created CTA catalogue object.  Please note that it is the
-   * responsibility of the caller to delete the returned CTA catalogue object.
-   * @param maxTriesToConnext The maximum number of times a single method should
-   * try to connect to the database in the event of LostDatabaseConnection
-   * exceptions being thrown.
+   * Returns a newly created CTA catalogue object.
    */
-  static std::unique_ptr<Catalogue> create(
-    log::Logger &log,
-    const rdbms::Login &login,
-    const uint64_t nbConns,
-    const uint64_t nbArchiveFileListingConns,
-    const uint32_t maxTriesToConnect = 3);
+  virtual std::unique_ptr<Catalogue> create() = 0;
 
 }; // class CatalogueFactory
 
diff --git a/catalogue/CatalogueFactoryFactory.cpp b/catalogue/CatalogueFactoryFactory.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..69c885444c37ad1187218342510d94876a0cf752
--- /dev/null
+++ b/catalogue/CatalogueFactoryFactory.cpp
@@ -0,0 +1,67 @@
+/*
+ * The CERN Tape Archive (CTA) project
+ * Copyright (C) 2015  CERN
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "catalogue/CatalogueFactoryFactory.hpp"
+#include "catalogue/InMemoryCatalogueFactory.hpp"
+#include "catalogue/MysqlCatalogueFactory.hpp"
+#include "catalogue/OracleCatalogueFactory.hpp"
+#include "catalogue/PostgresqlCatalogueFactory.hpp"
+#include "catalogue/SqliteCatalogueFactory.hpp"
+#include "common/make_unique.hpp"
+
+namespace cta {
+namespace catalogue {
+
+//------------------------------------------------------------------------------
+// create
+//------------------------------------------------------------------------------
+std::unique_ptr<CatalogueFactory> CatalogueFactoryFactory::create(
+  log::Logger &log,
+  const rdbms::Login &login,
+  const uint64_t nbConns,
+  const uint64_t nbArchiveFileListingConns,
+  const uint32_t maxTriesToConnect) {
+  try {
+    switch(login.dbType) {
+    case rdbms::Login::DBTYPE_IN_MEMORY:
+      return cta::make_unique<InMemoryCatalogueFactory>(log, nbConns, nbArchiveFileListingConns, maxTriesToConnect);
+    case rdbms::Login::DBTYPE_MYSQL:
+      return cta::make_unique<MysqlCatalogueFactory>(log, login, nbConns, nbArchiveFileListingConns, maxTriesToConnect);
+    case rdbms::Login::DBTYPE_ORACLE:
+      return cta::make_unique<OracleCatalogueFactory>(log, login, nbConns, nbArchiveFileListingConns,
+        maxTriesToConnect);
+    case rdbms::Login::DBTYPE_POSTGRESQL:
+      return cta::make_unique<PostgresqlCatalogueFactory>(log, login, nbConns, nbArchiveFileListingConns, maxTriesToConnect);
+    case rdbms::Login::DBTYPE_SQLITE:
+      return cta::make_unique<SqliteCatalogueFactory>(log, login, nbConns, nbArchiveFileListingConns, maxTriesToConnect);
+    case rdbms::Login::DBTYPE_NONE:
+      throw exception::Exception("Cannot create a catalogue without a database type");
+    default:
+      {
+        exception::Exception ex;
+        ex.getMessage() << "Unknown database type: value=" << login.dbType;
+        throw ex;
+      }
+    }
+  } catch(exception::Exception &ex) {
+    throw exception::Exception(std::string(__FUNCTION__) + " failed: " + ex.getMessage().str());
+  }
+}
+
+} // namespace catalogue
+} // namespace cta
diff --git a/catalogue/CatalogueFactoryFactory.hpp b/catalogue/CatalogueFactoryFactory.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..b06a9440843888a6634a5164246b20da2ab2b730
--- /dev/null
+++ b/catalogue/CatalogueFactoryFactory.hpp
@@ -0,0 +1,68 @@
+/*
+ * The CERN Tape Archive (CTA) project
+ * Copyright (C) 2015  CERN
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "catalogue/CatalogueFactory.hpp"
+#include "rdbms/Login.hpp"
+
+#include <memory>
+
+namespace cta {
+namespace catalogue {
+
+/**
+ * Factory of catalogue factories.  This class is a singleton.
+ */
+class CatalogueFactoryFactory {
+public:
+
+  /**
+   * Prevent objects of this class from being instantiated.
+   */
+  CatalogueFactoryFactory() = delete;
+
+  /**
+   * Creates a factory of CTA catalogue objects using the specified database
+   * login details.
+   *
+   * @param log Object representing the API to the CTA logging system.
+   * @param login The database connection details.
+   * @param nbConns The maximum number of concurrent connections to the
+   * underlying relational database for all operations accept listing archive
+   * files which can be relatively long operations.
+   * @param nbArchiveFileListingConns The maximum number of concurrent
+   * connections to the underlying relational database for the sole purpose of
+   * listing archive files.
+   * @return The newly created CTA catalogue object.  Please note that it is the
+   * responsibility of the caller to delete the returned CTA catalogue object.
+   * @param maxTriesToConnext The maximum number of times a single method should
+   * try to connect to the database in the event of LostDatabaseConnection
+   * exceptions being thrown.
+   */
+  static std::unique_ptr<CatalogueFactory> create(
+    log::Logger &log,
+    const rdbms::Login &login,
+    const uint64_t nbConns,
+    const uint64_t nbArchiveFileListingConns,
+    const uint32_t maxTriesToConnect = 3);
+
+}; // class CatalogueFactoryFactory
+
+} // namespace catalogue
+} // namespace cta
diff --git a/catalogue/CatalogueFactoryTest.cpp b/catalogue/CatalogueFactoryTest.cpp
deleted file mode 100644
index 259fbbe6bcce5e1249a57a25cfa6d1d0e77ecc0c..0000000000000000000000000000000000000000
--- a/catalogue/CatalogueFactoryTest.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * The CERN Tape Archive (CTA) project
- * Copyright (C) 2015  CERN
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * 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, see <http://www.gnu.org/licenses/>.
- */
-
-#include "catalogue/ArchiveFileRow.hpp"
-#include "catalogue/CatalogueFactory.hpp"
-#include "common/exception/Exception.hpp"
-#include "common/log/DummyLogger.hpp"
-
-#include <gtest/gtest.h>
-#include <memory>
-
-namespace unitTests {
-
-class cta_catalogue_CatalogueFactoryTest : public ::testing::Test {
-public:
-  cta_catalogue_CatalogueFactoryTest():
-    m_dummyLog("dummy", "dummy") {
-    m_localAdmin.username = "local_admin_user";
-    m_localAdmin.host = "local_admin_host";
-
-    m_admin.username = "admin_user";
-    m_admin.host = "admin_host";
-  }
-
-protected:
-
-  virtual void SetUp() {
-  }
-
-  virtual void TearDown() {
-  }
-
-  cta::log::DummyLogger m_dummyLog;
-  cta::common::dataStructures::SecurityIdentity m_localAdmin;
-  cta::common::dataStructures::SecurityIdentity m_admin;
-};
-
-TEST_F(cta_catalogue_CatalogueFactoryTest, instance_in_memory) {
-  using namespace cta;
-  using namespace cta::catalogue;
-
-  rdbms::Login login(rdbms::Login::DBTYPE_IN_MEMORY, "", "", "", "", 0);
-  const uint64_t nbConns = 1;
-  const uint64_t nbArchiveFileListingConns = 1;
-  std::unique_ptr<Catalogue> catalogue(CatalogueFactory::create(m_dummyLog, login, nbConns, nbArchiveFileListingConns));
-  ASSERT_TRUE(nullptr != catalogue.get());
-
-  ASSERT_TRUE(catalogue->getAdminUsers().empty());
-
-  const std::string createAdminUserComment = "Create admin user";
-  catalogue->createAdminUser(m_localAdmin, m_admin.username, createAdminUserComment);
-
-  {
-    std::list<common::dataStructures::AdminUser> admins;
-    admins = catalogue->getAdminUsers();
-    ASSERT_EQ(1, admins.size());
-
-    const common::dataStructures::AdminUser admin = admins.front();
-    ASSERT_EQ(createAdminUserComment, admin.comment);
-
-    const common::dataStructures::EntryLog creationLog = admin.creationLog;
-    ASSERT_EQ(m_localAdmin.username, creationLog.username);
-    ASSERT_EQ(m_localAdmin.host, creationLog.host);
-
-    const common::dataStructures::EntryLog lastModificationLog = admin.lastModificationLog;
-    ASSERT_EQ(creationLog, lastModificationLog);
-  }
-}
-
-} // namespace unitTests
diff --git a/catalogue/CatalogueTest.cpp b/catalogue/CatalogueTest.cpp
index d7a4f9064530ba1b9efc394fd76d0633b7bdc1e7..cc8b6bacde19e69634b252db0a97c0fc7f4d34ad 100644
--- a/catalogue/CatalogueTest.cpp
+++ b/catalogue/CatalogueTest.cpp
@@ -17,7 +17,6 @@
  */
 
 #include "catalogue/ArchiveFileRow.hpp"
-#include "catalogue/CatalogueFactory.hpp"
 #include "catalogue/CatalogueTest.hpp"
 #include "catalogue/ChecksumTypeMismatch.hpp"
 #include "catalogue/ChecksumValueMismatch.hpp"
@@ -40,6 +39,8 @@
 #include "common/exception/UserError.hpp"
 #include "common/make_unique.hpp"
 #include "rdbms/wrapper/ConnFactoryFactory.hpp"
+#include "rdbms/Conn.hpp"
+#include "rdbms/ConnPool.hpp"
 
 #include <algorithm>
 #include <gtest/gtest.h>
@@ -71,13 +72,17 @@ void cta_catalogue_CatalogueTest::SetUp() {
   using namespace cta::catalogue;
 
   try {
-    const rdbms::Login &login = GetParam()->create();
-    auto connFactory = rdbms::wrapper::ConnFactoryFactory::create(login);
-    const uint64_t nbConns = 2;
-    const uint64_t nbArchiveFileListingConns = 2;
+    CatalogueFactory *const *const catalogueFactoryPtrPtr = GetParam();
 
-    m_catalogue = CatalogueFactory::create(m_dummyLog, login, nbConns, nbArchiveFileListingConns);
-    m_conn = connFactory->create();
+    if(nullptr == catalogueFactoryPtrPtr) {
+      throw exception::Exception("Global pointer to the catalogue factory pointer for unit-tests in null");
+    }
+
+    if(nullptr == (*catalogueFactoryPtrPtr)) {
+      throw exception::Exception("Global pointer to the catalogue factoryfor unit-tests in null");
+    }
+
+    m_catalogue = (*catalogueFactoryPtrPtr)->create();
 
     {
       const std::list<common::dataStructures::AdminUser> adminUsers = m_catalogue->getAdminUsers();
@@ -10373,29 +10378,4 @@ TEST_P(cta_catalogue_CatalogueTest, ping) {
   m_catalogue->ping();
 }
 
-TEST_P(cta_catalogue_CatalogueTest, schemaTables) {
-  const auto tableNameList = m_conn->getTableNames();
-  std::set<std::string> tableNameSet;
-
-  std::map<std::string, uint32_t> tableNameToListPos;
-  uint32_t listPos = 0;
-  for(auto &tableName: tableNameList) {
-    ASSERT_EQ(tableNameToListPos.end(), tableNameToListPos.find(tableName));
-    tableNameToListPos[tableName] = listPos++;
-  }
-
-  ASSERT_NE(tableNameToListPos.end(), tableNameToListPos.find("ADMIN_USER"));
-  ASSERT_NE(tableNameToListPos.end(), tableNameToListPos.find("ARCHIVE_FILE"));
-  ASSERT_NE(tableNameToListPos.end(), tableNameToListPos.find("ARCHIVE_ROUTE"));
-  ASSERT_NE(tableNameToListPos.end(), tableNameToListPos.find("CTA_CATALOGUE"));
-  ASSERT_NE(tableNameToListPos.end(), tableNameToListPos.find("LOGICAL_LIBRARY"));
-  ASSERT_NE(tableNameToListPos.end(), tableNameToListPos.find("MOUNT_POLICY"));
-  ASSERT_NE(tableNameToListPos.end(), tableNameToListPos.find("REQUESTER_GROUP_MOUNT_RULE"));
-  ASSERT_NE(tableNameToListPos.end(), tableNameToListPos.find("REQUESTER_MOUNT_RULE"));
-  ASSERT_NE(tableNameToListPos.end(), tableNameToListPos.find("STORAGE_CLASS"));
-  ASSERT_NE(tableNameToListPos.end(), tableNameToListPos.find("TAPE"));
-  ASSERT_NE(tableNameToListPos.end(), tableNameToListPos.find("TAPE_FILE"));
-  ASSERT_NE(tableNameToListPos.end(), tableNameToListPos.find("TAPE_POOL"));
-}
-
 } // namespace unitTests
diff --git a/catalogue/CatalogueTest.hpp b/catalogue/CatalogueTest.hpp
index d57f26b846e48c61fc8efa98be0aea4960b83f70..20e3b3a5e565c2affb17e0e6910cf129089f753d 100644
--- a/catalogue/CatalogueTest.hpp
+++ b/catalogue/CatalogueTest.hpp
@@ -22,8 +22,6 @@
 #include "catalogue/CatalogueFactory.hpp"
 #include "common/exception/Exception.hpp"
 #include "common/log/DummyLogger.hpp"
-#include "rdbms/wrapper/Conn.hpp"
-#include "rdbms/LoginFactory.hpp"
 
 #include <gtest/gtest.h>
 #include <map>
@@ -32,7 +30,7 @@
 
 namespace unitTests {
 
-class cta_catalogue_CatalogueTest : public ::testing::TestWithParam<cta::rdbms::LoginFactory*> {
+class cta_catalogue_CatalogueTest : public ::testing::TestWithParam<cta::catalogue::CatalogueFactory **> {
 public:
 
   cta_catalogue_CatalogueTest();
@@ -44,12 +42,6 @@ protected:
   cta::common::dataStructures::SecurityIdentity m_localAdmin;
   cta::common::dataStructures::SecurityIdentity m_admin;
 
-  /**
-   * A general purpose database connection outside of the m_catalogue object to
-   * be used to run tests directly on the underlying "raw" catalogue database.
-   */
-  std::unique_ptr<cta::rdbms::wrapper::Conn> m_conn;
-
   virtual void SetUp();
 
   virtual void TearDown();
diff --git a/catalogue/CreateAdminUserCmd.cpp b/catalogue/CreateAdminUserCmd.cpp
index fd77a83e20d830c6242a25675003ad22d27e862b..9016bee20b9b4c86ed97a6874dd1cc399c8981c3 100644
--- a/catalogue/CreateAdminUserCmd.cpp
+++ b/catalogue/CreateAdminUserCmd.cpp
@@ -16,7 +16,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "catalogue/CatalogueFactory.hpp"
+#include "catalogue/CatalogueFactoryFactory.hpp"
 #include "catalogue/CreateAdminUserCmd.hpp"
 #include "catalogue/CreateAdminUserCmdLineArgs.hpp"
 #include "common/exception/Exception.hpp"
@@ -57,7 +57,8 @@ int CreateAdminUserCmd::exceptionThrowingMain(const int argc, char *const *const
   const uint64_t nbDbConns = 1;
   const uint64_t nbArchiveFileListingDbConns = 1;
   log::DummyLogger dummyLog("dummy", "dummy");
-  auto catalogue = CatalogueFactory::create(dummyLog, dbLogin, nbDbConns, nbArchiveFileListingDbConns);
+  auto catalogueFactory = CatalogueFactoryFactory::create(dummyLog, dbLogin, nbDbConns, nbArchiveFileListingDbConns);
+  auto catalogue = catalogueFactory->create();
   const common::dataStructures::SecurityIdentity adminRunningCommand(getUsername(), getHostname());
 
   catalogue->createAdminUser(adminRunningCommand, cmdLineArgs.adminUsername, cmdLineArgs.comment);
diff --git a/catalogue/DbConfigVersionOfCatalogueTest.cpp b/catalogue/DbConfigVersionOfCatalogueTest.cpp
index 5883c254e4cf0a9edca5ff5d631a8a0cf2199f15..bedde86255c07eb7d12029faf26a77bf1fb617b3 100644
--- a/catalogue/DbConfigVersionOfCatalogueTest.cpp
+++ b/catalogue/DbConfigVersionOfCatalogueTest.cpp
@@ -17,41 +17,10 @@
  */
 
 #include "catalogue/CatalogueTest.hpp"
-#include "tests/CatalogueUnitTestsCmdLineArgs.hpp"
-
-namespace {
-
-/**
- * Creates Login objects for the test catalogue database whose database login
- * details are specified in a database configuration file passed on the
- * command-line to the catalogue unit-tests program.
- */
-class DbConfigFileLoginFactory: public cta::rdbms::LoginFactory {
-public:
-
-  /**
-   * Destructor.
-   */
-  virtual ~DbConfigFileLoginFactory() {
-  }
-
-  /**
-   * Returns a newly created Login object.
-   *
-   * @return A newly created Login object.
-   */
-  virtual cta::rdbms::Login create() {
-    return cta::rdbms::Login::parseFile(g_cmdLineArgs.dbConfigPath);
-  }
-}; // class OracleLoginFactory
-
-DbConfigFileLoginFactory g_dbConfigLoginFactory;
-
-} // anonymous namespace
+#include "tests/GlobalCatalogueFactoryForUnitTests.hpp"
 
 namespace unitTests {
 
-INSTANTIATE_TEST_CASE_P(DbConfigFile, cta_catalogue_CatalogueTest,
-  ::testing::Values(dynamic_cast<cta::rdbms::LoginFactory*>(&g_dbConfigLoginFactory)));
+INSTANTIATE_TEST_CASE_P(DbConfigFile, cta_catalogue_CatalogueTest, ::testing::Values(&g_catalogueFactoryForUnitTests));
 
 } // namespace unitTests
diff --git a/catalogue/InMemoryCatalogueFactory.cpp b/catalogue/InMemoryCatalogueFactory.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e6f560129b74d24fbe8655c3cbc23f43082f90d4
--- /dev/null
+++ b/catalogue/InMemoryCatalogueFactory.cpp
@@ -0,0 +1,55 @@
+/*
+ * The CERN Tape Archive (CTA) project
+ * Copyright (C) 2015  CERN
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "catalogue/CatalogueRetryWrapper.hpp"
+#include "catalogue/InMemoryCatalogueFactory.hpp"
+#include "catalogue/InMemoryCatalogue.hpp"
+#include "common/exception/Exception.hpp"
+#include "common/make_unique.hpp"
+
+namespace cta {
+namespace catalogue {
+
+//------------------------------------------------------------------------------
+// constructor
+//------------------------------------------------------------------------------
+InMemoryCatalogueFactory::InMemoryCatalogueFactory(
+  log::Logger &log,
+  const uint64_t nbConns,
+  const uint64_t nbArchiveFileListingConns,
+  const uint32_t maxTriesToConnect):
+  m_log(log),
+  m_nbConns(nbConns),
+  m_nbArchiveFileListingConns(nbArchiveFileListingConns),
+  m_maxTriesToConnect(maxTriesToConnect) {
+}
+
+//------------------------------------------------------------------------------
+// create
+//------------------------------------------------------------------------------
+std::unique_ptr<Catalogue> InMemoryCatalogueFactory::create() {
+  try {
+    auto c = cta::make_unique<InMemoryCatalogue>(m_log, m_nbConns, m_nbArchiveFileListingConns);
+    return cta::make_unique<CatalogueRetryWrapper>(m_log, std::move(c), m_maxTriesToConnect);
+  } catch(exception::Exception &ex) {
+    throw exception::Exception(std::string(__FUNCTION__) + " failed: " + ex.getMessage().str());
+  }
+}
+
+} // namespace catalogue
+} // namespace cta
diff --git a/catalogue/InMemoryCatalogueFactory.hpp b/catalogue/InMemoryCatalogueFactory.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..7659bda233b17737d1fe60549b6eb5f251f1612d
--- /dev/null
+++ b/catalogue/InMemoryCatalogueFactory.hpp
@@ -0,0 +1,88 @@
+/*
+ * The CERN Tape Archive (CTA) project
+ * Copyright (C) 2015  CERN
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "catalogue/CatalogueFactory.hpp"
+#include "rdbms/Login.hpp"
+
+namespace cta {
+namespace catalogue {
+
+/**
+ * Factory of Catalogue objects.
+ */
+class InMemoryCatalogueFactory: public CatalogueFactory {
+public:
+
+  /**
+   * Constructor
+   *
+   * @param log Object representing the API to the CTA logging system.
+   * @param nbConns The maximum number of concurrent connections to the
+   * underlying relational database for all operations accept listing archive
+   * files which can be relatively long operations.
+   * @param nbArchiveFileListingConns The maximum number of concurrent
+   * connections to the underlying relational database for the sole purpose of
+   * listing archive files.
+   * @param maxTriesToConnext The maximum number of times a single method should
+   * try to connect to the database in the event of LostDatabaseConnection
+   * exceptions being thrown.
+   */
+  InMemoryCatalogueFactory(
+    log::Logger &log,
+    const uint64_t nbConns,
+    const uint64_t nbArchiveFileListingConns,
+    const uint32_t maxTriesToConnect);
+
+  /**
+   * Returns a newly created CTA catalogue object.
+   */
+  std::unique_ptr<Catalogue> create() override;
+
+private:
+
+  /**
+   * Object representing the API to the CTA logging system.
+   */
+  log::Logger &m_log;
+
+  /**
+   * The maximum number of concurrent connections to the underlying relational
+   * database for all operations accept listing archive files which can be
+   * relatively long operations.
+   */
+  uint64_t m_nbConns;
+
+  /**
+   * The maximum number of concurrent connections to the underlying relational
+   * database for the sole purpose of listing archive files.
+   */
+  uint64_t m_nbArchiveFileListingConns;
+
+  /**
+   * The maximum number of times a single method should try to connect to the
+   * database in the event of LostDatabaseConnection
+   * exceptions being thrown.
+   */
+  uint32_t m_maxTriesToConnect;
+
+}; // class InMemoryCatalogueFactory
+
+} // namespace catalogue
+} // namespace cta
diff --git a/catalogue/InMemoryCatalogueTest.cpp b/catalogue/InMemoryCatalogueTest.cpp
index 19160cd8913cfebf0eeb6636bef7671774eaff61..ca09bdc9dd9386093b5f1f24f0211492184c0af1 100644
--- a/catalogue/InMemoryCatalogueTest.cpp
+++ b/catalogue/InMemoryCatalogueTest.cpp
@@ -51,4 +51,36 @@ TEST_F(cta_catalogue_InMemoryCatalogue, createSameSchemaInTwoSeparateInMemoryDat
   }
 }
 
+TEST_F(cta_catalogue_InMemoryCatalogue, schemaTables) {
+  using namespace cta;
+
+  log::DummyLogger dummyLog("dummy", "dummy");
+  const uint64_t nbConns = 1;
+  const uint64_t nbArchiveFileListingConns = 0;
+
+  catalogue::InMemoryCatalogue inMemoryCatalogue(dummyLog, nbConns, nbArchiveFileListingConns);
+  const auto tableNameList = inMemoryCatalogue.getTableNames();
+  std::set<std::string> tableNameSet;
+
+  std::map<std::string, uint32_t> tableNameToListPos;
+  uint32_t listPos = 0;
+  for(auto &tableName: tableNameList) {
+    ASSERT_EQ(tableNameToListPos.end(), tableNameToListPos.find(tableName));
+    tableNameToListPos[tableName] = listPos++;
+  }
+
+  ASSERT_NE(tableNameToListPos.end(), tableNameToListPos.find("ADMIN_USER"));
+  ASSERT_NE(tableNameToListPos.end(), tableNameToListPos.find("ARCHIVE_FILE"));
+  ASSERT_NE(tableNameToListPos.end(), tableNameToListPos.find("ARCHIVE_ROUTE"));
+  ASSERT_NE(tableNameToListPos.end(), tableNameToListPos.find("CTA_CATALOGUE"));
+  ASSERT_NE(tableNameToListPos.end(), tableNameToListPos.find("LOGICAL_LIBRARY"));
+  ASSERT_NE(tableNameToListPos.end(), tableNameToListPos.find("MOUNT_POLICY"));
+  ASSERT_NE(tableNameToListPos.end(), tableNameToListPos.find("REQUESTER_GROUP_MOUNT_RULE"));
+  ASSERT_NE(tableNameToListPos.end(), tableNameToListPos.find("REQUESTER_MOUNT_RULE"));
+  ASSERT_NE(tableNameToListPos.end(), tableNameToListPos.find("STORAGE_CLASS"));
+  ASSERT_NE(tableNameToListPos.end(), tableNameToListPos.find("TAPE"));
+  ASSERT_NE(tableNameToListPos.end(), tableNameToListPos.find("TAPE_FILE"));
+  ASSERT_NE(tableNameToListPos.end(), tableNameToListPos.find("TAPE_POOL"));
+}
+
 } // namespace unitTests
diff --git a/catalogue/InMemoryVersionOfCatalogueTest.cpp b/catalogue/InMemoryVersionOfCatalogueTest.cpp
index 9f3400b89174f4210f489a716ab09f86cd9a161e..425e585db12bdc0f19e9367dfcbdb5f7c7051b03 100644
--- a/catalogue/InMemoryVersionOfCatalogueTest.cpp
+++ b/catalogue/InMemoryVersionOfCatalogueTest.cpp
@@ -17,39 +17,25 @@
  */
 
 #include "catalogue/CatalogueTest.hpp"
+#include "catalogue/InMemoryCatalogueFactory.hpp"
+#include "common/log/DummyLogger.hpp"
 
 namespace unitTests {
 
 namespace {
 
-/**
- * Creates Login objects for in-memory catalogue databases.
- */
-class InMemoryLoginFactory: public cta::rdbms::LoginFactory {
-public:
-
-  /**
-   * Destructor.
-   */
-  virtual ~InMemoryLoginFactory() {
-  }
-
-  /**
-   * Returns a newly created Login object.
-   *
-   * @return A newly created Login object.
-   */
-  virtual cta::rdbms::Login create() {
-    using namespace cta::catalogue;
-    return cta::rdbms::Login(cta::rdbms::Login::DBTYPE_IN_MEMORY, "", "", "", "", 0);
-  }
-}; // class InMemoryLoginFactory
-
-InMemoryLoginFactory g_inMemoryLoginFactory;
+const uint64_t g_in_memory_CatalogueTest_nbConn = 1;
+const uint64_t g_in_memory_nbArchiveFileListingConns = 1;
+const uint64_t g_in_memory_maxTriesToConnect = 1;
+cta::log::DummyLogger g_in_memory_CatalogueTest_dummyLogger("dummy", "dummy");
+
+cta::catalogue::InMemoryCatalogueFactory g_inMemoryCatalogueFactory(g_in_memory_CatalogueTest_dummyLogger,
+  g_in_memory_CatalogueTest_nbConn, g_in_memory_nbArchiveFileListingConns, g_in_memory_maxTriesToConnect);
+
+cta::catalogue::CatalogueFactory *g_inMemoryCatalogueFactoryPtr = &g_inMemoryCatalogueFactory;
 
 } // anonymous namespace
 
-INSTANTIATE_TEST_CASE_P(InMemory, cta_catalogue_CatalogueTest,
-  ::testing::Values(dynamic_cast<cta::rdbms::LoginFactory*>(&g_inMemoryLoginFactory)));
+INSTANTIATE_TEST_CASE_P(InMemory, cta_catalogue_CatalogueTest, ::testing::Values(&g_inMemoryCatalogueFactoryPtr));
 
 } // namespace unitTests
diff --git a/catalogue/MysqlCatalogueFactory.cpp b/catalogue/MysqlCatalogueFactory.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b0dec25d845fbb63008d8f9a8e7ea7a8c768205d
--- /dev/null
+++ b/catalogue/MysqlCatalogueFactory.cpp
@@ -0,0 +1,63 @@
+/*
+ * The CERN Tape Archive (CTA) project
+ * Copyright (C) 2015  CERN
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "catalogue/CatalogueRetryWrapper.hpp"
+#include "catalogue/MysqlCatalogueFactory.hpp"
+#include "catalogue/MysqlCatalogue.hpp"
+#include "common/exception/Exception.hpp"
+#include "common/make_unique.hpp"
+
+namespace cta {
+namespace catalogue {
+
+//------------------------------------------------------------------------------
+// constructor
+//------------------------------------------------------------------------------
+MysqlCatalogueFactory::MysqlCatalogueFactory(
+  log::Logger &log,
+  const rdbms::Login &login,
+  const uint64_t nbConns,
+  const uint64_t nbArchiveFileListingConns,
+  const uint32_t maxTriesToConnect):
+  m_log(log),
+  m_login(login),
+  m_nbConns(nbConns),
+  m_nbArchiveFileListingConns(nbArchiveFileListingConns),
+  m_maxTriesToConnect(maxTriesToConnect) {
+  if(rdbms::Login::DBTYPE_MYSQL != login.dbType) {
+    exception::Exception ex;
+    ex.getMessage() << __FUNCTION__ << "failed: Incorrect database type: expected=DBTYPE_MYSQL actual=" <<
+      login.dbTypeToString(login.dbType);
+    throw ex;
+  }
+}
+
+//------------------------------------------------------------------------------
+// create
+//------------------------------------------------------------------------------
+std::unique_ptr<Catalogue> MysqlCatalogueFactory::create() {
+  try {
+    auto c = cta::make_unique<MysqlCatalogue>(m_log, m_login, m_nbConns, m_nbArchiveFileListingConns);
+    return cta::make_unique<CatalogueRetryWrapper>(m_log, std::move(c), m_maxTriesToConnect);
+  } catch(exception::Exception &ex) {
+    throw exception::Exception(std::string(__FUNCTION__) + " failed: " + ex.getMessage().str());
+  }
+}
+
+} // namespace catalogue
+} // namespace cta
diff --git a/catalogue/MysqlCatalogueFactory.hpp b/catalogue/MysqlCatalogueFactory.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..90cbc4962f87b784391e599d180a2238c91c9a98
--- /dev/null
+++ b/catalogue/MysqlCatalogueFactory.hpp
@@ -0,0 +1,96 @@
+/*
+ * The CERN Tape Archive (CTA) project
+ * Copyright (C) 2015  CERN
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "catalogue/CatalogueFactory.hpp"
+#include "rdbms/Login.hpp"
+
+namespace cta {
+namespace catalogue {
+
+/**
+ * Factory of Catalogue objects.
+ */
+class MysqlCatalogueFactory: public CatalogueFactory {
+public:
+
+  /**
+   * Constructor
+   *
+   * @param log Object representing the API to the CTA logging system.
+   * @param login The database login details to be used to create new
+   * connections.
+   * @param nbConns The maximum number of concurrent connections to the
+   * underlying relational database for all operations accept listing archive
+   * files which can be relatively long operations.
+   * @param nbArchiveFileListingConns The maximum number of concurrent
+   * connections to the underlying relational database for the sole purpose of
+   * listing archive files.
+   * @param maxTriesToConnext The maximum number of times a single method should
+   * try to connect to the database in the event of LostDatabaseConnection
+   * exceptions being thrown.
+   */
+  MysqlCatalogueFactory(
+    log::Logger &log,
+    const rdbms::Login &login,
+    const uint64_t nbConns,
+    const uint64_t nbArchiveFileListingConns,
+    const uint32_t maxTriesToConnect);
+
+  /**
+   * Returns a newly created CTA catalogue object.
+   */
+  std::unique_ptr<Catalogue> create() override;
+
+private:
+
+  /**
+   * Object representing the API to the CTA logging system.
+   */
+  log::Logger &m_log;
+
+  /**
+   * The database login details to be used to create new connections.
+   */
+  rdbms::Login m_login;
+
+  /**
+   * The maximum number of concurrent connections to the underlying relational
+   * database for all operations accept listing archive files which can be
+   * relatively long operations.
+   */
+  uint64_t m_nbConns;
+
+  /**
+   * The maximum number of concurrent connections to the underlying relational
+   * database for the sole purpose of listing archive files.
+   */
+  uint64_t m_nbArchiveFileListingConns;
+
+  /**
+   * The maximum number of times a single method should try to connect to the
+   * database in the event of LostDatabaseConnection
+   * exceptions being thrown.
+   */
+  uint32_t m_maxTriesToConnect;
+
+}; // class MysqlCatalogueFactory
+
+} // namespace catalogue
+} // namespace cta
diff --git a/catalogue/OracleCatalogueFactory.cpp b/catalogue/OracleCatalogueFactory.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fdd716d225b0d9fffd0e4e348336d96431ed0a71
--- /dev/null
+++ b/catalogue/OracleCatalogueFactory.cpp
@@ -0,0 +1,64 @@
+/*
+ * The CERN Tape Archive (CTA) project
+ * Copyright (C) 2015  CERN
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "catalogue/CatalogueRetryWrapper.hpp"
+#include "catalogue/OracleCatalogueFactory.hpp"
+#include "catalogue/OracleCatalogue.hpp"
+#include "common/exception/Exception.hpp"
+#include "common/make_unique.hpp"
+
+namespace cta {
+namespace catalogue {
+
+//------------------------------------------------------------------------------
+// constructor
+//------------------------------------------------------------------------------
+OracleCatalogueFactory::OracleCatalogueFactory(
+  log::Logger &log,
+  const rdbms::Login &login,
+  const uint64_t nbConns,
+  const uint64_t nbArchiveFileListingConns,
+  const uint32_t maxTriesToConnect):
+  m_log(log),
+  m_login(login),
+  m_nbConns(nbConns),
+  m_nbArchiveFileListingConns(nbArchiveFileListingConns),
+  m_maxTriesToConnect(maxTriesToConnect) {
+  if(rdbms::Login::DBTYPE_ORACLE != login.dbType) {
+    exception::Exception ex;
+    ex.getMessage() << __FUNCTION__ << "failed: Incorrect database type: expected=DBTYPE_ORACLE actual=" <<
+      login.dbTypeToString(login.dbType);
+    throw ex;
+  }
+}
+
+//------------------------------------------------------------------------------
+// create
+//------------------------------------------------------------------------------
+std::unique_ptr<Catalogue> OracleCatalogueFactory::create() {
+  try {
+    auto c = cta::make_unique<OracleCatalogue>(m_log, m_login.username, m_login.password, m_login.database, m_nbConns,
+      m_nbArchiveFileListingConns);
+    return cta::make_unique<CatalogueRetryWrapper>(m_log, std::move(c), m_maxTriesToConnect);
+  } catch(exception::Exception &ex) {
+    throw exception::Exception(std::string(__FUNCTION__) + " failed: " + ex.getMessage().str());
+  }
+}
+
+} // namespace catalogue
+} // namespace cta
diff --git a/catalogue/OracleCatalogueFactory.hpp b/catalogue/OracleCatalogueFactory.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..b3dd2ad3def3a07a0b64e3d5a314a913f5435bf3
--- /dev/null
+++ b/catalogue/OracleCatalogueFactory.hpp
@@ -0,0 +1,96 @@
+/*
+ * The CERN Tape Archive (CTA) project
+ * Copyright (C) 2015  CERN
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "catalogue/CatalogueFactory.hpp"
+#include "rdbms/Login.hpp"
+
+namespace cta {
+namespace catalogue {
+
+/**
+ * Factory of Catalogue objects.
+ */
+class OracleCatalogueFactory: public CatalogueFactory {
+public:
+
+  /**
+   * Constructor
+   *
+   * @param log Object representing the API to the CTA logging system.
+   * @param login The database login details to be used to create new
+   * connections.
+   * @param nbConns The maximum number of concurrent connections to the
+   * underlying relational database for all operations accept listing archive
+   * files which can be relatively long operations.
+   * @param nbArchiveFileListingConns The maximum number of concurrent
+   * connections to the underlying relational database for the sole purpose of
+   * listing archive files.
+   * @param maxTriesToConnext The maximum number of times a single method should
+   * try to connect to the database in the event of LostDatabaseConnection
+   * exceptions being thrown.
+   */
+  OracleCatalogueFactory(
+    log::Logger &log,
+    const rdbms::Login &login,
+    const uint64_t nbConns,
+    const uint64_t nbArchiveFileListingConns,
+    const uint32_t maxTriesToConnect);
+
+  /**
+   * Returns a newly created CTA catalogue object.
+   */
+  std::unique_ptr<Catalogue> create() override;
+
+private:
+
+  /**
+   * Object representing the API to the CTA logging system.
+   */
+  log::Logger &m_log;
+
+  /**
+   * The database login details to be used to create new connections.
+   */
+  rdbms::Login m_login;
+
+  /**
+   * The maximum number of concurrent connections to the underlying relational
+   * database for all operations accept listing archive files which can be
+   * relatively long operations.
+   */
+  uint64_t m_nbConns;
+
+  /**
+   * The maximum number of concurrent connections to the underlying relational
+   * database for the sole purpose of listing archive files.
+   */
+  uint64_t m_nbArchiveFileListingConns;
+
+  /**
+   * The maximum number of times a single method should try to connect to the
+   * database in the event of LostDatabaseConnection
+   * exceptions being thrown.
+   */
+  uint32_t m_maxTriesToConnect;
+
+}; // class OracleCatalogueFactory
+
+} // namespace catalogue
+} // namespace cta
diff --git a/catalogue/PollDatabaseCmd.cpp b/catalogue/PollDatabaseCmd.cpp
index 5f796a6f404fdfd54adeb542b09058116c4f34f8..b685f8cd2055fd764e15b8bb126fea696130c02c 100644
--- a/catalogue/PollDatabaseCmd.cpp
+++ b/catalogue/PollDatabaseCmd.cpp
@@ -16,7 +16,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "catalogue/CatalogueFactory.hpp"
+#include "catalogue/CatalogueFactoryFactory.hpp"
 #include "catalogue/PollDatabaseCmd.hpp"
 #include "catalogue/PollDatabaseCmdLineArgs.hpp"
 #include "rdbms/ConnPool.hpp"
diff --git a/catalogue/PostgresqlCatalogueFactory.cpp b/catalogue/PostgresqlCatalogueFactory.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6f38aafbd7a8d6663bd6a7f311d9da9df7f7b7c2
--- /dev/null
+++ b/catalogue/PostgresqlCatalogueFactory.cpp
@@ -0,0 +1,57 @@
+/*
+ * The CERN Tape Archive (CTA) project
+ * Copyright (C) 2015  CERN
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "catalogue/CatalogueRetryWrapper.hpp"
+#include "catalogue/PostgresqlCatalogueFactory.hpp"
+#include "common/exception/Exception.hpp"
+#include "common/make_unique.hpp"
+
+namespace cta {
+namespace catalogue {
+
+//------------------------------------------------------------------------------
+// constructor
+//------------------------------------------------------------------------------
+PostgresqlCatalogueFactory::PostgresqlCatalogueFactory(
+  log::Logger &log,
+  const rdbms::Login &login,
+  const uint64_t nbConns,
+  const uint64_t nbArchiveFileListingConns,
+  const uint32_t maxTriesToConnect):
+  m_log(log),
+  m_login(login),
+  m_nbConns(nbConns),
+  m_nbArchiveFileListingConns(nbArchiveFileListingConns),
+  m_maxTriesToConnect(maxTriesToConnect) {
+  if(rdbms::Login::DBTYPE_POSTGRESQL != login.dbType) {
+    exception::Exception ex;
+    ex.getMessage() << __FUNCTION__ << "failed: Incorrect database type: expected=DBTYPE_POSTGRESQL actual=" <<
+      login.dbTypeToString(login.dbType);
+    throw ex;
+  }
+}
+
+//------------------------------------------------------------------------------
+// create
+//------------------------------------------------------------------------------
+std::unique_ptr<Catalogue> PostgresqlCatalogueFactory::create() {
+  throw exception::Exception(std::string(__FUNCTION__) + ": Not implemented");
+}
+
+} // namespace catalogue
+} // namespace cta
diff --git a/catalogue/PostgresqlCatalogueFactory.hpp b/catalogue/PostgresqlCatalogueFactory.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..5289aa7d5c52097e8f86aaa37ca6807eb475c1ff
--- /dev/null
+++ b/catalogue/PostgresqlCatalogueFactory.hpp
@@ -0,0 +1,96 @@
+/*
+ * The CERN Tape Archive (CTA) project
+ * Copyright (C) 2015  CERN
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "catalogue/CatalogueFactory.hpp"
+#include "rdbms/Login.hpp"
+
+namespace cta {
+namespace catalogue {
+
+/**
+ * Factory of Catalogue objects.
+ */
+class PostgresqlCatalogueFactory: public CatalogueFactory {
+public:
+
+  /**
+   * Constructor
+   *
+   * @param log Object representing the API to the CTA logging system.
+   * @param login The database login details to be used to create new
+   * connections.
+   * @param nbConns The maximum number of concurrent connections to the
+   * underlying relational database for all operations accept listing archive
+   * files which can be relatively long operations.
+   * @param nbArchiveFileListingConns The maximum number of concurrent
+   * connections to the underlying relational database for the sole purpose of
+   * listing archive files.
+   * @param maxTriesToConnext The maximum number of times a single method should
+   * try to connect to the database in the event of LostDatabaseConnection
+   * exceptions being thrown.
+   */
+  PostgresqlCatalogueFactory(
+    log::Logger &log,
+    const rdbms::Login &login,
+    const uint64_t nbConns,
+    const uint64_t nbArchiveFileListingConns,
+    const uint32_t maxTriesToConnect);
+
+  /**
+   * Returns a newly created CTA catalogue object.
+   */
+  std::unique_ptr<Catalogue> create() override;
+
+private:
+
+  /**
+   * Object representing the API to the CTA logging system.
+   */
+  log::Logger &m_log;
+
+  /**
+   * The database login details to be used to create new connections.
+   */
+  rdbms::Login m_login;
+
+  /**
+   * The maximum number of concurrent connections to the underlying relational
+   * database for all operations accept listing archive files which can be
+   * relatively long operations.
+   */
+  uint64_t m_nbConns;
+
+  /**
+   * The maximum number of concurrent connections to the underlying relational
+   * database for the sole purpose of listing archive files.
+   */
+  uint64_t m_nbArchiveFileListingConns;
+
+  /**
+   * The maximum number of times a single method should try to connect to the
+   * database in the event of LostDatabaseConnection
+   * exceptions being thrown.
+   */
+  uint32_t m_maxTriesToConnect;
+
+}; // class PostgresqlCatalogueFactory
+
+} // namespace catalogue
+} // namespace cta
diff --git a/catalogue/SqliteCatalogueFactory.cpp b/catalogue/SqliteCatalogueFactory.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bbd4d1c98fb005b7b37b6d387d1d9f9cd239326a
--- /dev/null
+++ b/catalogue/SqliteCatalogueFactory.cpp
@@ -0,0 +1,63 @@
+/*
+ * The CERN Tape Archive (CTA) project
+ * Copyright (C) 2015  CERN
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "catalogue/CatalogueRetryWrapper.hpp"
+#include "catalogue/SqliteCatalogueFactory.hpp"
+#include "catalogue/SqliteCatalogue.hpp"
+#include "common/exception/Exception.hpp"
+#include "common/make_unique.hpp"
+
+namespace cta {
+namespace catalogue {
+
+//------------------------------------------------------------------------------
+// constructor
+//------------------------------------------------------------------------------
+SqliteCatalogueFactory::SqliteCatalogueFactory(
+  log::Logger &log,
+  const rdbms::Login &login,
+  const uint64_t nbConns,
+  const uint64_t nbArchiveFileListingConns,
+  const uint32_t maxTriesToConnect):
+  m_log(log),
+  m_login(login),
+  m_nbConns(nbConns),
+  m_nbArchiveFileListingConns(nbArchiveFileListingConns),
+  m_maxTriesToConnect(maxTriesToConnect) {
+  if(rdbms::Login::DBTYPE_SQLITE != login.dbType) {
+    exception::Exception ex;
+    ex.getMessage() << __FUNCTION__ << "failed: Incorrect database type: expected=DBTYPE_SQLITE actual=" <<
+      login.dbTypeToString(login.dbType);
+    throw ex;
+  }
+}
+
+//------------------------------------------------------------------------------
+// create
+//------------------------------------------------------------------------------
+std::unique_ptr<Catalogue> SqliteCatalogueFactory::create() {
+  try {
+    auto c = cta::make_unique<SqliteCatalogue>(m_log, m_login.database, m_nbConns, m_nbArchiveFileListingConns);
+    return cta::make_unique<CatalogueRetryWrapper>(m_log, std::move(c), m_maxTriesToConnect);
+  } catch(exception::Exception &ex) {
+    throw exception::Exception(std::string(__FUNCTION__) + " failed: " + ex.getMessage().str());
+  }
+}
+
+} // namespace catalogue
+} // namespace cta
diff --git a/catalogue/SqliteCatalogueFactory.hpp b/catalogue/SqliteCatalogueFactory.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..18b92d7506b145e9a01238a7006e327cef738845
--- /dev/null
+++ b/catalogue/SqliteCatalogueFactory.hpp
@@ -0,0 +1,96 @@
+/*
+ * The CERN Tape Archive (CTA) project
+ * Copyright (C) 2015  CERN
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "catalogue/CatalogueFactory.hpp"
+#include "rdbms/Login.hpp"
+
+namespace cta {
+namespace catalogue {
+
+/**
+ * Factory of Catalogue objects.
+ */
+class SqliteCatalogueFactory: public CatalogueFactory {
+public:
+
+  /**
+   * Constructor
+   *
+   * @param log Object representing the API to the CTA logging system.
+   * @param login The database login details to be used to create new
+   * connections.
+   * @param nbConns The maximum number of concurrent connections to the
+   * underlying relational database for all operations accept listing archive
+   * files which can be relatively long operations.
+   * @param nbArchiveFileListingConns The maximum number of concurrent
+   * connections to the underlying relational database for the sole purpose of
+   * listing archive files.
+   * @param maxTriesToConnext The maximum number of times a single method should
+   * try to connect to the database in the event of LostDatabaseConnection
+   * exceptions being thrown.
+   */
+  SqliteCatalogueFactory(
+    log::Logger &log,
+    const rdbms::Login &login,
+    const uint64_t nbConns,
+    const uint64_t nbArchiveFileListingConns,
+    const uint32_t maxTriesToConnect);
+
+  /**
+   * Returns a newly created CTA catalogue object.
+   */
+  std::unique_ptr<Catalogue> create() override;
+
+private:
+
+  /**
+   * Object representing the API to the CTA logging system.
+   */
+  log::Logger &m_log;
+
+  /**
+   * The database login details to be used to create new connections.
+   */
+  rdbms::Login m_login;
+
+  /**
+   * The maximum number of concurrent connections to the underlying relational
+   * database for all operations accept listing archive files which can be
+   * relatively long operations.
+   */
+  uint64_t m_nbConns;
+
+  /**
+   * The maximum number of concurrent connections to the underlying relational
+   * database for the sole purpose of listing archive files.
+   */
+  uint64_t m_nbArchiveFileListingConns;
+
+  /**
+   * The maximum number of times a single method should try to connect to the
+   * database in the event of LostDatabaseConnection
+   * exceptions being thrown.
+   */
+  uint32_t m_maxTriesToConnect;
+
+}; // class SqliteCatalogueFactory
+
+} // namespace catalogue
+} // namespace cta
diff --git a/cta.spec.in b/cta.spec.in
index 25a8ab9ecd0ed9b32d351f4b42c5e23d0ff40781..6c0b81c66a9926fedd2025b2f6b5a5d6f67ff70c 100644
--- a/cta.spec.in
+++ b/cta.spec.in
@@ -265,7 +265,7 @@ Unit tests and system tests with virtual tape drives
 %defattr(0755,root,root,-)
 %{_libdir}/libsystemTestHelperTests.so*
 %{_libdir}/libcta-tapedSystemTests.so*
-%{_bindir}/cta-catalogueUnitTests
+%{_bindir}/cta-rdbmsUnitTests
 %{_bindir}/cta-unitTests
 %{_bindir}/cta-unitTests-multiProcess
 %{_bindir}/cta-valgrindUnitTests.sh
diff --git a/objectstore/cta-objectstore-collect-orphaned-object.cpp b/objectstore/cta-objectstore-collect-orphaned-object.cpp
index 445f8d68cab90aeec3f431cf3e57b69b0b98884b..2a8cc49c64567d9fae15722a3efe0501cd0547c7 100644
--- a/objectstore/cta-objectstore-collect-orphaned-object.cpp
+++ b/objectstore/cta-objectstore-collect-orphaned-object.cpp
@@ -26,7 +26,7 @@
 #include "ArchiveRequest.hpp"
 #include "BackendFactory.hpp"
 #include "BackendVFS.hpp"
-#include "catalogue/CatalogueFactory.hpp"
+#include "catalogue/CatalogueFactoryFactory.hpp"
 #include "common/Configuration.hpp"
 #include "common/log/StringLogger.hpp"
 #include "common/utils/utils.hpp"
@@ -50,7 +50,9 @@ int main(int argc, char ** argv) {
       const cta::rdbms::Login catalogueLogin = cta::rdbms::Login::parseFile(argv[2]);
       const uint64_t nbConns = 1;
       const uint64_t nbArchiveFileListingConns = 0;
-      catalogue=std::move(cta::catalogue::CatalogueFactory::create(sl, catalogueLogin, nbConns, nbArchiveFileListingConns));
+      auto catalogueFactory = cta::catalogue::CatalogueFactoryFactory::create(sl, catalogueLogin, nbConns,
+        nbArchiveFileListingConns);
+      catalogue=catalogueFactory->create();
       objectName = argv[3];
     } else if (2 == argc) {
       cta::common::Configuration m_ctaConf("/etc/cta/cta-objectstore-tools.conf");
@@ -58,7 +60,9 @@ int main(int argc, char ** argv) {
       const cta::rdbms::Login catalogueLogin = cta::rdbms::Login::parseFile("/etc/cta/cta-catalogue.conf");
       const uint64_t nbConns = 1;
       const uint64_t nbArchiveFileListingConns = 0;
-      catalogue = std::move(cta::catalogue::CatalogueFactory::create(sl, catalogueLogin, nbConns, nbArchiveFileListingConns));
+      auto catalogueFactory = cta::catalogue::CatalogueFactoryFactory::create(sl, catalogueLogin, nbConns,
+        nbArchiveFileListingConns);
+      catalogue = catalogueFactory->create();
       objectName = argv[1];
     } else {
       throw std::runtime_error("Wrong number of arguments: expected 1 or 3: [objectstoreURL catalogueLoginFile] objectname");
diff --git a/tapeserver/castor/tape/tapeserver/daemon/MigrationReportPackerTest.cpp b/tapeserver/castor/tape/tapeserver/daemon/MigrationReportPackerTest.cpp
index 72fc0d1fcbd5f6f15ff48b2f15500cfd36c86242..f6c30cf6292b7faadab4695058475baf2bb94c47 100644
--- a/tapeserver/castor/tape/tapeserver/daemon/MigrationReportPackerTest.cpp
+++ b/tapeserver/castor/tape/tapeserver/daemon/MigrationReportPackerTest.cpp
@@ -25,7 +25,7 @@
 #include "common/log/StringLogger.hpp"
 #include "castor/tape/tapeserver/daemon/MigrationReportPacker.hpp"
 #include "castor/tape/tapeserver/drive/DriveInterface.hpp"
-#include "catalogue/CatalogueFactory.hpp"
+#include "catalogue/CatalogueFactoryFactory.hpp"
 #include "scheduler/testingMocks/MockArchiveMount.hpp"
 
 #include <gtest/gtest.h>
@@ -51,7 +51,9 @@ namespace unitTests {
       rdbms::Login catalogueLogin(rdbms::Login::DBTYPE_IN_MEMORY, "", "", "", "", 0);
       const uint64_t nbConns = 1;
       const uint64_t nbArchiveFileListingConns = 0;
-      m_catalogue = CatalogueFactory::create(m_dummyLog, catalogueLogin, nbConns, nbArchiveFileListingConns);
+      auto catalogueFactory = CatalogueFactoryFactory::create(m_dummyLog, catalogueLogin, nbConns,
+        nbArchiveFileListingConns);
+      m_catalogue = catalogueFactory->create();
     }
 
     void TearDown() {
diff --git a/tapeserver/daemon/DriveHandler.cpp b/tapeserver/daemon/DriveHandler.cpp
index 683b6121d79c2b49fa703383106768b6a596c501..35f8bb9cd8f3d6005ba82ba6ea7f90c60a11eea4 100644
--- a/tapeserver/daemon/DriveHandler.cpp
+++ b/tapeserver/daemon/DriveHandler.cpp
@@ -16,7 +16,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "catalogue/CatalogueFactory.hpp"
+#include "catalogue/CatalogueFactoryFactory.hpp"
 #include "common/log/LogContext.hpp"
 #include "common/exception/Errnum.hpp"
 #include "common/processCap/ProcessCap.hpp"
@@ -908,7 +908,9 @@ int DriveHandler::runChild() {
     const uint64_t nbConns = 1;
     const uint64_t nbArchiveFileListingConns = 0;
     lc.log(log::DEBUG, "In DriveHandler::runChild(): will connect to catalogue.");
-    catalogue=cta::catalogue::CatalogueFactory::create(m_sessionEndContext.logger(), catalogueLogin, nbConns, nbArchiveFileListingConns);
+    auto catalogueFactory = cta::catalogue::CatalogueFactoryFactory::create(m_sessionEndContext.logger(),
+      catalogueLogin, nbConns, nbArchiveFileListingConns);
+    catalogue=catalogueFactory->create();
     osdb.reset(new cta::OStoreDBWithAgent(*backend, backendPopulator->getAgentReference(), *catalogue, lc.logger()));
   } catch(cta::exception::Exception &ex) {
     log::ScopedParamContainer param(lc);
diff --git a/tapeserver/daemon/GarbageCollectorHandler.cpp b/tapeserver/daemon/GarbageCollectorHandler.cpp
index 4859d9f2da85ee7a349bb5f6e5e2593da7e1e804..b15a32d4f2cd68ec80bf25b57dcaf304da692d41 100644
--- a/tapeserver/daemon/GarbageCollectorHandler.cpp
+++ b/tapeserver/daemon/GarbageCollectorHandler.cpp
@@ -25,7 +25,7 @@
 #include "objectstore/GarbageCollector.hpp"
 #include "scheduler/OStoreDB/OStoreDBWithAgent.hpp"
 #include "catalogue/Catalogue.hpp"
-#include "catalogue/CatalogueFactory.hpp"
+#include "catalogue/CatalogueFactoryFactory.hpp"
 #include "scheduler/Scheduler.hpp"
 #include "rdbms/Login.hpp"
 #include "common/make_unique.hpp"
@@ -272,7 +272,9 @@ int GarbageCollectorHandler::runChild() {
     const cta::rdbms::Login catalogueLogin = cta::rdbms::Login::parseFile(m_tapedConfig.fileCatalogConfigFile.value());
     const uint64_t nbConns = 1;
     const uint64_t nbArchiveFileListingConns = 0;
-    catalogue=cta::catalogue::CatalogueFactory::create(m_processManager.logContext().logger(), catalogueLogin, nbConns, nbArchiveFileListingConns);
+    auto catalogueFactory = cta::catalogue::CatalogueFactoryFactory::create(m_processManager.logContext().logger(),
+      catalogueLogin, nbConns, nbArchiveFileListingConns);
+    catalogue=catalogueFactory->create();
     scheduler=make_unique<cta::Scheduler>(*catalogue, *osdb, 5, 2*1000*1000); //TODO: we have hardcoded the mount policy parameters here temporarily we will remove them once we know where to put them
   // Before launching the transfer session, we validate that the scheduler is reachable.
     scheduler->ping(m_processManager.logContext());
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index bcf74c85da726a2239db5b15510d332d5925900b..9c70c6f7c422e30d6ef97d593f7d7273cbf463fc 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -53,18 +53,19 @@ if (OCCI_SUPPORT)
   set_property (TARGET cta-unitTests APPEND PROPERTY INSTALL_RPATH ${ORACLE-INSTANTCLIENT_RPATH})
 endif (OCCI_SUPPORT)
 
-add_executable(cta-catalogueUnitTests
-  CatalogueUnitTestsCmdLineArgs.cpp
-  catalogueUnitTests.cpp
+add_executable(cta-rdbmsUnitTests
+  GlobalCatalogueFactoryForUnitTests.cpp
+  RdbmsUnitTestsCmdLineArgs.cpp
+  rdbmsUnitTests.cpp
   ${GMOCK_SRC})
 
-target_link_libraries(cta-catalogueUnitTests
+target_link_libraries(cta-rdbmsUnitTests
   ctacatalogueunittests
   gtest
   pthread)
 
 if (OCCI_SUPPORT)
-  set_property (TARGET cta-catalogueUnitTests APPEND PROPERTY INSTALL_RPATH ${ORACLE-INSTANTCLIENT_RPATH})
+  set_property (TARGET cta-rdbmsUnitTests APPEND PROPERTY INSTALL_RPATH ${ORACLE-INSTANTCLIENT_RPATH})
 endif (OCCI_SUPPORT)
 
 add_executable(cta-unitTests-multiProcess
@@ -105,7 +106,7 @@ target_link_libraries(cta-systemTests
   gtest
   pthread)
 
-install(TARGETS cta-catalogueUnitTests cta-unitTests cta-unitTests-multiProcess cta-systemTests DESTINATION usr/bin)
+install(TARGETS cta-rdbmsUnitTests cta-unitTests cta-unitTests-multiProcess cta-systemTests DESTINATION usr/bin)
 
 install(TARGETS systemTestHelperTests DESTINATION usr/${CMAKE_INSTALL_LIBDIR})
 
diff --git a/tests/GlobalCatalogueFactoryForUnitTests.cpp b/tests/GlobalCatalogueFactoryForUnitTests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..aba8f88d0ddc280958cdddbd0a4c7a23dd95802b
--- /dev/null
+++ b/tests/GlobalCatalogueFactoryForUnitTests.cpp
@@ -0,0 +1,24 @@
+/*
+ * The CERN Tape Archive (CTA) project
+ * Copyright (C) 2015  CERN
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "tests/GlobalCatalogueFactoryForUnitTests.hpp"
+
+//------------------------------------------------------------------------------
+// g_catalogueFactoryForUnitTests
+//------------------------------------------------------------------------------
+cta::catalogue::CatalogueFactory *g_catalogueFactoryForUnitTests = nullptr;
diff --git a/tests/GlobalCatalogueFactoryForUnitTests.hpp b/tests/GlobalCatalogueFactoryForUnitTests.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..b2a3b9daae5cd063d5821d6d9b7b8dac3b842418
--- /dev/null
+++ b/tests/GlobalCatalogueFactoryForUnitTests.hpp
@@ -0,0 +1,27 @@
+/*
+ * The CERN Tape Archive (CTA) project
+ * Copyright (C) 2015  CERN
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "catalogue/CatalogueFactory.hpp"
+
+/**
+ * Declaration of the global variable used to point to a factory of CTA
+ * catalogue objects.
+ */
+extern cta::catalogue::CatalogueFactory *g_catalogueFactoryForUnitTests;
diff --git a/tests/CatalogueUnitTestsCmdLineArgs.cpp b/tests/RdbmsUnitTestsCmdLineArgs.cpp
similarity index 89%
rename from tests/CatalogueUnitTestsCmdLineArgs.cpp
rename to tests/RdbmsUnitTestsCmdLineArgs.cpp
index 270f921f24a1cbd90cd3363063f28c3ff35fa0b9..d43cbaf47f4ba4ba7a49375b48c960c539b228b8 100644
--- a/tests/CatalogueUnitTestsCmdLineArgs.cpp
+++ b/tests/RdbmsUnitTestsCmdLineArgs.cpp
@@ -16,10 +16,10 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "tests/CatalogueUnitTestsCmdLineArgs.hpp"
+#include "tests/RdbmsUnitTestsCmdLineArgs.hpp"
 
 /**
  * Global variable used to store the command-line arguments so that they are
  * visible to the tests.
  */
-CatalogueUnitTestsCmdLineArgs g_cmdLineArgs;
+RdbmsUnitTestsCmdLineArgs g_cmdLineArgs;
diff --git a/tests/CatalogueUnitTestsCmdLineArgs.hpp b/tests/RdbmsUnitTestsCmdLineArgs.hpp
similarity index 76%
rename from tests/CatalogueUnitTestsCmdLineArgs.hpp
rename to tests/RdbmsUnitTestsCmdLineArgs.hpp
index 8c53df64038007b8ff92ad371d2d31a569e1dd55..e58e39f5d39a299b056deca37a09d9c985441621 100644
--- a/tests/CatalogueUnitTestsCmdLineArgs.hpp
+++ b/tests/RdbmsUnitTestsCmdLineArgs.hpp
@@ -19,13 +19,11 @@
 #include <string>
 
 /**
- * Structure to store the command-line arguments of the CTA-catalogue unit-tests
- * program.
+ * Structure to store the command-line arguments of cta-rdbmsUnitTests.
  */
-struct CatalogueUnitTestsCmdLineArgs {
+struct RdbmsUnitTestsCmdLineArgs {
   /**
-   * Absolute path to the file containing the connection details of a test CTA
-   * catalogue database.
+   * Absolute path to the file containing the database connection details.
    */
   std::string dbConfigPath;
 };
@@ -34,4 +32,4 @@ struct CatalogueUnitTestsCmdLineArgs {
  * Declaration of the global variable used to store the command-line arguments
  * so that they are visible to the tests.
  */
-extern CatalogueUnitTestsCmdLineArgs g_cmdLineArgs;
+extern RdbmsUnitTestsCmdLineArgs g_cmdLineArgs;
diff --git a/tests/catalogueUnitTests.cpp b/tests/rdbmsUnitTests.cpp
similarity index 68%
rename from tests/catalogueUnitTests.cpp
rename to tests/rdbmsUnitTests.cpp
index 0ccbecb347a4b656f46e7e42634ea897ae0b67fd..cf57c2158eb83db10679edb0375e3353db7ea333 100644
--- a/tests/catalogueUnitTests.cpp
+++ b/tests/rdbmsUnitTests.cpp
@@ -16,8 +16,11 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "catalogue/CatalogueTest.hpp"
-#include "tests/CatalogueUnitTestsCmdLineArgs.hpp"
+#include "catalogue/CatalogueFactoryFactory.hpp"
+#include "common/log/DummyLogger.hpp"
+#include "rdbms/Login.hpp"
+#include "tests/GlobalCatalogueFactoryForUnitTests.hpp"
+#include "tests/RdbmsUnitTestsCmdLineArgs.hpp"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
@@ -29,7 +32,7 @@
 static void printUsage(std::ostream &os) {
   os <<
     "Usage:" << std::endl <<
-    '\t' << "cta-catalogueUnitTests [Google test options] databaseConnectionFile" << std::endl;
+    '\t' << "cta-rdbmsUnitTests [Google test options] databaseConnectionFile" << std::endl;
 }
 
 /**
@@ -37,14 +40,14 @@ static void printUsage(std::ostream &os) {
  * Google test has consumed all of its command-line options from the
  * command-line.
  */
-static CatalogueUnitTestsCmdLineArgs parseCmdLine(const int argc, char ** argv) {
+static RdbmsUnitTestsCmdLineArgs parseCmdLine(const int argc, char ** argv) {
   if(argc != 2) {
     std::cerr << "Invalid number of command-line arguments";
     printUsage(std::cerr);
     exit(1);
   }
 
-  CatalogueUnitTestsCmdLineArgs cmdLineArgs;
+  RdbmsUnitTestsCmdLineArgs cmdLineArgs;
   cmdLineArgs.dbConfigPath = argv[1];
 
   return cmdLineArgs;
@@ -58,6 +61,15 @@ int main(int argc, char** argv) {
   // Google test will consume its options from the command-line and leave everything else
   g_cmdLineArgs = parseCmdLine(argc, argv);
 
+  cta::log::DummyLogger dummyLogger("dummy", "dummy");
+  const auto login = cta::rdbms::Login::parseFile(g_cmdLineArgs.dbConfigPath);
+  const uint64_t nbConns = 1;
+  const uint64_t nbArchiveFileListingConns = 1;
+  const uint64_t maxTriesToConnect = 1;
+  auto catalogueFactory = cta::catalogue::CatalogueFactoryFactory::create(dummyLogger, login, nbConns,
+    nbArchiveFileListingConns, maxTriesToConnect);
+  g_catalogueFactoryForUnitTests = catalogueFactory.get();
+
   const int ret = RUN_ALL_TESTS();
 
   // Close standard in, out and error so that valgrind can be used with the
diff --git a/xroot_plugins/XrdSsiCtaServiceProvider.cpp b/xroot_plugins/XrdSsiCtaServiceProvider.cpp
index 3756ddc2e653467177df2faa1a716b05611ff92e..7beb487d609a7370673ebe9e48f8d8102b1c2e44 100644
--- a/xroot_plugins/XrdSsiCtaServiceProvider.cpp
+++ b/xroot_plugins/XrdSsiCtaServiceProvider.cpp
@@ -16,6 +16,7 @@
  *                 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "catalogue/CatalogueFactoryFactory.hpp"
 #include "cta_frontend.pb.h"
 #include "common/make_unique.hpp"
 #include "common/log/SyslogLogger.hpp"
@@ -23,7 +24,6 @@
 #include "common/log/FileLogger.hpp"
 #include "common/log/LogLevel.hpp"
 #include "common/utils/utils.hpp"
-#include "catalogue/CatalogueFactory.hpp"
 #include "objectstore/BackendVFS.hpp"
 #include "rdbms/Login.hpp"
 #include "version.h"
@@ -119,7 +119,11 @@ void XrdSsiCtaServiceProvider::ExceptionThrowingInit(XrdSsiLogger *logP, XrdSsiC
    }
    const uint64_t nbArchiveFileListingConns = 2;
 
-   m_catalogue = catalogue::CatalogueFactory::create(*m_log, catalogueLogin, catalogue_numberofconnections.second, nbArchiveFileListingConns);
+   {
+     auto catalogueFactory = catalogue::CatalogueFactoryFactory::create(*m_log, catalogueLogin,
+       catalogue_numberofconnections.second, nbArchiveFileListingConns);
+     m_catalogue = catalogueFactory->create();
+   }
 
    // Initialise the Backend
    auto objectstore_backendpath = config.getOptionValueStr("cta.objectstore.backendpath");