---

vdbl_joinview.h

Go to the documentation of this file.

// Join view implementation -*- C++ -*-

// Copyright (C) 2003 Hermann Schichl
//
// This file is part of the Vienna Database Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the Library GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// Library GNU General Public License for more details.

// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the Library GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the Library GNU General Public License.

#ifndef __VDBL_JOINVIEW_H
#define __VDBL_JOINVIEW_H

#include <iostream>
#include <vdbl_table.h>
#include <vdbl_view.h>

__VDBL_BEGIN_NAMESPACE

#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
#pragma set woff 1209
#endif

class _VDBL_joinview : public _VDBL_view
{
private:
  typedef _VDBL_view _Base;
  
  typedef std::pair<_VDBL_tableid,_VDBL_colid> _V_colref;
  typedef std::map<_VDBL_tableid, _VDBL_rowid> _V_rowref;
  typedef std::map<std::pair<_VDBL_rowid,_VDBL_tableid>, _VDBL_col> _V_colentry;
  typedef std::map<_V_colref, _V_colentry> _V_colcache;
  typedef std::vector<_V_rowref> _V_rows;
  typedef std::vector<_V_colref> _V_cols;
  
private:
  std::map<_VDBL_tableid,_VDBL_table *> _V_t;    
  const _VDBL_context* _V_ctx;              

  std::map<_VDBL_tableid,unsigned int> _V_lastchg;

  _V_colcache _V_cc;

protected:
  _V_rows _V_r;
  _V_cols _V_c;

private:
  std::map<std::string,_V_colref> _V_colnames;

  friend class _VDBL_table;

public:
  typedef _Base::default_const_iterator defaults_const_iterator;

protected:
  std::pair<_VDBL_tableid,_VDBL_colid>
        _next_def_col(const _VDBL_tableid& _t, const _VDBL_colid& _c) const
    {
      std::cerr << "standard_view: _next_def_col NYI!" << std::endl;
      return std::make_pair(0,0);
    }

  std::pair<_VDBL_tableid,_VDBL_colid>
        _prev_def_col(const _VDBL_tableid& _t, const _VDBL_colid& _c) const
    {
      std::cerr << "standard_view: _prev_def_col NYI!" << std::endl;
      return std::make_pair(0,0);
    }

  std::pair<_VDBL_tableid,_VDBL_colid>
        _next_col(const _VDBL_tableid& _t, const _VDBL_rowid& _r,
                  const _VDBL_colid& _c) const
    {
      std::cerr << "standard_view: _next_col NYI!" << std::endl;
      return std::make_pair(0,0);
    }

  std::pair<_VDBL_tableid,_VDBL_colid>
        _prev_col(const _VDBL_tableid& _t, const _VDBL_rowid& _r,
                  const _VDBL_colid& _c) const
    {
      std::cerr << "standard_view: _prev_col NYI!" << std::endl;
      return std::make_pair(0,0);
    }

  std::pair<_VDBL_tableid,_VDBL_rowid>
        _next_row(const _VDBL_tableid& _t, const _VDBL_rowid& _r) const
    {
      std::cerr << "standard_view: _next_row NYI!" << std::endl;
      return std::make_pair(0,0);
    }

  std::pair<_VDBL_tableid,_VDBL_rowid>
        _prev_row(const _VDBL_tableid& _t, const _VDBL_rowid& _r) const
    {
      std::cerr << "standard_view: _prev_row NYI!" << std::endl;
      return std::make_pair(0,0);
    }

public:
  _VDBL_joinview(const _VDBL_tableid& __ti, _VDBL_table* __t,
                     const _VDBL_context& __c, _V_enum __e)
              : _Base(__e), _V_t(), _V_ctx(&__c),
                _V_lastchg(), _V_cc(), _V_r(), _V_c(), _V_colnames()
      {
        _V_t.insert(std::make_pair(__ti,__t));
        _VDBL_table::col_const_iterator __x;
        for(__x = __t->col_begin(); __x != __t->col_end(); ++__x)
          _V_colnames.insert(std::make_pair((*__x).first,
                                        std::make_pair(__ti,(*__x).second)));
        _V_lastchg.insert(std::make_pair(__ti,__t->get_change_ctr()));
      }

