Connection_p.h

#include "Connection.h"
#include <knowRDF/BlankNode.h>
 
#include <libpq-fe.h>
 
#include <QMutex>
#include <QHash>
#include <QSharedPointer>
#include <QUuid>
 
#include <Cyqlops/Crypto/RSAAlgorithm.h>
 
#include "krQuery/Engine.h"
 
namespace kDB
{
  namespace Repository
  {
    struct Connection::Private
    {
      Private();
      ~Private();
      void disconnect();
 
      void addOid(Oid _oid, const QString& _name) const;
 
      knowCore::WeakReference<Connection> self_p;
      QAtomicInt self_p_count; // TODO Ugly, duplicate the counting from the shared pointer, maybe use QSharedDataPointer in the future?
      
      QString host, database;
      int port;
      
      QMutex connections_lock;
      QList<PGconn*> connections;
      QList<PGconn*> available_connections;
      
      QStringList kdb_rdf_value_type_enum_values;
      
      mutable QMutex metainformation_lock;
      
      mutable QHash<Oid, QString> oids2name;
      mutable QHash<QString, Oid> name2oid;
      QString oidToName(Oid _oid) const;
      Oid nameToOid(const QString& _name) const;
      
      GraphsManager* graphsManager = nullptr;
      SPARQLFunctionsManager* sparqlFunctionsManager = nullptr;
      NotificationsManager* notificationsManager = nullptr;
      
      knowCore::ReturnVoid load_sql_files(PGconn* _conn, const QStringList& _files);
      knowCore::ReturnVoid execute_sql_query(PGconn* _conn, const QByteArray& _query);
      
      void update_kdb_rdf_value_type_enum_values();
      
      DatabaseInterface::PostgreSQL::RDFValueBinaryMarshal* rdf_value_marshal = nullptr;
      DatabaseInterface::PostgreSQL::RDFTermBinaryMarshal* rdf_term_marshal = nullptr;
      
      QHash<QString, AbstractBinaryMarshal*> oid2marshals;
      QHash<knowCore::Uri, AbstractBinaryMarshal*> metaTypeId2marshals;
      
      knowCore::ReturnValue<knowCore::Value> toValue(const QString& _oid, const QByteArray& _source);
      knowCore::ReturnValue<QByteArray> toByteArray(const knowCore::Value& _source, QString& _oidName);
      
      void write(const knowCore::Value& val, QByteArray* r, Oid* oid, bool* is_binary, bool* is_valid);
      
      QHash<QString, knowRDF::BlankNode> blanknodes;
      knowRDF::BlankNode blankNode(const QString& _url);
      
      QUuid m_server_uuid;
      Cyqlops::Crypto::RSAAlgorithm m_rsa_algorithm;
      
      QHash<QString, QHash<QString, QString>> prefix2key2tablename;
      
      QString uniqueTableName(const QString& _prefix, const QString& _key);
      
      QStringList loadedExtensions, enabledExtensions;
      knowCore::ReturnVoid loadExtension(const QString& _extension);
      knowCore::ReturnVoid loadExtensions();
      
      QUuid uuid;
 
      QHash<QUuid, std::function<void()>> disconnection_listener;
      QHash<QUuid, std::function<void(const Connection&)>> connection_listener;
      QMap<std::type_index, QObject*> extensionObjects;
      
      krQuery::Engine* krQueryEngine = nullptr;
    };
  }
}