vdbl_table.h

Go to the documentation of this file.

// Table implementation -*- C++ -*-

// $Id: vdbl_table.h 921 2009-11-12 17:03:02Z mihaly $
// 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_TABLE_H
#define __VDBL_TABLE_H

#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <string>
#include <triple>
#include <vdbl_config.h>
#include <vdbl_row.h>
#include <vdbl_col.h>
#include <vdbl_index.h>
#include <vdbl_context.h>
#include <vdbl_view.h>

__VDBL_BEGIN_NAMESPACE

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


static _VDBL_row ___empty_row_return;


class _VDBL_table
{
private:
  friend class _VDBL_view;

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

private:

  _VDBL_colid _T_ci;
  _VDBL_rowid _T_ri;

  unsigned int last_change;

protected:

  _VDBL_colid get_colid() { return ++_T_ci; }
  _VDBL_rowid get_rowid() { return ++_T_ri; }

  void made_change() { last_change++; }

public:
  virtual const std::type_info& get_colinfo(const std::string& _C_n,
                             std::triple<bool,_VDBL_colid,_VDBL_colflags>& _r) const
                                                        VDBL_PURE_VIRTUAL

public:
  unsigned int get_change_ctr() const { return last_change; }

public:
  class _col_iterator_base
  {
  private:
    typedef std::pair<std::string,_VDBL_colid> entry;
  public:
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;
    typedef std::bidirectional_iterator_tag iterator_category;

  protected:
    entry _CI_ci;
    const _VDBL_table* _CI_t;

  public:
    _col_iterator_base(const _VDBL_table* __x, const entry& __c)
                : _CI_ci(__c), _CI_t(__x) { }

    _col_iterator_base() : _CI_ci(), _CI_t(NULL) {}

    void _D_incr() { _CI_ci = _CI_t->_next_col(_CI_ci); }

    void _D_decr() { _CI_ci = _CI_t->_prev_col(_CI_ci); }

    
    bool operator==(const _col_iterator_base& __x) const
              { return _CI_t == __x._CI_t && _CI_ci == __x._CI_ci; }

    bool operator!=(const _col_iterator_base& __x) const
              { return _CI_t != __x._CI_t || _CI_ci != __x._CI_ci; }
  };

  template<typename _Tp, typename _Ref, typename _Ptr>
  struct _col_iterator : public _col_iterator_base
  {
  public:
    typedef _col_iterator<_Tp,_Tp&,_Tp*>             iterator;
    typedef _col_iterator<_Tp,const _Tp&,const _Tp*> const_iterator;
    typedef _col_iterator<_Tp,_Ref,_Ptr>             _Self;

    typedef _Tp value_type;
    typedef _Ptr pointer;
    typedef _Ref reference;

    _col_iterator(const _VDBL_table* __x,
                  const std::pair<std::string,_VDBL_colid>& __c)
                                : _col_iterator_base(__x,__c) { }

    _col_iterator(const _VDBL_table* __x, const std::string& __s,
                  const _VDBL_colid& __c)
                         : _col_iterator_base(__x,std::make_pair(__s,__c)) { }

    _col_iterator() : _col_iterator_base() { }

    _col_iterator(const iterator& __x)
        : _col_iterator_base(__x._CI_t, __x._CI_ci) { }

    reference operator*() const { return _CI_ci; }

    pointer operator->() const { return &(operator*()); }

    _Self& operator++() { this->_D_incr(); return *this; }

    _Self operator++(int)
        { _Self __tmp = *this; this->_D_incr(); return __tmp; }

    _Self& operator--() { this->_D_decr(); return *this; }

    _Self operator--(int)
        { _Self __tmp = *this; this->_D_decr(); return __tmp; }
  };

  typedef _col_iterator<std::pair<std::string,_VDBL_colid>,
                        const std::pair<std::string,_VDBL_colid>&,
                        const std::pair<std::string,_VDBL_colid>*>
                                                col_const_iterator;

  virtual std::pair<std::string,_VDBL_colid> _next_col(
        const std::pair<std::string,_VDBL_colid>& _ci)
                                        const VDBL_PURE_VIRTUAL
  virtual std::pair<std::string,_VDBL_colid> _prev_col(
        const std::pair<std::string,_VDBL_colid>& _ci)
                                        const VDBL_PURE_VIRTUAL
  virtual col_const_iterator col_begin() const VDBL_PURE_VIRTUAL
  virtual col_const_iterator col_end() const VDBL_PURE_VIRTUAL

