Tanl Linguistic Pipeline

search/ixe/Common/table.h

/*
**      IXE
**      Common/table.h: database tables
** ----------------------------------------------------------------------
**
**  This file is part of Tanl.
**
**  Tanl is free software; you can redistribute it and/or modify it
**  under the terms of the GNU General Public License, version 3,
**  as published by the Free Software Foundation.
**
**  Tanl 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
**  GNU General Public License for more details.
**
**  You should have received a copy of the GNU General Public License
**  along with this program.  If not, see <http://www.gnu.org/licenses/>.
**  ----------------------------------------------------------------------
*/

#ifndef IXE_TABLE_H
#define IXE_TABLE_H

// Settings
#include "platform.h"

// standard
#include <sys/stat.h>           /* for stat, S_IROTH, ... */

// Tokyo Cabinet
#include "Store/tcbdb.h"
#include "Store/tcfdb.h"        // for metadata

// local
#include "include/ixe.h"
#include "include/error.h"
#include "include/Enumerator.h"
#include "Common/Lock.h"
#include "Common/metaclass.h"
#include "Common/util.h"
#include "Index/Indexer.h"
#include "io/File.h"

using namespace IXE::io;

inline bool tcbdbcurmatch(BDBCUR* dbc, const void* data, int size)
{
  if (!tcbdbcurjump(dbc, data, size))
    return 0;
  int ksize;
  const void* kdata = tcbdbcurkey3(dbc, &ksize);
  return (ksize == size && !memcmp(kdata, data, size));
}

namespace IXE {

char const      Bext[] = "tcb"; // B+ tree DB file extension
char const      Hext[] = "tch"; // Hash DB file extension
char const      Fext[] = "tcf"; // Fixed-length DB file extension
char const      Uext[] = "unv"; // Uninverted facet values

struct DBT {
  DBT() : data(0), size(0), len(0) { }
  DBT(int len) : data(calloc(len, 1)), size(0), len(len) { }

  const void*   data;
  int           size;           
  int           len;            
};

bool realloc_record(DBT& record, ulong len);
void fappend(char* f1, char* f2);

// WARNING!!! This assumes littleEndian ordering on keys
void inline incrementKey(DBT& key_)
{
  int n = key_.size, i = 0;
  byte* keyData = (byte*)key_.data;
  while (i < n && !++keyData[i++]) ;
}

void inline decrementKey(DBT& key_)
{
  int n = key_.size, i = 0;
  byte* keyData = (byte*)key_.data;
  while (i < n && !keyData[i++]--) ;
}


//=============================================================================
//=============================================================================

class SubField {
public:
  SubField(Field* field, TCBDB* table) :
    field(field), table(table) { }

  Field*        field;
  TCBDB*        table;
};

//=============================================================================
//=============================================================================

class MappedSubField {
public:
  MappedSubField(Field* field, mappedFile* table) :
    field(field), table(table) { }

  Field*        field;
  mappedFile*   table;
};

class SubCursor
{
public:
  SubCursor(TCBDB* db, MetaClass* mc) {
    cursor = tcbdbcurnew(db);
    mc->createInstance((byte*)obj); // initialize object
  }

  ~SubCursor() { tcbdbcurdel(cursor); }

private:
  BDBCUR*       cursor;
  double        obj[0];         // double for proper alignment
};

//=============================================================================
struct NoDoc : std::unary_function<DocID, bool>
{
  bool  operator ()(DocID a) const { return false; }
};

#define DocIDof(obj)            (*(DocID*)FieldOf(obj, primaryField))

//=============================================================================
//=============================================================================

class DynamicTable;

template <class T, class IndexerClass = TextIndexer>
class Table : public Indexable<T>
{
  friend class DynamicTable;
  friend class Cursor;          // Solaris

public:

  typedef T             ItemType;
  typedef Table<T, IndexerClass>        TableType;

  enum DbType {
    Btree,              
    Hash,               
    FixLen              
  };

  MetaClass*            metaClass;
  IndexerClass*         fulltextIndexer; 
  std::vector<MappedSubField>   mappedFields; 
  std::vector<SubField> subFields; 

  char const*           tableName() { return table_name; }

protected:

