Database.h

/* 
   EyeDB Object Database Management System
   Copyright (C) 1994-2008 SYSRA
   
   EyeDB is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.
   
   EyeDB 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
   Lesser General Public License for more details.
   
   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA 
*/

/*
   Author: Eric Viara <viara@sysra.com>
*/


#ifndef _EYEDB_DATABASE_H
#define _EYEDB_DATABASE_H

#include <eyedb/ObjCache.h>
#include <vector>
#include <map>

namespace eyedb {

  class BEQueue;
  class ObjCache;
  class ExecutableCache;
  class Protection;
  class SchemaInfo;
  class DBProperty;
  class Transaction;
  class GenHashTable;

  class Database : public Struct {

    // ----------------------------------------------------------------------
    // Database Interface
    // ----------------------------------------------------------------------
  public:

    enum OpenFlag {
      DBRead                    = _DBRead,
      DBRW                      = _DBRW,
      DBReadLocal               = DBRead | _DBOpenLocal,
      DBRWLocal                 = DBRW | _DBOpenLocal,
      DBReadAdmin               = DBRead | _DBAdmin,
      DBRWAdmin                 = DBRW | _DBAdmin,
      DBReadAdminLocal          = DBReadAdmin | _DBOpenLocal,
      DBRWAdminLocal            = DBRWAdmin | _DBOpenLocal,
      DBSRead                   = _DBSRead,
      DBSReadLocal              = DBSRead | _DBOpenLocal,
      DBSReadAdmin              = DBSRead | _DBAdmin
    };

    Database(const char *dbname, const char *dbmdb_str = 0);

    Database(Connection *conn,
             const char *dbname,
             Database::OpenFlag flag = Database::DBRead,
             const char *user = 0,
             const char *passwd = 0);

    Database(Connection *conn,
             const char *dbname,
             const char *dbmdb_str,
             Database::OpenFlag flag = Database::DBRead,
             const char *user = 0,
             const char *passwd = 0);

    Database(const char *dbname, int dbid, const char *dbmdb_str = 0);

    Database(int dbid, const char *dbmdb_str = 0);

    Database(const Database &db);

    virtual Object *clone() const {return new Database(*this);}

    Status create(Connection *conn, const char *user = 0,
                  const char *passwd = 0,
                  DbCreateDescription *pdbdesc = 0);

    Status create(Connection *conn, DbCreateDescription *pdbdesc);

    Status remove(Connection *conn, const char *user = 0, const char *passwd = 0);

    Status remove(const char *user = 0, const char *passwd = 0);

    Status setDefaultDBAccess(Connection *conn, int mode,
                              const char *user = 0, const char *passwd = 0);

    Status setUserDBAccess(Connection *conn, const char *username,
                           int mode,
                           const char *user = 0, const char *passwd = 0);

    Status getInfo(Connection *conn,
                   const char *user, const char *passwd, DbInfoDescription *pdbdesc) const;

    Status getInfo(const char *user, const char *passwd, DbInfoDescription *pdbdesc) const;

    virtual Status open(Connection *conn,
                        Database::OpenFlag flag = Database::DBRead,
                        const char *user = 0,
                        const char *passwd = 0);

    virtual Status open(Connection *conn,
                        Database::OpenFlag flag,
                        const OpenHints *hints,
                        const char *user = 0,
                        const char *passwd = 0);

    Status close();

    Status rename(const char *newdbname, const char *user = 0, const char *passwd = 0);

    Status move(DbCreateDescription *dbdesc, const char *user = 0, const char *passwd = 0);

    Status copy(const char *newdbname, Bool newdbid, DbCreateDescription *dbdesc,
                const char *user = 0, const char *passwd = 0);

    Status rename(Connection *conn, const char *newdbname,
                  const char *user = 0, const char *passwd = 0);

    Status move(Connection *conn, DbCreateDescription *dbdesc,
                const char *user = 0, const char *passwd = 0);

    Status copy(Connection *conn, const char *newdbname, Bool newdbid,
                DbCreateDescription *dbdesc,
                const char *user = 0, const char *passwd = 0);

    Status containsObject(const Oid &oid, Bool &found);

    Status getObjectClass(const Oid &oid, Class *&cl);

    Status getObjectClass(const Oid &oid, Oid &cls_oid);

    // object locking
    Status setObjectLock(const Oid &oid, LockMode lockmode);

    Status setObjectLock(const Oid &oid, LockMode lockmode,
                         LockMode &alockmode);

    Status getObjectLock(const Oid &oid, LockMode &alockmode);

