OMSFileLoad.h

Go to the documentation of this file.

// Copyright (c) 2002-present, OpenMS Inc. -- EKU Tuebingen, ETH Zurich, and FU Berlin
// SPDX-License-Identifier: BSD-3-Clause
//
// --------------------------------------------------------------------------
// $Maintainer: Hendrik Weisser $
// $Authors: Hendrik Weisser, Chris Bielow $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/CONCEPT/ProgressLogger.h>
#include <OpenMS/METADATA/ID/IdentificationData.h>
#include <OpenMS/FORMAT/OMSFileStore.h>
 
namespace SQLite
{
  class Database;
} // namespace SQLite
 
namespace OpenMS
{
  class FeatureMap;
  class ConsensusMap;
 
  namespace Internal
  {
    class OMSFileLoad: public ProgressLogger
    {
    public:
      using Key = OMSFileStore::Key; 
 
      OMSFileLoad(const String& filename, LogType log_type);
 
      ~OMSFileLoad();
 
      void load(IdentificationData& id_data);
 
      void load(FeatureMap& features);
 
      void load(ConsensusMap& consensus);
 
      void exportToJSON(std::ostream& output);
 
    private:
      static bool isEmpty_(const SQLite::Statement& query);
 
      static DataValue makeDataValue_(const SQLite::Statement& query);
 
      // static CVTerm loadCVTerm_(int id);
 
      void loadScoreTypes_(IdentificationData& id_data);
 
      void loadInputFiles_(IdentificationData& id_data);
 
      void loadProcessingSoftwares_(IdentificationData& id_data);
 
      void loadDBSearchParams_(IdentificationData& id_data);
 
      void loadProcessingSteps_(IdentificationData& id_data);
 
      void loadObservations_(IdentificationData& id_data);
 
      void loadParentSequences_(IdentificationData& id_data);
 
      void loadParentGroupSets_(IdentificationData& id_data);
 
      void loadIdentifiedCompounds_(IdentificationData& id_data);
 
      void loadIdentifiedSequences_(IdentificationData& id_data);
 
      void loadAdducts_(IdentificationData& id_data);
 
      void loadObservationMatches_(IdentificationData& id_data);
 
      template <class MapType> String loadMapMetaDataTemplate_(MapType& features);
 
      void loadMapMetaData_(FeatureMap& features);
 
      void loadMapMetaData_(ConsensusMap& consensus);
 
      void loadDataProcessing_(std::vector<DataProcessing>& data_processing);
 
      void loadFeatures_(FeatureMap& features);
 
      Feature loadFeatureAndSubordinates_(SQLite::Statement& query_feat,
                                          SQLite::Statement& query_meta,
                                          SQLite::Statement& query_match,
                                          SQLite::Statement& query_hull);
 
      void loadConsensusColumnHeaders_(ConsensusMap& consensus);
 
      void loadConsensusFeatures_(ConsensusMap& consensus);
 
      BaseFeature makeBaseFeature_(int id, SQLite::Statement& query_feat,
                                   SQLite::Statement& query_meta,
                                   SQLite::Statement& query_match);
 
      void prepareQueriesBaseFeature_(SQLite::Statement& query_meta,
                                      SQLite::Statement& query_match);
 
      bool prepareQueryMetaInfo_(SQLite::Statement& query, const String& parent_table);
 
      void handleQueryMetaInfo_(SQLite::Statement& query, MetaInfoInterface& info,
                                Key parent_id);
 
      bool prepareQueryAppliedProcessingStep_(SQLite::Statement& query,
                                              const String& parent_table);
 
      void handleQueryAppliedProcessingStep_(
        SQLite::Statement& query,
        IdentificationDataInternal::ScoredProcessingResult& result,
        Key parent_id);
 
      void handleQueryParentMatch_(
        SQLite::Statement& query, IdentificationData::ParentMatches& parent_matches,
        Key molecule_id);
 
      void handleQueryPeakAnnotation_(
        SQLite::Statement& query, IdentificationData::ObservationMatch& match,
        Key parent_id);
 
      std::unique_ptr<SQLite::Database> db_;
 
      int version_number_; 
 
      String subquery_score_; 
 
      // mappings between database keys and loaded data:
      std::unordered_map<Key, IdentificationData::ScoreTypeRef> score_type_refs_;
      std::unordered_map<Key, IdentificationData::InputFileRef> input_file_refs_;
      std::unordered_map<Key, IdentificationData::ProcessingSoftwareRef> processing_software_refs_;
      std::unordered_map<Key, IdentificationData::ProcessingStepRef> processing_step_refs_;
      std::unordered_map<Key, IdentificationData::SearchParamRef> search_param_refs_;
      std::unordered_map<Key, IdentificationData::ObservationRef> observation_refs_;
      std::unordered_map<Key, IdentificationData::ParentSequenceRef> parent_sequence_refs_;
      std::unordered_map<Key, IdentificationData::IdentifiedMolecule> identified_molecule_vars_;
      std::unordered_map<Key, IdentificationData::ObservationMatchRef> observation_match_refs_;
      std::unordered_map<Key, IdentificationData::AdductRef> adduct_refs_;
 
      // mapping: table name -> ordering critera (for JSON export)
      static std::map<String, String> export_order_by_;
    };
  }
}