Glossary

• access layer  

  The classes in the package com.webobjects.eoaccess, which include the model-level classes EOEntity, EOAttribute, and EORelationship. You usually do not work with classes in this layer directly, but rather indirectly through an EOModel.



• adaptor, database  

  A mechanism that connects your application to a particular database server. For each type of server you use, you need a separate adaptor. WebObjects provides an adaptor for databases conforming to JDBC.



• adaptor, WebObjects  

  A process (or a part of one) that connects WebObjects applications to an HTTP server.



• adaptor layer  

  A sublayer of the access layer that provides classes that communicate directly with data sources.



• application object  

  An object (of the WOApplication class) that represents a single instance of a WebObjects application. The application object’s main role is to coordinate the handling of HTTP requests, but it can also maintain application-wide state information.



• attribute  

  In Entity-Relationship modeling, an identifiable characteristic of an entity. For example, lastName can be an attribute of an Employee entity. An attribute typically corresponds to a column in a database table. See also entity; relationship.



• batch faulting  

  An feature that allows you to reduce round-trips to the database by firing multiple faults in a single fetch. See also faulting.



• business logic  

  The rules associated with the data in a database that typically encode business policies. An example is automatically adding late fees for overdue items.



• CGI (Common Gateway Interface)  

  A standard for interfacing external applications with information servers, such as HTTP or Web servers.



• class  

  In object-oriented languages such as Java, a prototype for a particular kind of object. A class definition declares fields and defines methods for all members of the class. Objects that have the same types of fields and have access to the same methods belong to the same class.



• class property  

  A field in an enterprise object that meets two criteria: It’s based on an attribute in your model, and it can be fetched from the database. “Class property” can refer either to an attribute or to a relationship.



• Cocoa  

  An object-oriented application-development environment in Mac OS X.



• column  

  In a relational database, the dimension of a table that holds values for a particular attribute. For example, a table that contains employee records might have a column titled “LAST_NAME” that contains the values for each employee’s last name. See also attribute.



• component  

  An object (of the WOComponent class) that represents a Web page or a reusable portion of one.



• control layer  

  The classes in the package com.webobjects.eocontrol, which include EOEditingContext and EOEnterpriseObject. You use classes in this layer to fetch, create, manage, and save persistent data to a data source.



• data modeling  

  The process of building a data model to describe the mapping between a relational database schema and an object model.



• database server  

  A data storage and retrieval system. Database servers typically run on a dedicated computer and are accessed by client applications over a network.



• deep fetch  

  An option available to fetch specifications that causes database fetches to occur against the root table and any leaf tables. Applicable to inheritance hierarchies.



• deferred faults  

  A special kind of fault that represents a number of other faults in a single object. See also fault; faulting.



• delegation  

  A way of extending a class in an object-oriented framework. In object-oriented design methodology, delegation is a form of class composition.



• derived attribute  

  An attribute in a data model that does not directly correspond to a column in a database. Derived attributes are usually calculated from a SQL expression.



• dynamic element  

  A dynamic version of an HTML element. WebObjects includes a list of dynamic elements with which you can build components.



• enterprise object  

  A Java object that conforms to the key-value coding protocol and whose properties (instance data) can map to stored data. An enterprise object brings together stored data with methods for operating on that data. It allows this data to persist in memory. See also key-value coding; property.



• entity  

  In Entity-Relationship modeling, a distinguishable object about which data is kept. An entity typically corresponds to a table in a relational database; an entity’s attributes, in turn, correspond to a table’s columns. An entity is used to map a relational database table to a Java class. See also attribute; table.



• Entity-Relationship modeling  

  A discipline for examining and representing the components and interrelationships in a database system. Also known as ER modeling, this discipline factors a database system into entities, attributes, and relationships. See also object-relational mapping.



• EOModeler  

  A tool used to create and edit models.



• faulting  

  A mechanism used by Enterprise Objects to increase performance whereby destination objects of relationships are not fetched until they are explicitly accessed.



• fault  

  A type of object in Enterprise Objects that represents a partially formed enterprise object instance. Faults are proxy or stand-in objects that provide performance benefits by delaying the retrieval of data in an enterprise object until it’s absolutely needed.



• fetch specification  

  In Enterprise Objects applications, used to retrieve data from the database server into the client application, usually into enterprise objects.



• fetch timestamp  

  An attribute of an EOEditingContext that records the time of the most recent fetch of objects into that editing context.



• flattened attribute   

  An attribute that is added from one entity to another by traversing a relationship.



• foreign key  

  An attribute in an entity that gives it access to rows in another entity. This attribute must be the primary key of the related entity. For example, an Employee entity can contain the foreign key deptID, which matches the primary key in the entity Department. You can then use deptID as the source attribute in Employee and as the destination attribute in Department to form a relationship between the entities. See also primary key; relationship.



• inheritance  

  In object-oriented programming, the ability of a superclass to pass its characteristics (methods and fields) on to its subclasses, allowing subclasses to reuse these characteristics.



• instance  

  In object-oriented languages such as Java, an object that belongs to (is a member of) a particular class. Instances are created at runtime according to the specification in the class definition.



• inverse relationship   

  A relationship that goes in the reverse direction of another relationship. Also known as a back relationship.



• Java Client  

  A WebObjects development approach that allows you to create graphical user interface applications that run on the user’s computer and communicate with a WebObjects server.



• Java Foundation Classes  

  A set of graphical user interface components and services written in Java. The component set is known as Swing.



