TriplesStore_p.h

#pragma once
 
#include "TriplesStore.h"
 
#include <QMutex>
#include <QVariantMap>
 
#include <knowCore/Uri.h>
 
#include "RDFDataset_p.h"
#include "VersionControl/Transaction_p.h"
 
namespace kDB::Repository
{
  struct TriplesStoreNotifications : public QObject
  {
    Q_OBJECT
  signals:
    void optionsChanged();
    void metaChanged();
  };
  struct TriplesStore::Definition
  { // Do not change
    QMutex mutex;
    TriplesStoreNotifications notifications;
    knowCore::Uri name;
    QString table;
    TriplesStore::Options options;
    bool isValid = false;
    knowCore::ValueHash meta;
    knowCore::ReturnVoid setMeta(const QStringList& _path, const knowCore::Value& _value, const Transaction& _transaction);
    knowCore::ReturnValue<knowCore::Value> getMeta(const QStringList& _path, const Transaction& _transaction = Transaction());
  private:
    QHash<QString, knowCore::Value> setMeta(QHash<QString, knowCore::Value> _map, const QStringList& _path, const knowCore::Value& _value);
  };
  struct TriplesStore::Private : public RDFDataset::Private
  {
    Private(const Connection& _connection) : RDFDataset::Private(RDFDataset::Type::TriplesStore, _connection) {}
    ~Private();
    QSharedPointer<Definition> definition;
    VersionControl::Manager* manager = nullptr;
    bool disable_recording_version = false; 
    bool isValid() const override
    {
      return true;
    }
    knowCore::Uri uri() const override
    {
      return definition->name;
    }
    TSTemporaryTransaction acquireTransaction(TriplesStore* _self, const Transaction& _transaction);
  };
  struct TriplesStore::TSTemporaryTransaction
  {
    bool own_sql_transaction = false;
    Transaction sql_transaction;
    
    knowCore::ReturnVoid commitIfOwn()
    {
      if(own_sql_transaction)
      {
        return sql_transaction.commit();
      } else {
        return kCrvSuccess();
      }
    }
    knowCore::ReturnVoid rollback()
    {
      return sql_transaction.rollback();
    }
  };
  KNOWCORE_D_FUNC_DEF(TriplesStore)
}