  class _row_iterator_base
  {
  private:
    typedef _VDBL_rowid entry;
  public:
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;
    typedef std::bidirectional_iterator_tag iterator_category;

  protected:
    entry _CI_ci;
    const _VDBL_table* _CI_t;

  public:
    _row_iterator_base(const _VDBL_table* __x, const entry& __c)
                : _CI_ci(__c), _CI_t(__x) { }

    _row_iterator_base() : _CI_ci(), _CI_t(NULL) {}

    void _D_incr() { _CI_ci = _CI_t->_next_row(_CI_ci); }

    void _D_decr() { _CI_ci = _CI_t->_prev_row(_CI_ci); }

    
    bool operator==(const _row_iterator_base& __x) const
              { return _CI_t == __x._CI_t && _CI_ci == __x._CI_ci; }

    bool operator!=(const _row_iterator_base& __x) const
              { return _CI_t != __x._CI_t || _CI_ci != __x._CI_ci; }
  };

  template<typename _Tp, typename _Ref, typename _Ptr>
  struct _row_iterator : public _row_iterator_base
  {
  public:
    typedef _row_iterator<_Tp,_Tp&,_Tp*>             iterator;
    typedef _row_iterator<_Tp,const _Tp&,const _Tp*> const_iterator;
    typedef _row_iterator<_Tp,_Ref,_Ptr>             _Self;

    typedef _Tp value_type;
    typedef _Ptr pointer;
    typedef _Ref reference;

    _row_iterator(const _VDBL_table* __x, const _VDBL_rowid& __c)
                                : _row_iterator_base(__x,__c) { }

    _row_iterator() : _row_iterator_base() { }

    _row_iterator(const iterator& __x)
        : _row_iterator_base(__x._CI_t, __x._CI_ci) { }

    reference operator*() const { return _CI_ci; }

    pointer operator->() const { return &(operator*()); }

    _Self& operator++() { this->_D_incr(); return *this; }

    _Self operator++(int)
        { _Self __tmp = *this; this->_D_incr(); return __tmp; }

    _Self& operator--() { this->_D_decr(); return *this; }

    _Self operator--(int)
        { _Self __tmp = *this; this->_D_decr(); return __tmp; }
  };

  typedef _row_iterator<_VDBL_rowid, const _VDBL_rowid&, const _VDBL_rowid*>
                                                row_const_iterator;

  virtual _VDBL_rowid _next_row(const _VDBL_rowid& _ci)
                                        const VDBL_PURE_VIRTUAL
  virtual _VDBL_rowid _prev_row(const _VDBL_rowid& _ci)
                                        const VDBL_PURE_VIRTUAL
  virtual row_const_iterator row_begin() const VDBL_PURE_VIRTUAL
  virtual row_const_iterator row_end() const VDBL_PURE_VIRTUAL
  virtual row_const_iterator* row_iterator_copy(const row_const_iterator&)
        const VDBL_PURE_VIRTUAL

public:
  _VDBL_table() : _T_ci(0), _T_ri(0), last_change(0) {}
  _VDBL_table(const _VDBL_table& __t) : _T_ci(__t._T_ci), _T_ri(__t._T_ri),
                                        last_change(0) {}

  template <template <class __Tp, class __AllocTp> class __SequenceCtr,
            class Allocator1>
  _VDBL_table(const __SequenceCtr<std::triple<std::string, _VDBL_col,
              _VDBL_colflags>,Allocator1>& __cc) : _T_ci(0), _T_ri(0),
                                                   last_change(0) {}

  virtual ~_VDBL_table() {}

  virtual _VDBL_table* new_copy() VDBL_PURE_VIRTUAL

  virtual void destroy_copy(_VDBL_table* t) VDBL_PURE_VIRTUAL

  virtual bool add_col(const std::string& _C_n, const _VDBL_col& __c,
                       const _VDBL_colflags& __f) VDBL_PURE_VIRTUAL

  virtual bool modify_col(const std::string& _C_n, const _VDBL_col& __c,
                          const _VDBL_colflags& __f) VDBL_PURE_VIRTUAL