    // object loading
    Status loadObject(const Oid &oid, ObjectPtr &o,
                      const RecMode *recmode = RecMode::NoRecurs);

    // object loading
    Status loadObject(const Oid &oid, Object *&o,
                      const RecMode *recmode = RecMode::NoRecurs);

    Status loadObject(const Oid &xoid, ObjectPtr &o,
                      LockMode lockmode,
                      const RecMode *recmode = RecMode::NoRecurs);

    Status loadObject(const Oid &xoid, Object *&o,
                      LockMode lockmode,
                      const RecMode *recmode = RecMode::NoRecurs);

    Status reloadObject(const Oid &oid, ObjectPtr &o,
                        const RecMode *recmode = RecMode::NoRecurs);


    Status reloadObject(const Oid &oid, Object *&o,
                        const RecMode *recmode = RecMode::NoRecurs);


    Status reloadObject(const Oid &oid, ObjectPtr &o,
                        LockMode lockmode,
                        const RecMode *recmode = RecMode::NoRecurs);

    Status reloadObject(const Oid &oid, Object *&o,
                        LockMode lockmode,
                        const RecMode *recmode = RecMode::NoRecurs);

    Status loadObjects(const OidArray &oid_array, ObjectPtrVector &obj_vect,
                       const RecMode *recmode = RecMode::NoRecurs);

    Status loadObjects(const OidArray &oid_array, ObjectArray &obj_array,
                       const RecMode *recmode = RecMode::NoRecurs);

    Status loadObjects(const OidArray &oid_array, ObjectPtrVector &obj_vect,
                       LockMode lockmode,
                       const RecMode *recmode = RecMode::NoRecurs);

    Status loadObjects(const OidArray &oid_array, ObjectArray &obj_array,
                       LockMode lockmode,
                       const RecMode *recmode = RecMode::NoRecurs);

    Status removeObject(const Oid &poid, const RecMode *recmode = RecMode::NoRecurs);

    Status isRemoved(const Oid &poid, Bool &isremoved) const;

    Status makeObject(const Oid *poid, const ObjectHeader *hdr,
                      Data idr, Object **o, Bool useCache = False);

    Status makeObject_realize(const Oid *, const ObjectHeader *,
                              Data, Object **,
                              Bool useCache = False);

    Status setObjectProtection(const Oid &obj_oid, const Oid &prot_oid);

    Status setObjectProtection(const Oid &obj_oid, Protection *prot);

    Status getObjectProtection(const Oid &obj_oid, Oid &prot_oid);

    Status getObjectProtection(const Oid &obj_oid, Protection *&prot);

    // location management
    Status getObjectLocations(const OidArray &oid_arr, ObjectLocationArray &locarr);

    Status getObjectLocations(const ObjectArray &obj_arr, ObjectLocationArray &locarr);

    Status moveObjects(const OidArray &oid_arr, const Dataspace *dataspace);

    Status moveObjects(const ObjectArray &obj_arr, const Dataspace *dataspace);

    // transaction support
  
    Status transactionBegin();

    Status transactionBegin(const TransactionParams &params);

    Status transactionBeginExclusive();

    Status transactionCommit();

    Status transactionAbort();

    Transaction *getCurrentTransaction();

    Transaction *getRootTransaction();

    Bool isInTransaction() const;

    Status setDefaultTransactionParams(const TransactionParams &params);

    TransactionParams getDefaultTransactionParams();

    void setCommitOnClose(Bool commit_on_close);

    Bool getCommitOnClose() const {return commit_on_close;}

    static void setDefaultCommitOnClose(Bool _def_commit_on_close) {
      def_commit_on_close = _def_commit_on_close;
    }    

    static Bool getDefaultCommitOnClose() {return def_commit_on_close;}
  
    const char *getName() const;

    int getDbid() const;

    int getVersionNumber() const {return version;}

    const char *getVersion() const;

    Bool isOpened() const;

    Database::OpenFlag getOpenFlag() const;

    DbHandle *getDbHandle();

    const Schema *getSchema() const;

    Schema *getSchema();

    Connection *getConnection();

    static void setDefaultDBMDB(const char *dbmdb_str);

    static const char *getDefaultDBMDB();

    static const char *getDefaultServerDBMDB();

    static const std::vector<std::string> &getGrantedDBMDB();

    const char *getDBMDB() const;

    Bool isBackEnd() const;

    Bool isLocal() const;

    const char *getUser() const {return _user;}

    const char *getPassword() const {return _passwd;}

    int getUid() const {return uid;}
  
    // datafile management
    Status getDatabasefile(const char *&database_file,
                           Bool fetch = False,
                           const char *user = 0,
                           const char *passwd = 0);