  char const*           table_name;
# ifndef noMETADATA
  TCFDB*                metadata; 
# endif
  TCBDB*                primary; 
  TCHDB*                unique; 
  std::vector<TCBDB*>   keys;   
# ifdef FACETED_SEARCH
  std::vector<TCBDB*>   facets; 
# endif
  DBT                   key;    
  DBT                   row;    
  ulonglong             keyID;  
  DocID                 lastID; 
  bool                  isNew; 
  Count                 nFulltext; 
  Count                 nRows;  
  Count                 nUnique; 
  Field*                autoincrementField;
  Field*                externalField;
  Field*                primaryField;
  Field*                uniqueField;
  Size                  maxRowSize; 
  bool                  master; 
  DbType                dbType;

  // common initialization
  void          open(char const* basename, bool readonly,
                     DbType dbType, Size uniqueElements = 0,
                     int cacheLeaves = 0, int cacheNodes = 0);

  byte*         mappedField(Field* fd, DocID id) {
    return (byte*)mappedFields[fd->position].table->begin() + (id - 1) * fd->itemSize();
  }

  public:

  Table(char const* pathname, bool readonly = false,
        MetaClass* meta = CLASS_OF(T),
        Size cacheSize = 0,
        DbType DBtype = Btree, Size uniqueElements = 0);

  Table(Table const& table) :
    table_name(::strdup(table.table_name)),
    metaClass(table.metaClass),
    primary(table.primary),
    unique(table.unique),
    keys(table.keys),
    lastID(table.lastID),       // can't keep synchronized with original
    isNew(table.isNew),
    nFulltext(table.nFulltext),
    nRows(table.nRows),
    nUnique(table.nUnique),
    autoincrementField(table.autoincrementField),
    externalField(table.externalField),
    primaryField(table.primaryField),
    uniqueField(table.uniqueField),
    fulltextIndexer(table.fulltextIndexer),
    mappedFields(table.mappedFields),
    subFields(table.subFields),
    maxRowSize(table.maxRowSize),
    master(false)
  {
    Size keySize = table.key.len;
    key.data = (keySize <= sizeof(keyID)) ? (char *)&keyID : malloc(keySize);
    key.size = 0;
    key.len = keySize;
  }

  Table(Table const& table, bool readonly) :
    table_name(::strdup(table.table_name)),
    metaClass(table.metaClass),
    isNew(false),
    master(false)
  {
    char const* filename = ::strrchr(table_name, PATH_SEPARATOR);
    string dirname(table_name, filename ? filename - table_name : 0);
    filename = filename ? filename + 1 : table_name;
    if (!dirname.empty() && !io::File(dirname).exists())
      throw TableError("Non existing directory: " + dirname);

    open(filename, readonly, table.dbType);
    free((void*)filename);
  }

  Table() { }

  ~Table();

  void                  noFulltextIndexing() {
    delete fulltextIndexer;
    fulltextIndexer = 0;
  }

  void                  commit() {
    tcbdbsync(primary);         // FIXME: Btree
    vector<TCBDB*>::const_iterator index = keys.begin();
    for (Field* fd = this->metaClass->fields(); fd != NULL; fd = fd->next)
      if (fd->indexType & Field::indexed) {
        if (fd->indexType == Field::unique ||
            fd->indexType == Field::uniqueHash)
          tchdbsync((TCHDB*)*index);
        else
          tcbdbsync(*index);
        index++;
      }
#   ifdef FACETED_SEARCH
    for (std::vector<TCBDB*>::const_iterator fit = facets.begin();
         fit != facets.end();
         fit++)
      tcbdbsync(*fit);
#   endif
    if (fulltextIndexer)
      fulltextIndexer->commit();
  }

  bool                  insert(ItemType* obj);

  bool                  remove(ItemType* obj);

  // cannot just specialize Table<AnyObject>::insert, because it produces
  // multiple definitions
  bool                  insertDynamic(AnyObject* obj);

  void                  stopWords(StopWords* stopWords);

  void                  stopWords(char const* fieldname, StopWords* stopWords);

  T                     operator [](int i) const {
    Cursor cursor((TableType*)this);
    T* obj = cursor.get((DocID)i);
    return obj ? *obj : T();
  }

  DocID                 getDocID(const char* field, const char* value);

  DocID                 getDocID(ItemType* obj);

# ifndef noMETADATA

  void                  Metadata(byte* obj, MetaClass* metadataClass);

  void                  Metadata(MetaClass* metadataClass, byte* obj);

# endif

  Count                 size() { return nRows; }

  DocID                 merge(TableType* table2, Remap& remap) {
    return merge(table2, NoDoc(), remap);
  }

