orthanc: OrthancServer/Sources/Database/SQLiteDatabaseWrapper.cpp comparison

comparison OrthancServer/Sources/Database/SQLiteDatabaseWrapper.cpp @ 4591:ff8170d17d90 db-changes

moving all accesses to databases from IDatabaseWrapper to ITransaction

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Mon, 15 Mar 2021 15:30:42 +0100
parents	bec74e29f86b
children	36bbf3169a27

comparison

equal deleted inserted replaced

-:4a0bf1019335
+:ff8170d17d90
 #include "../../../OrthancFramework/Sources/DicomFormat/DicomArray.h"
 #include "../../../OrthancFramework/Sources/Logging.h"
 #include "../../../OrthancFramework/Sources/SQLite/Transaction.h"
 #include "../Search/ISqlLookupFormatter.h"
 #include "../ServerToolbox.h"
+#include "Compatibility/ICreateInstance.h"
+#include "Compatibility/IGetChildrenMetadata.h"
+#include "Compatibility/ILookupResourceAndParent.h"
+#include "Compatibility/ISetResourcesContent.h"
+#include "VoidDatabaseListener.h"
 #include <OrthancServerResources.h>
 #include <stdio.h>
 #include <boost/lexical_cast.hpp>
 namespace Orthanc
 {
+class SQLiteDatabaseWrapper::LookupFormatter : public ISqlLookupFormatter
+{
+private:
+std::list<std::string>  values_;
+public:
+virtual std::string GenerateParameter(const std::string& value) ORTHANC_OVERRIDE
+{
+values_.push_back(value);
+return "?";
+}
+virtual std::string FormatResourceType(ResourceType level) ORTHANC_OVERRIDE
+{
+return boost::lexical_cast<std::string>(level);
+}
+virtual std::string FormatWildcardEscape() ORTHANC_OVERRIDE
+{
+return "ESCAPE '\\'";
+}
+void Bind(SQLite::Statement& statement) const
+{
+size_t pos = 0;
+for (std::list<std::string>::const_iterator
+it = values_.begin(); it != values_.end(); ++it, pos++)
+{
+statement.BindString(pos, *it);
+}
+}
+};
+class SQLiteDatabaseWrapper::SignalRemainingAncestor : public SQLite::IScalarFunction
+{
+private:
+bool hasRemainingAncestor_;
+std::string remainingPublicId_;
+ResourceType remainingType_;
+public:
+SignalRemainingAncestor() :
+hasRemainingAncestor_(false)
+{
+}
+void Reset()
+{
+hasRemainingAncestor_ = false;
+}
+virtual const char* GetName() const ORTHANC_OVERRIDE
+{
+return "SignalRemainingAncestor";
+}
+virtual unsigned int GetCardinality() const ORTHANC_OVERRIDE
+{
+return 2;
+}
+virtual void Compute(SQLite::FunctionContext& context) ORTHANC_OVERRIDE
+{
+CLOG(TRACE, SQLITE) << "There exists a remaining ancestor with public ID \""
+<< context.GetStringValue(0) << "\" of type "
+<< context.GetIntValue(1);
+if (!hasRemainingAncestor_ ||
+remainingType_ >= context.GetIntValue(1))
+{
+hasRemainingAncestor_ = true;
+remainingPublicId_ = context.GetStringValue(0);
+remainingType_ = static_cast<ResourceType>(context.GetIntValue(1));
+}
+}
+bool HasRemainingAncestor() const
+{
+return hasRemainingAncestor_;
+}
+const std::string& GetRemainingAncestorId() const
+{
+assert(hasRemainingAncestor_);
+return remainingPublicId_;
+}
+ResourceType GetRemainingAncestorType() const
+{
+assert(hasRemainingAncestor_);
+return remainingType_;
+}
+};
+class SQLiteDatabaseWrapper::TransactionBase :
+public SQLiteDatabaseWrapper::UnitTestsTransaction,
+public Compatibility::ICreateInstance,
+public Compatibility::IGetChildrenMetadata,
+public Compatibility::ILookupResourceAndParent,
+public Compatibility::ISetResourcesContent
+{
+private:
+void AnswerLookup(std::list<std::string>& resourcesId,
+std::list<std::string>& instancesId,
+ResourceType level)
+{
+resourcesId.clear();
+instancesId.clear();
+std::unique_ptr<SQLite::Statement> statement;
+switch (level)
+{
+case ResourceType_Patient:
+{
+statement.reset(
+new SQLite::Statement(
+db_, SQLITE_FROM_HERE,
+"SELECT patients.publicId, instances.publicID FROM Lookup AS patients "
+"INNER JOIN Resources studies ON patients.internalId=studies.parentId "
+"INNER JOIN Resources series ON studies.internalId=series.parentId "
+"INNER JOIN Resources instances ON series.internalId=instances.parentId "
+"GROUP BY patients.publicId"));
+break;
+}
+case ResourceType_Study:
+{
+statement.reset(
+new SQLite::Statement(
+db_, SQLITE_FROM_HERE,
+"SELECT studies.publicId, instances.publicID FROM Lookup AS studies "
+"INNER JOIN Resources series ON studies.internalId=series.parentId "
+"INNER JOIN Resources instances ON series.internalId=instances.parentId "
+"GROUP BY studies.publicId"));
+break;
+}
+case ResourceType_Series:
+{
+statement.reset(
+new SQLite::Statement(
+db_, SQLITE_FROM_HERE,
+"SELECT series.publicId, instances.publicID FROM Lookup AS series "
+"INNER JOIN Resources instances ON series.internalId=instances.parentId "
+"GROUP BY series.publicId"));
+break;
+}
+case ResourceType_Instance:
+{
+statement.reset(
+new SQLite::Statement(
+db_, SQLITE_FROM_HERE, "SELECT publicId, publicId FROM Lookup"));
+break;
+}
+default:
+throw OrthancException(ErrorCode_InternalError);
+}
+assert(statement.get() != NULL);
+while (statement->Step())
+{
+resourcesId.push_back(statement->ColumnString(0));
+instancesId.push_back(statement->ColumnString(1));
+}
+}
+void ClearTable(const std::string& tableName)
+{
+db_.Execute("DELETE FROM " + tableName);
+}
+void GetChangesInternal(std::list<ServerIndexChange>& target,
+bool& done,
+SQLite::Statement& s,
+uint32_t maxResults)
+{
+target.clear();
+while (target.size() < maxResults && s.Step())
+{
+int64_t seq = s.ColumnInt64(0);
+ChangeType changeType = static_cast<ChangeType>(s.ColumnInt(1));
+ResourceType resourceType = static_cast<ResourceType>(s.ColumnInt(3));
+const std::string& date = s.ColumnString(4);
+int64_t internalId = s.ColumnInt64(2);
+std::string publicId = GetPublicId(internalId);
+target.push_back(ServerIndexChange(seq, changeType, resourceType, publicId, date));
+}
+done = !(target.size() == maxResults && s.Step());
+}
+void GetExportedResourcesInternal(std::list<ExportedResource>& target,
+bool& done,
+SQLite::Statement& s,
+uint32_t maxResults)
+{
+target.clear();
+while (target.size() < maxResults && s.Step())
+{
+int64_t seq = s.ColumnInt64(0);
+ResourceType resourceType = static_cast<ResourceType>(s.ColumnInt(1));
+std::string publicId = s.ColumnString(2);
+ExportedResource resource(seq,
+resourceType,
+publicId,
+s.ColumnString(3),  // modality
+s.ColumnString(8),  // date
+s.ColumnString(4),  // patient ID
+s.ColumnString(5),  // study instance UID
+s.ColumnString(6),  // series instance UID
+s.ColumnString(7)); // sop instance UID
+target.push_back(resource);
+}
+done = !(target.size() == maxResults && s.Step());
+}
+void GetChildren(std::list<std::string>& childrenPublicIds,
+int64_t id)
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT publicId FROM Resources WHERE parentId=?");
+s.BindInt64(0, id);
+childrenPublicIds.clear();
+while (s.Step())
+{
+childrenPublicIds.push_back(s.ColumnString(0));
+}
+}
+IDatabaseListener&        listener_;
+SignalRemainingAncestor&  signalRemainingAncestor_;
+public:
+TransactionBase(SQLite::Connection& db,
+IDatabaseListener& listener,
+SignalRemainingAncestor& signalRemainingAncestor) :
+UnitTestsTransaction(db),
+listener_(listener),
+signalRemainingAncestor_(signalRemainingAncestor)
+{
+}
+IDatabaseListener& GetListener() const
+{
+return listener_;
+}
+virtual void AddAttachment(int64_t id,
+const FileInfo& attachment) ORTHANC_OVERRIDE
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "INSERT INTO AttachedFiles VALUES(?, ?, ?, ?, ?, ?, ?, ?)");
+s.BindInt64(0, id);
+s.BindInt(1, attachment.GetContentType());
+s.BindString(2, attachment.GetUuid());
+s.BindInt64(3, attachment.GetCompressedSize());
+s.BindInt64(4, attachment.GetUncompressedSize());
+s.BindInt(5, attachment.GetCompressionType());
+s.BindString(6, attachment.GetUncompressedMD5());
+s.BindString(7, attachment.GetCompressedMD5());
+s.Run();
+}
+virtual void ApplyLookupResources(std::list<std::string>& resourcesId,
+std::list<std::string>* instancesId,
+const std::vector<DatabaseConstraint>& lookup,
+ResourceType queryLevel,
+size_t limit) ORTHANC_OVERRIDE
+{
+LookupFormatter formatter;
+std::string sql;
+LookupFormatter::Apply(sql, formatter, lookup, queryLevel, limit);
+sql = "CREATE TEMPORARY TABLE Lookup AS " + sql;
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "DROP TABLE IF EXISTS Lookup");
+s.Run();
+}
+{
+SQLite::Statement statement(db_, sql);
+formatter.Bind(statement);
+statement.Run();
+}
+if (instancesId != NULL)
+{
+AnswerLookup(resourcesId, *instancesId, queryLevel);
+}
+else
+{
+resourcesId.clear();
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT publicId FROM Lookup");
+while (s.Step())
+{
+resourcesId.push_back(s.ColumnString(0));
+}
+}
+}
+virtual void AttachChild(int64_t parent,
+int64_t child) ORTHANC_OVERRIDE
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "UPDATE Resources SET parentId = ? WHERE internalId = ?");
+s.BindInt64(0, parent);
+s.BindInt64(1, child);
+s.Run();
+}
+virtual void ClearChanges() ORTHANC_OVERRIDE
+{
+ClearTable("Changes");
+}
+virtual void ClearExportedResources() ORTHANC_OVERRIDE
+{
+ClearTable("ExportedResources");
+}
+virtual void ClearMainDicomTags(int64_t id) ORTHANC_OVERRIDE
+{
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "DELETE FROM DicomIdentifiers WHERE id=?");
+s.BindInt64(0, id);
+s.Run();
+}
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "DELETE FROM MainDicomTags WHERE id=?");
+s.BindInt64(0, id);
+s.Run();
+}
+}
+virtual bool CreateInstance(CreateInstanceResult& result,
+int64_t& instanceId,
+const std::string& patient,
+const std::string& study,
+const std::string& series,
+const std::string& instance) ORTHANC_OVERRIDE
+{
+return ICreateInstance::Apply
+(*this, result, instanceId, patient, study, series, instance);
+}
+virtual int64_t CreateResource(const std::string& publicId,
+ResourceType type) ORTHANC_OVERRIDE
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "INSERT INTO Resources VALUES(NULL, ?, ?, NULL)");
+s.BindInt(0, type);
+s.BindString(1, publicId);
+s.Run();
+return db_.GetLastInsertRowId();
+}
+virtual void DeleteAttachment(int64_t id,
+FileContentType attachment) ORTHANC_OVERRIDE
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "DELETE FROM AttachedFiles WHERE id=? AND fileType=?");
+s.BindInt64(0, id);
+s.BindInt(1, attachment);
+s.Run();
+}
+virtual void DeleteMetadata(int64_t id,
+MetadataType type) ORTHANC_OVERRIDE
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "DELETE FROM Metadata WHERE id=? and type=?");
+s.BindInt64(0, id);
+s.BindInt(1, type);
+s.Run();
+}
+virtual void DeleteResource(int64_t id) ORTHANC_OVERRIDE
+{
+signalRemainingAncestor_.Reset();
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "DELETE FROM Resources WHERE internalId=?");
+s.BindInt64(0, id);
+s.Run();
+if (signalRemainingAncestor_.HasRemainingAncestor())
+{
+listener_.SignalRemainingAncestor(signalRemainingAncestor_.GetRemainingAncestorType(),
+signalRemainingAncestor_.GetRemainingAncestorId());
+}
+}
+virtual void GetAllMetadata(std::map<MetadataType, std::string>& target,
+int64_t id) ORTHANC_OVERRIDE
+{
+target.clear();
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT type, value FROM Metadata WHERE id=?");
+s.BindInt64(0, id);
+while (s.Step())
+{
+MetadataType key = static_cast<MetadataType>(s.ColumnInt(0));
+target[key] = s.ColumnString(1);
+}
+}
+virtual void GetAllPublicIds(std::list<std::string>& target,
+ResourceType resourceType) ORTHANC_OVERRIDE
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT publicId FROM Resources WHERE resourceType=?");
+s.BindInt(0, resourceType);
+target.clear();
+while (s.Step())
+{
+target.push_back(s.ColumnString(0));
+}
+}
+virtual void GetAllPublicIds(std::list<std::string>& target,
+ResourceType resourceType,
+size_t since,
+size_t limit) ORTHANC_OVERRIDE
+{
+if (limit == 0)
+{
+target.clear();
+return;
+}
+SQLite::Statement s(db_, SQLITE_FROM_HERE,
+"SELECT publicId FROM Resources WHERE "
+"resourceType=? LIMIT ? OFFSET ?");
+s.BindInt(0, resourceType);
+s.BindInt64(1, limit);
+s.BindInt64(2, since);
+target.clear();
+while (s.Step())
+{
+target.push_back(s.ColumnString(0));
+}
+}
+virtual void GetChanges(std::list<ServerIndexChange>& target /*out*/,
+bool& done /*out*/,
+int64_t since,
+uint32_t maxResults) ORTHANC_OVERRIDE
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT * FROM Changes WHERE seq>? ORDER BY seq LIMIT ?");
+s.BindInt64(0, since);
+s.BindInt(1, maxResults + 1);
+GetChangesInternal(target, done, s, maxResults);
+}
+virtual void GetChildrenMetadata(std::list<std::string>& target,
+int64_t resourceId,
+MetadataType metadata) ORTHANC_OVERRIDE
+{
+IGetChildrenMetadata::Apply(*this, target, resourceId, metadata);
+}
+virtual void GetChildrenInternalId(std::list<int64_t>& target,
+int64_t id) ORTHANC_OVERRIDE
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT a.internalId FROM Resources AS a, Resources AS b  "
+"WHERE a.parentId = b.internalId AND b.internalId = ?");
+s.BindInt64(0, id);
+target.clear();
+while (s.Step())
+{
+target.push_back(s.ColumnInt64(0));
+}
+}
+virtual void GetChildrenPublicId(std::list<std::string>& target,
+int64_t id) ORTHANC_OVERRIDE
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT a.publicId FROM Resources AS a, Resources AS b  "
+"WHERE a.parentId = b.internalId AND b.internalId = ?");
+s.BindInt64(0, id);
+target.clear();
+while (s.Step())
+{
+target.push_back(s.ColumnString(0));
+}
+}
+virtual void GetExportedResources(std::list<ExportedResource>& target,
+bool& done,
+int64_t since,
+uint32_t maxResults) ORTHANC_OVERRIDE
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE,
+"SELECT * FROM ExportedResources WHERE seq>? ORDER BY seq LIMIT ?");
+s.BindInt64(0, since);
+s.BindInt(1, maxResults + 1);
+GetExportedResourcesInternal(target, done, s, maxResults);
+}
+virtual void GetLastChange(std::list<ServerIndexChange>& target /*out*/) ORTHANC_OVERRIDE
+{
+bool done;  // Ignored
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT * FROM Changes ORDER BY seq DESC LIMIT 1");
+GetChangesInternal(target, done, s, 1);
+}
+int64_t GetLastChangeIndex() ORTHANC_OVERRIDE
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE,
+"SELECT seq FROM sqlite_sequence WHERE name='Changes'");
+if (s.Step())
+{
+int64_t c = s.ColumnInt(0);
+assert(!s.Step());
+return c;
+}
+else
+{
+// No change has been recorded so far in the database
+return 0;
+}
+}
+virtual void GetLastExportedResource(std::list<ExportedResource>& target) ORTHANC_OVERRIDE
+{
+bool done;  // Ignored
+SQLite::Statement s(db_, SQLITE_FROM_HERE,
+"SELECT * FROM ExportedResources ORDER BY seq DESC LIMIT 1");
+GetExportedResourcesInternal(target, done, s, 1);
+}
+virtual void GetMainDicomTags(DicomMap& map,
+int64_t id) ORTHANC_OVERRIDE
+{
+map.Clear();
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT * FROM MainDicomTags WHERE id=?");
+s.BindInt64(0, id);
+while (s.Step())
+{
+map.SetValue(s.ColumnInt(1),
+s.ColumnInt(2),
+s.ColumnString(3), false);
+}
+}
+virtual std::string GetPublicId(int64_t resourceId) ORTHANC_OVERRIDE
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE,
+"SELECT publicId FROM Resources WHERE internalId=?");
+s.BindInt64(0, resourceId);
+if (s.Step())
+{
+return s.ColumnString(0);
+}
+else
+{
+throw OrthancException(ErrorCode_UnknownResource);
+}
+}
+virtual uint64_t GetResourceCount(ResourceType resourceType) ORTHANC_OVERRIDE
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE,
+"SELECT COUNT(*) FROM Resources WHERE resourceType=?");
+s.BindInt(0, resourceType);
+if (!s.Step())
+{
+return 0;
+}
+else
+{
+int64_t c = s.ColumnInt(0);
+assert(!s.Step());
+return c;
+}
+}
+virtual ResourceType GetResourceType(int64_t resourceId) ORTHANC_OVERRIDE
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE,
+"SELECT resourceType FROM Resources WHERE internalId=?");
+s.BindInt64(0, resourceId);
+if (s.Step())
+{
+return static_cast<ResourceType>(s.ColumnInt(0));
+}
+else
+{
+throw OrthancException(ErrorCode_UnknownResource);
+}
+}
+virtual uint64_t GetTotalCompressedSize() ORTHANC_OVERRIDE
+{
+// Old SQL query that was used in Orthanc <= 1.5.0:
+// SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT SUM(compressedSize) FROM AttachedFiles");
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT value FROM GlobalIntegers WHERE key=0");
+s.Run();
+return static_cast<uint64_t>(s.ColumnInt64(0));
+}
+virtual uint64_t GetTotalUncompressedSize() ORTHANC_OVERRIDE
+{
+// Old SQL query that was used in Orthanc <= 1.5.0:
+// SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT SUM(uncompressedSize) FROM AttachedFiles");
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT value FROM GlobalIntegers WHERE key=1");
+s.Run();
+return static_cast<uint64_t>(s.ColumnInt64(0));
+}
+virtual bool IsDiskSizeAbove(uint64_t threshold) ORTHANC_OVERRIDE
+{
+return GetTotalCompressedSize() > threshold;
+}
+virtual bool IsExistingResource(int64_t internalId) ORTHANC_OVERRIDE
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE,
+"SELECT * FROM Resources WHERE internalId=?");
+s.BindInt64(0, internalId);
+return s.Step();
+}
+virtual bool IsProtectedPatient(int64_t internalId) ORTHANC_OVERRIDE
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE,
+"SELECT * FROM PatientRecyclingOrder WHERE patientId = ?");
+s.BindInt64(0, internalId);
+return !s.Step();
+}
+virtual void ListAvailableAttachments(std::set<FileContentType>& target,
+int64_t id) ORTHANC_OVERRIDE
+{
+target.clear();
+SQLite::Statement s(db_, SQLITE_FROM_HERE,
+"SELECT fileType FROM AttachedFiles WHERE id=?");
+s.BindInt64(0, id);
+while (s.Step())
+{
+target.insert(static_cast<FileContentType>(s.ColumnInt(0)));
+}
+}
+virtual void LogChange(int64_t internalId,
+const ServerIndexChange& change) ORTHANC_OVERRIDE
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "INSERT INTO Changes VALUES(NULL, ?, ?, ?, ?)");
+s.BindInt(0, change.GetChangeType());
+s.BindInt64(1, internalId);
+s.BindInt(2, change.GetResourceType());
+s.BindString(3, change.GetDate());
+s.Run();
+}
+virtual void LogExportedResource(const ExportedResource& resource) ORTHANC_OVERRIDE
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE,
+"INSERT INTO ExportedResources VALUES(NULL, ?, ?, ?, ?, ?, ?, ?, ?)");
+s.BindInt(0, resource.GetResourceType());
+s.BindString(1, resource.GetPublicId());
+s.BindString(2, resource.GetModality());
+s.BindString(3, resource.GetPatientId());
+s.BindString(4, resource.GetStudyInstanceUid());
+s.BindString(5, resource.GetSeriesInstanceUid());
+s.BindString(6, resource.GetSopInstanceUid());
+s.BindString(7, resource.GetDate());
+s.Run();
+}
+virtual bool LookupAttachment(FileInfo& attachment,
+int64_t id,
+FileContentType contentType) ORTHANC_OVERRIDE
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE,
+"SELECT uuid, uncompressedSize, compressionType, compressedSize, "
+"uncompressedMD5, compressedMD5 FROM AttachedFiles WHERE id=? AND fileType=?");
+s.BindInt64(0, id);
+s.BindInt(1, contentType);
+if (!s.Step())
+{
+return false;
+}
+else
+{
+attachment = FileInfo(s.ColumnString(0),
+contentType,
+s.ColumnInt64(1),
+s.ColumnString(4),
+static_cast<CompressionType>(s.ColumnInt(2)),
+s.ColumnInt64(3),
+s.ColumnString(5));
+return true;
+}
+}
+virtual bool LookupGlobalProperty(std::string& target,
+GlobalProperty property) ORTHANC_OVERRIDE
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE,
+"SELECT value FROM GlobalProperties WHERE property=?");
+s.BindInt(0, property);
+if (!s.Step())
+{
+return false;
+}
+else
+{
+target = s.ColumnString(0);
+return true;
+}
+}
+virtual bool LookupMetadata(std::string& target,
+int64_t id,
+MetadataType type) ORTHANC_OVERRIDE
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE,
+"SELECT value FROM Metadata WHERE id=? AND type=?");
+s.BindInt64(0, id);
+s.BindInt(1, type);
+if (!s.Step())
+{
+return false;
+}
+else
+{
+target = s.ColumnString(0);
+return true;
+}
+}
+virtual bool LookupParent(int64_t& parentId,
+int64_t resourceId) ORTHANC_OVERRIDE
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE,
+"SELECT parentId FROM Resources WHERE internalId=?");
+s.BindInt64(0, resourceId);
+if (!s.Step())
+{
+throw OrthancException(ErrorCode_UnknownResource);
+}
+if (s.ColumnIsNull(0))
+{
+return false;
+}
+else
+{
+parentId = s.ColumnInt(0);
+return true;
+}
+}
+virtual bool LookupResourceAndParent(int64_t& id,
+ResourceType& type,
+std::string& parentPublicId,
+const std::string& publicId) ORTHANC_OVERRIDE
+{
+return ILookupResourceAndParent::Apply(*this, id, type, parentPublicId, publicId);
+}
+virtual bool LookupResource(int64_t& id,
+ResourceType& type,
+const std::string& publicId) ORTHANC_OVERRIDE
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE,
+"SELECT internalId, resourceType FROM Resources WHERE publicId=?");
+s.BindString(0, publicId);
+if (!s.Step())
+{
+return false;
+}
+else
+{
+id = s.ColumnInt(0);
+type = static_cast<ResourceType>(s.ColumnInt(1));
+// Check whether there is a single resource with this public id
+assert(!s.Step());
+return true;
+}
+}
+virtual bool SelectPatientToRecycle(int64_t& internalId) ORTHANC_OVERRIDE
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE,
+"SELECT patientId FROM PatientRecyclingOrder ORDER BY seq ASC LIMIT 1");
+if (!s.Step())
+{
+// No patient remaining or all the patients are protected
+return false;
+}
+else
+{
+internalId = s.ColumnInt(0);
+return true;
+}
+}
+virtual bool SelectPatientToRecycle(int64_t& internalId,
+int64_t patientIdToAvoid) ORTHANC_OVERRIDE
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE,
+"SELECT patientId FROM PatientRecyclingOrder "
+"WHERE patientId != ? ORDER BY seq ASC LIMIT 1");
+s.BindInt64(0, patientIdToAvoid);
+if (!s.Step())
+{
+// No patient remaining or all the patients are protected
+return false;
+}
+else
+{
+internalId = s.ColumnInt(0);
+return true;
+}
+}
+virtual void SetGlobalProperty(GlobalProperty property,
+const std::string& value) ORTHANC_OVERRIDE
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "INSERT OR REPLACE INTO GlobalProperties VALUES(?, ?)");
+s.BindInt(0, property);
+s.BindString(1, value);
+s.Run();
+}
+virtual void SetIdentifierTag(int64_t id,
+const DicomTag& tag,
+const std::string& value) ORTHANC_OVERRIDE
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "INSERT INTO DicomIdentifiers VALUES(?, ?, ?, ?)");
+s.BindInt64(0, id);
+s.BindInt(1, tag.GetGroup());
+s.BindInt(2, tag.GetElement());
+s.BindString(3, value);
+s.Run();
+}
+virtual void SetProtectedPatient(int64_t internalId,
+bool isProtected) ORTHANC_OVERRIDE
+{
+if (isProtected)
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "DELETE FROM PatientRecyclingOrder WHERE patientId=?");
+s.BindInt64(0, internalId);
+s.Run();
+}
+else if (IsProtectedPatient(internalId))
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "INSERT INTO PatientRecyclingOrder VALUES(NULL, ?)");
+s.BindInt64(0, internalId);
+s.Run();
+}
+else
+{
+// Nothing to do: The patient is already unprotected
+}
+}
+virtual void SetMainDicomTag(int64_t id,
+const DicomTag& tag,
+const std::string& value) ORTHANC_OVERRIDE
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "INSERT INTO MainDicomTags VALUES(?, ?, ?, ?)");
+s.BindInt64(0, id);
+s.BindInt(1, tag.GetGroup());
+s.BindInt(2, tag.GetElement());
+s.BindString(3, value);
+s.Run();
+}
+virtual void SetMetadata(int64_t id,
+MetadataType type,
+const std::string& value) ORTHANC_OVERRIDE
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "INSERT OR REPLACE INTO Metadata VALUES(?, ?, ?)");
+s.BindInt64(0, id);
+s.BindInt(1, type);
+s.BindString(2, value);
+s.Run();
+}
+virtual void SetResourcesContent(const Orthanc::ResourcesContent& content) ORTHANC_OVERRIDE
+{
+ISetResourcesContent::Apply(*this, content);
+}
+virtual void TagMostRecentPatient(int64_t patient) ORTHANC_OVERRIDE
+{
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE,
+"DELETE FROM PatientRecyclingOrder WHERE patientId=?");
+s.BindInt64(0, patient);
+s.Run();
+assert(db_.GetLastChangeCount() == 0 ||
+db_.GetLastChangeCount() == 1);
+if (db_.GetLastChangeCount() == 0)
+{
+// The patient was protected, there was nothing to delete from the recycling order
+return;
+}
+}
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE,
+"INSERT INTO PatientRecyclingOrder VALUES(NULL, ?)");
+s.BindInt64(0, patient);
+s.Run();
+}
+}
+};
 class SQLiteDatabaseWrapper::SignalFileDeleted : public SQLite::IScalarFunction
 {
 private:
 SQLiteDatabaseWrapper& sqlite_;
 return 7;
 }
 virtual void Compute(SQLite::FunctionContext& context) ORTHANC_OVERRIDE
 {
-if (sqlite_.listener_ != NULL)
+if (sqlite_.activeTransaction_ != NULL)
 {
 std::string uncompressedMD5, compressedMD5;
 if (!context.IsNullValue(5))
 {
 uncompressedMD5,
 static_cast<CompressionType>(context.GetIntValue(3)),
 static_cast<uint64_t>(context.GetInt64Value(4)),
 compressedMD5);
-sqlite_.listener_->SignalAttachmentDeleted(info);
+sqlite_.activeTransaction_->GetListener().SignalAttachmentDeleted(info);
 }
 }
 };
 return 2;
 }
 virtual void Compute(SQLite::FunctionContext& context) ORTHANC_OVERRIDE
 {
-if (sqlite_.listener_ != NULL)
+if (sqlite_.activeTransaction_ != NULL)
 {
-sqlite_.listener_->SignalResourceDeleted(static_cast<ResourceType>(context.GetIntValue(1)),
+sqlite_.activeTransaction_->GetListener().
-context.GetStringValue(0));
+SignalResourceDeleted(static_cast<ResourceType>(context.GetIntValue(1)),
+context.GetStringValue(0));
 }
 }
 };
