Glossary

• 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.



• 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.



• 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 instance variables and defines methods for all members of the class. Objects that have the same types of instance variables and have access to the same methods belong to the same class.



• class property  

  An instance variable 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.



• 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.



• 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.



• 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.



• Direct to Java Client  

  A WebObjects development approach that can generate a Java Client application from a model.



• Direct to Java Client Assistant  

  A tool used to customize a Direct to Java Client application.



• Direct to Web  

  A WebObjects development approach that can generate an HTML-based Web application from a model.



• Direct to Web Assistant  

  A tool used to customize a Direct to Web application.



• Direct to Web template  

  A component used in Direct to Web applications that can generate a Web page for a particular task (for example, a list page) for any entity.



• 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.



• 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.



• fetch specification  

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



• 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 instance variables) 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.



• Interface Builder  

  A tool used to create and edit graphical user interfaces like those used in Java Client applications.



• inverse relationship   

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



• Java Browser  

  A tool used to peruse Java APIs and class hierarchies.



• 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.



• 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.



• 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.



• look  

  In Direct to Web applications, one of three user interface styles. The looks differ in both layout and appearance.



• 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.



• Monitor  

  A tool used to configure and maintain deployed WebObjects applications capable of handling multiple applications, instances, and application servers at the same time.



• object  

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



• 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.



• Project Builder  

  A tool used to manage the development of a WebObjects application or framework.



• 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.



• property  

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



• prototype attribute  

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



• raw row fetching  

  An 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.



• reusable component  

  A component that can be nested within other components and acts like a dynamic element. Reusable components allow you to extend WebObject’s selection of dynamically generated HTML elements.



• request  

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



• request-response loop  

  The main loop of a WebObjects application that 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.



• rule  

  In the Direct to Web and Direct to Java Client approaches, a specification used to customize the user interfaces of applications developed with these approaches.



• Rule Editor  

  A tool used to edit the rules in Direct to Web and Direct to Java Client applications.



• 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.



• validation  

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



• WebObjects Builder  

  A tool used to graphically edit WebObjects components.