  // This could be defined outside this class template as follows:
  //
  // template <class T, class I>
  // template <class DeleteTest>
  // void Table<T, I>::merge(Table<T, I>* table2, DeleteTest delendum) { ... }
  //
  // but VC7 does not understand it.
  // @see ANSI C++, section 14.5.2
  // (http://www.comnets.rwth-aachen.de/doc/c++std/template.html)

  template<class DeleteTest>
  DocID                 merge(TableType* table2, DeleteTest delendum,
                              Remap& remap) {
    TCBDB* primary2 = table2->Primary();

    if (unique) {
      // objects in two tables may overlap.
      // Version in table2 overrides the copy in this table.

      // allocate buffer for row record
      if (realloc_record(row, maxRowSize))
        throw MemoryError("Out of memory");
      
      BDBCUR* cursor2 = tcbdbcurnew(primary2);
      for (bool hasNext = tcbdbcurfirst(cursor2);
           hasNext && (key.data = tcbdbcurkey3(cursor2, &key.size));
           hasNext = tcbdbcurnext(cursor2)) {
        DocID docID = *(DocID*)(key.data);
        if (!delendum(docID)) {
          ItemType obj;         // FIXME: obj might need its own MetaClass
          int row2Size;
          table2->fetch((byte*)&obj, (byte*)tcbdbcurval3(cursor2, &row2Size));

          // do something similar to insert(), except fulltext indexing.
          DocID oldDocID = getDocID(&obj);
          if (oldDocID != noDocID) {
            // assigning to remap[docID] the number of docs skipped
            // till now, including the actual
            remap[docID] = remap.size();
          } else {
            // assign new ID
            DocIDof(&obj) = docID = ++lastID;
            // prepare key
            key.size = primaryField->storeKey((byte*)key.data, (byte*)&docID);
            insertRow(&obj);
          }
          // clear object, to avoid problem with its destructor
          obj._clear();
        } else {
          // Store deleted items in remap:
          // assign to remap[docID] the number of docs skipped so far,
          // including the current.
          remap[docID] = remap.size();
        }
      }
      tcbdbcurdel(cursor2);
    } else {
      // add primary index entries
      DocID id_offset;
      LastID(&id_offset);
      BDBCUR* cursor2 = tcbdbcurnew(primary2);
      for (bool hasNext = tcbdbcurfirst(cursor2);
           hasNext && (key.data = tcbdbcurkey3(cursor2, &key.size));
           hasNext = tcbdbcurnext(cursor2)) {
        DocID docID = *(DocID*)(key.data);
        if (!delendum(docID)) {
          DBT row2;
          row2.data = (byte*)tcbdbcurval3(cursor2, &row2.size);
          // update DocID
          *(DocID*)(key.data) += id_offset;
          *(DocID*)(row2.data) += id_offset;
          tcbdbput(primary, key.data, key.size, row2.data, row2.size);
          lastID++;
        }
      }
      tcbdbcurdel(cursor2);

      // add secondary indexes and mapped references
      int index = 0;
      int index2 = 0;
      int index3 = 0;
      for (Field* fd = this->metaClass->fields(); fd != NULL; fd = fd->next) {
        // advance to next indexed field
        if (fd->indexType & Field::indexed) {
          TCBDB* bdb = keys[index++];
          TCBDB* bdb2 = table2->Keys()[index2++];
          BDBCUR* scursor = tcbdbcurnew(bdb);
          BDBCUR* scursor2 = tcbdbcurnew(bdb2);
          for (bool hasNext = tcbdbcurfirst(scursor2);
               hasNext && (key.data = tcbdbcurkey3(scursor2, &key.size));
               hasNext = tcbdbcurnext(scursor2)) {
            DocID docID = *(DocID*)(key.data);
            if (!delendum(docID)) { // skip documents to delete
              DBT row2;
              row2.data = (byte*)tcbdbcurval3(scursor2, &row2.size);
              // update DocID
              *(DocID*)(key.data) += id_offset;
              // DocIDs are stored in increasing order
              tcbdbputdup(bdb, row2.data, row2.size, key.data, key.size);
            } else {
              // storing of delete items in remaps
              // assigning to remap[docID] the number of docs skipped
              // till now, including the actual
              remap[docID] = remap.size();
            }
          }
          tcbdbcurdel(scursor);
          tcbdbcurdel(scursor2);
        } else if (fd->indexType == Field::mapped) {
          // merge mapped reference fields
          // FIXME: should skip deleted objects!!!!
          char mapfile1[PATH_MAX];
          char mapfile2[PATH_MAX];
          sprintf(mapfile1, "%s/%s.%s", table_name, fd->name, Fext);
          sprintf(mapfile2, "%s/%s.%s", table2->table_name, fd->name, Fext);
          fappend(mapfile1, mapfile2);
#       ifdef FACETED_SEARCH
        } else if (fd->indexType == Field::facet) {
          // just copy forward lists into the first table.
          // ColumnIndexer will later fix the term IDs according to the
          // Lexicon of the merged table.
          // FIXME: discards any duplicate documents in second table.
          TCBDB* bdb = Facets()[index3];
          // remember how many in first index
          ColumnIndexer& ci = fulltextIndexer->indexer[fd->position];
          ci.partialCounts.push_back(tcbdbrnum(bdb));
          TCBDB* bdb2 = table2->Facets()[index3++];
          BDBCUR* cur2 = tcbdbcurnew(bdb2);
          byte* key;
          int klen;
          tcbdbcurfirst(cur2);
          while ((key = (byte*)tcbdbcurkey(cur2, &klen))) {
            int vlen;
            byte* value = (byte*)tcbdbcurval(cur2, &vlen);
            if (value && tcbdbvnum(bdb, key, klen) == 0)
              tcbdbput(bdb, key, klen, value, vlen);
            free(value);
            free(key);
            tcbdbcurnext(cur2);
          }
          tcbdbcurdel(cur2);
#       endif
        }
      }
    }
    return lastID;
  }

