---

d_Database.h

Go to the documentation of this file.

#ifndef d_Database_h
#define d_Database_h 1
//------------------------------------------------------------------------------

#include "cTypes.h"
#include "oStorage.h"
#include "d_Project.h"

//------------------------------------------------------------------------------
class _ODLL oObjectManager;
class _ODLL d_String;
class _ODLL d_Ref_Any;
class _ODLL oClass;

//------------------------------------------------------------------------------
// DEFAULT VALUES
#define dDataStart      5104 // (5Kb - 16bytes of fix segment size)
#define dDataStep       5120
#define dRefStart       1008 // (1Kb - 16bytes of fix segment size)
#define dRefStep        1024

/**
 * Represents a logical database.
 *
 * A logical database is a container of objects of different classes. A
 * database is contained in a project (d_Project class). Classes inside a
 * database can refer objects in the same database or into the databases of the
 * same Project (federated databases).
 *
 * MULTI-THREADS:
 * d_Database class is not thread-safe, thus multiple threads cannot share the
 * same istance of d_Database. Instead define one d_Database object per
 * threads. Orient ODBMS will optimize multiple connections to the same database
 * with just one.
 *
 * DATABASE DEFINITION AND CREATION:
 * To create a database, see Schema Definition in Orient Main Guide document.
 *
 * LOCATION:
 * d_Database.h
 *
 * USAGE:
 * d_Database   <variable-name>;
 *
 * WHERE:
 * <variable-name>:     is the name of d_Database object
 * 
 * EXAMPLES:
 * d_Database   db;                      * Database object
 * db.open( "business" );                * Open the database
 * 
 * SEE ALSO:
 * d_Project
 *
 * ODMG:
 * Compliant 
 */

class _ODLL d_Database 
{
  public:

    typedef oUInt1 orDatabase;

    /**
     * Default Constructor.
     *
     * ODMG    :        Compliant 
     */
    d_Database ();

    /**
     * Destructor.
     *
     * ODMG    :        Compliant 
     */
    ~d_Database();

    /**
     * Opens the database.
     *
     * Opens the database <iName> with read_write access.
     * If a database is already opened throws a d_Error_DatabaseOpen
     * exception.
     *
     * SEE ALSO:  create(), close()
     * ODMG    :        Compliant 
     */
    void open (const char* iName);

    /**
     * Creates a new database.
     *
     * Creates the database <iName> in the project <iProject>.
     * If a database already exists, throws a d_Error_DatabaseNotCreated
     * exception.
     *
     * SEE ALSO:  open(), close()
     * ODMG    :        Extension
     */
    void create( d_Project& iProject, const char* iName, const char* iUrl,
                 orDsk iDataStart = dDataStart, orDsk iDataStep = dDataStep,
                 orDsk iRefStart = dRefStart, orDsk iRefStep = dRefStep );

    /**
     * Closes the database open.
     *
     * Any attempt to access a closed database throws d_ErrorDatabaseClosed
     * exception.
     *
     * SEE ALSO:  open(), create()
     * ODMG    :        Compliant
     */
    void close ();

    /**
     * Assign a name to a persistent object.
     *
     * Estabilishes an association between the <iObj> object and <iName> name
     * in the database dictionary. If it's already present an entry with the
     * same name throws d_Error_NameNotUnique exception. It's possible to
     * associate to an object more names. To remove all entries of an object,
     * just call this method passing 0 as second argoument.
     * 
     * SEE ALSO:  d_Dictionary::bind()
     * ODMG    :  Compliant 
     */
    void set_object_name (const d_Ref_Any &iObj, const char* iName);

    /**
     * Rename a named object.
     *
     * Renames an entry in the database dictionary from <iOldName> to
     * <iNewName>. To remove the entry of an object, just call this method
     * passing 0 as second argoument.
     *
     * SEE ALSO:  d_Dictionary::bind()
     * ODMG    :  Compliant 
     */
    void rename_object (const char* iOldName, const char* iNewName);

    /**
     * Return the named object searched.
     *
     * Search into the database dictionary the object associated with <iName>
     * name. If founds, returns a reference to found object, otherwise a null
     * reference.
     *
     * SEE ALSO:  d_Dictionary::lookup()
     * ODMG    :  Compliant 
     */
    d_Ref_Any lookup_object (const char* iName);

    /**
     * Set the retry values for database open when the database is locked by
     * another application.
     *
     * <iTimes> are the times that Orient will try to open the database, while
     * <iDelay> is the time between a test and another.
     *
     * SEE ALSO:  d_Database::open()
     * ODMG    :  Extension
     */
    void set_retry( int iTimes = 30, int iDelay = 100 );

    /**
     * Returns the name of database.
     *
     * If the database is not yet open or created, then a empty string is
     * returned ("").
     *
     * ODMG    :  Extension
     */
    d_String getName() const;

    /**
     * Returns the url of database.
     *
     * If the database is not yet open or created, then a empty string is
     * returned ("").
     *
     * ODMG    :  Extension
     */
    d_String getUrl() const;

    /**
     * Returns the schema object (oSysDatabase) of database. This permits to
     * inspect the database schema and to change it at run-time.
     *
     * ODMG    :  Extension
     */
    d_Ref<oSysDatabase> getSchema() const;

    /**
     * Returns true if the database is open, otherwise false.
     *
     * ODMG    :  Extension
     */
    bool isOpen() const;

    /**
     * Returns the domain of database.
     *
     * If the database is not yet open or created, then 0 is returned.
     *
     * ODMG    :  Extension
     */
    oDomain* getDomain() const;

    // Internal.
    d_Object* newObject (const char* iClassName);

    // Internal.
    oStorage* getStorage() const;

  private:
    // Internal.
    oStorage*             storage;

    // Internal.
    int retryMax;
    int retryDelay;

  // FRIENDSHIPS
  friend class oObjectManager;
};
//------------------------------------------------------------------------------
inline oStorage* d_Database::getStorage () const
{
  return storage;
}
//------------------------------------------------------------------------------
inline bool d_Database::isOpen() const
{
  return storage ? true : false;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

#endif

---