quickfix_ruby_ud 2.0.7-aarch64-linux

data/ext/quickfix/PostgreSQLLog.h

@@ -0,0 +1,157 @@
+/* -*- C++ -*- */
+
+/****************************************************************************
+** Copyright (c) 2001-2014
+**
+** This file is part of the QuickFIX FIX Engine
+**
+** This file may be distributed under the terms of the quickfixengine.org
+** license as defined by quickfixengine.org and appearing in the file
+** LICENSE included in the packaging of this file.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.quickfixengine.org/LICENSE for licensing information.
+**
+** Contact ask@quickfixengine.org if any conditions of this licensing are
+** not clear to you.
+**
+****************************************************************************/
+
+#ifndef FIX_POSTGRESQLLOG_H
+#define FIX_POSTGRESQLLOG_H
+
+#ifndef HAVE_POSTGRESQL
+#error PostgreSQLLog.h included, but HAVE_POSTGRESQL not defined
+#endif
+
+#ifdef HAVE_POSTGRESQL
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4503 4355 4786 4290)
+#endif
+
+#include "Log.h"
+#include "PostgreSQLConnection.h"
+#include "SessionSettings.h"
+#include <fstream>
+#include <string>
+
+namespace FIX {
+/// PostgreSQL based implementation of Log.
+class PostgreSQLLog : public Log {
+public:
+  PostgreSQLLog(const SessionID &s, const DatabaseConnectionID &d, PostgreSQLConnectionPool *p);
+  PostgreSQLLog(const DatabaseConnectionID &d, PostgreSQLConnectionPool *p);
+  PostgreSQLLog(
+      const SessionID &s,
+      const std::string &database,
+      const std::string &user,
+      const std::string &password,
+      const std::string &host,
+      short port);
+  PostgreSQLLog(
+      const std::string &database,
+      const std::string &user,
+      const std::string &password,
+      const std::string &host,
+      short port);
+
+  ~PostgreSQLLog();
+
+  void clear();
+  void backup();
+  void setIncomingTable(const std::string &incomingTable) { m_incomingTable = incomingTable; }
+  void setOutgoingTable(const std::string &outgoingTable) { m_outgoingTable = outgoingTable; }
+  void setEventTable(const std::string &eventTable) { m_eventTable = eventTable; }
+
+  void onIncoming(const std::string &value) { insert(m_incomingTable, value); }
+  void onOutgoing(const std::string &value) { insert(m_outgoingTable, value); }
+  void onEvent(const std::string &value) { insert(m_eventTable, value); }
+
+private:
+  void init();
+  void insert(const std::string &table, const std::string value);
+
+  std::string m_incomingTable;
+  std::string m_outgoingTable;
+  std::string m_eventTable;
+  PostgreSQLConnection *m_pConnection;
+  PostgreSQLConnectionPool *m_pConnectionPool;
+  SessionID *m_pSessionID;
+};
+
+/// Creates a MySQL based implementation of Log.
+class PostgreSQLLogFactory : public LogFactory {
+public:
+  static const std::string DEFAULT_DATABASE;
+  static const std::string DEFAULT_USER;
+  static const std::string DEFAULT_PASSWORD;
+  static const std::string DEFAULT_HOST;
+  static const short DEFAULT_PORT;
+
+  PostgreSQLLogFactory(const SessionSettings &settings)
+      : m_settings(settings),
+        m_useSettings(true) {
+    bool poolConnections = false;
+    try {
+      poolConnections = settings.get().getBool(POSTGRESQL_LOG_USECONNECTIONPOOL);
+    } catch (ConfigError &) {}
+
+    m_connectionPoolPtr = PostgreSQLConnectionPoolPtr(new PostgreSQLConnectionPool(poolConnections));
+  }
+
+  PostgreSQLLogFactory(
+      const std::string &database,
+      const std::string &user,
+      const std::string &password,
+      const std::string &host,
+      short port)
+      : m_database(database),
+        m_user(user),
+        m_password(password),
+        m_host(host),
+        m_port(port),
+        m_useSettings(false) {
+    m_connectionPoolPtr = PostgreSQLConnectionPoolPtr(new PostgreSQLConnectionPool(false));
+  }
+
+  PostgreSQLLogFactory()
+      : m_database(DEFAULT_DATABASE),
+        m_user(DEFAULT_USER),
+        m_password(DEFAULT_PASSWORD),
+        m_host(DEFAULT_HOST),
+        m_port(DEFAULT_PORT),
+        m_useSettings(false) {
+    m_connectionPoolPtr = PostgreSQLConnectionPoolPtr(new PostgreSQLConnectionPool(false));
+  }
+
+  Log *create();
+  Log *create(const SessionID &);
+  void destroy(Log *);
+
+private:
+  void init(
+      const Dictionary &settings,
+      std::string &database,
+      std::string &user,
+      std::string &password,
+      std::string &host,
+      short &port);
+
+  void initLog(const Dictionary &settings, PostgreSQLLog &log);
+
+  PostgreSQLConnectionPoolPtr m_connectionPoolPtr;
+  SessionSettings m_settings;
+  std::string m_database;
+  std::string m_user;
+  std::string m_password;
+  std::string m_host;
+  short m_port;
+  bool m_useSettings;
+};
+} // namespace FIX
+
+#endif // FIX_POSTGRESQLLOG_H
+#endif // HAVE_POSTGRESQL