  std::vector<TCBDB*>&  Keys() { return keys; }
# ifdef FACETED_SEARCH
  std::vector<TCBDB*>&  Facets() { return facets; }
# endif
  TCBDB*                Primary() const { return primary; }
  DBT&                  Key() { return key; }
  Field*                PrimaryField() const { return primaryField; } 
  Size                  MaxRowSize() const { return maxRowSize; }

  //===========================================================================
  //===========================================================================

  // This could be defined outside this class template as follows:
  //
  // template <class T, IndexerClass>
  // class Table<T, IndexerClass>::Cursor { ... }
  //
  // but VC7 does not understand it.
  // @see ANSI C++, section 14.5.2
  // (http://www.comnets.rwth-aachen.de/doc/c++std/template.html)

  class Cursor : public Enumerator<ItemType*> {
  protected:
    ItemType            object;
    Table<ItemType, IndexerClass>*      table;
    // may have several open Cursors: each one needs its own DBTs
    DBT                 key_;
    DBT                 row_;
    Field*              field;          
    Field*              fieldStart;     
    Field*              fieldEnd;       

  private:
    BDBCUR*     dbc;
    TCBDB*      db;
    ulonglong   keyBuf;         // optimize short keys
    ulonglong   rowBuf;         // optimize short values

    void init(Field* field) {
      fieldStart = table->metaClass->fields();
      fieldEnd = 0;
      if (field) {
        this->field = field;
        // find key
        std::vector<TCBDB*>::const_iterator keys = table->Keys().begin();
        for (Field* fd = table->metaClass->fields(); fd; fd = fd->next) {
          if (fd == field) {
            if (fd->indexType == Field::indexed) {
              db = *keys;
              break;
            } else
              throw TableError(string("Not an indexed field: ") + field->name);
          }
        }
        if (db) {
          // allocate BDB key/value pair
          // key can be any value for field
          Size fieldSize = field->maxLength() * field->size();
          if (fieldSize <= sizeof(keyBuf))
            key_.data = (char*)&keyBuf;
          // must allocate, since range searches may overwrite key
          else if (realloc_record(key_, fieldSize))
            throw MemoryError("Out of memory");
          key_.size = key_.len = fieldSize;
          // value is primary key
          Size rowSize = table->Key().len;
          row_.data = (rowSize <= sizeof(rowBuf)) ?
            (char*)&rowBuf : (char*)malloc(rowSize);
          row_.size = row_.len = rowSize;
        } else
          throw TableError(string("No such field: ") + field->name);
      } else {
        this->field = table->PrimaryField();
        db = table->Primary();
        Size keySize = table->Key().len;
        // allocate row of max size
        if (realloc_record(row_, table->maxRowSize))
          throw MemoryError("Out of memory");
        row_.size = 0;
        row_.len = table->maxRowSize;
        // allocate key
        key_.data = (keySize <= sizeof(keyBuf)) ?
          (char*)&keyBuf : (char*)malloc(keySize);
        ::memset((void*)key_.data, 0, keySize);
        key_.size = key_.len = keySize;
      }
      dbc = tcbdbcurnew(db);
    }