    Status getDatafiles(const Datafile **&datafiles, unsigned int &cnt,
                        Bool fetch = False,
                        const char *user = 0,
                        const char *passwd = 0);

    Status getDatafile(unsigned short id, const Datafile *&datafile,
                       Bool fetch = False,
                       const char *user = 0,
                       const char *passwd = 0);

    Status getDatafile(const char *name_or_file, const Datafile *&datafile,
                       Bool fetch = False,
                       const char *user = 0,
                       const char *passwd = 0);

    Status createDatafile(const char *filedir, const char *filename,
                          const char *name, unsigned int maxsize,
                          unsigned int slotsize, DatType dtype);

    // dataspace management
    Status getDataspaces(const Dataspace **&dataspace, unsigned int &cnt,
                         Bool fetch = False,
                         const char *user = 0,
                         const char *passwd = 0);

    Status getDataspace(unsigned short id, const Dataspace *&dataspace,
                        Bool fetch = False,
                        const char *user = 0,
                        const char *passwd = 0);

    Status getDataspace(const char *name, const Dataspace *&dataspace,
                        Bool fetch = False,
                        const char *user = 0,
                        const char *passwd = 0);

    Status getDefaultDataspace(const Dataspace *&dataspace);

    Status setDefaultDataspace(const Dataspace *dataspace);

    Status createDataspace(const char *dspname, const Datafile **datafiles,
                           unsigned int datafile_cnt);

    const DBProperty *getProperty(const char *) const;
    DBProperty *getProperty(const char *);
    const DBProperty **getProperties(int &prop_cnt) const;
    DBProperty **getProperties(int &prop_cnt);

    static const char *getStringFlag(Database::OpenFlag open_flag);

    virtual Database *asDatabase() {return this;}

    virtual const Database *asDatabase() const {return this;}

    virtual ~Database();

    Object *getCacheObject(const Oid &xoid);

    // auto register
    void autoRegisterObjects(Bool on);

    Bool areObjectsAutoRegistered() const {return auto_register_on;}

    void addToRegister(const Object *o, Bool force = False);

    void rmvFromRegister(const Object *o);

    ObjectList *getRegisteredObjects();

    Status storeRegisteredObjects();

    void clearRegister();

    void storeOnCommit(Bool on);

    Bool isStoreOnCommit() const {return store_on_commit;}

    Status setMaxObjectCount(unsigned int max_obj_cnt);

    Status getMaxObjectCount(unsigned int& max_obj_cnt);

    Status setLogSize(unsigned int logsize);

    Status getLogSize(unsigned int& logsize);

    // deprecated
    Status loadObject(const Oid *, Object **,
                      const RecMode * = RecMode::NoRecurs);

    Status loadObject(const Oid *, Object **,
                      LockMode lockmode,
                      const RecMode * = RecMode::NoRecurs);

    Status reloadObject(const Oid *, Object **,
                        const RecMode * = RecMode::NoRecurs);

    Status reloadObject(const Oid *, Object **,
                        LockMode lockmode,
                        const RecMode * = RecMode::NoRecurs);

    Status removeObject(const Oid *,
                        const RecMode * = RecMode::NoRecurs);

    Status updateSchema(const char *odlfile, const char *package,
                        const char *schname = 0, const char *db_prefix = 0,
                        FILE *fd = stdout, const char *cpp_cmd = 0,
                        const char *cpp_flags = 0);

    // not implemented (yet ?)
    /*
    Status execOQL(Object *&, const char *fmt, ...);
    Status execOQL(Object *&, const RecMode *,
                   const char *fmt, ...);
    Status execOQL(ObjectArray &, const char *fmt, ...);
    Status execOQL(ObjectArray &, const RecMode *,
                   const char *fmt, ...);
    Status execOQL(Oid &, const char *fmt, ...);
    Status execOQL(OidArray &, const char *fmt, ...);
    Status execOQL(Value &, const char *fmt, ...);
    Status execOQL(ValueArray &, const char *fmt, ...);
    */

    static void operator delete(void *);

    // ----------------------------------------------------------------------
    // Database Protected Part
    // ----------------------------------------------------------------------
  protected:
    char *name;
    int dbid;
    unsigned int version;
    Connection *conn;
    OpenFlag open_flag;
    DbHandle *dbh;
    Schema *sch;
    ObjCache *temp_cache;
    ObjCache *obj_register;
    Bool auto_register_on;
    Bool store_on_commit;
    Bool open_state;
    int open_refcnt;
    BEQueue *bequeue;
    Bool is_back_end;
    static char *defaultDBMDB;
    static LinkedList *dbopen_list;
    char *_user, *_passwd;
    int uid;
    Transaction *curtrs, *roottrs;
    Bool commit_on_close_set;
    Bool commit_on_close;
    static Bool def_commit_on_close;
    Oid m_protoid;
    Bool oqlInit;