  virtual bool modify_col(const std::string& _C_n, const _VDBL_col& __c)
        VDBL_PURE_VIRTUAL

  virtual bool modify_col(const std::string& _C_n, const _VDBL_colflags& __f)
        VDBL_PURE_VIRTUAL

  virtual bool drop_col(const std::string& _C_n) VDBL_PURE_VIRTUAL

  virtual bool rename_col(const std::string& _C_old, const std::string& _C_new)
        VDBL_PURE_VIRTUAL

  virtual bool insert(const std::vector<_T_ptrcolspec>& _row, _VDBL_rowid& _r)
        VDBL_PURE_VIRTUAL

  virtual bool insert(const std::vector<_T_ptrcolspec>& _row) VDBL_PURE_VIRTUAL

  template <template <class __Tp, class __AllocTp> class __SequenceCtr,
            class Allocator1>
  bool insert_row(const __SequenceCtr<_T_colspec,Allocator1>& _row)
  {
    typename __SequenceCtr<_T_colspec,Allocator1>::const_iterator __x;
    std::vector<_T_ptrcolspec> __v;
    __v.reserve(_row.size());
    for(__x = _row.begin(); __x != _row.end(); ++__x)
      __v.push_back(std::make_pair(&(*__x).first, &(*__x).second));
    return this->insert(__v);
  }

  template <template <class __Tp1, class __AllocTp1> class __SequenceCtrOut,
            template <class __Tp2, class __AllocTp2> class __SequenceCtrIn,
            class AllocatorOut, class AllocatorIn>
  bool insert_row(const __SequenceCtrOut<__SequenceCtrIn<_T_colspec,AllocatorIn>,
                        AllocatorOut>& _rows)
  {
    typedef typename __SequenceCtrOut<__SequenceCtrIn<_T_colspec,AllocatorIn>,
                                AllocatorOut>::const_iterator _OutCIt;
    _OutCIt __x;
    bool ret = true;
    
    for(__x = _rows.begin(); __x != _rows.end(); ++__x)
      if(!insert(*__x))
        ret = false;
    return ret;
  }

  virtual bool update(const std::vector<_T_ptrcolspec>& _row, _VDBL_rowid& _r)
        VDBL_PURE_VIRTUAL

  virtual bool remove(const _VDBL_rowid _ri) VDBL_PURE_VIRTUAL

  virtual bool has_col(const std::string& _C_n) const VDBL_PURE_VIRTUAL

  virtual const _VDBL_row& get_row(const _VDBL_rowid& _ri, bool& error) const
        VDBL_PURE_VIRTUAL

  virtual const _VDBL_row* get_row_ptr(const _VDBL_rowid& _ri) const
        VDBL_PURE_VIRTUAL

  virtual _VDBL_row& get_row(const _VDBL_rowid& _ri, bool& error)
        VDBL_PURE_VIRTUAL

  virtual const _VDBL_col& get_def(const _VDBL_colid& _ci, bool& error) const
        VDBL_PURE_VIRTUAL

  virtual _VDBL_col& get_def(const _VDBL_colid& _ci, bool& error)
        VDBL_PURE_VIRTUAL

  virtual bool has_def(const _VDBL_colid& _ci) const
        VDBL_PURE_VIRTUAL

  virtual bool has_col(const _VDBL_rowid& _ri, const _VDBL_colid& _ci) const
        VDBL_PURE_VIRTUAL

  virtual bool retrieve(const _VDBL_rowid& _r, const _VDBL_colid& _c,
                const _VDBL_context* _ctx, _VDBL_alltype_base*& _val) const
        VDBL_PURE_VIRTUAL

  virtual bool create_index(const std::string& _C_i, const index& i) VDBL_PURE_VIRTUAL
  virtual bool alter_index(const std::string& _C_i, const index& i) VDBL_PURE_VIRTUAL
  virtual bool drop_index(const std::string& _C_i) VDBL_PURE_VIRTUAL
};


class _VDBL_standardtable : 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<std::string, index> _T_indices;
  typedef std::map<_VDBL_rowid,_VDBL_row> _T_rows;

  friend class _VDBL_view;

