---

vdbl_vtable.h

Go to the documentation of this file.

// View table 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_VTABLE_H
#define __VDBL_VTABLE_H

#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_viewtable : public _VDBL_table
{
private:
  typedef _VDBL_table _Base;

  typedef std::pair<_VDBL_colflags,_VDBL_col> _T_col_entry;
  typedef std::map<std::string, _VDBL_colid> _T_cols;
  typedef std::map<_VDBL_colid, _T_col_entry> _T_defaults;
  typedef std::map<_VDBL_colid,__VDBL_index> _T_indices;
  typedef std::map<_VDBL_rowid,_VDBL_row> _T_rows;
  typedef std::map<_VDBL_rowid,std::map<_VDBL_tableid,_VDBL_rowid> > _T_rowref;
  typedef std::map<_VDBL_colid,std::pair<_VDBL_colid,_VDBL_tableid> > _T_colref;

  friend class _VDBL_view;

public:
  typedef std::pair<std::string,_VDBL_col> _T_colspec;

private:
  _VDBL_view* _T_v;
  unsigned int _T_v_lastchg;

  _T_indices _T_i;
  _T_rows _T_r;

  _T_colref _T_cr;
  _T_rowref _T_rr;

  _T_rows _T_rowcache;

private:
  const std::type_info& get_colinfo(const std::string& _C_n,
                             triple<bool,_VDBL_colid,_VDBL_colflags>& _r) const
  {
    const _VDBL_col* _x;
    return _T_v->get_colinfo(_C_n, _r);
  }
  
public:
  _VDBL_viewtable(_VDBL_view& _v) : _Base(), _T_v(&_v), _T_i(), _T_r(), _T_cr(),
                                    _T_rr(), _T_rowcache()
     {
       for(_VDBL_view::row_const_iterator __x = _T_v->rows_begin();
           __x != _T_v->rows_end(); ++__x)
         _T_rr.insert(get_rowid(), *__x);
       for(_VDBL_view::default_const_iterator __x = _T_v->defaults_begin();
           __x != _T_v->defaults_end(); ++__x)
         _T_cr.insert(get_colid(), *__x);
       _T_v_lastchg = _T_v->get_change_ctr();
     }

  _VDBL_viewtable(const _VDBL_viewtable& __t) : _Base(__t), _T_v(__t._T_v),
                                        _T_v_lastchg(__t._T_v_lastchg),
                                        _T_i(__t._T_i), _T_r(__t._T_r),
                                        _T_cr(__t._T_cr), _T_rr(__t._T_rr)
                                        _T_rowcache() {}

  virtual ~_VDBL_viewtable() {}

  bool add_col(const std::string& _C_n, const _VDBL_col& __c,
               const _VDBL_colflags& __f)
  {
    return false;
  }

  bool modify_col(const std::string& _C_n, const _VDBL_col& __c,
                  const _VDBL_colflags& __f)
  {
    return false;
  }

  bool modify_col(const std::string& _C_n, const _VDBL_col& __c)
  {
    return false;
  }

  bool modify_col(const std::string& _C_n, const _VDBL_colflags& __f)
  {
    return false;
  }

  bool drop_col(const std::string& _C_n)
  {
    return false;
  }

  bool rename_col(const std::string& _C_old, const std::string& _C_new)
  {
    return false;      // old column name does not exist
  }

  bool insert(const std::vector<_T_colspec>& _row)
  {
    if(_T_v->view_type() == _VDBL_V_window)
    {
      bool ret = _T_v->insert(_row);
      if(ret)
        made_change();
      return ret;
    }
    else if(_T_v->view_type() == _VDBL_V_materialized) 
      return false;
    else 
    {
      std::vector<_T_colspec>::const_iterator __x;
      bool ret = true;
      _VDBL_row _r;
      std::set<_VDBL_colid> _isdef;

      for(__x = _row.begin(); __x != _row.end(); ++__x)
      {
        _T_colspec& _c(*__x);
        triple<bool, _VDBL_colid, _VDBL_colflags> _ru;
        const std::type_info& _rt(get_colinfo(_c.first, _ru));
        if(_isdef.find(_ru.second) != _isdef.end())
        { // column is doubly defined
          ret = false;
          break;
        }
        if(!_ru.first || !VDBL_CMP_TYPEID(_rt, _c.second.return_type_id()))
        { // value of the default col and the defined col are incompatible
          ret = false;
          break;
        }
        else
        {
          if(_ru.third.is_master)
          {
#if _VDBL_DEBUG
            std::cout <<
                  "We should check the constraints here in table::insert" <<
                  std::endl;
#endif
          }
          _isdef.insert(_ru.second);
          _r.insert(_ru.second,_c.second);
        }
      }
      // now check whether all columns without default are actually defined
      if(ret)
      {
        for(_VDBL_view::defaults_const_iterator __b = _T_v->defaults_begin();
            __b != _T_v->defaults_end(); ++__b)
        {
          const _T_col_entry& __de((*__b).second);
          if(!__de.first.has_default &&
             _isdef.find((*__b).first) == _isdef.end())
          // this col must be defined but isn't
          {
            ret = false;
            break;
          }
        }
      }
      if(ret)
      {
        _T_r.insert(std::make_pair(get_rowid(), _r));
        made_change();
      }
      return ret;
    }
  }

  bool remove(const _VDBL_rowid _ri)
  {
    if(_T_v->view_type() == _VDBL_V_window)
    {
      _T_rowref::iterator _v(_T_rr.find(_ri));
      if(_ri == _T_rr.end())
        return false;
      else
      {
        std::map<_VDBL_rowid,_VDBL_tableid>& _rowmap(_v.second);
        std::map<_VDBL_rowid,_VDBL_tableid>::iterator __r;
        bool ret = true;
        for(__r = _rowmap.begin(); __r != _rowmap.end(); ++__r)
          ret = _T_v->remove(*__r) && ret;
        made_change();
        return ret;
      }
    }
    else
    {
      _T_rows::iterator __x = _T_r.find(_ri);
      if(__x == _T_r.end())
        return false;
      else
      {
        _T_r.erase(__x);
        made_change();
        return true;
      }
    }
  }

  bool has_col(const std::string& _C_n) const
  {
    return _T_v->has_col(_C_n);
  }

  const _VDBL_row& get_row(const _VDBL_rowid& _ri, bool& error) const
  {
    _T_rows::const_iterator _x(_T_r.find(_ri));
    if(_x == _T_r.end()) // this row is not local -> get it from view
    {
      if(_T_v->get_change_ctr() == _T_v_lastchg)
      {
        _x = _T_rowcache.find();
        if(_x != _T_rowcache.end()) // this row is in the cache
        {
          error = false;
          return (*_x).second;
        }
      }
      else
      { // invalidate (i.e. remove) the cache
        _T_rowcache.erase(_T_rowcache.begin(), _T_rowcache.end());
      }
      _T_rowref::const_iterator _y(_T_rr.find(_ri));
      if(_y == _T_rr.end()) // this row is nowhere -> fail
      {
        error = true;
        return ___empty_row_return;
      }
      const std::map<_VDBL_tableid,_VDBL_rowid>& _yr(_y.second);

      _VDBL_row _rw;
      error = false;
      std::map<_VDBL_tableid,const _VDBL_row*> _fetched;
      std::map<_VDBL_tableid,const _VDBL_row*>::iterator _fit;
      for(_T_colref::const_iterator _cr = _T_cr.begin(); _cr != _T_cr.end();
          ++_cr)
      {
        const _VDBL_tableid& _ti((*_cr).second.second);
        if((_fit = _fetched.find(_ti)) == _fetched.end())
        {
          std::map<_VDBL_tableid,_VDBL_rowid>::const_iterator
                                                        _rri(_yr.find(_ti));
          const _VDBL_row& _rrr(_T_v->get_row(*_rri));
          _fit = _fetched.insert(std::make_pair(_ti,&_rrr));
        }
        const _VDBL_col& _rrc((*_fit).second->get_col((*_cr).second.first,
                              error));
        if(error)
          return ___empty_row_return;
        error = _rw.insert((*_cr).first,_rrc);
        if(error)
          return ___empty_row_return;
      }
      return _rw;
    }
    else
    {
      error = false;
      return (*_x).second;
    }
  }

  const _VDBL_row* get_row_ptr(const _VDBL_rowid& _ri) const
  {
    _T_rows::const_iterator _x(_T_r.find(_ri));
    if(_x == _T_r.end()) // this row is not local -> get it from view
    {
      if(_T_v->get_change_ctr() == _T_v_lastchg)
      {
        _x = _T_rowcache.find();
        if(_x != _T_rowcache.end()) // this row is in the cache
          return &(*_x).second;
      }
      else
      { // invalidate (i.e. remove) the cache
        _T_rowcache.erase(_T_rowcache.begin(), _T_rowcache.end());
      }
      _T_rowref::const_iterator _y(_T_rr.find(_ri));
      if(_y == _T_rr.end()) // this row is nowhere -> fail
        return NULL;

      const std::map<_VDBL_tableid,_VDBL_rowid>& _yr(_y.second);

      _VDBL_row _rw;
      bool error(false);
      std::map<_VDBL_tableid,const _VDBL_row*> _fetched;
      std::map<_VDBL_tableid,const _VDBL_row*>::iterator _fit;
      for(_T_colref::const_iterator _cr = _T_cr.begin(); _cr != _T_cr.end();
          ++_cr)
      {
        const _VDBL_tableid& _ti((*_cr).second.second);
        if((_fit = _fetched.find(_ti)) == _fetched.end())
        {
          std::map<_VDBL_tableid,_VDBL_rowid>::const_iterator
                                                        _rri(_yr.find(_ti));
          const _VDBL_row& _rrr(_T_v->get_row(*_rri));
          _fit = _fetched.insert(std::make_pair(_ti,&_rrr));
        }
        const _VDBL_col& _rrc((*_fit).second->get_col((*_cr).second.first,
                              error));
        if(error)
          return NULL;
        error = _rw.insert((*_cr).first,_rrc);
        if(error)
          return NULL;
      }
      return &_rw;
    }
    else
      return &(*_x).second;
  }

  _VDBL_row& get_row(const _VDBL_rowid& _ri, bool& error)
  {
    _T_rows::iterator _x(_T_r.find(_ri));
    if(_x == _T_r.end()) // this row is not local -> get it from view
    {
      if(_T_v->get_change_ctr() == _T_v_lastchg)
      {
        _x = _T_rowcache.find();
        if(_x != _T_rowcache.end()) // this row is in the cache
        {
          error = false;
          return (*_x).second;
        }
      }
      else
      { // invalidate (i.e. remove) the cache
        _T_rowcache.erase(_T_rowcache.begin(), _T_rowcache.end());
      }
      _T_rowref::iterator _y(_T_rr.find(_ri));
      if(_y == _T_rr.end()) // this row is nowhere -> fail
      {
        error = true;
        return ___empty_row_return;
      }
      std::map<_VDBL_tableid,_VDBL_rowid>& _yr(_y.second);

      _VDBL_row _rw;
      error = false;
      std::map<_VDBL_tableid,_VDBL_row*> _fetched;
      std::map<_VDBL_tableid,_VDBL_row*>::iterator _fit;
      for(_T_colref::const_iterator _cr = _T_cr.begin(); _cr != _T_cr.end();
          ++_cr)
      {
        _VDBL_tableid& _ti((*_cr).second.second);
        if((_fit = _fetched.find(_ti)) == _fetched.end())
        {
          std::map<_VDBL_tableid,_VDBL_rowid>::iterator
                                                        _rri(_yr.find(_ti));
          _VDBL_row& _rrr(_T_v->get_row(*_rri));
          _fit = _fetched.insert(std::make_pair(_ti,&_rrr));
        }
        _VDBL_col& _rrc((*_fit).second->get_col((*_cr).second.first,
                        error));
        if(error)
          return ___empty_row_return;
        error = _rw.insert((*_cr).first,_rrc);
        if(error)
          return ___empty_row_return;
      }
      _x = _T_rowcache.insert(_ri,_rw);
      return (*_x).second;
    }
    else
    {
      error = false;
      return (*_x).second;
    }
  }

  bool retrieve(const _VDBL_rowid& _r, const _VDBL_colid& _c,
                const _VDBL_context& _ctx, _VDBL_alltype_base*& _val) const
  {
    bool ret;
    const _VDBL_row& _row(get_row(_r, ret));
    if(ret)
      return false;

    const _VDBL_col& _col(_row.get_col(_c, ret));
    if(ret)
    {           // row does not contain this col -> get default
      _T_defaults::const_iterator _x(_T_d.find(_c));
      if(_x == _T_d.end())      // there is no default
        return false;
      _VDBL_col _col2((*_x).second.second);
      if(!VDBL_CMP_TYPEID(_col2.return_type_id(), typeid(_R)))
        return false;
      _col2.setcontext(_ctx, &_row);
      _col2.def_copy(_val);
      return true;
    }
    else
    {           // row contains this col
      if(!VDBL_CMP_TYPEID(_col.return_type_id(), typeid(_R)))
        return false;
      _col.setcontext(_ctx, &_row);
      _col.get_copy(_val);
      return true;
    }
  }

  bool create_index(const std::string& _C_i) { throw "create_index: NYI"; }
  bool alter_index(const std::string& _C_i) { throw "alter_index: NYI"; }
  bool drop_index(const std::string& _C_i) { throw "drop_index: NYI"; }
};

class view_table : _VDBL_viewtable
{
public:
  typedef _VDBL_row row;
  typedef _VDBL_col col;
  typedef __VDBL_index index;
  typedef _VDBL_context context;
  typedef _VDBL_col def;

  typedef _VDBL_table::_T_colspec col_spec;
};

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

__VDBL_END_NAMESPACE

#endif /* __VDBL_VTABLE_H */

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

---