• JDBC  

  An interface between Java platforms and databases.



• join  

  An operation that provides access to data from two tables at the same time, based on values contained in related columns.



• key  

  An arbitrary value (usually a string) used to locate a datum in a data structure such as a dictionary. See also key-value coding.



• keypath  

  A chain of keys supported by key-value coding that allows for the traversal of relationships between enterprise objects. See also key-value coding.



• key-value coding  

  The mechanism that allows the properties in enterprise objects to be accessed by name (that is, as key-value pairs) by other parts of the application. See also keypath.



• locking  

  A mechanism to ensure that data isn’t modified by more than one user at a time and that data isn’t read as it is being modified.



• many-to-many relationship  

  A relationship in which each record in the source entity may correspond to more than one record in the destination entity, and each record in the destination may correspond to more than one record in the source. For example, an employee can work on many projects, and a project can be staffed by many employees. In Enterprise Objects, a many-to-many relationship is composed of multiple relationships. See also relationship.



• method  

  In object-oriented programming, a procedure that can be executed by an object.



• model  

  An object (of the EOModel class) that defines, in Entity-Relationship terms, the mapping between enterprise object classes and the database schema. This definition is typically stored in a file created with the EOModeler application. A model also includes the information needed to connect to a particular database server.



• notification  

  A mechanism within Enterprise Objects that provides an asychronous communication infrastructure between objects.



• object  

  A programming unit that groups together a data structure (fields) and the operations (methods) that can use or affect that data. Objects are the principal building blocks of object-oriented programs.



• object graph  

  Refers to the graph of objects (especially enterprise object instances) that are contained by EOEditingContext objects.



• object-relational mapping  

  A system for transforming Entity-Relationship models to an object-oriented programming framework. Enterprise Objects performs object-relational mapping (mapping database structures to Java objects) with the help of Entity-Relationship models called EOModels. See also Entity-Relationship modeling.



• prefetching  

  A feature in Enterprise Object that allows you to suppress fault creation for an entity’s relationships. Instead of creating faults, the relationship data is fetched when the entity is first fetched. See also faulting.



• primary key  

  An attribute in an entity that uniquely identifies rows of that entity. For example, the Employee entity can contain an empID attribute that uniquely identifies each employee.



• property  

  In Entity-Relationship modeling, an attribute or relationship. See also attribute; relationship.



• prototype attribute  

  A special type of attribute available in EOModeler to provide a template for creating attributes.



• raw row fetching  

  A possible option in a fetch specification that retrieves database rows without forming enterprise objects from those rows.



• record  

  The set of values that describes a single instance of an entity; in a relational database, a record is equivalent to a row.



• referential integrity  

  The rules governing the consistency of relationships.



• reflexive relationship  

  A relationship within the same entity; the relationship’s source join attribute and destination join attribute are in the same entity.



• relational database  

  A database designed according to the relational model, which uses the discipline of Entity-Relationship modeling and the data design standards called normal forms.



• relationship  

  A link between two entities that’s based on attributes of the entities. For example, the Department and Employee entities can have a relationship based on the deptID attribute as a foreign key in Employee, and as the primary key in Department (note that although the join attribute deptID is the same for the source and destination entities in this example, it doesn’t have to be). This relationship would make it possible to find the employees for a given department. See also foreign key; primary key; many-to-many relationship; to-many relationship; to-one relationship.



• relationship key  

  A key (an attribute) on which a relationship joins.



• request  

  A message conforming to the Hypertext Transfer Protocol (HTTP) sent from a user’s Web browser to a Web server to ask for a resource like a Web page. See also response.



• request-response loop  

  The main loop of a WebObjects application, which receives a request, responds to it, and awaits the next request.



• response  

  A message conforming to the Hypertext Transfer Protocol (HTTP) sent from the Web server to the user’s Web browser that contains the resource specified by the corresponding request. The response is typically a Web page. See also request.



• row  

  In a relational database, the dimension of a table that groups attributes into records.



• session  

  A period during which access to a WebObjects application and its resources is granted to a particular client (typically a browser). Also an object (of the WOSession class) representing a session.



• snapshotting  

  Part of the Enterprise Objects optimistic locking mechanism in which snapshots of database rows in memory are compared with the data in the database.



• table  

  A two-dimensional set of values corresponding to an entity. The columns of a table represent characteristics of the entity and the rows represent instances of the entity.



• target  

  A blueprint for building a product from specified files in your project. It consists of a list of the necessary files and specifications on how to build them. Some common types of targets build frameworks, libraries, applications, and command-line tools.



• template  

  In a WebObjects component, a file containing HTML that specifies the overall appearance of a Web page generated from the component.



• to-many relationship  

  A relationship in which each source record has zero to many corresponding destination records. For example, a department has many employees.



• to-one relationship  

  A relationship in which each source record has one corresponding destination record. For example, each employee has one job title.



• transaction  

  A set of actions that is treated as a single operation that either succeeds completely (COMMIT) or fails completely (ROLLBACK).



• uniquing  

  A mechanism to ensure that, within a given context, only one object is associated with each row in the database.



• update conflicts  

  The realm of database applicataion development that deals with the problem of multiple users or processess accessing and updating the same set of data simultaneously.



• update strategy  

  A strategy for managing update conflicts. See also update conflicts.



• validation  

  A mechanism to ensure that user-entered data lies within specified limits.



• WebObjects Builder  

  A tool used to graphically edit WebObjects components.