  _VDBL_joinview(const std::vector<std::pair<_VDBL_tableid,_VDBL_table *> >&
                     __t, const _VDBL_context& __c, _V_enum __e)
                : _Base(__e), _V_t(), _V_ctx(&__c), _V_cc(), _V_r(), _V_c(),
                  _V_colnames()
      {
        std::vector<std::pair<_VDBL_tableid,_VDBL_table *> >::const_iterator
                                                                __y;
        for(__y = __t.begin(); __y != __t.end(); ++__y)
        {
          _V_t.insert(std::make_pair((*__y).first, (*__y).second));
          _VDBL_table::col_const_iterator __x;
          for(__x = (*__y).second->col_begin();
              __x != (*__y).second->col_end(); ++__x)
          {
            const std::string &s((*__x).first);
            if(_V_colnames.find(s) != _V_colnames.end())
              _V_colnames.insert(std::make_pair(s,
                        std::make_pair((*__x).second, (*__y).first)));
            // else this column is inherited from an earlier table
          }
          _V_lastchg.insert(std::make_pair((*__y).first,
                                        (*__y).second->get_change_ctr()));
        }
      }

  _VDBL_joinview(const _VDBL_joinview& __v)
                : _Base(__v), _V_t(__v._V_t), _V_ctx(__v._V_ctx),
                  _V_cc(__v._V_cc), _V_r(__v._V_r), _V_c(__v._V_c),
                  _V_colnames(__v._V_colnames)
      {}
                

  virtual ~_VDBL_joinview() {}

public:
  const std::type_info& get_colinfo(const std::string& _C_n,
                triple<bool,_VDBL_colid,_VDBL_colflags>& _r) const
  {
    std::map<std::string,_V_colref>::const_iterator __x(_V_colnames.find(_C_n));
    if(__x == _V_colnames.end())
    {
      _r = make_triple(false, _VDBL_colid(), _VDBL_colflags());
      return typeid(void);
    }
    const _V_colref& _cr((*__x).second);
    typedef std::pair<_VDBL_colid,_VDBL_tableid> _V_colref;
    std::map<_VDBL_tableid,_VDBL_table *>::const_iterator
                                                __y(_V_t.find(_cr.second));
    if(__y == _V_t.end())
    {
      std::cerr << "Corrupted view detected! Table entry not found for stored ID!" << std::endl;
      throw "VDBL: Programming error";
    }
    return (*__y).second->get_colinfo(_C_n, _r);
  }

  bool insert(const std::vector<_T_colspec>& _row)
  {
    if(view_type() != V_window)
      return false;
    std::map<_VDBL_tableid,_VDBL_table *>::iterator __x(_V_t.begin());
    return (*__x).second->insert_row(_row);
  }

  bool remove(std::pair<_VDBL_tableid,_VDBL_rowid> _r)
  {
    if(view_type() != V_window)
      return false;
    std::map<_VDBL_tableid,_VDBL_table *>::iterator __x(_V_t.begin());
    if(_r.first != (*__x).first)
      return false;
    return (*__x).second->remove(_r.second);
  }

  bool has_col(const std::string& _C_n) const
  {
    std::map<std::string,_V_colref>::const_iterator __x(_V_colnames.find(_C_n));
    return __x != _V_colnames.end();
  }

  std::pair<_VDBL_tableid,_VDBL_colid> get_col_id(const std::string& _C_n) const
  {
    std::map<std::string,_V_colref>::const_iterator __x(_V_colnames.find(_C_n));
    if(__x == _V_colnames.end())
      return std::make_pair(_VDBL_tableid(),_VDBL_colid());
    return (*__x).second;
  }