  public:

    Cursor(TableType* table, Field* field = 0) : table(table) {
      init(field);
    }

    Cursor(TableType* table, char const* name) : table(table) {
      init(table->metaClass->find(name));
    }

    ~Cursor() {
      tcbdbcurdel(dbc);
      if (key_.data != &keyBuf)
        free((void*)key_.data); // allocated with malloc/realloc
      if (row_.data != &rowBuf)
        free((void*)row_.data); // allocated with malloc/realloc
      // clear object, to avoid problem with its destructor
      object._clear();
    }

    void                setKey(int8 const value) {
      field->setKey((byte*)key_.data, value);
    }

    void                setKey(char const* value) {
      field->setKey((byte*)key_.data, (byte*)value, (Size&)key_.size, (Size)key_.len);
    }

    void                setKey(byte const* value) {
      field->setKey((byte*)key_.data, value, (Size&)key_.size, (Size)key_.len);
    }

    DocID               getKey() {
      DocID docID;
      field->fetchKey((byte*)&docID, (byte*)row_.data);
      return docID;
    }

    void                getPrimaryKey(byte* key) {
      table->primaryField->fetchKey(key, getRowData());
    }

    byte*               fetchRowData() {
      DBT row;
      row.data = tcbdbcurval3(dbc, &row.size);
      memcpy((void*)row_.data, row.data, row.size);
      row_.size = row.size;
      return (byte*)row_.data;
    }

    bool                MoveNext() {
      // Must determine whether cursor must be initialized, using dbc->id
      if ((dbc->id < 1) ? tcbdbcurfirst(dbc) : tcbdbcurnext(dbc)) {
        fetchRowData();
        return true;
      }
      return false;
    }

    byte*               NextSame() {
      if (dbc->id < 1) {
        // not initialized yet
        if (!tcbdbcurjump(dbc, key_.data, key_.size))
          return 0;
      } else if (!tcbdbcurnext(dbc))
        return 0;
      DBT next;
      next.data = tcbdbcurkey3(dbc, &next.size);
      return (key_.size == next.size && !memcmp(key_.data, next.data, next.size)) ?
          fetchRowData() : 0;
    }

    T*                  first() {
      return tcbdbcurfirst(dbc) ? get() : 0;
    }

    T*                  last() {
      return tcbdbcurlast(dbc) ? get() : 0;
    }

    T*                  previous() {
      return tcbdbcurprev(dbc) ? get() : 0;
    }

    virtual T*          get() {
      if (field != table->PrimaryField()) {
        // fetch row from primary table
        TCBDB* dbp = table->Primary();
        const void* row;
        int rowSize;
        if (!(row = tcbdbget3(dbp, row_.data, row_.size, &rowSize)))
          return 0;
        // allocate record of suitable size
        if (realloc_record(row_, rowSize))
          throw MemoryError("Out of memory");
        ::memcpy((void*)row_.data, row, rowSize);
        row_.size = rowSize;
      } else
        fetchRowData();
      byte* value = (byte*)row_.data;
      DocID id;
      getPrimaryKey((byte*)&id);
      for (Field* fd = fieldStart; fd != fieldEnd; fd = fd->next) {
        byte* field = FieldOf(&object, fd);
        if (fd->isReference()) {
          if (fd->indexType == Field::mapped) {
            byte* mf = table->mappedField(fd, id);
            fd->fetch(field, mf);
          } else {
            // reference field
            FOR_EACH (std::vector<SubField>, table->subFields, sit) {
              if (sit->field == fd) {
                Field* sf = sit->field;
                TCBDB* dbp = sit->table;
                const void* subField;
                int subFieldSize;
                if (!(subField = tcbdbget3(dbp, &id, sizeof(id), &subFieldSize)))       
                  throw TableError(string("Failed fetching field from: ")
                                   + sf->name);
                sf->fetch((byte*)subField, value);
                break;
              }
            }
          }
        } else
          fd->fetch(field, value);
      }
      return &object;
    }

    byte*               getKeyData() { return key_.data; }

    byte*               getRowData() { return (byte*)row_.data; }

    int                 size() const {
      return tcbdbvnum(db, key_.data, key_.size);
    }

    byte*               getNext() {
      return ((dbc->id < 1) ? tcbdbcurfirst(dbc) : tcbdbcurnext(dbc)) ?
        fetchRowData() : 0;
    }