-class SQLiteDatabaseWrapper::SignalRemainingAncestor : public SQLite::IScalarFunction
+class SQLiteDatabaseWrapper::ReadWriteTransaction : public SQLiteDatabaseWrapper::TransactionBase
 {
 private:
-bool hasRemainingAncestor_;
+SQLiteDatabaseWrapper&                that_;
-std::string remainingPublicId_;
+std::unique_ptr<SQLite::Transaction>  transaction_;
-ResourceType remainingType_;
+int64_t                               initialDiskSize_;
 public:
-SignalRemainingAncestor() :
+ReadWriteTransaction(SQLiteDatabaseWrapper& that,
-hasRemainingAncestor_(false)
+IDatabaseListener& listener) :
-{
+TransactionBase(that.db_, listener, *that.signalRemainingAncestor_),
-}
+that_(that),
+transaction_(new SQLite::Transaction(that_.db_))
-void Reset()
+{
-{
+if (that_.activeTransaction_ != NULL)
-hasRemainingAncestor_ = false;
+{
-}
+throw OrthancException(ErrorCode_InternalError);
+}
-virtual const char* GetName() const ORTHANC_OVERRIDE
-{
+that_.activeTransaction_ = this;
-return "SignalRemainingAncestor";
-}
+#if defined(NDEBUG)
+// Release mode
-virtual unsigned int GetCardinality() const ORTHANC_OVERRIDE
+initialDiskSize_ = 0;
-{
+#else
-return 2;
+// Debug mode
-}
+initialDiskSize_ = static_cast<int64_t>(GetTotalCompressedSize());
+#endif
-virtual void Compute(SQLite::FunctionContext& context) ORTHANC_OVERRIDE
+}
-{
-CLOG(TRACE, SQLITE) << "There exists a remaining ancestor with public ID \""
+virtual ~ReadWriteTransaction()
-<< context.GetStringValue(0) << "\" of type "
+{
-<< context.GetIntValue(1);
+assert(that_.activeTransaction_ != NULL);
+that_.activeTransaction_ = NULL;
-if (!hasRemainingAncestor_ ||
+}
-remainingType_ >= context.GetIntValue(1))
-{
+void Begin()
-hasRemainingAncestor_ = true;
+{
-remainingPublicId_ = context.GetStringValue(0);
+transaction_->Begin();
-remainingType_ = static_cast<ResourceType>(context.GetIntValue(1));
+}
-}
-}
+virtual void Rollback() ORTHANC_OVERRIDE
+{
-bool HasRemainingAncestor() const
+transaction_->Rollback();
-{
+}
-return hasRemainingAncestor_;
-}
+virtual void Commit(int64_t fileSizeDelta /* only used in debug */) ORTHANC_OVERRIDE
+{
-const std::string& GetRemainingAncestorId() const
+transaction_->Commit();
-{
-assert(hasRemainingAncestor_);
+assert(initialDiskSize_ + fileSizeDelta >= 0 &&
-return remainingPublicId_;
+initialDiskSize_ + fileSizeDelta == static_cast<int64_t>(GetTotalCompressedSize()));
-}
-ResourceType GetRemainingAncestorType() const
-{
-assert(hasRemainingAncestor_);
-return remainingType_;
 }
 };
-void SQLiteDatabaseWrapper::GetChangesInternal(std::list<ServerIndexChange>& target,
+class SQLiteDatabaseWrapper::ReadOnlyTransaction : public SQLiteDatabaseWrapper::TransactionBase
-bool& done,
+{
-SQLite::Statement& s,
+private:
-uint32_t maxResults)
+SQLiteDatabaseWrapper&  that_;
-{
-target.clear();
+public:
+ReadOnlyTransaction(SQLiteDatabaseWrapper& that,
-while (target.size() < maxResults && s.Step())
+IDatabaseListener& listener) :
-{
+TransactionBase(that.db_, listener, *that.signalRemainingAncestor_),
-int64_t seq = s.ColumnInt64(0);
+that_(that)
-ChangeType changeType = static_cast<ChangeType>(s.ColumnInt(1));
+{
-ResourceType resourceType = static_cast<ResourceType>(s.ColumnInt(3));
+if (that_.activeTransaction_ != NULL)
-const std::string& date = s.ColumnString(4);
+{
+throw OrthancException(ErrorCode_InternalError);
-int64_t internalId = s.ColumnInt64(2);
+}
-std::string publicId = GetPublicId(internalId);
+that_.activeTransaction_ = this;
-target.push_back(ServerIndexChange(seq, changeType, resourceType, publicId, date));
+}
-}
+virtual ~ReadOnlyTransaction()
-done = !(target.size() == maxResults && s.Step());
+{
+assert(that_.activeTransaction_ != NULL);
+that_.activeTransaction_ = NULL;
+}
+virtual void Rollback() ORTHANC_OVERRIDE
+{
+}
+virtual void Commit(int64_t fileSizeDelta /* only used in debug */) ORTHANC_OVERRIDE
+{
+if (fileSizeDelta != 0)
+{
+throw OrthancException(ErrorCode_InternalError);
+}
+}
+};
+SQLiteDatabaseWrapper::SQLiteDatabaseWrapper(const std::string& path) :
+activeTransaction_(NULL),
+signalRemainingAncestor_(NULL),
+version_(0)
+{
+db_.Open(path);
 }
-void SQLiteDatabaseWrapper::GetExportedResourcesInternal(std::list<ExportedResource>& target,
+SQLiteDatabaseWrapper::SQLiteDatabaseWrapper() :
-bool& done,
+activeTransaction_(NULL),
-SQLite::Statement& s,
+signalRemainingAncestor_(NULL),
-uint32_t maxResults)
+version_(0)
 {
-target.clear();
+db_.OpenInMemory();
-while (target.size() < maxResults && s.Step())
-{
-int64_t seq = s.ColumnInt64(0);
-ResourceType resourceType = static_cast<ResourceType>(s.ColumnInt(1));
-std::string publicId = s.ColumnString(2);
-ExportedResource resource(seq,
-resourceType,
-publicId,
-s.ColumnString(3),  // modality
-s.ColumnString(8),  // date
-s.ColumnString(4),  // patient ID
-s.ColumnString(5),  // study instance UID
-s.ColumnString(6),  // series instance UID
-s.ColumnString(7)); // sop instance UID
-target.push_back(resource);
-}
-done = !(target.size() == maxResults && s.Step());
 }
+SQLiteDatabaseWrapper::~SQLiteDatabaseWrapper()
-void SQLiteDatabaseWrapper::GetChildren(std::list<std::string>& childrenPublicIds,
+{
-int64_t id)
+if (activeTransaction_ != NULL)
 {
-SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT publicId FROM Resources WHERE parentId=?");
+LOG(ERROR) << "A SQLite transaction is still active in the SQLiteDatabaseWrapper destructor: Expect a crash";
+}
+}
+void SQLiteDatabaseWrapper::Open()
+{
+if (signalRemainingAncestor_ != NULL)
+{
+throw OrthancException(ErrorCode_BadSequenceOfCalls);  // Cannot open twice
+}
+signalRemainingAncestor_ = dynamic_cast<SignalRemainingAncestor*>(db_.Register(new SignalRemainingAncestor));
+db_.Register(new SignalFileDeleted(*this));
+db_.Register(new SignalResourceDeleted(*this));
+db_.Execute("PRAGMA ENCODING=\"UTF-8\";");
+// Performance tuning of SQLite with PRAGMAs
+// http://www.sqlite.org/pragma.html
+db_.Execute("PRAGMA SYNCHRONOUS=NORMAL;");
+db_.Execute("PRAGMA JOURNAL_MODE=WAL;");
+db_.Execute("PRAGMA LOCKING_MODE=EXCLUSIVE;");
+db_.Execute("PRAGMA WAL_AUTOCHECKPOINT=1000;");
+//db_.Execute("PRAGMA TEMP_STORE=memory");
+// Make "LIKE" case-sensitive in SQLite
+db_.Execute("PRAGMA case_sensitive_like = true;");
+VoidDatabaseListener listener;
+{
+std::unique_ptr<ITransaction> transaction(StartTransaction(TransactionType_ReadOnly, listener));
+if (!db_.DoesTableExist("GlobalProperties"))
+{
+LOG(INFO) << "Creating the database";
+std::string query;
+ServerResources::GetFileResource(query, ServerResources::PREPARE_DATABASE);
+db_.Execute(query);
+}
+// Check the version of the database
+std::string tmp;
+if (!transaction->LookupGlobalProperty(tmp, GlobalProperty_DatabaseSchemaVersion))
+{
+tmp = "Unknown";
+}
+bool ok = false;
+try
+{
+LOG(INFO) << "Version of the Orthanc database: " << tmp;
+version_ = boost::lexical_cast<unsigned int>(tmp);
+ok = true;
+}
+catch (boost::bad_lexical_cast&)
+{
+}
+if (!ok)
+{
+throw OrthancException(ErrorCode_IncompatibleDatabaseVersion,
+"Incompatible version of the Orthanc database: " + tmp);
+}
+// New in Orthanc 1.5.1
+if (version_ == 6)
+{
+if (!transaction->LookupGlobalProperty(tmp, GlobalProperty_GetTotalSizeIsFast) ||
+tmp != "1")
+{
+LOG(INFO) << "Installing the SQLite triggers to track the size of the attachments";
+std::string query;
+ServerResources::GetFileResource(query, ServerResources::INSTALL_TRACK_ATTACHMENTS_SIZE);
+db_.Execute(query);
+}
+}
+transaction->Commit(0);
+}
+}
+static void ExecuteUpgradeScript(SQLite::Connection& db,
+ServerResources::FileResourceId script)
+{
+std::string upgrade;
+ServerResources::GetFileResource(upgrade, script);
+db.BeginTransaction();
+db.Execute(upgrade);
+db.CommitTransaction();
+}
+void SQLiteDatabaseWrapper::Upgrade(unsigned int targetVersion,
+IStorageArea& storageArea)
+{
+if (targetVersion != 6)
+{
+throw OrthancException(ErrorCode_IncompatibleDatabaseVersion);
+}
+// This version of Orthanc is only compatible with versions 3, 4,
+// 5 and 6 of the DB schema
+if (version_ != 3 &&
+version_ != 4 &&
+version_ != 5 &&
+version_ != 6)
+{
+throw OrthancException(ErrorCode_IncompatibleDatabaseVersion);
+}
+if (version_ == 3)
+{
+LOG(WARNING) << "Upgrading database version from 3 to 4";
+ExecuteUpgradeScript(db_, ServerResources::UPGRADE_DATABASE_3_TO_4);
+version_ = 4;
+}
+if (version_ == 4)
+{
+LOG(WARNING) << "Upgrading database version from 4 to 5";
+ExecuteUpgradeScript(db_, ServerResources::UPGRADE_DATABASE_4_TO_5);
+version_ = 5;
+}
+if (version_ == 5)
+{
+LOG(WARNING) << "Upgrading database version from 5 to 6";
+// No change in the DB schema, the step from version 5 to 6 only
+// consists in reconstructing the main DICOM tags information
+// (as more tags got included).
+VoidDatabaseListener listener;
+{
+std::unique_ptr<ITransaction> transaction(StartTransaction(TransactionType_ReadWrite, listener));
+ServerToolbox::ReconstructMainDicomTags(*transaction, storageArea, ResourceType_Patient);
+ServerToolbox::ReconstructMainDicomTags(*transaction, storageArea, ResourceType_Study);
+ServerToolbox::ReconstructMainDicomTags(*transaction, storageArea, ResourceType_Series);
+ServerToolbox::ReconstructMainDicomTags(*transaction, storageArea, ResourceType_Instance);
+db_.Execute("UPDATE GlobalProperties SET value=\"6\" WHERE property=" +
+boost::lexical_cast<std::string>(GlobalProperty_DatabaseSchemaVersion) + ";");
+transaction->Commit(0);
+}
+version_ = 6;
+}
+}
+IDatabaseWrapper::ITransaction* SQLiteDatabaseWrapper::StartTransaction(TransactionType type,
+IDatabaseListener& listener)
+{
+switch (type)
+{
+case TransactionType_ReadOnly:
+return new ReadOnlyTransaction(*this, listener);  // This is a no-op transaction in SQLite (thanks to mutex)
+case TransactionType_ReadWrite:
+{
+std::unique_ptr<ReadWriteTransaction> transaction;
+transaction.reset(new ReadWriteTransaction(*this, listener));
+transaction->Begin();
+return transaction.release();
+}
+default:
+throw OrthancException(ErrorCode_InternalError);
+}
+}
+int64_t SQLiteDatabaseWrapper::UnitTestsTransaction::CreateResource(const std::string& publicId,
+ResourceType type)
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "INSERT INTO Resources VALUES(NULL, ?, ?, NULL)");
+s.BindInt(0, type);
+s.BindString(1, publicId);
+s.Run();
+return db_.GetLastInsertRowId();
+}
+void SQLiteDatabaseWrapper::UnitTestsTransaction::AttachChild(int64_t parent,
+int64_t child)
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "UPDATE Resources SET parentId = ? WHERE internalId = ?");
+s.BindInt64(0, parent);
+s.BindInt64(1, child);
+s.Run();
+}
+void SQLiteDatabaseWrapper::UnitTestsTransaction::SetIdentifierTag(int64_t id,
+const DicomTag& tag,
+const std::string& value)
+{
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "INSERT INTO DicomIdentifiers VALUES(?, ?, ?, ?)");
 s.BindInt64(0, id);