public:
  typedef std::pair<std::string,_VDBL_col> _T_colspec;
  typedef std::pair<const std::string*,const _VDBL_col*> _T_ptrcolspec;
  
  typedef _Base::col_const_iterator col_const_iterator;

private:
  _T_cols _T_c;
  _T_defaults _T_d;
  _T_indices _T_i;
  _T_rows _T_r;

public:
  const std::type_info& get_colinfo(const std::string& _C_n,
                           std::triple<bool,_VDBL_colid,_VDBL_colflags>& _r) const
  {
    _T_cols::const_iterator _x;
    _x = _T_c.find(_C_n);
    if(_x != _T_c.end())
    {
      _T_defaults::const_iterator _y(_T_d.find((*_x).second));
      if(_y == _T_d.end())
        throw "_VDBL_table::get_colinfo: inconsistency - this can't happen!";
      _r = std::make_triple(true, (*_x).second, (*_y).second.first);
      return (*_y).second.second.return_type_id();
    }
    else
    {
      _r = std::make_triple(false, _VDBL_colid(), _VDBL_colflags());
      return typeid(void);
    }
  }

  _VDBL_colid get_col_id(const std::string& _C_n) const
  {
    _T_cols::const_iterator _x;
    _x = _T_c.find(_C_n);
    if(_x != _T_c.end())
      return (*_x).second;
    else
      return _VDBL_colid();
  }

  std::string get_col_name(const _VDBL_colid& _C_id) const
  {
    _T_cols::const_iterator _x, _e(_T_c.end());
    for(_x = _T_c.begin(); _x != _e; ++_x)
      if((*_x).second == _C_id)
        return (*_x).first;
    return std::string();
  }
  
