seismic_qsql.hpp

/* seis.hpp */
/* $Id$ */
#ifndef __hds_db_seismic_qsql_hpp
#define __hds_db_seismic_qsql_hpp

#include <QSqlDatabase>
#include <QSqlQuery>

#include <map>
#include <hds_db/base/seismic.hpp>
#include <hds_db/qsql/qsql_impl.hpp>
#include <hds_db/qsql/tr_hdrs_cache_qsql.hpp>
#include <hds_db/qsql/tr_bodies_cache_qsql.hpp>

namespace hds
{
  namespace db
  {
    class ProjectQSql;
    
    class SeismicQSql : public Seismic, public QSqlImpl
    {
      friend class ProjectQSql;
      
    public:
      
      SeismicQSql(const ContextQSql &dbc, 
          const std::string &project_str, 
          const size_t hdrs_cache_size = 8192,
          const size_t bodies_cache_size = 4096);
      
      virtual ~SeismicQSql();
      
      //--- Access to data storage ---------------------------------------------------------------
      
      virtual ErrCode open(const std::string &name, OpenMode mode);
      
      virtual ErrCode close();
      
      virtual ErrCode flush();
      
      virtual ErrCode setName(const std::string &name_str);
      
      virtual std::string name(ErrCode *rc = NULL) const;
      
      virtual ErrCode remove(const std::string &name);
      
      virtual ErrCode getList(Names &list) const;
      
      virtual size_t dataSize(const std::string &name,
                  ErrCode *prc = NULL) const;
      
      virtual time_t creationTime(const std::string &name,
                  ErrCode *prc = NULL) const;
      
      virtual time_t modificationTime(const std::string &name,
                      ErrCode *prc = NULL) const;
      
      virtual DbIndex rawDbIndex(size_t id, ErrCode *prc = NULL) const;

      
      //--- Reading facilities -------------------------------------------------------------------
      
      virtual ErrCode getVolumeHeader(VolumeHeader &vol_header) const;
      
      virtual size_t tracesNum(ErrCode *rc = NULL) const;
      
      virtual const TrHeader& rawTrHeader(const DbIndex &id, ErrCode *rc = NULL) const;  
      
      virtual const TrBody& rawTrBody(const DbIndex &id, ErrCode *rc = NULL) const;  
      
      //--- Writing/editing facilities -----------------------------------------------------------
      
      virtual ErrCode setVolumeHeader(const VolumeHeader &vol_header);
      
      virtual ErrCode rawSetTrHeader(const DbIndex &id, const TrHeader &hdr);  
      
      virtual ErrCode rawSetTrBody(const DbIndex &id, const TrBody &body);  
      
      virtual ErrCode appendTr(const TrHeader &header, const TrBody &body);
      
      virtual ErrCode eraseTr(size_t id);
      
      //--- Selection facilities -----------------------------------------------------------------
      
      virtual ErrCode select(const TrSelector &selector = TrSelector());
      
      virtual const TrSelector& getSelector() const;
      
      
      //--- Extra functionality  -----------------------------------------------------------------
      
      const DbIndex& getCurrentSeismicId() const {return m_cur_seismic_id;} 

      void setBufferAllHeadersFlag(bool flag = true);
      
      bool getBufferAllHeadersFlag();
      
    protected:
      
      DbIndex m_cur_seismic_id;
      
      TrSelector m_tr_selector;

      DbIndex m_db_lock_id;

    private:
      
      size_t m_cur_traces_num;

      std::vector<DbIndex> m_trace_id_vec;
      
      size_t m_hdrs_cache_size;
      
      size_t m_bodies_cache_size;

      bool m_buffer_all_hdrs_flag;

      mutable TrHdrsCacheQSql m_hdrs_cache;
      
      mutable TrBodiesCacheQSql m_bodies_cache;
      
      DbIndex db_get_trace_id(const size_t id) const;
      
      ErrCode db_select_tr_indexes(const TrSelector &selector,
                    const bool is_temporary,
                    std::vector<DbIndex> &ids);
      
      void matching_condition_rule(QString &match_str, 
                   const QString &rule_str, 
                   const TrSelBaseRule *ppr, 
                   const TrSelBaseRule *pr);
            
      ErrCode db_get_volume_header(const DbIndex &seis_id, 
                   const bool is_temporary, 
                   VolumeHeader &hdr) const;
      
      ErrCode db_update_volume_header(const DbIndex &seis_id, 
                      const VolumeHeader &hdr,
                      const bool is_temporary);
      
      ErrCode db_create_seismic(const std::string &name, 
                const DbIndex &project_id,
                const bool is_temporary,
                DbIndex &id);
      
      ErrCode db_remove_seismic(const DbIndex &project_id,
                const DbIndex &seis_id);
      
      bool db_tmp_seismic_exists(const DbIndex &seis_id) const;
      
      ErrCode db_get_hdrs_bodies_tbl_names(const std::string &name,
                       QString &hdrs_str, 
                       QString &bodies_str,
                       DbIndex &seis_id) const;
            
      static ErrCode db_create_seismic_table(QSqlDatabase &m_db,
                         const bool is_temporary);
      
      
      // DB query strings generators
      ErrCode qs_create_tr_headers_table(const DbIndex &id, 
                     const bool is_temporary,
                     QString &qs) const;
      ErrCode qs_create_tr_bodies_table(const DbIndex &id, 
                    const bool is_temporary,
                    QString &qs) const;
      QString qs_match_rule(const TrSelBaseRule *prule, const QString &op) const;
      QString qs_sort_rule(const TrSelBaseRule *prule) const;
      QString qs_range_rule(const TrSelBaseRule *prule) const;
            
      static ErrCode name2id(QSqlDatabase &db, 
                 const std::string &name,
                 const DbIndex &project_id,
                 DbIndex &id);
      
      static ErrCode tmp_name2id(QSqlDatabase &db, 
                 const std::string &name,
                 DbIndex &id);
      
      static ErrCode clear(QSqlDatabase &db, const DbIndex &project_id);
    };
  }; // db
}; // hds

#endif /* __hds_db_seismic_qsql_hpp */