class.h

一个不错的fastdb使用例子

   * Fetch record from the database
   * This method performs interation thtough all components in one scope
   * and recursively invoke itself for structure and array components.      
   * @param dst pointer to the application object into which record is extract
   * @param src image of the object in the database
   */
  void fetchRecordFields(byte* dst, byte* src);

  /**
   * Adjust references in all fetched records (current records in all opened cursors)
   * when database was reallocated.
   * @param record pointer to the application object which references should be adjusted
   * @param base new address of memory mapping 
   * @param size database isze before extension
   * @paramdifference between old and new addresses of memory mapping obejct location.
   */
  void adjustReferences(byte* record, size_t base, size_t size, long shift);

  /**
   * Find component with specified name (for structures only)
   * @param name component name
   * @return descriptor of the field or <code>NULL</code> if not found
   */
  dbFieldDescriptor* find(const char* name);

  /**
   * Get first component of the field (for structures only)
   * @param return first component of the structure
   */
  dbFieldDescriptor* getFirstComponent()
  {
    return components;
  }

  /**
   * Get next component within the scope
   * @return next component within the scope
   */
  dbFieldDescriptor* getNextComponent(dbFieldDescriptor* field)
  {
    if (field != NULL)
    {
      field = field->next;

      if (field == components)
      {
        return NULL;
      }
    }

    return field;
  }

  /**
   * Redefined ',' operator used to form list of components
   */
  dbFieldDescriptor& operator, (dbFieldDescriptor& field)
  {
    dbFieldDescriptor* tail = field.prev;
    tail->next = this;
    prev->next = &field;
    field.prev = prev;
    prev = tail;
    return *this;
  }

  void* operator new(size_t size EXTRA_DEBUG_NEW_PARAMS);
  void  operator delete(void* p EXTRA_DEBUG_NEW_PARAMS);

  /**
   * Adjust offsets within application objects for descriptors of base classes.
   */
  dbFieldDescriptor& adjustOffsets(long offs);

  /**
   * Field descriptor constructor
   * @param name name of the field
   * @param offs offset of the field
   * @param size size of the field
   * @param indexType type of index used for this field
   * @param name of inverse field
   * @param components comopnents of structure or array
   */
  dbFieldDescriptor(char* name, int offs, int size, int indexType,
                    char* inverse = NULL,
                    dbFieldDescriptor* components = NULL);

  /**
   * Constructor of dummy field descriptor 
   * @param  name name of the field
   */
  dbFieldDescriptor(char* name);

  /**
   * Field descriptor destructor
   */
  ~dbFieldDescriptor();
};


/**
 * Table descriptor
 */

class FASTDB_DLL_ENTRY dbTableDescriptor
{

  friend class dbCompiler;

  friend class dbDatabase;

  friend class dbTable;

  friend class dbAnyCursor;

  friend class dbSubSql;

  friend class dbHashTable;

  friend class dbTtreeNode;

  friend class dbServer;

  friend class dbColumnBinding;

  friend class dbFieldDescriptor;

  friend class dbAnyContainer;

  friend class dbCLI;

  friend class dbSelection;

  friend class dbXmlIo;

protected:
  /**
   * Chain of all tables in application
   */
  dbTableDescriptor*  next;
  static dbTableDescriptor* chain;

  /**
   * Chain of all tables associated with database
   */
  dbTableDescriptor*  nextDbTable; // next table in the database

  /**
   * Name of the table
   */
  char*               name;

  /**
   * Indetifier of table object in the database
   */
  oid_t               tableId;

  /**
   * List of table columns
   */
  dbFieldDescriptor*  columns;

  /**
   * List of hashed fields
   */
  dbFieldDescriptor*  hashedFields;

  /**
   * List of fields indexed by T-Ttree
   */
  dbFieldDescriptor*  indexedFields;

  /**
   * List of related fields (fields, for which inverse references exist)
   */
  dbFieldDescriptor*  inverseFields;

  /**
   * List of all fields
   */
  dbFieldDescriptor*  firstField;

  /**
   * Pointer of next field of the last field (used for list construction)
   */
  dbFieldDescriptor** nextFieldLink;

  /**
   * Attached database
   */
  dbDatabase*         db;

  /**
   * Database staticly attached to the table (by means of REGISTER_IN macro)
   */
  bool                fixedDatabase;

  /**
   * Table descriptor is static object created by one of REGISTER macros
   */
  bool                isStatic;

  /**
   * Size of tghe correspondent applciation object
   */
  size_t              appSize;

  /**
   * Size of fixed part of the records (without string and array bodies)
   */
  size_t              fixedSize;

  /**
   * Number of fields in the table
   */
  size_t              nFields;

  /**
   * Number of columns in the table
   */
  size_t              nColumns;

  /**
   * Autoincremented counter for this table
   */
  int4                autoincrementCount;