    byte*               getPrevious() {
      return tcbdbcurprev(dbc) ? fetchRowData() : 0;
    }

    T*                  get(DocID docID) {
      field->setKey((byte*)key_.data, docID);
      return tcbdbcurmatch(dbc, key_.data, key_.size) ? get() : 0;
    }

    T*                  get(byte const* key) {
      setKey(key);              // set key to value
      return tcbdbcurmatch(dbc, key_.data, key_.size) ? get() : 0;
    }

    T*                  get(ItemType* obj) {
      byte* key = FieldOf(obj, field);
      return get(key);
    }

    byte*               getEQ() {
      return tcbdbcurmatch(dbc, key_.data, key_.size) ? fetchRowData() : 0;
    }

    byte*               getGE() {
      return tcbdbcurjump(dbc, key_.data, key_.size) ? fetchRowData() : 0;
    }

    byte*               getGT() {
      // Trick: increment key
      incrementKey(key_);
      return tcbdbcurjump(dbc, key_.data, key_.size) ? fetchRowData() : 0;
    }

    byte*               getLE() {
      return tcbdbcurjumpback(dbc, key_.data, key_.size) ? fetchRowData() : 0;
    }

    byte*               getLT() {
      // Trick: decrement key
      decrementKey(key_);
      return tcbdbcurjumpback(dbc, key_.data, key_.size) ? fetchRowData() : 0;
    }

    ItemType* operator	->() { return &object; }

    bool                update() {
      Field* primaryField = table->PrimaryField();
      // prepare key
      DBT& key = table->Key();
      key.size = primaryField->storeKey((byte*)key.data,
                                        FieldOf(&object, primaryField));
      table->insertRow(&object);
      return true;
    }
  };

  DocID                 LastID() { return lastID; }

  void                  LastID(DocID lastID) { this->lastID = lastID; }

protected:
  Lock  mutex;

  void  close();

  void                  LastID(DocID* lastID) {
    Cursor cursor(this);
    if (cursor.last())
      *lastID = cursor.getKey();
  }

  void                  fetch(byte* obj, byte* row) {
    DocID docID;
    if (!mappedFields.empty())
      primaryField->fetchKey((byte*)&docID, row);
    // FIXME: table metaClass might differ from object->metaClass()
    for (Field* fd = metaClass->fields(); fd; fd = fd->next) {
      byte* field = FieldOf(obj, fd);
      if (fd->indexType == Field::mapped) {
        byte* mf = mappedField(fd, docID);
        fd->fetch(field, mf);
      } else
        fd->fetch(field, row);
    }
  }

  void                  removeSecondary(ItemType const& obj);

  void                  insertRow(ItemType* obj);
};

//=============================================================================
//=============================================================================

class DynamicTable : public Table<AnyObject>
{
public:

  DynamicTable(char const* table_name, MetaClass* metaClass,
               bool readonly = true) :
    Table<AnyObject>(table_name, readonly, metaClass) { }

  bool insert(AnyObject* obj);

  class Cursor : public Table<AnyObject>::Cursor
  {
  public:
    Cursor(DynamicTable* table, Field* field = 0) :
      Table<AnyObject>::Cursor(table, field) {
      object = AnyObject(table->metaClass);
    }

    virtual AnyObject*                  get() {
      if (field != table->PrimaryField()) {
        // fetch row from primary table
        TCBDB* dbp = table->Primary();
        const void* row;
        int rowSize;
        if (!(row = tcbdbget3(dbp, row_.data, row_.size, &rowSize)))
          return 0;
        // allocate record of suitable size
        if (realloc_record(row_, rowSize))
          throw MemoryError("Out of memory");
        ::memcpy((void*)row_.data, row, rowSize);
        row_.size = rowSize;
      } else
        fetchRowData();
      byte* field = (byte*)row_.data;
      std::vector<Item*>::const_iterator item = object.values.begin();
      Field* fd = table->metaClass->fields();
      for ( ; fd != fieldStart; fd = fd->next)
        item++;
      for ( ; fd != fieldEnd; fd = fd->next)
        field = fd->fetch((*item++)->value(), field);
      return &object;
    }
  };
};

} // namespace IXE

// Mechanism to keep .cpp file separate
# ifndef NON_TEMPLATE
# include "table.cpp"
# endif

#endif // IXE_TABLE_H

 

Copyright © 2005-2011 G. Attardi. Generated on 4 Mar 2011 by doxygen 1.6.1.