+s.BindInt(1, tag.GetGroup());
-childrenPublicIds.clear();
+s.BindInt(2, tag.GetElement());
-while (s.Step())
+s.BindString(3, value);
-{
+s.Run();
-childrenPublicIds.push_back(s.ColumnString(0));
-}
 }
-void SQLiteDatabaseWrapper::DeleteResource(int64_t id)
+void SQLiteDatabaseWrapper::UnitTestsTransaction::SetMainDicomTag(int64_t id,
-{
+const DicomTag& tag,
-signalRemainingAncestor_->Reset();
+const std::string& value)
+{
-SQLite::Statement s(db_, SQLITE_FROM_HERE, "DELETE FROM Resources WHERE internalId=?");
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "INSERT INTO MainDicomTags VALUES(?, ?, ?, ?)");
 s.BindInt64(0, id);
+s.BindInt(1, tag.GetGroup());
+s.BindInt(2, tag.GetElement());
+s.BindString(3, value);
 s.Run();
-if (signalRemainingAncestor_->HasRemainingAncestor() &&
-listener_ != NULL)
-{
-listener_->SignalRemainingAncestor(signalRemainingAncestor_->GetRemainingAncestorType(),
-signalRemainingAncestor_->GetRemainingAncestorId());
-}
 }
-bool SQLiteDatabaseWrapper::GetParentPublicId(std::string& target,
+int64_t SQLiteDatabaseWrapper::UnitTestsTransaction::GetTableRecordCount(const std::string& table)
-int64_t id)
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT a.publicId FROM Resources AS a, Resources AS b "
-"WHERE a.internalId = b.parentId AND b.internalId = ?");
-s.BindInt64(0, id);
-if (s.Step())
-{
-target = s.ColumnString(0);
-return true;
-}
-else
-{
-return false;
-}
-}
-int64_t SQLiteDatabaseWrapper::GetTableRecordCount(const std::string& table)
 {
 /**
 * "Generally one cannot use SQL parameters/placeholders for
 * database identifiers (tables, columns, views, schemas, etc.) or
 * database functions (e.g., CURRENT_DATE), but instead only for
 {
 throw OrthancException(ErrorCode_InternalError);
 }
 }
-SQLiteDatabaseWrapper::SQLiteDatabaseWrapper(const std::string& path) :
+bool SQLiteDatabaseWrapper::UnitTestsTransaction::GetParentPublicId(std::string& target,
-listener_(NULL),
+int64_t id)
-signalRemainingAncestor_(NULL),
+{
-version_(0)
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT a.publicId FROM Resources AS a, Resources AS b "
-{
+"WHERE a.internalId = b.parentId AND b.internalId = ?");
-db_.Open(path);
+s.BindInt64(0, id);
-}
-SQLiteDatabaseWrapper::SQLiteDatabaseWrapper() :
-listener_(NULL),
-signalRemainingAncestor_(NULL),
-version_(0)
-{
-db_.OpenInMemory();
-}
-int SQLiteDatabaseWrapper::GetGlobalIntegerProperty(GlobalProperty property,
-int defaultValue)
-{
-std::string tmp;
-if (!LookupGlobalProperty(tmp, GlobalProperty_DatabasePatchLevel))
-{
-return defaultValue;
-}
-else
-{
-try
-{
-return boost::lexical_cast<int>(tmp);
-}
-catch (boost::bad_lexical_cast&)
-{
-throw OrthancException(ErrorCode_ParameterOutOfRange,
-"Global property " + boost::lexical_cast<std::string>(property) +
-" should be an integer, but found: " + tmp);
-}
-}
-}
-void SQLiteDatabaseWrapper::Open()
-{
-db_.Execute("PRAGMA ENCODING=\"UTF-8\";");
-// Performance tuning of SQLite with PRAGMAs
-// http://www.sqlite.org/pragma.html
-db_.Execute("PRAGMA SYNCHRONOUS=NORMAL;");
-db_.Execute("PRAGMA JOURNAL_MODE=WAL;");
-db_.Execute("PRAGMA LOCKING_MODE=EXCLUSIVE;");
-db_.Execute("PRAGMA WAL_AUTOCHECKPOINT=1000;");
-//db_.Execute("PRAGMA TEMP_STORE=memory");
-// Make "LIKE" case-sensitive in SQLite
-db_.Execute("PRAGMA case_sensitive_like = true;");
-{
-SQLite::Transaction t(db_);
-t.Begin();
-if (!db_.DoesTableExist("GlobalProperties"))
-{
-LOG(INFO) << "Creating the database";
-std::string query;
-ServerResources::GetFileResource(query, ServerResources::PREPARE_DATABASE);
-db_.Execute(query);
-}
-// Check the version of the database
-std::string tmp;
-if (!LookupGlobalProperty(tmp, GlobalProperty_DatabaseSchemaVersion))
-{
-tmp = "Unknown";
-}
-bool ok = false;
-try
-{
-LOG(INFO) << "Version of the Orthanc database: " << tmp;
-version_ = boost::lexical_cast<unsigned int>(tmp);
-ok = true;
-}
-catch (boost::bad_lexical_cast&)
-{
-}
-if (!ok)
-{
-throw OrthancException(ErrorCode_IncompatibleDatabaseVersion,
-"Incompatible version of the Orthanc database: " + tmp);
-}
-// New in Orthanc 1.5.1
-if (version_ == 6)
-{
-if (!LookupGlobalProperty(tmp, GlobalProperty_GetTotalSizeIsFast) ||
-tmp != "1")
-{
-LOG(INFO) << "Installing the SQLite triggers to track the size of the attachments";
-std::string query;
-ServerResources::GetFileResource(query, ServerResources::INSTALL_TRACK_ATTACHMENTS_SIZE);
-db_.Execute(query);
-}
-}
-t.Commit();
-}
-signalRemainingAncestor_ = dynamic_cast<SignalRemainingAncestor*>(db_.Register(new SignalRemainingAncestor));
-db_.Register(new SignalFileDeleted(*this));
-db_.Register(new SignalResourceDeleted(*this));
-}
-static void ExecuteUpgradeScript(SQLite::Connection& db,
-ServerResources::FileResourceId script)
-{
-std::string upgrade;
-ServerResources::GetFileResource(upgrade, script);
-db.BeginTransaction();
-db.Execute(upgrade);
-db.CommitTransaction();
-}
-void SQLiteDatabaseWrapper::Upgrade(unsigned int targetVersion,
-IStorageArea& storageArea)
-{
-if (targetVersion != 6)
-{
-throw OrthancException(ErrorCode_IncompatibleDatabaseVersion);
-}
-// This version of Orthanc is only compatible with versions 3, 4,
-// 5 and 6 of the DB schema
-if (version_ != 3 &&
-version_ != 4 &&
-version_ != 5 &&
-version_ != 6)
-{
-throw OrthancException(ErrorCode_IncompatibleDatabaseVersion);
-}
-if (version_ == 3)
-{
-LOG(WARNING) << "Upgrading database version from 3 to 4";
-ExecuteUpgradeScript(db_, ServerResources::UPGRADE_DATABASE_3_TO_4);
-version_ = 4;
-}
-if (version_ == 4)
-{
-LOG(WARNING) << "Upgrading database version from 4 to 5";
-ExecuteUpgradeScript(db_, ServerResources::UPGRADE_DATABASE_4_TO_5);
-version_ = 5;
-}
-if (version_ == 5)
-{
-LOG(WARNING) << "Upgrading database version from 5 to 6";
-// No change in the DB schema, the step from version 5 to 6 only
-// consists in reconstructing the main DICOM tags information
-// (as more tags got included).
-db_.BeginTransaction();
-ServerToolbox::ReconstructMainDicomTags(*this, storageArea, ResourceType_Patient);
-ServerToolbox::ReconstructMainDicomTags(*this, storageArea, ResourceType_Study);
-ServerToolbox::ReconstructMainDicomTags(*this, storageArea, ResourceType_Series);
-ServerToolbox::ReconstructMainDicomTags(*this, storageArea, ResourceType_Instance);
-db_.Execute("UPDATE GlobalProperties SET value=\"6\" WHERE property=" +
-boost::lexical_cast<std::string>(GlobalProperty_DatabaseSchemaVersion) + ";");
-db_.CommitTransaction();
-version_ = 6;
-}
-}
-void SQLiteDatabaseWrapper::ClearTable(const std::string& tableName)
-{
-db_.Execute("DELETE FROM " + tableName);
-}
-bool SQLiteDatabaseWrapper::LookupParent(int64_t& parentId,
-int64_t resourceId)
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE,
-"SELECT parentId FROM Resources WHERE internalId=?");
-s.BindInt64(0, resourceId);
-if (!s.Step())
-{
-throw OrthancException(ErrorCode_UnknownResource);
-}
-if (s.ColumnIsNull(0))
-{
-return false;
-}
-else
-{
-parentId = s.ColumnInt(0);
-return true;
-}
-}
-ResourceType SQLiteDatabaseWrapper::GetResourceType(int64_t resourceId)
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE,
-"SELECT resourceType FROM Resources WHERE internalId=?");
-s.BindInt64(0, resourceId);
 if (s.Step())
-{
-return static_cast<ResourceType>(s.ColumnInt(0));
-}
-else
-{
-throw OrthancException(ErrorCode_UnknownResource);
-}
-}
-std::string SQLiteDatabaseWrapper::GetPublicId(int64_t resourceId)
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE,
-"SELECT publicId FROM Resources WHERE internalId=?");
-s.BindInt64(0, resourceId);
-if (s.Step())
-{
-return s.ColumnString(0);
-}
-else
-{
-throw OrthancException(ErrorCode_UnknownResource);
-}
-}
-void SQLiteDatabaseWrapper::GetChanges(std::list<ServerIndexChange>& target /*out*/,
-bool& done /*out*/,
-int64_t since,
-uint32_t maxResults)
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT * FROM Changes WHERE seq>? ORDER BY seq LIMIT ?");
-s.BindInt64(0, since);
-s.BindInt(1, maxResults + 1);
-GetChangesInternal(target, done, s, maxResults);
-}
-void SQLiteDatabaseWrapper::GetLastChange(std::list<ServerIndexChange>& target /*out*/)
-{
-bool done;  // Ignored
-SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT * FROM Changes ORDER BY seq DESC LIMIT 1");
-GetChangesInternal(target, done, s, 1);
-}
-class SQLiteDatabaseWrapper::ReadWriteTransaction : public IDatabaseWrapper::ITransaction
-{
-private:
-SQLiteDatabaseWrapper&                that_;
-std::unique_ptr<SQLite::Transaction>  transaction_;
-int64_t                               initialDiskSize_;
-public:
-ReadWriteTransaction(SQLiteDatabaseWrapper& that,
-IDatabaseListener& listener) :
-that_(that),
-transaction_(new SQLite::Transaction(that_.db_))
-{
-assert(that_.listener_ == NULL);
-that_.listener_ = &listener;   // TODO - STORE IN TRANSACTION
-#if defined(NDEBUG)
-// Release mode
-initialDiskSize_ = 0;
-#else
-// Debug mode
-initialDiskSize_ = static_cast<int64_t>(that_.GetTotalCompressedSize());
-#endif
-}
-virtual ~ReadWriteTransaction()
-{
-assert(that_.listener_ != NULL);
-that_.listener_ = NULL;   // TODO - STORE IN TRANSACTION
-}
-void Begin()
-{
-transaction_->Begin();
-}
-virtual void Rollback() ORTHANC_OVERRIDE
-{
-transaction_->Rollback();
-}
-virtual void Commit(int64_t fileSizeDelta /* only used in debug */) ORTHANC_OVERRIDE
-{
-transaction_->Commit();
-assert(initialDiskSize_ + fileSizeDelta >= 0 &&
-initialDiskSize_ + fileSizeDelta == static_cast<int64_t>(that_.GetTotalCompressedSize()));
-}
-};
-class SQLiteDatabaseWrapper::ReadOnlyTransaction : public IDatabaseWrapper::ITransaction
-{
-private:
-SQLiteDatabaseWrapper&  that_;
-public:
-ReadOnlyTransaction(SQLiteDatabaseWrapper& that,
-IDatabaseListener& listener) :
-that_(that)
-{
-assert(that_.listener_ == NULL);
-that_.listener_ = &listener;
-}
-virtual ~ReadOnlyTransaction()
-{
-assert(that_.listener_ != NULL);
-that_.listener_ = NULL;
-}
-virtual void Rollback() ORTHANC_OVERRIDE
-{
-}
-virtual void Commit(int64_t fileSizeDelta /* only used in debug */) ORTHANC_OVERRIDE
-{
-if (fileSizeDelta != 0)
-{
-throw OrthancException(ErrorCode_InternalError);
-}
-}
-};
-IDatabaseWrapper::ITransaction* SQLiteDatabaseWrapper::StartTransaction(TransactionType type,
-IDatabaseListener& listener)
-{
-switch (type)
-{
-case TransactionType_ReadOnly:
-return new ReadOnlyTransaction(*this, listener);  // This is a no-op transaction in SQLite (thanks to mutex)
-case TransactionType_ReadWrite:
-{
-std::unique_ptr<ReadWriteTransaction> transaction;
-transaction.reset(new ReadWriteTransaction(*this, listener));
-transaction->Begin();
-return transaction.release();
-}
-default:
-throw OrthancException(ErrorCode_InternalError);
-}
-}
-void SQLiteDatabaseWrapper::GetAllMetadata(std::map<MetadataType, std::string>& target,
-int64_t id)
-{
-target.clear();
-SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT type, value FROM Metadata WHERE id=?");
-s.BindInt64(0, id);
-while (s.Step())
-{
-MetadataType key = static_cast<MetadataType>(s.ColumnInt(0));
-target[key] = s.ColumnString(1);
-}
-}
-void SQLiteDatabaseWrapper::SetGlobalProperty(GlobalProperty property,
-const std::string& value)
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE, "INSERT OR REPLACE INTO GlobalProperties VALUES(?, ?)");
-s.BindInt(0, property);
-s.BindString(1, value);
-s.Run();
-}
-bool SQLiteDatabaseWrapper::LookupGlobalProperty(std::string& target,
-GlobalProperty property)
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE,
-"SELECT value FROM GlobalProperties WHERE property=?");
-s.BindInt(0, property);
-if (!s.Step())
-{
-return false;
-}
-else
 {
 target = s.ColumnString(0);
 return true;
 }