public:
  _VDBL_standardtable() : _Base(), _T_c(), _T_d(), _T_i(), _T_r() {}
  _VDBL_standardtable(const _VDBL_standardtable& __t) : _Base(__t),
                                        _T_c(__t._T_c), _T_d(__t._T_d),
                                        _T_i(__t._T_i), _T_r(__t._T_r) {}

  template <template <class __Tp, class __AllocTp> class __SequenceCtr,
            class Allocator1>
  _VDBL_standardtable(const __SequenceCtr<std::triple<std::string, _VDBL_col,
              _VDBL_colflags>,Allocator1>& __cc) : _Base(), _T_c(),
                                                   _T_d(), _T_i(), _T_r()
  {
    typedef typename __SequenceCtr<std::triple<std::string, _VDBL_col,
                             _VDBL_colflags>,Allocator1>::const_iterator _CIt;

    for(_CIt __b = __cc.begin(); __b != __cc.end(); ++__b)
    {
      const std::string& _s((*__b).first);
      const _VDBL_col& _c((*__b).second);
      const _VDBL_colflags& _f((*__b).third);
      _T_cols::iterator __x(_T_c.find(_s));
      if(__x == _T_c.end())
      {
        _VDBL_colid _ci(get_colid());
        _T_c.insert(std::make_pair(_s,_ci));
        _T_d.insert(std::make_pair(_ci, std::make_pair(_c,_f)));
      }
      else
      {
        std::cerr << "Warning: Doubly defined column " << _s << " ignored!" <<
          std::endl;
      } 
    }
  }

  virtual ~_VDBL_standardtable() {}

  virtual _VDBL_table* new_copy() { return new _VDBL_standardtable(*this); }

  virtual void destroy_copy(_VDBL_table* t)
    { delete (_VDBL_standardtable*)t; }

  bool add_col(const std::string& _C_n, const _VDBL_col& __c,
               const _VDBL_colflags& __f)
  {
    _T_cols::iterator __x = _T_c.find(_C_n);
    if(__x == _T_c.end())
    {
      _VDBL_colid _ci(get_colid());
      _T_c.insert(std::make_pair(_C_n,_ci));
      _T_d.insert(std::make_pair(_ci,std::make_pair(__f,__c)));
      made_change();
      return true;
    }
    else
      return false;
  }

  bool modify_col(const std::string& _C_n, const _VDBL_col& __c,
                  const _VDBL_colflags& __f)
  {
    _T_cols::iterator __x(_T_c.find(_C_n));
    if(__x != _T_c.end())
    {
      _VDBL_colid _ci = (*__x).second;
      _T_defaults::iterator __y(_T_d.find(_ci));
      if(__y == _T_d.end())
        throw "_VDBL_standardtable::modify_col: inconsistency - this can't happen!";
      if(!VDBL_CMP_TYPEID((*__y).second.second.return_type_id(),
                          __c.return_type_id()))
        // must not change the basic type of the column
        return false;
      _T_d.erase(__y);
      _T_d.insert(std::make_pair(_ci,std::make_pair(__f,__c)));
      made_change();
      return true;
    }
    else
      return false;
  }

  bool modify_col(const std::string& _C_n, const _VDBL_col& __c)
  {
    _T_cols::iterator __x(_T_c.find(_C_n));
    if(__x != _T_c.end())
    {
      _VDBL_colid _ci = (*__x).second;
      _T_defaults::iterator __y(_T_d.find(_ci));
      if(__y == _T_d.end())
        throw "_VDBL_standardtable::modify_col: inconsistency - this can't happen!";
      if(!VDBL_CMP_TYPEID((*__y).second.second.return_type_id(),
                           __c.return_type_id()))
        // must not change the basic type of the column
        return false;
      _VDBL_colflags __f = (*__y).second.first;
      _T_d.erase(__y);
      _T_d.insert(std::make_pair(_ci,std::make_pair(__f,__c)));
      made_change();
      return true;
    }
    else
      return false;
  }

  bool modify_col(const std::string& _C_n, const _VDBL_colflags& __f)
  {
    _T_cols::iterator __x(_T_c.find(_C_n));
    if(__x != _T_c.end())
    {
      _VDBL_colid _ci = (*__x).second;
      _T_defaults::iterator __y(_T_d.find(_ci));
      if(__y == _T_d.end())
        throw "_VDBL_standardtable::modify_col: inconsistency - this can't happen!";
      _VDBL_col __c = (*__y).second.second;
      _T_d.erase(__y);
      _T_d.insert(std::make_pair(_ci,std::make_pair(__f,__c)));
      made_change();
      return true;
    }
    else
      return false;
  }

  bool drop_col(const std::string& _C_n)
  {
    _T_cols::iterator __x = _T_c.find(_C_n);
    if(__x != _T_c.end())
    {
      _VDBL_colid _ci = (*__x).second;
      _T_defaults::iterator __y(_T_d.find(_ci));
      if(__y == _T_d.end())
        throw "_VDBL_standardtable::drop_col: inconsistency - this can't happen!";
      // now remove all occurrences of _C_n in the rows
      _T_d.erase(__y);
      for(_T_rows::iterator __r = _T_r.begin(); __r != _T_r.end(); ++__r)
        (*__r).second.drop(_ci);
      made_change();
      return true;
    }
    else
      return false;
  }

  bool rename_col(const std::string& _C_old, const std::string& _C_new)
  {
    _T_cols::iterator __x = _T_c.find(_C_new);
    if(__x != _T_c.end())
      return false;       // new column name exists already
    __x = _T_c.find(_C_old);
    if(__x != _T_c.end())
    {
      _T_c.insert(std::make_pair(_C_new,(*__x).second));
      _T_c.erase(__x);
      made_change();
      return true;
    }
    else
      return false;      // old column name does not exist
  }

  bool insert(const std::vector<_T_ptrcolspec>& _row, _VDBL_rowid& _ri)
  {
    std::vector<_T_ptrcolspec>::const_iterator __x;
    bool ret = true;
    _VDBL_row _r;
    std::set<_VDBL_colid> _isdef;

    for(__x = _row.begin(); __x != _row.end(); ++__x)
    {
      const _T_ptrcolspec& _c(*__x);
      std::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.master_index)
        {
#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(_T_defaults::const_iterator __b = _T_d.begin(); __b != _T_d.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)
    {
      _ri = get_rowid();
      _T_r.insert(std::make_pair(_ri, _r));
      for(_T_indices::iterator i = _T_i.begin(); i != _T_i.end(); ++i)
        (*i).second.ins(_r, _ri);
      made_change();
    }
    return ret;
  }

  bool insert(const std::vector<_T_ptrcolspec>& _row)
  {
    _VDBL_rowid dummy;
    return insert(_row,dummy);
  }

  bool update(const std::vector<_T_ptrcolspec>& _row, _VDBL_rowid& _ri)
  {
    bool ret(true);
    _T_rows::iterator __xr = _T_r.find(_ri);
    if(__xr == _T_r.end())
      ret = false;
    else
    {
      std::vector<_T_ptrcolspec>::const_iterator __x;
      _VDBL_row _r((*__xr).second);
      std::set<_VDBL_colid> _isdef;
  
      for(__x = _row.begin(); __x != _row.end(); ++__x)
      {
        const _T_ptrcolspec& _c(*__x);
        std::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.master_index)
          {
  #if _VDBL_DEBUG
            std::cout <<
                  "We should check the constraints here in table::insert" <<
                  std::endl;
  #endif
          }
          _isdef.insert(_ru.second);
          _r.update(_ru.second,*_c.second);
        }
      }
      if(ret)
      {
        _T_r.erase(__xr);
        _T_r.insert(std::make_pair(_ri,_r));
        for(_T_indices::iterator i=_T_i.begin(); i != _T_i.end(); ++i)
        {
          (*i).second.del(_ri);
          (*i).second.ins(_r, _ri);
        }
        made_change();
      }
    }
    return ret;
  }

  bool remove(const _VDBL_rowid _ri)
  {
    _T_rows::iterator __x = _T_r.find(_ri);
    if(__x == _T_r.end())
      return false;
    else
    {
      _T_r.erase(__x);
      for(_T_indices::iterator i=_T_i.begin(); i != _T_i.end(); ++i)
        (*i).second.del(_ri);
      made_change();
      return true;
    }
  }

  bool has_col(const std::string& _C_n) const
  {
    _T_cols::const_iterator _x(_T_c.find(_C_n));
    return _x != _T_c.end();
  }

  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())
    {
      error = true;
      return ___empty_row_return;
    }
    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())
      return NULL;
    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())
    {
      error = true;
      return ___empty_row_return;
    }
    else
    {
      error = false;
      return (*_x).second;
    }
  }

  const _VDBL_col& get_def(const _VDBL_colid& _ci, bool& error) const
  {
    _T_defaults::const_iterator _x(_T_d.find(_ci));
    if(_x == _T_d.end() || !(*_x).second.first.has_default)
    {
      error = true;
      return ___empty_col_return;
    }
    else
    {
      error = false;
      return (*_x).second.second;
    }
  }

  _VDBL_col& get_def(const _VDBL_colid& _ci, bool& error)
  {
    _T_defaults::iterator _x(_T_d.find(_ci));
    if(_x == _T_d.end() || !(*_x).second.first.has_default)
    {
      error = true;
      return ___empty_col_return;
    }
    else
    {
      error = false;
      return (*_x).second.second;
    }
  }

  virtual bool has_def(const _VDBL_colid& _ci) const
  {
    _T_defaults::const_iterator _x(_T_d.find(_ci));
    if(_x == _T_d.end() || !(*_x).second.first.has_default)
      return false;
    else
      return true;
  }

  virtual bool has_col(const _VDBL_rowid& _ri, const _VDBL_colid& _ci) const
  {
    bool error;
    const _VDBL_row& _r(get_row(_ri, error));
    if(error)
      return false;
    return _r.has_col(_ci);
  }

  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;

    _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);
      _col2.setcontext(_ctx, &_row);
      _col2.def_copy(_val);
      return true;
    }
    else
    {           // row contains this col
      _col.setcontext(_ctx, &_row);
      _col.get_copy(_val);
      return true;
    }
  }

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

    _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);
      _col2.setcontext(_ctx, &_row);
      _col2.def_copy(_val);
      return true;
    }
    else
    {           // row contains this col
      _col.setcontext(_ctx, &_row);
      _col.get_copy(_val);
      return true;
    }
  }

  void update_index(index& i)
    {
      i.clear();
      _T_rows::const_iterator __r, __e(_T_r.end());
      for(__r = _T_r.begin(); __r != __e; ++__r)
        i.ins((*__r).second, (*__r).first);
    }
  bool create_index(const std::string& _C_i, const index& i)
    { _T_indices::iterator _i = _T_i.find(_C_i);
      if(_i != _T_i.end())
        return false;
      else
      {
        _T_i.insert(std::make_pair(_C_i, i));
        update_index(_T_i[_C_i]);
        return true;
      }
    } 
  bool alter_index(const std::string& _C_i, const index& i)
    { _T_indices::iterator _i = _T_i.find(_C_i);
      if(_i == _T_i.end())
        return false;
      else
      {
        _T_i.erase(_i);
        _T_i.insert(std::make_pair(_C_i, i));
        update_index(_T_i[_C_i]);
        return true;
      }
    }
  bool drop_index(const std::string& _C_i)
    { _T_indices::iterator _i = _T_i.find(_C_i);
      if(_i == _T_i.end())
        return false;
      else
      {
        _T_i.erase(_i);
        return true;
      }
    }