  const _VDBL_row& get_row(const std::pair<_VDBL_tableid,_VDBL_rowid>& _ri,
                           bool& error) const
  {
    std::map<_VDBL_tableid,_VDBL_table *>::const_iterator
                                        __x(_V_t.find(_ri.first));
    return (*__x).second->get_row(_ri.second, error);
  }                                             
 
  const _VDBL_col& get_col(const std::pair<_VDBL_tableid,_VDBL_rowid>& _ri,
                           const _VDBL_colid& _ci, _VDBL_row const *& __r,
                           bool& error) const
  {
    std::map<_VDBL_tableid,_VDBL_table *>::const_iterator
                                        __x(_V_t.find(_ri.first));
    const _VDBL_row& _r((*__x).second->get_row(_ri.second, error));
    if(error)
      return ___empty_col_return;
    _rr = &_r;
    const _VDBL_col& _c(_r.get_col(_ci, error));
    if(error)
      return (*__x).second->get_def(_ci, error);
    else
      return _c;
  }                                             

  template <class _R>
  bool get_raw_ptr(const std::pair<_VDBL_tableid,_VDBL_rowid>& _ri,
                   const _VDBL_colid& _ci, _R const *& r) const
  {
    bool error;
    const VDBL_row* _rr;
    vdbl::col c(get_col(_ri, _ci, _rr, error));
    if(error)
      return false;
    c.setcontext(_V_ctx, _rr);
    c.get_ptr(r);
    return true;
  }
 
  template <class _R>
  bool get(const std::pair<_VDBL_tableid,_VDBL_rowid>& _ri,
                                 const _VDBL_colid& _ci, _R& r) const
  {
    bool error;
    const VDBL_row* _rr;
    vdbl::col c(get_col(_ri, _ci, _rr, error));
    if(error)
      return false;
    c.setcontext(_V_ctx, _rr);
    c.get(r);
    return true;
  }
 
  const _VDBL_col& get_def(const std::pair<_VDBL_tableid,_VDBL_colid>& _ri,
                           bool& error) const
  {
    std::map<_VDBL_tableid,_VDBL_table *>::const_iterator
                                                __x(_V_t.find(_ri.first));
    return (*__x).second->get_def(_ri.second, error);
  }

  default_const_iterator defaults_begin() const
  {
    return default_const_iterator();
  }

  default_const_iterator defaults_end() const
  {
    return default_const_iterator();
  }

  col_const_iterator cols_begin(const _VDBL_rowid& _r) const
  {
    return col_const_iterator();
  }

  col_const_iterator cols_end(const _VDBL_rowid& _r) const
  {
    return col_const_iterator();
  }

  row_const_iterator rows_begin() const
  {
    return row_const_iterator();
  }

  row_const_iterator rows_end() const
  {
    return row_const_iterator();
  }
};

class join_view : public _VDBL_joinview
{
  typedef _VDBL_joinview _Base;

public:
  typedef _V_enum view_enum;

public:
  join_view(const _VDBL_tableid& __ti, _VDBL_table* __t,
            const _VDBL_context& __c, _V_enum __e = V_transparent)
                : _VDBL_joinview(__ti,__t,__c,__e) {}

  join_view(const join_view& _v) : _VDBL_joinview(_v) {}

  template <class _R>
  bool get(const tableid& _ti, const rowid& _ri, const colid& _ci, _R& r) const
  { return _Base::get(std::make_pair(_ti, _ri), _ci, r); }

  template <class _R>
  bool get(const rowid& _ri, const std::string& _c, _R& r) const
  { std::pair<tableid,colid> _tci(get_col_id(_c));
    return _Base::get(std::make_pair(_tci.first, _ri), _tci.second, r); }

  template <class _R>
  bool get(const rowid& _ri, const char* _c, _R& r) const
  { return get(_ri, std::string(_c), r); }
};

#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
#pragma reset woff 1209
#endif

__VDBL_END_NAMESPACE

#endif /* __VDBL_JOINVIEW_H */

// Local Variables:
// mode:C++
// End:

---