+else
+{
+return false;
+}
 }
-int64_t SQLiteDatabaseWrapper::CreateResource(const std::string& publicId,
+void SQLiteDatabaseWrapper::UnitTestsTransaction::GetChildren(std::list<std::string>& childrenPublicIds,
-ResourceType type)
+int64_t id)
 {
-SQLite::Statement s(db_, SQLITE_FROM_HERE, "INSERT INTO Resources VALUES(NULL, ?, ?, NULL)");
+SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT publicId FROM Resources WHERE parentId=?");
-s.BindInt(0, type);
-s.BindString(1, publicId);
-s.Run();
-return db_.GetLastInsertRowId();
-}
-bool SQLiteDatabaseWrapper::LookupResource(int64_t& id,
-ResourceType& type,
-const std::string& publicId)
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE,
-"SELECT internalId, resourceType FROM Resources WHERE publicId=?");
-s.BindString(0, publicId);
-if (!s.Step())
-{
-return false;
-}
-else
-{
-id = s.ColumnInt(0);
-type = static_cast<ResourceType>(s.ColumnInt(1));
-// Check whether there is a single resource with this public id
-assert(!s.Step());
-return true;
-}
-}
-void SQLiteDatabaseWrapper::AttachChild(int64_t parent,
-int64_t child)
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE, "UPDATE Resources SET parentId = ? WHERE internalId = ?");
-s.BindInt64(0, parent);
-s.BindInt64(1, child);
-s.Run();
-}
-void SQLiteDatabaseWrapper::SetMetadata(int64_t id,
-MetadataType type,
-const std::string& value)
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE, "INSERT OR REPLACE INTO Metadata VALUES(?, ?, ?)");
 s.BindInt64(0, id);