public:
  std::pair<std::string,_VDBL_colid> _next_col(
                        const std::pair<std::string,_VDBL_colid>& _ci) const
  {
    _T_cols::const_iterator __x = _T_c.find(_ci.first);
    if(__x == _T_c.end())
      return std::make_pair("", _VDBL_colid());
    ++__x;
    if(__x == _T_c.end())
      return std::make_pair("", _VDBL_colid());
    else
      return *__x;
  }

  virtual std::pair<std::string,_VDBL_colid> _prev_col(
                         const std::pair<std::string,_VDBL_colid>& _ci) const
  {
    _T_cols::const_iterator __x = _T_c.find(_ci.first);
    if(__x == _T_c.end())
      return std::make_pair("", _VDBL_colid());
    --__x;
    if(__x == _T_c.end())
      return std::make_pair("", _VDBL_colid());
    else
      return *__x;
  }

  col_const_iterator col_begin() const
        { if(_T_c.empty())
            return col_const_iterator(this, "", 0);
          else
            return col_const_iterator(this, *_T_c.begin());
        }
  col_const_iterator col_end() const
        { return col_const_iterator(this, "", 0); }

  _VDBL_rowid _next_row(const _VDBL_rowid& _ci) const
  {
    _T_rows::const_iterator __x = _T_r.find(_ci);
    if(__x == _T_r.end())
      return _VDBL_rowid();
    ++__x;
    if(__x == _T_r.end())
      return _VDBL_rowid();
    else
      return (*__x).first;
  }

  _VDBL_rowid _prev_row(const _VDBL_rowid& _ci) const
  {
    _T_rows::const_iterator __x = _T_r.find(_ci);
    if(__x == _T_r.end())
      return _VDBL_rowid();
    --__x;
    if(__x == _T_r.end())
      return _VDBL_rowid();
    else
      return (*__x).first;
  }

  row_const_iterator row_begin() const
        { if(_T_r.empty())
            return row_const_iterator(this, 0);
          else
            return row_const_iterator(this, _T_r.begin()->first);
        }
  row_const_iterator row_end() const
        { return row_const_iterator(this, 0); }

  row_const_iterator* row_iterator_copy(const row_const_iterator& r) const
        { return new row_const_iterator(r); }
};