data/ext/quickfix/PostgreSQLStore.cpp

@@ -0,0 +1,327 @@
+/****************************************************************************
+** Copyright (c) 2001-2014
+**
+** This file is part of the QuickFIX FIX Engine
+**
+** This file may be distributed under the terms of the quickfixengine.org
+** license as defined by quickfixengine.org and appearing in the file
+** LICENSE included in the packaging of this file.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.quickfixengine.org/LICENSE for licensing information.
+**
+** Contact ask@quickfixengine.org if any conditions of this licensing are
+** not clear to you.
+**
+****************************************************************************/
+
+#ifdef _MSC_VER
+#include "stdafx.h"
+#else
+#include "config.h"
+#endif
+
+#ifdef HAVE_POSTGRESQL
+
+#include "FieldConvertors.h"
+#include "Parser.h"
+#include "PostgreSQLStore.h"
+#include "SessionID.h"
+#include "SessionSettings.h"
+#include "Utility.h"
+#include "strptime.h"
+#include <fstream>
+#include <string>
+
+namespace FIX {
+
+const std::string PostgreSQLStoreFactory::DEFAULT_DATABASE = "quickfix";
+const std::string PostgreSQLStoreFactory::DEFAULT_USER = "postgres";
+const std::string PostgreSQLStoreFactory::DEFAULT_PASSWORD = "";
+const std::string PostgreSQLStoreFactory::DEFAULT_HOST = "localhost";
+const short PostgreSQLStoreFactory::DEFAULT_PORT = 0;
+
+PostgreSQLStore::PostgreSQLStore(
+    const UtcTimeStamp &now,
+    const SessionID &sessionID,
+    const DatabaseConnectionID &connection,
+    PostgreSQLConnectionPool *pool)
+    : m_cache(now),
+      m_pConnectionPool(pool),
+      m_sessionID(sessionID) {
+  m_pConnection = m_pConnectionPool->create(connection);
+  populateCache();
+}
+
+PostgreSQLStore::PostgreSQLStore(
+    const UtcTimeStamp &now,
+    const SessionID &sessionID,
+    const std::string &database,
+    const std::string &user,
+    const std::string &password,
+    const std::string &host,
+    short port)
+    : m_cache(now),
+      m_pConnectionPool(0),
+      m_sessionID(sessionID) {
+  m_pConnection = new PostgreSQLConnection(database, user, password, host, port);
+  populateCache();
+}
+
+PostgreSQLStore::~PostgreSQLStore() {
+  if (m_pConnectionPool) {
+    m_pConnectionPool->destroy(m_pConnection);
+  } else {
+    delete m_pConnection;
+  }
+}
+
+void PostgreSQLStore::populateCache() {
+  std::stringstream queryString;
+
+  queryString << "SELECT creation_time, incoming_seqnum, outgoing_seqnum FROM quickfix.sessions WHERE "
+              << "beginstring=" << "'" << m_sessionID.getBeginString().getValue() << "' and "
+              << "sendercompid=" << "'" << m_sessionID.getSenderCompID().getValue() << "' and "
+              << "targetcompid=" << "'" << m_sessionID.getTargetCompID().getValue() << "' and "
+              << "session_qualifier=" << "'" << m_sessionID.getSessionQualifier() << "'";
+
+  PostgreSQLQuery query(queryString.str());
+  if (!m_pConnection->execute(query)) {
+    throw ConfigError("Unable to query sessions table");
+  }
+
+  int rows = query.rows();
+  if (rows > 1) {
+    throw ConfigError("Multiple entries found for session in database");
+  }
+
+  if (rows == 1) {
+    struct tm time;
+    std::string sqlTime = query.getValue(0, 0);
+    strptime(sqlTime.c_str(), "%Y-%m-%d %H:%M:%S", &time);
+    m_cache.setCreationTime(UtcTimeStamp(&time));
+    m_cache.setNextTargetMsgSeqNum(std::stoull(query.getValue(0, 1)));
+    m_cache.setNextSenderMsgSeqNum(std::stoull(query.getValue(0, 2)));
+  } else {
+    UtcTimeStamp time = m_cache.getCreationTime();
+    char sqlTime[100];
+    int year, month, day, hour, minute, second, millis;
+    time.getYMD(year, month, day);
+    time.getHMS(hour, minute, second, millis);
+    STRING_SPRINTF(sqlTime, "%d-%02d-%02d %02d:%02d:%02d", year, month, day, hour, minute, second);
+    std::stringstream queryString2;
+    queryString2 << "INSERT INTO quickfix.sessions (beginstring, sendercompid, targetcompid, session_qualifier,"
+                 << "creation_time, incoming_seqnum, outgoing_seqnum) VALUES("
+                 << "'" << m_sessionID.getBeginString().getValue() << "',"
+                 << "'" << m_sessionID.getSenderCompID().getValue() << "',"
+                 << "'" << m_sessionID.getTargetCompID().getValue() << "',"
+                 << "'" << m_sessionID.getSessionQualifier() << "',"
+                 << "'" << sqlTime << "'," << m_cache.getNextTargetMsgSeqNum() << ","
+                 << m_cache.getNextSenderMsgSeqNum() << ")";
+
+    PostgreSQLQuery query2(queryString2.str());
+    if (!m_pConnection->execute(query2)) {
+      throw ConfigError("Unable to create session in database");
+    }
+  }
+}
+
+MessageStore *PostgreSQLStoreFactory::create(const UtcTimeStamp &now, const SessionID &sessionID) {
+  if (m_useSettings) {
+    return create(now, sessionID, m_settings.get(sessionID));
+  } else if (m_useDictionary) {
+    return create(now, sessionID, m_dictionary);
+  } else {
+    DatabaseConnectionID id(m_database, m_user, m_password, m_host, m_port);
+    return new PostgreSQLStore(now, sessionID, id, m_connectionPoolPtr.get());
+  }
+}
+
+MessageStore *PostgreSQLStoreFactory::create(
+    const UtcTimeStamp &now,
+    const SessionID &sessionID,
+    const Dictionary &settings) {
+  std::string database = DEFAULT_DATABASE;
+  std::string user = DEFAULT_USER;
+  std::string password = DEFAULT_PASSWORD;
+  std::string host = DEFAULT_HOST;
+  short port = DEFAULT_PORT;
+
+  try {
+    database = settings.getString(POSTGRESQL_STORE_DATABASE);
+  } catch (ConfigError &) {}
+
+  try {
+    user = settings.getString(POSTGRESQL_STORE_USER);
+  } catch (ConfigError &) {}
+
+  try {
+    password = settings.getString(POSTGRESQL_STORE_PASSWORD);
+  } catch (ConfigError &) {}
+
+  try {
+    host = settings.getString(POSTGRESQL_STORE_HOST);
+  } catch (ConfigError &) {}
+
+  try {
+    port = (short)settings.getInt(POSTGRESQL_STORE_PORT);
+  } catch (ConfigError &) {}
+
+  DatabaseConnectionID id(database, user, password, host, port);
+  return new PostgreSQLStore(now, sessionID, id, m_connectionPoolPtr.get());
+}
+
+void PostgreSQLStoreFactory::destroy(MessageStore *pStore) { delete pStore; }
+
+bool PostgreSQLStore::set(SEQNUM msgSeqNum, const std::string &msg) EXCEPT(IOException) {
+  char *msgCopy = new char[(msg.size() * 2) + 1];
+  PQescapeString(msgCopy, msg.c_str(), msg.size());
+
+  std::stringstream queryString;
+  queryString << "INSERT INTO quickfix.messages "
+              << "(beginstring, sendercompid, targetcompid, session_qualifier, msgseqnum, message) "
+              << "VALUES ("
+              << "'" << m_sessionID.getBeginString().getValue() << "',"
+              << "'" << m_sessionID.getSenderCompID().getValue() << "',"
+              << "'" << m_sessionID.getTargetCompID().getValue() << "',"
+              << "'" << m_sessionID.getSessionQualifier() << "'," << msgSeqNum << ","
+              << "'" << msgCopy << "')";
+
+  delete[] msgCopy;
+
+  PostgreSQLQuery query(queryString.str());
+  if (!m_pConnection->execute(query)) {
+    std::stringstream queryString2;
+    queryString2 << "UPDATE quickfix.messages SET message='" << msg << "' WHERE "
+                 << "beginstring=" << "'" << m_sessionID.getBeginString().getValue() << "' and "
+                 << "sendercompid=" << "'" << m_sessionID.getSenderCompID().getValue() << "' and "
+                 << "targetcompid=" << "'" << m_sessionID.getTargetCompID().getValue() << "' and "
+                 << "session_qualifier=" << "'" << m_sessionID.getSessionQualifier() << "' and "
+                 << "msgseqnum=" << msgSeqNum;
+    PostgreSQLQuery query2(queryString2.str());
+    if (!m_pConnection->execute(query2)) {
+      query2.throwException();
+    }
+  }
+
+  return true;
+}
+
+void PostgreSQLStore::get(SEQNUM begin, SEQNUM end, std::vector<std::string> &result) const EXCEPT(IOException) {
+  result.clear();
+  std::stringstream queryString;
+  queryString << "SELECT message FROM quickfix.messages WHERE "
+              << "beginstring=" << "'" << m_sessionID.getBeginString().getValue() << "' and "
+              << "sendercompid=" << "'" << m_sessionID.getSenderCompID().getValue() << "' and "
+              << "targetcompid=" << "'" << m_sessionID.getTargetCompID().getValue() << "' and "
+              << "session_qualifier=" << "'" << m_sessionID.getSessionQualifier() << "' and "
+              << "msgseqnum>=" << begin << " and " << "msgseqnum<=" << end << " "
+              << "ORDER BY msgseqnum";
+
+  PostgreSQLQuery query(queryString.str());
+  if (!m_pConnection->execute(query)) {
+    query.throwException();
+  }
+
+  int rows = query.rows();
+  for (int row = 0; row < rows; row++) {
+    result.push_back(query.getValue(row, 0));
+  }
+}
+
+SEQNUM PostgreSQLStore::getNextSenderMsgSeqNum() const EXCEPT(IOException) { return m_cache.getNextSenderMsgSeqNum(); }
+
+SEQNUM PostgreSQLStore::getNextTargetMsgSeqNum() const EXCEPT(IOException) { return m_cache.getNextTargetMsgSeqNum(); }
+
+void PostgreSQLStore::setNextSenderMsgSeqNum(SEQNUM value) EXCEPT(IOException) {
+  std::stringstream queryString;
+  queryString << "UPDATE quickfix.sessions SET outgoing_seqnum=" << value << " WHERE "
+              << "beginstring=" << "'" << m_sessionID.getBeginString().getValue() << "' and "
+              << "sendercompid=" << "'" << m_sessionID.getSenderCompID().getValue() << "' and "
+              << "targetcompid=" << "'" << m_sessionID.getTargetCompID().getValue() << "' and "
+              << "session_qualifier=" << "'" << m_sessionID.getSessionQualifier() << "'";
+
+  PostgreSQLQuery query(queryString.str());
+  if (!m_pConnection->execute(query)) {
+    query.throwException();
+  }
+
+  m_cache.setNextSenderMsgSeqNum(value);
+}
+
+void PostgreSQLStore::setNextTargetMsgSeqNum(SEQNUM value) EXCEPT(IOException) {
+  std::stringstream queryString;
+  queryString << "UPDATE quickfix.sessions SET incoming_seqnum=" << value << " WHERE "
+              << "beginstring=" << "'" << m_sessionID.getBeginString().getValue() << "' and "
+              << "sendercompid=" << "'" << m_sessionID.getSenderCompID().getValue() << "' and "
+              << "targetcompid=" << "'" << m_sessionID.getTargetCompID().getValue() << "' and "
+              << "session_qualifier=" << "'" << m_sessionID.getSessionQualifier() << "'";
+
+  PostgreSQLQuery query(queryString.str());
+  if (!m_pConnection->execute(query)) {
+    query.throwException();
+  }
+
+  m_cache.setNextTargetMsgSeqNum(value);
+}
+
+void PostgreSQLStore::incrNextSenderMsgSeqNum() EXCEPT(IOException) {
+  m_cache.incrNextSenderMsgSeqNum();
+  setNextSenderMsgSeqNum(m_cache.getNextSenderMsgSeqNum());
+}
+
+void PostgreSQLStore::incrNextTargetMsgSeqNum() EXCEPT(IOException) {
+  m_cache.incrNextTargetMsgSeqNum();
+  setNextTargetMsgSeqNum(m_cache.getNextTargetMsgSeqNum());
+}
+
+UtcTimeStamp PostgreSQLStore::getCreationTime() const EXCEPT(IOException) { return m_cache.getCreationTime(); }
+
+void PostgreSQLStore::reset(const UtcTimeStamp &now) EXCEPT(IOException) {
+  std::stringstream queryString;
+  queryString << "DELETE FROM quickfix.messages WHERE "
+              << "beginstring=" << "'" << m_sessionID.getBeginString().getValue() << "' and "
+              << "sendercompid=" << "'" << m_sessionID.getSenderCompID().getValue() << "' and "
+              << "targetcompid=" << "'" << m_sessionID.getTargetCompID().getValue() << "' and "
+              << "session_qualifier=" << "'" << m_sessionID.getSessionQualifier() << "'";
+
+  PostgreSQLQuery query(queryString.str());
+  if (!m_pConnection->execute(query)) {
+    query.throwException();
+  }
+
+  m_cache.reset(now);
+  UtcTimeStamp time = m_cache.getCreationTime();
+
+  int year, month, day, hour, minute, second, millis;
+  time.getYMD(year, month, day);
+  time.getHMS(hour, minute, second, millis);
+
+  char sqlTime[100];
+  STRING_SPRINTF(sqlTime, "%d-%02d-%02d %02d:%02d:%02d", year, month, day, hour, minute, second);
+
+  std::stringstream queryString2;
+  queryString2 << "UPDATE quickfix.sessions SET creation_time='" << sqlTime << "', "
+               << "incoming_seqnum=" << m_cache.getNextTargetMsgSeqNum() << ", "
+               << "outgoing_seqnum=" << m_cache.getNextSenderMsgSeqNum() << " WHERE "
+               << "beginstring=" << "'" << m_sessionID.getBeginString().getValue() << "' and "
+               << "sendercompid=" << "'" << m_sessionID.getSenderCompID().getValue() << "' and "
+               << "targetcompid=" << "'" << m_sessionID.getTargetCompID().getValue() << "' and "
+               << "session_qualifier=" << "'" << m_sessionID.getSessionQualifier() << "'";
+
+  PostgreSQLQuery query2(queryString2.str());
+  if (!m_pConnection->execute(query2)) {
+    query2.throwException();
+  }
+}
+
+void PostgreSQLStore::refresh() EXCEPT(IOException) {
+  m_cache.reset(UtcTimeStamp::now());
+  populateCache();
+}
+
+} // namespace FIX
+
+#endif

