Guide Reference Contents Previous Next Index
Glossary
- ACID
- Acronym for the properties--atomicity, consistency, isolation, and durability--maintained when the operations within a transaction are applied to a database.
- autonomous partition (FTO)
- A partitioning of data within a federated database that can perform most database functions independently of any other autonomous partition, even if the others are completely unavailable.
- basic object
- An instance of a class that is derived from ooObj or implements the Persistent interface. A basic object is the fundamental unit of storage in an Objectivity/DB database.
- bidirectional relationship
- A relationship in which two related objects have references to each other.
- boot file
- A file that contains information used by an application or tool to locate and open a federated database.
- cache
- See Objectivity/DB cache and session cache.
- cardinality (of a relationship)
- A property of a relationship that specifies whether an object on one side of the relationship can be related to multiple objects on the other side. The cardinality of a relationship can be any one of the following: one to one, one to many, many to one, or many to many.
- clustering
- The process of assigning an object to a storage location when the object is made persistent. Clustering a basic object assigns it a location in a particular container; clustering a container assigns it a location in a particular database.
- clustering strategy
- An object of a class that implements the ClusterStrategy interface. A clustering strategy determines where to cluster objects when they are made persistent.
- connection
- An object (of class Connection) that represents a connection between an application and a federated database.
- container
- A grouping of basic objects in a database. Containers are the fundamental units of locking; when any basic object in a container is locked, the entire container is locked, effectively locking all basic objects in the container.
- database
- The second level in the Objectivity/DB storage hierarchy. A database contains one or more containers, which in turn contain fundamental units of persistent data, called basic objects. A database is physically maintained in a file.
- database image (DRO)
- A copy of a database contained in an autonomous partition.
- dead object
- An object that is no longer valid for Objectivity for Java operations. When you terminate a session, all objects that the session owns become dead objects. Objects also become dead when they are deleted within a session.
- deep copy
- An object created by setting the value of each field to a copy of the value in the corresponding field of another object.
- federated database
- The highest level in the Objectivity/DB storage model. A federated database consists of a system database and one or more application-defined databases. Each federated database maintains a global schema containing all class descriptions. See storage hierarchy.
- garbage-collectible container
- A container that adheres to the garbage-collection paradigm: If an object in the container is not a named root and cannot be reached by references and/or relationships from a named root, that object is considered to be garbage.
- growth factor (of a name map)
- The percentage by which the name map's hash table grows when it is resized. Each time the hash table is resized, the number of bins is increased by the growth factor, then rounded up to the nearest prime number.
- handler method (for a persistent event)
- A method of a persistence-capable class that is called when a persistent event occurs to an object of that class. The handler method performs whatever application-specific processing is required to respond to the event.
- index
- A data structure that maintains references to objects that have been sorted according to the values in one or more fields of the object. The sorting order is determined by the ordering of the fields specified in the keys of the index.
- journal file
- A file that contains a log of changes made during a transaction. It is used to restore the database if a transaction is aborted or its session is terminated abnormally. Journal files are removed after the normal completion of a transaction.
- maximum average density (of a name map)
- The average number of elements per bin allowed before the name map's hash table must be resized.
- MROW
- Multiple Readers, One Writer. A concurrency mechanism that allows a container to have multiple readers and one writer simultaneously.
- name map
- An unordered persistent collection of key-value pairs in which the key is a string and the value is a persistent object.
- name scope
- A set of names defined by a particular object to identify basic objects and containers; each name in the set is called a scope name.
- named root
- A persistent object that can be located by a root name, which is unique within the federated database or a particular database.
- non-garbage-collectible container
- A container in which all objects are assumed to be valid.
- non-persistence-capable class
- A class whose instances cannot be saved in a database.
- object conversion
- The process of converting persistent objects in a federated database to make their persistent data consistent with a new version of their class description in the schema.
- object graph
- A directed graph data structure consisting of objects linked to other related or associated objects. The links in a graph of persistent objects can be references in persistent fields, relationships, or memberships in persistent collections.
- Objectivity/DB cache
- A part of virtual memory that is allocated and managed by Objectivity/DB to allow high speed access to persistent objects. When a persistent object is retrieved from physical storage, Objectivity/DB places the page in which the object resides into the cache.
- Objectivity/DB object
- Any persistent object or storage object.
- OID
- Object identifier; a number that uniquely identifies a basic object within a federated database. An object's OID identifies its database, container within the database, logical page within the container, and logical slot on the page.
- page
- The minimum unit of transfer to and from disk and across networks. Objects reside in pages. The Objectivity/DB page size can be chosen by the database developer. These pages are not the same as operating system pages.
- persistence-capable class
- A class whose instances can be made persistent and saved in a database. All persistence-capable classes are derived from ooObj or implement Persistent.
- persistent collection
- An aggregate persistent object that can contain a variable number of elements; each element is either a persistent object, or a key-value pair whose value is a persistent object.
- persistent data
- The values in the persistent fields of a persistent object; these values are saved persistently in the federated database.
- persistent event
- A pre- or post-processing event; when a persistent object is involved in certain persistent operations, the object receives a persistent-event notification immediately before or after the persistent operation occurs. In response to the notification, the object can perform whatever application-specific processing is required.
- persistent field
- An application-defined field of a persistent object whose value is saved persistently if the object is written to a database. All nonstatic, nontransient, application-defined fields of persistence-capable classes are persistent by default.
- persistent object
- An object that has been assigned a storage location in the database where it will be stored. When you commit the transaction in which you create a persistent object, the object is saved in the database. A persistent object continues to exist and retains its data beyond the duration of the process that created it.
- persistor
- An object that provides persistence behavior on behalf of a persistent object.
- property (of a persistent object)
- Information about the object that is considered part of its internal representation; for example, information stored in fields defined by Objectivity for Java. Properties of a persistent object are not considered part of the object's persistent data.
- referential integrity
- A characteristic of an object that ensures that the object has references only to objects that actually exist. Maintaining referential integrity requires that, when any object is deleted, all references from other objects to the deleted object are removed.
- relationship
- A reference or link between one object and one or more other objects. Relationships may be one-to-one, one-to-many, many-to-one, or many-to-many. They may connect objects of the same class or different classes. In Objectivity/DB, relationships are persistent objects that are stored in the database.
- restricted thread policy
- A session's thread-management policy that requires a Java thread to be joined to the session before the thread can interact with the session (and its associated transaction).
- root dictionary
- A name map used by a database or a federated database to pair root names with the corresponding objects. The objects identified in the root dictionary are the named root of the database or federated database.
- root name
- A name that uniquely identifies a persistent object to a particular database or federated database. An object can have more than one root name within the same database, and can have a root name in more than one database. Objects that have root names are a named root of the database or federated database.
- roots container
- A special container of a database where the database stores its root dictionary; any object that becomes persistent when it is made a named root is also stored in this container.
- scalable collection
- A collection that can increase in size without performance degradation.
- schema
- A language-independent data model that describes the classes of all persistent objects maintained in a federated database.
- schema class name
- The name used in the schema to identify a persistence-capable class. Each application also has a schema class name for each persistence-capable class. When the application reads or writes an object, Objectivity for Java maps between the Java class name and the application's schema class name.
- schema evolution
- The process of modifying the schema of a federated database so that its class descriptions are consistent with new versions of the corresponding Java class.
- scope name
- The name that identifies an object within the name scope defined by a particular object.
- scope object
- An object that defines a name scope; each scope name in the name scope uniquely identifies an object to the scope object (but not to other objects).
- session
- An object (of class Session) that represents an extended interaction between an application and the connected federated database. An application can have multiple interactions, each corresponding to a particular subtask that the application performs.
- session cache
- A part of virtual memory in which a particular session keeps its persistent objects, organized by their object identifiers (OIDs).
- shallow copy
- An object created by setting the value of each field to the value in the corresponding field of another object.
- storage hierarchy
- The four-level hierarchy of containment relationships between objects in a federated database. Each non-leaf object in the hierarchy is a storage object; each leaf object is a basic object. The federated database is the root of the hierarchy; its databases form the second level of the hierarchy. Below each database are the containers stored in that database; below each container are the basic objects stored in that container
- storage object
- Any object representing a level of the Objectivity/DB storage hierarchy. The storage objects are federated databases, databases, and containers.
- system name
- A name, similar to a file name, that uniquely identifies a federated database, autonomous partition, database, or container to Objectivity/DB.
- thread policy
- The policy by which Java threads are allowed to interact with sessions. See restricted thread policy and unrestricted thread policy.
- transaction
- A unit of work an application applies to a federated database. Transaction control is used to make several database requests or operations appear to all users as a single, indivisible operation.
- transient field
- A field whose value is not saved persistently if the object is written to a database. Transient fields are specified with the transient modifier in the class declaration.
- transient object
- An object that exists only within the application that created it.
- unidirectional relationship
- A relationship in which one object has a reference to the related object, but the related object has no reference back to the relating object.
- unique index
- An index in which each indexed object has a unique combination of values in its key fields.
- unrestricted thread policy
- A session's thread-management policy that allows any Java thread to interact with the session (and its associated transaction).
Guide Reference Contents Previous Next Index
Copyright © 2000, Objectivity, Inc. All rights
reserved.