class table : public _VDBL_table
{
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;
};


class col_spec : public _VDBL_table::_T_colspec
{
private:
  typedef _VDBL_table::_T_colspec _Base;

public:

  col_spec(const std::string& __s, const _VDBL_col& __c)
        : _Base(std::make_pair(__s,__c)) {}
  
  col_spec(const char* __s, const _VDBL_col& __c)
        : _Base(std::make_pair(std::string(__s),__c)) {}
  

  template <class _CR>
  col_spec(const std::string& __s, const _CR& __c)
        : _Base(std::make_pair(__s,_VDBL_col(__c))) {}

  template <class _CR>
  col_spec(const char* __s, const _CR& __c)
        : _Base(std::make_pair(std::string(__s),_VDBL_col(__c))) {}

  col_spec(const col_spec& __c) : _Base(__c) {}

  virtual ~col_spec() {}
};


class standard_table : public _VDBL_standardtable
{
private:
  typedef _VDBL_standardtable _Base;
public:
  typedef _VDBL_colflags colflags;
  typedef __VDBL_index index;
  typedef _VDBL_context context;
  typedef _VDBL_col def;

  standard_table() : _Base() {}
  standard_table(const standard_table& __t) : _Base(__t) {}

  template <template <class __Tp, class __AllocTp> class __SequenceCtr,
            class Allocator1>
  standard_table(const __SequenceCtr<std::triple<std::string, _VDBL_col,
              _VDBL_colflags>,Allocator1>& __cc) : _Base(__cc) {}