-s.BindInt(1, type);
-s.BindString(2, value);
+childrenPublicIds.clear();
-s.Run();
-}
-void SQLiteDatabaseWrapper::DeleteMetadata(int64_t id,
-MetadataType type)
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE, "DELETE FROM Metadata WHERE id=? and type=?");
-s.BindInt64(0, id);
-s.BindInt(1, type);
-s.Run();
-}
-bool SQLiteDatabaseWrapper::LookupMetadata(std::string& target,
-int64_t id,
-MetadataType type)
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE,
-"SELECT value FROM Metadata WHERE id=? AND type=?");
-s.BindInt64(0, id);
-s.BindInt(1, type);
-if (!s.Step())
-{
-return false;
-}
-else
-{
-target = s.ColumnString(0);
-return true;
-}
-}
-void SQLiteDatabaseWrapper::AddAttachment(int64_t id,
-const FileInfo& attachment)
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE, "INSERT INTO AttachedFiles VALUES(?, ?, ?, ?, ?, ?, ?, ?)");
-s.BindInt64(0, id);
-s.BindInt(1, attachment.GetContentType());
-s.BindString(2, attachment.GetUuid());
-s.BindInt64(3, attachment.GetCompressedSize());
-s.BindInt64(4, attachment.GetUncompressedSize());
-s.BindInt(5, attachment.GetCompressionType());
-s.BindString(6, attachment.GetUncompressedMD5());
-s.BindString(7, attachment.GetCompressedMD5());
-s.Run();
-}
-void SQLiteDatabaseWrapper::DeleteAttachment(int64_t id,
-FileContentType attachment)
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE, "DELETE FROM AttachedFiles WHERE id=? AND fileType=?");
-s.BindInt64(0, id);
-s.BindInt(1, attachment);
-s.Run();
-}
-void SQLiteDatabaseWrapper::ListAvailableAttachments(std::set<FileContentType>& target,
-int64_t id)
-{
-target.clear();
-SQLite::Statement s(db_, SQLITE_FROM_HERE,
-"SELECT fileType FROM AttachedFiles WHERE id=?");
-s.BindInt64(0, id);
 while (s.Step())
 {
-target.insert(static_cast<FileContentType>(s.ColumnInt(0)));
+childrenPublicIds.push_back(s.ColumnString(0));
-}
-}
-bool SQLiteDatabaseWrapper::LookupAttachment(FileInfo& attachment,
-int64_t id,
-FileContentType contentType)
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE,
-"SELECT uuid, uncompressedSize, compressionType, compressedSize, "
-"uncompressedMD5, compressedMD5 FROM AttachedFiles WHERE id=? AND fileType=?");
-s.BindInt64(0, id);
-s.BindInt(1, contentType);
-if (!s.Step())
-{
-return false;
-}
-else
-{
-attachment = FileInfo(s.ColumnString(0),
-contentType,
-s.ColumnInt64(1),
-s.ColumnString(4),
-static_cast<CompressionType>(s.ColumnInt(2)),
-s.ColumnInt64(3),
-s.ColumnString(5));
-return true;
-}
-}
-void SQLiteDatabaseWrapper::ClearMainDicomTags(int64_t id)
-{
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE, "DELETE FROM DicomIdentifiers WHERE id=?");
-s.BindInt64(0, id);
-s.Run();
-}
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE, "DELETE FROM MainDicomTags WHERE id=?");
-s.BindInt64(0, id);
-s.Run();
-}
-}
-void SQLiteDatabaseWrapper::SetMainDicomTag(int64_t id,
-const DicomTag& tag,
-const std::string& value)
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE, "INSERT INTO MainDicomTags VALUES(?, ?, ?, ?)");
-s.BindInt64(0, id);
-s.BindInt(1, tag.GetGroup());
-s.BindInt(2, tag.GetElement());
-s.BindString(3, value);
-s.Run();
-}
-void SQLiteDatabaseWrapper::SetIdentifierTag(int64_t id,
-const DicomTag& tag,
-const std::string& value)
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE, "INSERT INTO DicomIdentifiers VALUES(?, ?, ?, ?)");
-s.BindInt64(0, id);
-s.BindInt(1, tag.GetGroup());
-s.BindInt(2, tag.GetElement());
-s.BindString(3, value);
-s.Run();
-}
-void SQLiteDatabaseWrapper::GetMainDicomTags(DicomMap& map,
-int64_t id)
-{
-map.Clear();
-SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT * FROM MainDicomTags WHERE id=?");
-s.BindInt64(0, id);
-while (s.Step())
-{
-map.SetValue(s.ColumnInt(1),
-s.ColumnInt(2),
-s.ColumnString(3), false);
-}
-}
-void SQLiteDatabaseWrapper::GetChildrenPublicId(std::list<std::string>& target,
-int64_t id)
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT a.publicId FROM Resources AS a, Resources AS b  "
-"WHERE a.parentId = b.internalId AND b.internalId = ?");
-s.BindInt64(0, id);
-target.clear();
-while (s.Step())
-{
-target.push_back(s.ColumnString(0));
-}
-}
-void SQLiteDatabaseWrapper::GetChildrenInternalId(std::list<int64_t>& target,
-int64_t id)
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT a.internalId FROM Resources AS a, Resources AS b  "
-"WHERE a.parentId = b.internalId AND b.internalId = ?");
-s.BindInt64(0, id);
-target.clear();
-while (s.Step())
-{
-target.push_back(s.ColumnInt64(0));
-}
-}
-void SQLiteDatabaseWrapper::LogChange(int64_t internalId,
-const ServerIndexChange& change)
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE, "INSERT INTO Changes VALUES(NULL, ?, ?, ?, ?)");
-s.BindInt(0, change.GetChangeType());
-s.BindInt64(1, internalId);
-s.BindInt(2, change.GetResourceType());
-s.BindString(3, change.GetDate());
-s.Run();
-}
-void SQLiteDatabaseWrapper::LogExportedResource(const ExportedResource& resource)
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE,
-"INSERT INTO ExportedResources VALUES(NULL, ?, ?, ?, ?, ?, ?, ?, ?)");
-s.BindInt(0, resource.GetResourceType());
-s.BindString(1, resource.GetPublicId());
-s.BindString(2, resource.GetModality());
-s.BindString(3, resource.GetPatientId());
-s.BindString(4, resource.GetStudyInstanceUid());
-s.BindString(5, resource.GetSeriesInstanceUid());
-s.BindString(6, resource.GetSopInstanceUid());
-s.BindString(7, resource.GetDate());
-s.Run();
-}
-void SQLiteDatabaseWrapper::GetExportedResources(std::list<ExportedResource>& target,
-bool& done,
-int64_t since,
-uint32_t maxResults)
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE,
-"SELECT * FROM ExportedResources WHERE seq>? ORDER BY seq LIMIT ?");
-s.BindInt64(0, since);
-s.BindInt(1, maxResults + 1);
-GetExportedResourcesInternal(target, done, s, maxResults);
-}
-void SQLiteDatabaseWrapper::GetLastExportedResource(std::list<ExportedResource>& target)
-{
-bool done;  // Ignored
-SQLite::Statement s(db_, SQLITE_FROM_HERE,
-"SELECT * FROM ExportedResources ORDER BY seq DESC LIMIT 1");
-GetExportedResourcesInternal(target, done, s, 1);
-}
-uint64_t SQLiteDatabaseWrapper::GetTotalCompressedSize()
-{
-// Old SQL query that was used in Orthanc <= 1.5.0:
-// SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT SUM(compressedSize) FROM AttachedFiles");
-SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT value FROM GlobalIntegers WHERE key=0");
-s.Run();
-return static_cast<uint64_t>(s.ColumnInt64(0));
-}
-uint64_t SQLiteDatabaseWrapper::GetTotalUncompressedSize()
-{
-// Old SQL query that was used in Orthanc <= 1.5.0:
-// SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT SUM(uncompressedSize) FROM AttachedFiles");
-SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT value FROM GlobalIntegers WHERE key=1");
-s.Run();
-return static_cast<uint64_t>(s.ColumnInt64(0));
-}
-uint64_t SQLiteDatabaseWrapper::GetResourceCount(ResourceType resourceType)
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE,
-"SELECT COUNT(*) FROM Resources WHERE resourceType=?");
-s.BindInt(0, resourceType);
-if (!s.Step())
-{
-return 0;
-}
-else
-{
-int64_t c = s.ColumnInt(0);
-assert(!s.Step());
-return c;
-}
-}
-void SQLiteDatabaseWrapper::GetAllPublicIds(std::list<std::string>& target,
-ResourceType resourceType)
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT publicId FROM Resources WHERE resourceType=?");
-s.BindInt(0, resourceType);
-target.clear();
-while (s.Step())
-{
-target.push_back(s.ColumnString(0));
-}
-}
-void SQLiteDatabaseWrapper::GetAllPublicIds(std::list<std::string>& target,
-ResourceType resourceType,
-size_t since,
-size_t limit)
-{
-if (limit == 0)
-{
-target.clear();
-return;
-}
-SQLite::Statement s(db_, SQLITE_FROM_HERE,
-"SELECT publicId FROM Resources WHERE "
-"resourceType=? LIMIT ? OFFSET ?");
-s.BindInt(0, resourceType);
-s.BindInt64(1, limit);
-s.BindInt64(2, since);
-target.clear();
-while (s.Step())
-{
-target.push_back(s.ColumnString(0));
-}
-}
-bool SQLiteDatabaseWrapper::SelectPatientToRecycle(int64_t& internalId)
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE,
-"SELECT patientId FROM PatientRecyclingOrder ORDER BY seq ASC LIMIT 1");
-if (!s.Step())
-{
-// No patient remaining or all the patients are protected
-return false;
-}
-else
-{
-internalId = s.ColumnInt(0);
-return true;
-}
-}
-bool SQLiteDatabaseWrapper::SelectPatientToRecycle(int64_t& internalId,
-int64_t patientIdToAvoid)
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE,
-"SELECT patientId FROM PatientRecyclingOrder "
-"WHERE patientId != ? ORDER BY seq ASC LIMIT 1");
-s.BindInt64(0, patientIdToAvoid);
-if (!s.Step())
-{
-// No patient remaining or all the patients are protected
-return false;
-}
-else
-{
-internalId = s.ColumnInt(0);
-return true;
-}
-}
-bool SQLiteDatabaseWrapper::IsProtectedPatient(int64_t internalId)
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE,
-"SELECT * FROM PatientRecyclingOrder WHERE patientId = ?");
-s.BindInt64(0, internalId);
-return !s.Step();
-}
-void SQLiteDatabaseWrapper::SetProtectedPatient(int64_t internalId,
-bool isProtected)
-{
-if (isProtected)
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE, "DELETE FROM PatientRecyclingOrder WHERE patientId=?");
-s.BindInt64(0, internalId);
-s.Run();
-}
-else if (IsProtectedPatient(internalId))
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE, "INSERT INTO PatientRecyclingOrder VALUES(NULL, ?)");
-s.BindInt64(0, internalId);
-s.Run();
-}
-else
-{
-// Nothing to do: The patient is already unprotected
-}
-}
-bool SQLiteDatabaseWrapper::IsExistingResource(int64_t internalId)
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE,
-"SELECT * FROM Resources WHERE internalId=?");
-s.BindInt64(0, internalId);
-return s.Step();
-}
-bool SQLiteDatabaseWrapper::IsDiskSizeAbove(uint64_t threshold)
-{
-return GetTotalCompressedSize() > threshold;
-}
-class SQLiteDatabaseWrapper::LookupFormatter : public ISqlLookupFormatter
-{
-private:
-std::list<std::string>  values_;
-public:
-virtual std::string GenerateParameter(const std::string& value) ORTHANC_OVERRIDE
-{
-values_.push_back(value);
-return "?";
-}
-virtual std::string FormatResourceType(ResourceType level) ORTHANC_OVERRIDE
-{
-return boost::lexical_cast<std::string>(level);
-}
-virtual std::string FormatWildcardEscape() ORTHANC_OVERRIDE
-{
-return "ESCAPE '\\'";
-}
-void Bind(SQLite::Statement& statement) const
-{
-size_t pos = 0;
-for (std::list<std::string>::const_iterator
-it = values_.begin(); it != values_.end(); ++it, pos++)
-{
-statement.BindString(pos, *it);
-}
-}
-};
-static void AnswerLookup(std::list<std::string>& resourcesId,
-std::list<std::string>& instancesId,
-SQLite::Connection& db,
-ResourceType level)
-{
-resourcesId.clear();
-instancesId.clear();
-std::unique_ptr<SQLite::Statement> statement;
-switch (level)
-{
-case ResourceType_Patient:
-{
-statement.reset(
-new SQLite::Statement(
-db, SQLITE_FROM_HERE,
-"SELECT patients.publicId, instances.publicID FROM Lookup AS patients "
-"INNER JOIN Resources studies ON patients.internalId=studies.parentId "
-"INNER JOIN Resources series ON studies.internalId=series.parentId "
-"INNER JOIN Resources instances ON series.internalId=instances.parentId "
-"GROUP BY patients.publicId"));
-break;
-}
-case ResourceType_Study:
-{
-statement.reset(
-new SQLite::Statement(
-db, SQLITE_FROM_HERE,
-"SELECT studies.publicId, instances.publicID FROM Lookup AS studies "
-"INNER JOIN Resources series ON studies.internalId=series.parentId "
-"INNER JOIN Resources instances ON series.internalId=instances.parentId "
-"GROUP BY studies.publicId"));
-break;
-}
-case ResourceType_Series:
-{
-statement.reset(
-new SQLite::Statement(
-db, SQLITE_FROM_HERE,
-"SELECT series.publicId, instances.publicID FROM Lookup AS series "
-"INNER JOIN Resources instances ON series.internalId=instances.parentId "
-"GROUP BY series.publicId"));
-break;
-}
-case ResourceType_Instance:
-{
-statement.reset(
-new SQLite::Statement(
-db, SQLITE_FROM_HERE, "SELECT publicId, publicId FROM Lookup"));
-break;
-}
-default:
-throw OrthancException(ErrorCode_InternalError);
-}
-assert(statement.get() != NULL);
-while (statement->Step())
-{
-resourcesId.push_back(statement->ColumnString(0));
-instancesId.push_back(statement->ColumnString(1));
-}
-}
-void SQLiteDatabaseWrapper::ApplyLookupResources(std::list<std::string>& resourcesId,
-std::list<std::string>* instancesId,
-const std::vector<DatabaseConstraint>& lookup,
-ResourceType queryLevel,
-size_t limit)
-{
-LookupFormatter formatter;
-std::string sql;
-LookupFormatter::Apply(sql, formatter, lookup, queryLevel, limit);
-sql = "CREATE TEMPORARY TABLE Lookup AS " + sql;
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE, "DROP TABLE IF EXISTS Lookup");
-s.Run();
-}
-{
-SQLite::Statement statement(db_, sql);
-formatter.Bind(statement);
-statement.Run();
-}
-if (instancesId != NULL)
-{
-AnswerLookup(resourcesId, *instancesId, db_, queryLevel);
-}
-else
-{
-resourcesId.clear();
-SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT publicId FROM Lookup");
-while (s.Step())
-{
-resourcesId.push_back(s.ColumnString(0));
-}
-}
-}
-int64_t SQLiteDatabaseWrapper::GetLastChangeIndex()
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE,
-"SELECT seq FROM sqlite_sequence WHERE name='Changes'");
-if (s.Step())
-{
-int64_t c = s.ColumnInt(0);
-assert(!s.Step());
-return c;
-}
-else
-{
-// No change has been recorded so far in the database
-return 0;
-}
-}
-void SQLiteDatabaseWrapper::TagMostRecentPatient(int64_t patient)
-{
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE,
-"DELETE FROM PatientRecyclingOrder WHERE patientId=?");
-s.BindInt64(0, patient);
-s.Run();
-assert(db_.GetLastChangeCount() == 0 ||
-db_.GetLastChangeCount() == 1);
-if (db_.GetLastChangeCount() == 0)
-{
-// The patient was protected, there was nothing to delete from the recycling order
-return;
-}
-}
-{
-SQLite::Statement s(db_, SQLITE_FROM_HERE,
-"INSERT INTO PatientRecyclingOrder VALUES(NULL, ?)");
-s.BindInt64(0, patient);
-s.Run();
 }
 }
 }

Mercurial > hg > orthanc

comparison OrthancServer/Sources/Database/SQLiteDatabaseWrapper.cpp @ 4591:ff8170d17d90 db-changes