  public:
    typedef Object *(*consapp_t)(const Class *, Data);

  protected:
    int consapp_cnt;
    GenHashTable *hashapp[4];
    consapp_t *consapp[4];

    Status init_db(Connection *);
    Bool initialized;
    Status create_prologue(DbCreateDescription &,
                           DbCreateDescription **);
    Status transactionBegin_realize(const TransactionParams *params);
    Status transactionCommit_realize();
    Status transactionAbort_realize();
    void init(const char *);
    static Status open_realize(Connection *,
                               Bool (*)(const Database *, const void *),
                               const void *, const char *, OpenFlag,
                               const OpenHints *,
                               Database *(*)(const void *, const char *),
                               const char *, const char *,
                               Database **);
    const char *getTName() const;

    TransactionParams def_params;

    char *dbmdb_str;
    Status invalidDbmdb(Error) const;

    // ----------------------------------------------------------------------
    // Database Private Part
    // ----------------------------------------------------------------------
  private:
    void init_open(Connection *conn,
                   const char *dbname,
                   const char *dbmdb_str,
                   Database::OpenFlag flag,
                   const char *user,
                   const char *passwd);

    Status create();
    Status update();
    Status realize(const RecMode * = RecMode::NoRecurs);
    Status remove(const RecMode * = RecMode::NoRecurs);
    int trs_cnt;
    LinkedList mark_deleted;
    LinkedList purge_action_list;
    std::map<Oid, bool> mark_created;
    void purgeOnAbort();
    void purgeRelease();
    static ObjCache *makeRegister();
    ObjCache conv_cache;

    char *database_file;
    unsigned int datafile_cnt;
    Datafile **datafiles;
    unsigned int dataspace_cnt;
    Dataspace **dataspaces;
    std::map<Object *, bool> realizedMap;
    bool useMap;
    void make_dat_dsp(const DbCreateDescription &dbdesc);
    void garbage_dat_dsp();
    const Datafile **get_datafiles(const eyedbsm::Dataspace *dsp);
    Status getDatDspPrologue(Bool fetch,
                             const char *user, const char *passwd);

    // ----------------------------------------------------------------------
    // Database Restricted Access (conceptually private)
    // ----------------------------------------------------------------------
  public:
    static void init();
    static void _release();
    Status set(ConnHandle *, int, int, DbHandle *,
               rpcDB_LocalDBContext *, const Oid *, unsigned int);

    void beginRealize();
    bool isRealized(Object *o) const {
      return useMap && realizedMap.find(o) != realizedMap.end();
    }
    void setRealized(Object *o) {if (useMap) {realizedMap[o] = true;}}
    void endRealize();

    void cacheObject(Object *);
    void uncacheObject(Object *);
    void uncacheObject(const Oid &_oid);

    void insertTempCache(const Oid&, void *);
    Bool isOpeningState();
    BEQueue *getBEQueue();
    virtual void garbage();

    void setSchema(Schema *);

    static Status getOpenedDB(int dbid, Database *, Database *&);

    static Status open(Connection *, int,
                       const char *, const char *, const char *,
                       OpenFlag, const OpenHints *, Database **);

    static Status open(Connection *, const char *,
                       const char *, const char *, const char *,
                       OpenFlag, const OpenHints *, Database **);

    virtual Status loadObject_realize(const Oid *, Object **,
                                      LockMode lockmode,
                                      const RecMode * =
                                      RecMode::NoRecurs,
                                      Bool reload = False);
    Bool writeBackConvertedObjects() const;
    void addPurgeActionOnAbort(void (*purge_action)(void *), void *);
    ExecutableCache *exec_cache;
    void *trig_dl;
    const Oid& getMprotOid() const {return m_protoid;}
    void updateSchema(const SchemaInfo &schinfo);
    LinkedList& getMarkDeleted() {return mark_deleted;}
    void addMarkCreated(const Oid &);
    bool isMarkCreated(const Oid &) const;
    void markCreatedEmpty();
    void setIncoherency();
    Bool isOQLInit() const {return oqlInit;}
    void setOQLInit() {oqlInit = True;}
    Bool isApp() const {return IDBBOOL(hashapp);}
    void add(GenHashTable *, consapp_t *);
    consapp_t getConsApp(const Class *);
    ObjCache &getConvCache() {return conv_cache;}
  };

}

#endif

  

---