  virtual ~standard_table() {}

  virtual standard_table* new_copy() { return new standard_table(*this); }

  virtual void destroy_copy(standard_table* t) { delete (standard_table*)t; }


  template <class _CB>
  bool add_col(const char* _C_n, const _CB& __c, const _VDBL_colflags& __f)
  { return _Base::add_col(std::string(_C_n), _VDBL_col(__c), __f); }

  template <class _CB>
  bool add_col(const std::string& _C_n, const _CB& __c,
               const _VDBL_colflags& __f)
  { return _Base::add_col(_C_n, _VDBL_col(__c), __f); }

  bool insert(const std::vector<_T_ptrcolspec>& _row, rowid& _ri)
  { return _Base::insert(_row, _ri); }

  bool insert(const std::vector<_T_ptrcolspec>& _row)
  { rowid dummy; return _Base::insert(_row, dummy); }

  template <template <class __Tp, class __AllocTp> class __SequenceCtr,
            class Allocator1>
  bool insert_row(const __SequenceCtr<col_spec,Allocator1>& _row, rowid& _ri)
  {
    typename __SequenceCtr<col_spec,Allocator1>::const_iterator __x;
    std::vector<_T_ptrcolspec> __v;
    __v.reserve(_row.size());
    for(__x = _row.begin(); __x != _row.end(); ++__x)
      __v.push_back(std::make_pair(&(*__x).first, &(*__x).second));
    return this->insert(__v, _ri);
  }

  template <template <class __Tp, class __AllocTp> class __SequenceCtr,
            class Allocator1>
  bool insert_row(const __SequenceCtr<col_spec,Allocator1>& _row)
  {
    _VDBL_colid dummy;
    return this->insert_row(_row, dummy);
  }

  template <template <class __Tp1, class __AllocTp1> class __SequenceCtrOut,
            template <class __Tp2, class __AllocTp2> class __SequenceCtrIn,
            class AllocatorOut, class AllocatorIn>
  bool insert_row(const __SequenceCtrOut<__SequenceCtrIn<col_spec,AllocatorIn>,
                        AllocatorOut>& _rows)
  {
    typedef typename __SequenceCtrOut<__SequenceCtrIn<col_spec,AllocatorIn>,
                                AllocatorOut>::const_iterator _OutCIt;
    _OutCIt __x;
    bool ret = true;
    
    for(__x = _rows.begin(); __x != _rows.end(); ++__x)
      if(!insert_row(*__x))
        ret = false;
    return ret;
  }
  
  bool update(const std::vector<_T_ptrcolspec>& _row, _VDBL_rowid& _ri)
  {
    return _Base::update(_row, _ri);
  }

  template <template <class __Tp, class __AllocTp> class __SequenceCtr,
            class Allocator1>
  bool update_row(const __SequenceCtr<col_spec,Allocator1>& _row, rowid& _ri)
  {
    typename __SequenceCtr<col_spec,Allocator1>::const_iterator __x;
    std::vector<_T_ptrcolspec> __v;
    __v.reserve(_row.size());
    for(__x = _row.begin(); __x != _row.end(); ++__x)
      __v.push_back(std::make_pair(&(*__x).first, &(*__x).second));
    return this->update(__v, _ri);
  }

  const row& get_row(const rowid& _ri, bool& error) const
  { return *(row*)&_Base::get_row(_ri,error); }

  const row* get_row_ptr(const rowid& _ri) const
  { return (const row*)_Base::get_row_ptr(_ri); }

  row& get_row(const rowid& _ri, bool& error)
  { return *(row*)&_Base::get_row(_ri,error); }


  colid get_colid(const std::string& _C_n) const
  { return _Base::get_col_id(_C_n); }

  colid get_colid(const char* _C_n) const
  { return _Base::get_col_id(std::string(_C_n)); }
  
  std::string get_colname(const colid& _C_i) const
  { return _Base::get_col_name(_C_i); }

  row_const_iterator row_begin() const { return _Base::row_begin(); }
  row_const_iterator row_end() const { return _Base::row_end(); }
};

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

__VDBL_END_NAMESPACE

#endif /* __VDBL_TABLE_H */

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

---