Main Table of Contents

Table of Contents

class PtBase

PtBase: class summary

PtBase::PtBase()

PtBase::~PtBase()

PtBase::AbortTransaction()

PtBase::AdjustServerThreads()

PtBase::AuthorizationEnabled()

PtBase::BeginExternalBackup()

PtBase::BeginTransaction()

BeginTransaction returns the new transaction level.PtBase::BeTypeSafe()

PtBase::cast2PtWorkspace()

PtBase::CheckForEvent()

PtBase::Clone()

PtBase::Close()

PtBase::CloseAllChildren()

PtBase::CommitTransaction()

PtBase::Connect()

PtBase::Create()

PtBase::CreateWorkspace()

PtBase::Delete()

PtBase::DeleteUnusedChildren()

PtBase::DiscardWorkspace()

PtBase::DisConnect()

PtBase::EnableAuthorization()

PtBase::EndExternalBackup()

PtBase::GetClientId()

PtBase::GetClientName()

PtBase::GetCreationTime()

PtBase::GetCurrentUser()

PtBase::GetDbName()

PtBase::GetDBVersion()

PtBase::GetDefaultLock()

PtBase::GetDefaultWatch()

PtBase::GetDictionary()

PtBase::GetDictName()

PtBase::GetDictTimestamp()

PtBase::GetExcMgr()

PtBase::GetLastBaseError()

PtBase::GetLogicalDictName()

PtBase::GetLogicalName()

PtBase::GetNumClients()

PtBase::GetObjectInfo()

PtBase::GetOpenMode()

PtBase::GetPhysicalDictName()

PtBase::GetPhysicalName()

PtBase::GetPhysicalServer()

PtBase::GetServer()

PtBase::GetState()

PtBase::GetTypeMgr()

PtBase::IsDictionary()

PtBase::IsWorkspace()

PtBase::MapName()

PtBase::MoveBase()

PtBase::MoveServer()

PtBase::Open()

PtBase::POET()

PtBase::Recover()

PtBase::ReIndex()

PtBase::Reorg()

PtBase::SetBeTypeSafe()

PtBase::SetClientName()

PtBase::SetDefaultLock()

PtBase::SetDefaultWatch()

PtBase::TransactionLevel()

PtBase::Update()

PtBase::VersAll()

class PtBase

In an object oriented database system, you need an object which represents the database itself. PtBase is a class which defines the methods for opening and closing the database and contains data which POET uses for internal management. Once you have opened a database you use the PtBase to assign other objects to the database.

You can have several PtBase objects open simultaneously, which allows you to manage several databases in your program. An object may only reference other objects in its database. The client/server version of POET allows several users to access the same database simultaneously with full concurrency control.

Before you open a PtBase you must call the global function InitPOET(), which creates a PtRoot object to manage the PtBases that you open. The best way to open a database is to call PtRoot:: GetBase() like this:

#include <poet.hxx>

main()

{

InitPOET("ClientName");

PtBase* pObjBase;

int err = PtBase::POET()->GetBase("LOCAL", "base", pObjBase);

if (err < 0)

{

PtBase::POET()->UngetBase(pObjBase);

ErrorExit("Could not open database", err);

}

// now we have an open PtBase...let's close it

PtBase::POET()->UngetBase(pObjBase);

DeinitPOET();

return 0;

}

In the above code, the second parameter to GetBase() is the name of the database, and the first parameter is the name of the server to which we should connect. "LOCAL" means that we are in single-user mode. If we wanted to connect to a server then we would have specified the name of the server instead. For instance, if we wanted to connect to a server found on a computer named "DeepThought" we could use the following code:

PtBase::POET()->GetBase("DeepThought", "base", pObjBase);