  /**
   * When unassigned table descriptor is explicitly assigned to the database, 
   * new clone of descriptor is created and  <code>cloneOf</code> field of this descriptor
   * referes to original table descriptor.
   */
  dbTableDescriptor*  cloneOf;


  /**
   * Function returning list of record fields descriptors
   */
  typedef dbFieldDescriptor* (*describeFunc)();
  describeFunc        describeComponentsFunc;

  /**
   * Clone table descriptor
   */
  dbTableDescriptor*  clone();

  /**
   * Calculate total length of all names in table descriptor
   */
  size_t              totalNamesLength();

  /**
   * Recursively set field attributes.
   * @param fieldList list of record fields
   * @param prefix prefix for the field (in case of structures or arrays 
   * this functions is invoked resursively for components of this structure or
   * or array
   * @param offs - offset in application class
   * @param indexMask index mask for the structore containing the field
   * @param attr attributes of the parent field
   * @return alignment of the field
   */
  int calculateFieldsAttributes(dbFieldDescriptor* fieldsList,
                                char const* prefix, int offs,
                                int indexMask, int& attr);

  /**
   * Read table definiton from the database and build fields list
   * @param table databsae table descriptor
   * @param prefix prefix for the field (in case of structures or arrays 
   * @param prefixLen length of the prefix
   * @param attr attributes of the parent field
   * @return pointer to the constructed list
   */
  dbFieldDescriptor* buildFieldsList(dbTable* table, char const* prefix, int prefixLen, int& attr);

public:
  /**
   * Initial value for autoincrement conunt
   */
  static int initialAutoincrementCount;

  /**
   * Find field with specified symbol name
   */
  dbFieldDescriptor* findSymbol(char const* name);


  /**
   * Find field with specified name
   */
  dbFieldDescriptor* find(char const* name);


  /**
   * Get first record field
   * @return descriptor of first record field
   */
  dbFieldDescriptor* getFirstField()
  {
    return columns;
  }

  /**
   * Get next field
   * @param field current  field
   * @return next field after the current in table fields list
   */
  dbFieldDescriptor* getNextField(dbFieldDescriptor* field)
  {
    if (field != NULL)
    {
      field = field->next;

      if (field == columns)
      {
        return NULL;
      }
    }

    return field;
  }

  /**
   * Get table name.
   */
  char* getName()
  {
    return name;
  }

  /**
   * Set fields flags.  This method is called after loading table descriptor
   * from database.
   */
  void setFlags();

  /**
   * Check whether table descriptor in the database is the same as
   * table appplication table descriptor
   * @param table database table descriptor
   * @return <code>true</code> if two table descriptors are equal
   */
  bool equal(dbTable* table);

  /**
   * Check whether fprmats of table descriptor in the database 
   * and in application is compatible. This method also prepares 
   * information for performing conversion of record to new format
   * @param table database table descriptor
   * @param confirmDeleteColumns whether deletion of columns in allowed from non empty table
   * @return <code>true</code> if no reformatting is needed
   */
  bool match(dbTable* table, bool confirmDeleteColumns);

  /**
   * Check consuistency of declared realations (check that referenced table 
   * actually contains declared inverse reference field). 
   * This method also resolve references between table.
   */
  void checkRelationship();

  /**
   * Get reference to associated database
   * @return database to which this table is assigned
   */
  dbDatabase* getDatabase()
  {
    assert(db != DETACHED_TABLE);
    return db;
  }

  /**
   * Save table descriptor in the database.
   * @param table place where to store table descriptor
   */
  void storeInDatabase(dbTable* table);

  /**
   * Remove all table descriptors except static ones
   */
  static void cleanup();

  /**
   * Construct table descriptor using information stored in database
   * @param table pointer to database table descriptor
   */
  dbTableDescriptor(dbTable* table);

  /**
   * Constructor of application table descriptor
   * @param tableName name of the table
   * @param db assigned database (may be NULL)
   * @param objSize size of application object
   * @param func function returninglist of field descriptors
   * @param original roiginal table descriptor (for cloned descriptors)
   */
  dbTableDescriptor(char* tableName, dbDatabase* db, size_t objSize,
                    describeFunc func, dbTableDescriptor* original = NULL);

  /**
   * Table descriptor destructor
   */
  ~dbTableDescriptor();
};

/**
 * Header of database array or string
 */

struct dbVarying
{
  nat4 size; // number of elements in the array
  int4 offs; // offset from the beginning of the record
};

/**
 * Database record for storing field descriptor
 */

struct dbField
{
  enum FieldTypes {
    tpBool,
    tpInt1,
    tpInt2,
    tpInt4,
    tpInt8,
    tpReal4,
    tpReal8,
    tpString,
    tpReference,
    tpArray,
    tpMethodBool,