data/ext/quickfix/PostgreSQLStore.h

@@ -0,0 +1,160 @@
+/* -*- C++ -*- */
+
+/****************************************************************************
+** Copyright (c) 2001-2014
+**
+** This file is part of the QuickFIX FIX Engine
+**
+** This file may be distributed under the terms of the quickfixengine.org
+** license as defined by quickfixengine.org and appearing in the file
+** LICENSE included in the packaging of this file.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.quickfixengine.org/LICENSE for licensing information.
+**
+** Contact ask@quickfixengine.org if any conditions of this licensing are
+** not clear to you.
+**
+****************************************************************************/
+
+#ifndef FIX_POSTGRESQLSTORE_H
+#define FIX_POSTGRESQLSTORE_H
+
+#ifndef HAVE_POSTGRESQL
+#error PostgreSQLStore.h included, but HAVE_POSTGRESQL not defined
+#endif
+
+#ifdef HAVE_POSTGRESQL
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4503 4355 4786 4290)
+#endif
+
+#include "MessageStore.h"
+#include "PostgreSQLConnection.h"
+#include "SessionSettings.h"
+#include <fstream>
+#include <string>
+
+namespace FIX {
+/// Creates a PostgreSQL based implementation of MessageStore.
+class PostgreSQLStoreFactory : public MessageStoreFactory {
+public:
+  static const std::string DEFAULT_DATABASE;
+  static const std::string DEFAULT_USER;
+  static const std::string DEFAULT_PASSWORD;
+  static const std::string DEFAULT_HOST;
+  static const short DEFAULT_PORT;
+
+  PostgreSQLStoreFactory(const SessionSettings &settings)
+      : m_settings(settings),
+        m_useSettings(true),
+        m_useDictionary(false) {
+    bool poolConnections = false;
+    try {
+      poolConnections = settings.get().getBool(POSTGRESQL_STORE_USECONNECTIONPOOL);
+    } catch (ConfigError &) {}
+
+    m_connectionPoolPtr = PostgreSQLConnectionPoolPtr(new PostgreSQLConnectionPool(poolConnections));
+  }
+
+  PostgreSQLStoreFactory(const Dictionary &dictionary)
+      : m_dictionary(dictionary),
+        m_useSettings(false),
+        m_useDictionary(true) {
+    m_connectionPoolPtr = PostgreSQLConnectionPoolPtr(new PostgreSQLConnectionPool(false));
+  }
+
+  PostgreSQLStoreFactory(
+      const std::string &database,
+      const std::string &user,
+      const std::string &password,
+      const std::string &host,
+      short port)
+      : m_database(database),
+        m_user(user),
+        m_password(password),
+        m_host(host),
+        m_port(port),
+        m_useSettings(false),
+        m_useDictionary(false) {
+    m_connectionPoolPtr = PostgreSQLConnectionPoolPtr(new PostgreSQLConnectionPool(false));
+  }
+
+  PostgreSQLStoreFactory()
+      : m_database(DEFAULT_DATABASE),
+        m_user(DEFAULT_USER),
+        m_password(DEFAULT_PASSWORD),
+        m_host(DEFAULT_HOST),
+        m_port(DEFAULT_PORT),
+        m_useSettings(false),
+        m_useDictionary(false) {
+    m_connectionPoolPtr = PostgreSQLConnectionPoolPtr(new PostgreSQLConnectionPool(false));
+  }
+
+  MessageStore *create(const UtcTimeStamp &, const SessionID &);
+  void destroy(MessageStore *);
+
+private:
+  MessageStore *create(const UtcTimeStamp &, const SessionID &, const Dictionary &);
+
+  PostgreSQLConnectionPoolPtr m_connectionPoolPtr;
+  SessionSettings m_settings;
+  Dictionary m_dictionary;
+  std::string m_database;
+  std::string m_user;
+  std::string m_password;
+  std::string m_host;
+  short m_port;
+  bool m_useSettings;
+  bool m_useDictionary;
+};
+/*! @} */
+
+/// PostgreSQL based implementation of MessageStore.
+class PostgreSQLStore : public MessageStore {
+public:
+  PostgreSQLStore(
+      const UtcTimeStamp &now,
+      const SessionID &sessionID,
+      const DatabaseConnectionID &connection,
+      PostgreSQLConnectionPool *pool);
+  PostgreSQLStore(
+      const UtcTimeStamp &now,
+      const SessionID &sessionID,
+      const std::string &database,
+      const std::string &user,
+      const std::string &password,
+      const std::string &host,
+      short port);
+  ~PostgreSQLStore();
+
+  bool set(SEQNUM, const std::string &) EXCEPT(IOException);
+  void get(SEQNUM, SEQNUM, std::vector<std::string> &) const EXCEPT(IOException);
+
+  SEQNUM getNextSenderMsgSeqNum() const EXCEPT(IOException);
+  SEQNUM getNextTargetMsgSeqNum() const EXCEPT(IOException);
+  void setNextSenderMsgSeqNum(SEQNUM value) EXCEPT(IOException);
+  void setNextTargetMsgSeqNum(SEQNUM value) EXCEPT(IOException);
+  void incrNextSenderMsgSeqNum() EXCEPT(IOException);
+  void incrNextTargetMsgSeqNum() EXCEPT(IOException);
+
+  UtcTimeStamp getCreationTime() const EXCEPT(IOException);
+
+  void reset(const UtcTimeStamp &now) EXCEPT(IOException);
+  void refresh() EXCEPT(IOException);
+
+private:
+  void populateCache();
+
+  MemoryStore m_cache;
+  PostgreSQLConnection *m_pConnection;
+  PostgreSQLConnectionPool *m_pConnectionPool;
+  SessionID m_sessionID;
+};
+} // namespace FIX
+
+#endif // FIX_POSTGRESQLSTORE_H
+#endif // HAVE_POSTGRESQL