In previous versions of POET, databases were created and opened using the PtBase, and there was no PtRoot. The advantage of using a PtRoot is that the PtRoot can ensure that the resources for each PtBase are allocated only once. Each PtBase you open requires file handles and RAM, and it takes time to open a database. GetBase() makes sure that you do not incur this overhead when you open a database a second time (footnote #1) . You can still open a PtBase the old way, as long as you call InitPOET() first:

#include <poet.hxx>

main()

{

InitPOET("ClientName");

PtBase *pObjBase = new PtBase;

pObjBase->Connect("LOCAL");// Connect to server

pObjBase->Open ("base"); // Open database

pObjBase->Close(); // Close database

pObjBase->DisConnect(); // Disconnect

delete pObjBase;

DeinitPOET();

return 0;

}

footnote #1: If you call InitPOET() in a shared library or .DLL, you must insure that InitPOET() is called for each program which uses the library so that there is one PtRoot for each client process. Each client will have its own database connections, so if you have more than one program using a .DLL, you will need to run a personal server or a server.

PtBase: class summary

Member functions:

PtBase::PtBase()

Declaration:

Description:

Creates a PtBase and registers it in the object management kernel. POET can manage and synchronize multiple instances of PtBase. The constructor does not connect the program to the server or open a database.

PtBase::~PtBase()

Declaration:

Description:

Deletes the PtBase. You should first close the database and disconnect from the server. If the database is open then this method will close the database and disconnect from the server. All changes to objects in memory are lost if you do not store the objects before deleting the PtBase. Objects assigned to the database are removed from memory.

Important: You must delete or UnAssign() any objects, sets, or allsets that are assigned to the database before deleting the PtBase.

PtBase::AbortTransaction()

Declaration:

Description:

Aborts the current transaction. If you set an appropriate PtTransProps parameter for BeginTransaction(), the modified objects are automatically refreshed. See BeginTransaction() the description of the PtTransProps class.

Returns:

PtBase::AdjustServerThreads()

Declaration:

Description:

When using POET on a multi-threaded server, the server will create one thread for each database that a particular client opens. If your POET client opens two databases for example, the server will maintain two threads for that client. This may not be the most optimum from the client's point of view. If the client application executes multiple queries on one of the open databases, then the server will run these queries using a single thread on the server's machine. You can optimize this behavior from the client application with the method AdjustServerThreads().

The amount parameter tells the server to add the amount number of threads to the total number for the client's open database. For example, if you begin an operation that could benefit from an additional thread on the server, like a query, you could call AdjustServerThreads with an amount of one. This would add one extra thread to the number for the open client database. Here's an example of such a call:

PtBase * pBase;

// (call GetBase to connect and open the database[mldr ])

int err;

err = pBase->AdjustServerThreads( 1 ); // enable another server thread

// check error return

// do your extra thread thing[mldr ]

err = pBase->AdjustServerThreads( -1 ); // disable a server thread

// check error return

As you can see from the example calls above, you can call AdjustServerThreads() with a negative amount to disable extra threads that are no longer needed. Values for the amount parameter greater than one are also possible. Remember, that the amount is the number of threads that you want to add (or remove) from the number of active threads on the server. Also, the server maintains these threads for a particular database and client. The AdjustServerThreads() call is only for the database (and client) that makes the call.

Returns:

PtBase::AuthorizationEnabled()

Declaration:

Description:

Returns a non-zero value if user authorization has been enabled for this database. User authorization is enabled by calling the function PtBase:: EnableAuthorization(). Once this function has been called, user accounts are created and no user may access the database without first logging in. See the chapter on user authorization in the programmer's guide for details.

PtBase::BeginExternalBackup()

Declaration:

Description:

Prepares the database for an external backup.

Parameters:

The parameter is currently ignored by this function. This function ensures that no changes are made to the database files while a database is being backed up. Clients may continue to use the database while the backup is being made. BeginExternalBackup() flushes all files to disk, starts a global internal transaction, closes the database, and opens the database files again in read-only mode. At this point you may safely copy the database files to make a backup. Any changes made by other clients will be saved in the internal transaction buffer for the database. When you are done with your backup, call EndExternalBackup() to restore the normal database state.

Note: internal transactions generally allocate disk space for each operation to ensure that this space is available if the transaction is later committed. During an external backup, internal transactions can not allocate memory since they do not have the files open. If memory is exhausted on the device, this will not be detected until EndExternalBackup() is called.

PtBase::BeginTransaction()

Declaration:

Description:

POET supports nested transactions, which are described in a separate chapter. This method begins a transaction and returns the new transaction level.

Parameters:

The PtTransProps parameter determines the transaction behavior. Normally, you can simply call BeginTransaction() without a parameter, using the default value, NULL, for the PtTransProps pointer. However, you can control the transaction behavior by creating a PtTransProps object and passing its address to the BeginTransaction method.

For example, if you are not using indexed queries within the transaction you can use the transaction properties object to turn off the shadow indexes that are maintained during the transaction. You may also direct the transaction to do an automatic refresh of modified objects if you abort the transaction. See the description of the PtTransProps class and the Transactions chapter for a discussion of this extended transaction behavior.

Returns:

BeginTransaction returns the new transaction level.PtBase::BeTypeSafe()

Declaration:

Description:

Run time type checking gives you strong type checking for all database operations which are not checked at compile time. This is very helpful during development, but type errors are unlikely to occur in mature software systems. Disabling run time type checking can speed database operations somewhat.

This method returns 0 if type checking is disabled or a non-zero value if type checking is enabled.

PtBase::cast2PtWorkspace()

Declaration:

Description:

If the database is actually a workspace, this method will return the database address as a PtWorkspace pointer. If the database is not a workspace, this method will return NULL.

PtBase::CheckForEvent()

Declaration:

Description:

On systems which do not allow asynchronous events, such as the Macintosh, event handling is done by calling this function in the main program loop. CheckForEvent() asks the server to send any pending events, and forces your callback functions to be called. Currently, the Macintosh is the only system which needs to use this function. If you call this function on a system which does not need it, it just pings the server needlessly and then returns.

PtBase::Clone()

Declaration:

Description:

Clone() creates a new database which has the same dictionary and the same foreign database list. If you have read access to the user administration information, it also has the same user rights as the current database. If you do not have read rights to the user administration information, no user rights are assigned.

Parameters:

PtBase::Close()

Declaration:

Description:

Closes a database.

Returns:

PtBase::CloseAllChildren()

Declaration:

Description:

If you resolve a cross database reference for a database which is not yet open, POET opens the foreign database as a child of the PtBase which references it. This function closes all child databases for the PtBase.

PtBase::CommitTransaction()

Declaration:

Description:

Commits the current transaction. Non-negative return values report the new transaction level. Negative return values indicate that an error has occured during the commit. Since a commit is an all-or-nothing affair, the exact error is irrelevant.

If the commit fails no changes are written to the database.

Returns:

PtBase::Connect()

Declaration:

Description:

Establishes a connection to the network server. To obtain source code compatibility it must be called in a single-user environment as well as in a multi-user environment.

Parameters:

In previous versions of POET, this was the only way to connect to a server, and connecting to a server and opening a database were done with separate function calls. It is now possible to connect to a server and open a database using PtRoot:: GetBase(), which is generally better because it ensures that your application only opens a given database once - if the database is already open, it simply returns a pointer to the existing database. We generally recommend that you use PtRoot:: GetBase() instead of PtBase:: Open().

By default, POET looks for a service called "poet" running on the specified host. This behavior can be changed using configuration files.

Returns:

PtBase::Create()

Declaration:

Description:

This method is used internally by POET. If you want to create a new database, do not use this method, use PtClassDict:: CreateDatabase() instead.

PtBase::CreateWorkspace()

Declaration:

Description:

Creates a workspace for the current database

Parameters:

Discussion:

Workspaces are databases which can be used to check objects out of the original database. This function creates the files for a workspace. Within each database, each workspace name must be unique. If the workspace name has already been used for this database, an error will be returned. The workspace name may be an absolute or relative path, and it is interpreted just like any other database names in POET: if there you are working locally (without a server) then this name is relative to the current working directory; if you have a server, it is relative to the working directory of the server.

The second parameter determines whether the workspace will be created locally, or created on the same server as the original database (we would have specified PtSAME to create it on the same server). You can not create a workspace on a different server from the original database. Creating a workspace simply creates the files for the database, it does not create an open PtBase for the workspace. Before you can check objects out of or into the database, you must open the database as a PtWorkspace.

If you just want to use it as a normal database, you could open it using a PtBase.

PtBase::Delete()

Declaration:

Description:

Deletes the database. Before calling this function, you must call PtBase:: Connect() to connect to the server (or to "LOCAL"), but the database should not be open. To protect the database, this function will fail if anybody has the database open - even if you have it open. The inline function simply creates a PtString and calls the virtual function. This preserves polymorphism, but reduces the number of virtual functions, which can be important on some compilers.

Parameters:

PtBase::DeleteUnusedChildren()

Declaration:

Description:

If you resolve a cross database reference for a database which is not yet open, POET opens the foreign database as a child of the PtBase which references it. This function closes all child databases for the PtBase for which there are currently no objects in RAM.

PtBase::DiscardWorkspace()

Declaration:

Description:

Removes the workspace from the workspace list of the database. All persistent locks for objects belonging to the workspace are removed, and the objects are no longer checked out. The workspace will not be able to check objects in once this function has been called.

There is no way to undo DiscardWorkspace().

PtBase::DisConnect()

Declaration:

Description:

Breaks off the connection to the server.

Returns:

PtBase::EnableAuthorization()

Declaration:

Description:

Enables authorization for a database. When you first create a POET database anybody can read, write, or delete anything. To enable security for a database, you must first open the database, then call EnableAuthorization(). Once this function has been called, the database can only be opened after logging in as a user.

Parameters:

Groups created:

When you call EnableAuthorization(), POET creates the user POETADM, which is the database administrator, and logs your process in as POETADM. It also creates a default group, which will be assigned to any new user that you create, and an administrator's group, to which you can add any users who also need superuser access to the database. Here are the users and the groups that EnableAuthorization creates:

loginName	realName
POETADM	The POET Administrator
POETADMGROUP	The POET Administrator Group
PtDefault	Default group for all POET users

At first, there are no users except the administrator. Whenever a new user is created it belongs to the PtDefault group until it is moved to a different group. EnableAuthorization creates one more group called POETADMGROUP for users who should be able to act as database administrators.

Example:

In this example, the password for POETADM will be 'flummery,' and members of the PtDefault group will be able to read objects, but not write or delete them. When you call EnableAuthorization(), POET logs you in to the POETADM account.

Warning:

Once you close the database, you will have to log in explicitly. Please keep track of the password for the POETADM account - if you lose it, there is no way to read it or to set it to a known password. If this happens to you, only POET Software will be able to make your database accessible again (even we can not figure out the password, but we do know how to enter a new password).

PtBase::EndExternalBackup()

Declaration:

Description:

Ends the external backup session started by calling BeginExternalBackup(). Closes all database files, re-opens them in read/write mode, and ends the internal transaction which was used to enable backups.

PtBase::GetClientId()

Declaration:

Description:

Returns the client Id for your process.

PtBase::GetClientName()

Declarations:

Provides the client name. Each of these functions is documented below.

Declaration:

Description:

Returns the current client name for your process.

Declaration:

Description:

Returns the client name and Id for each client on the network who is currently using this database.

Parameters:

If you want to see all clients, simply call this function in a for loop, incrementing the counter until GetClientName() returns an error:

PtString ClientName;

PtClientId ClientId;

for (int i=0; GetClientName(ClientName,ClientId,i)==0; ++i)

cout << ClientName;

PtBase::GetCreationTime()

Declaration:

Description:

Reports the date and time at which this database was originally created.

Parameters:

PtBase::GetCurrentUser()

Declaration:

Description:

Returns the client name and the client Id for your process.

Parameters:

PtBase::GetDbName()

Declaration:

Description:

Returns the name of the current database by reference. This name has been mapped by the local POET.CFG file, but does not have any mappings that are done on the server due to PTSERVER.CFG. For example, if your logical database name is BASE and this database is physically in the C:/APPS/APPBASE directory you will need to map this name in a POET.CFG or PTSERVER.CFG file. If the .CFG entry reads BASE=C:/APPS/APPBASE/OBJECTS.DAT then:

GetLogicalName() returns:	BASE
GetDbName() returns:	C:/APPS/APPBASE/OBJECTS.DAT
GetPhysicalName() returns:	C:/APPS/APPBASE

PtBase::GetDBVersion()

Declaration:

Description:

Reports the version number for the database, the version of POET which created it, and the compilation date of the POET version which was used to create it.

Parameters:

PtBase::GetDefaultLock()

Declaration:

Description:

Returns the default lock for the database. Locks and default locks are described in the chapter "Locking".

PtBase::GetDefaultWatch()

Declaration:

Description:

Returns the default watch for the database. Watches and default watches are described in the chapter "Event Handling".

PtBase::GetDictionary()

Declaration:

Description:

Returns a pointer to the class dictionary manager for this database. This function is used only in programs that access the class dictionary.

PtBase::GetDictName()

Declaration:

Description:

Returns the name of this database's dictionary. This is usually the physical name of the dictionary unless a POET.CFG has defined a different mapped name for the logical dictionary name.

For example, if your logical dictionary name is DICT and this dictionary is physically in the C:/APPS/APPDICT directory you will need to map this name in a POET.CFG or PTSERVER.CFG file. If the .CFG entry reads SCHEMA=C:/APPS/APPDICT/_OBJECTS.DAT then:

GetLogicalDictName() returns:	DICT
GetDictName() returns:	C:/APPS/APPDICT/_OBJECTS.DAT
GetPhysicalDictName() returns:	C:/APPS/APPDICT

PtBase::GetDictTimestamp()

Declaration:

Description:

Returns the creation date and time of the database's dictionary as a PtDateTime reference.

PtBase::GetExcMgr()

Declaration:

Description:

Returns a pointer to the database's exception manager. Exception managers are used for event handling, and are described in the chapter "Event Handling."

PtBase::GetLastBaseError()

Declaration:

Description:

This method returns an undocumented error code which describes the last database error. These error codes are used for POET development, and can be helpful when reporting errors to technical support.

PtBase::GetLogicalDictName()

Declaration:

Description:

Returns the logical name of the dictionary, which is the string that you used when you created the dictionary using PTXX. This string is stored in the root block of the database.

PtBase::GetLogicalName()

Declaration:

Description:

Returns the logical name of the database, which is the string that you used in your PtBase:: Open() statement when you opened the database.

PtBase::GetNumClients()

Declaration:

Description:

Returns the number of clients currently using this database.

PtBase::GetObjectInfo()

Declaration:

Description:

Returns information on the objects being used by a client.

Parameters:

This function fills the PtObjectState with information on the requested object. The type of information depends on the full type of the PtObjectState. For instance, if you specify a PtObjStateMaxLock, you will receive information on the maximum lock for each locked object, and pos will iterate through only the locked objects. PtObjStateLockList reports all locks for each locked object, and pos iterates through only the watched objects. PtObjStateWatchList reports the watches for each watched object, and pos iterates through only the watched objects. If you specify a PtObjStateObjectInfo, you will receive all available status information on the objects which are in the RAM of each client.

PtBase::GetOpenMode()

Declaration:

Description:

Returns the open mode for this database. See PtBase::Open().

PtBase::GetPhysicalDictName()

Declaration:

Description:

Returns the full absolute path name of the dictionary. If you are using a server, this is the name as understood by the server, after any mappings done due to the server's PTSERVER.CFG file.

PtBase::GetPhysicalName()

Declaration:

Description:

Returns the full absolute path name of the database. If you are using a server, this is the name as understood by the server, after any mappings done due to the server's PTSERVER.CFG file.

PtBase::GetPhysicalServer()

Declaration:

Description:

Returns the physical name of the server, after any mappings due to the client's POET.CFG file.

PtBase::GetServer()

Declaration:

Description:

Returns the current server name by reference.

PtBase::GetState()

Declaration:

Description:

Returns the current database status. Here is the state table for a PtBase:

Previous state	Action	New state
Non-existent	call constructor	PtINITIALIZED
PtINITIALIZED	connect to server	PtCONNECTED
PtCONNECTED	open database	PtOPENED
PtCONNECTED	disconnect	PtINITIALIZED

Return value

PtBase::GetTypeMgr()

Declaration:

Description:

Returns a pointer to the type manager, which manages C++ base types and type manager types for POET. This function is useful primarily for some class dictionary and generic object programming.

PtBase::IsDictionary()

Declaration:

Description:

Returns a non-zero value if this database is a class dictionary. Every database has a class dictionary associated with it, and the class dictionary is also a database.

PtBase::IsWorkspace()

Declaration:

Description:

Returns a non-zero value if this database is a Workspace.

PtBase::MapName()

Declaration:

Description:

Maps a name using the configuration file entries.

Parameters:

This function can be used to map any names specified in the POET.CFG or PTSERVER.CFG configuration files. For instance, you can find the current value of "VerboseMode" by passing it as the second parameter to this function, or you can use this to see how logical names are mapped.

PtBase::MoveBase()

Declaration:

Description:

This function does not actually move a database, it just changes the name of the database in the foreign database table. If your database has ondemand references to objects in other databases, the names of these databases are kept in a table called the foreign database table. If the foreign database is moved to a different location or a different server, the foreign database table must be updated so that POET can find the foreign database.

Parameters:

PtBase::MoveServer()

Declaration:

Description:

This function changes the name of the server in the foreign database table. If your database has ondemand references to objects in other databases, the names of the servers are kept in a table called the foreign database table. If the foreign database is moved to a different location or a different server, the foreign database table must be updated so that POET can find the foreign database.

Parameters:

PtBase::Open()

Declaration:

Description:

Opens the database name on the current server. You will normally specify only the first parameter.

The inline function simply creates a PtString and calls the virtual function. This preserves polymorphism, but reduces the number of virtual functions, which can be important on some compilers.

Parameters:

Discussion:

In previous versions of POET, this was the only way to open a database. It is now possible to connect to a server and open a database using PtRoot:: GetBase(), which is generally better because it ensures that your application only opens a given database once - if the database is already open, it simply returns a pointer to the existing database. We generally recommend that you use PtRoot:: GetBase() instead of PtBase:: Open(). The database name is the name of the directory which contains the database files. It may be specified as a relative path or an absolute path. If you use a relative path under Windows, please note that the default home directory is the directory in which the executable resides. In previous versions of POET, this name was also interpreted as the schema name. This is no longer true. The database has the name of its class dictionary in its database header, and this class dictionary name will be used to open the dictionary. The dictionary, in turn, has the name of the class factory table in its header. This name must match the name used to generate the class factory files in the POET IDE.

You can use configuration files to map the database name or dictionary name to any physical directory anywhere on the network; for details, see the section on logical database names in the chapter "Configuration Files."

Returns:

PtBase::POET()

Declaration:

Description:

Returns a pointer to the PtRoot object for this database.

PtBase::Recover()

Declaration:

Description:

Commits any valid forward recovery logs to the database. There will only be a valid recovery log if the server crashed while writing to the database. Even then, you usually do not need to use this function, because POET always commits any valid forward recovery logs when it opens a database. Before calling this function, you must call PtBase:: Connect() to connect to the server (or to "LOCAL"), but the database should not be open. To protect the database, this function will fail if anybody has the database open - even if you have it open.

The inline function simply creates a PtString and calls the virtual function. This preserves polymorphism, but reduces the number of virtual functions, which can be important on some compilers.

Parameters:

PtBase::ReIndex()

Declaration:

Description:

Regenerates the indexes using the data from the objects in the database. Progress callbacks are generated while this is happening. Before calling this function, you must call PtBase:: Connect() to connect to the server (or to "LOCAL"), but the database should not be open. To protect the database, this function will fail if anybody has the database open - even if you have it open.

The inline function simply creates a PtString and calls the virtual function. This preserves polymorphism, but reduces the number of virtual functions, which can be important on some compilers.

Parameters:

Note:

PtBase::Update() calls ReIndex() only if it is necessary. If you call Update() instead of ReIndex() then you will not rebuild the indexes unless you really have to.

PtBase::Reorg()

Declaration:

Description:

Discards the indexes for the database and regenerates them using the data from the objects in the database. Also optimizes the disk allocation for any objects which have become fragmented. Progress callbacks are generated while this is happening.

Before calling this function, you must call PtBase:: Connect() to connect to the server (or to "LOCAL"), but the database should not be open. To protect the database, this function will fail if anybody has the database open - even if you have it open.

The inline function simply creates a PtString and calls the virtual function. This preserves polymorphism, but reduces the number of virtual functions, which can be important on some compilers.

Parameters:

PtBase::SetBeTypeSafe()

Declaration:

Description:

Sets run time type checking on or off. PtTRUE turns type checking on, PtFALSE turns it off.

PtBase::SetClientName()

Declaration:

Description:

Sets the client's name for this database and server. Should be called before connect().

PtBase::SetDefaultLock()

Declaration:

Description:

Sets the default lock for the database. Locks and default locks are described in the chapter "Locking".

PtBase::SetDefaultWatch()

Declaration:

Description:

Sets the default watch for the database. Watches and default watches are described in the chapter "Event Handling".

PtBase::TransactionLevel()

Declaration:

Description:

Returns the current transaction level for the database.

PtBase::Update()

Declaration:

Description:

When a dictionary has changes in its indexes, the database may need to be updated. This function updates the database indexes to allow you to open and use the database; it always makes as few changes as possible. If there are new indexes in the dictionary, it creates the new indexes. If indexes have changed, it does a PtBase::ReIndex(). If changes are so drastic that you need to do a PtBase::VersAll(), it does so. Progress callbacks are generated while this is happening.

Before calling this function, you must call PtBase:: Connect() to connect to the server (or to "LOCAL"), but the database should not be open. To protect the database, this function will fail if anybody has the database open - even if you have it open.

The inline function simply creates a PtString and calls the virtual function. This preserves polymorphism, but reduces the number of virtual functions, which can be important on some compilers.

Parameters:

PtBase::VersAll()

Declaration:

Description:

Uses schema versioning to convert all objects in the database to the most recent version that is registered in the class dictionary. Progress callbacks are generated while this is happening.

Before calling this function, you must call PtBase:: Connect() to connect to the server (or to "LOCAL"), but the database should not be open. To protect the database, this function will fail if anybody has the database open - even if you have it open.

The inline function simply creates a PtString and calls the virtual function. This preserves polymorphism, but reduces the number of virtual functions, which can be important on some compilers.

Parameters:

Copyright (c) 1996 POET Software, Inc. All rights reserved. Reproduction in whole or in part in any form or medium without the express permission of POET Software, Inc. is prohibited.