U.S. patent application number 10/966329 was filed with the patent office on 2005-11-24 for system and method for batch operation of cmp beans.
This patent application is currently assigned to BEA Systems, Inc.. Invention is credited to Chen, Michael, White, Seth.
Application Number | 20050262072 10/966329 |
Document ID | / |
Family ID | 35376433 |
Filed Date | 2005-11-24 |
United States Patent
Application |
20050262072 |
Kind Code |
A1 |
Chen, Michael ; et
al. |
November 24, 2005 |
System and method for batch operation of CMP beans
Abstract
The present invention improves the performance of storing
multiple instances of a CMP bean enrolled in a transaction by
utilizing CMP batch operations to update multiple entries in a
database table in one SQL statement only, thus avoiding multiple
database roundtrips. The batch operation of CMP beans can be
enabled by specifying certain options in a DTD file. As part of the
batch operation feature, another option may be added to the DTD
file as well, enabling the container to delay all database
operations in a transaction until the commit time, automatically
sort the database dependency between the operations, and send these
operations to the database in a way to avoid any potential database
constraint violations. This description is not intended to be a
complete description of, or limit the scope of, the invention.
Other features, aspects, and objects of the invention can be
obtained from a review of the specification, the figures, and the
claim.
Inventors: |
Chen, Michael; (Santa Clara,
CA) ; White, Seth; (San Francisco, CA) |
Correspondence
Address: |
FLIESLER MEYER, LLP
FOUR EMBARCADERO CENTER
SUITE 400
SAN FRANCISCO
CA
94111
US
|
Assignee: |
BEA Systems, Inc.
San Jose
CA
|
Family ID: |
35376433 |
Appl. No.: |
10/966329 |
Filed: |
October 15, 2004 |
Related U.S. Patent Documents
|
|
|
|
|
|
Application
Number |
Filing Date |
Patent Number |
|
|
60573217 |
May 21, 2004 |
|
|
|
Current U.S.
Class: |
1/1 ;
707/999.004; 707/E17.005; 707/E17.007 |
Current CPC
Class: |
G06F 16/24565 20190101;
Y10S 707/99942 20130101; Y10S 707/99943 20130101 |
Class at
Publication: |
707/004 |
International
Class: |
G06F 007/00 |
Claims
What is claimed is:
1. A system to provide batch operation for container-managed
components, comprising: a plurality of instances of a
container-managed component; a database maintaining a table
corresponding to the container-managed component; a batch of one or
more SQL statements maintained in an object, wherein each of the
one or more SQL statements is capable of performing one of
inserting, updating, and deleting operations against the database;
and said object capable of at least one of: generating an SQL
statement based on the plurality of instances; inserting the SQL
statement into the batch of the one or more SQL statements; and
executing the batch against a plurality of entries in the table in
the database; and a DTD file capable of defining one or more
features of the batch.
2. The system according to claim 1, wherein: The container-managed
component can be a CMP bean.
3. A system to provide batch operation for CMP beans, comprising: a
plurality of instances of a CMP bean; a database maintaining a
table corresponding to the CMP bean; a batch of one or more SQL
statements maintained in an object, wherein each of the one or more
SQL statements is capable of performing one of inserting, updating,
and deleting operations against the database; and said object
capable of at least one of: generating an SQL statement based on
the plurality of instances; inserting the SQL statement into the
batch of the one or more SQL statements; and executing the batch
against a plurality of entries in the table in the database; and a
DTD file capable of defining one or more features of the batch.
4. The system according to claim 3, wherein: the plurality of
instances can be enrolled, modified or updated by a
transaction.
5. The system according to claim 3, wherein: the database can be
one of a relational database, an object-oriented database, a DB2,
an Informix Database, an Oracle Database, an SQL Server, a Sybase
Database, a Point Base, and an SQL Server2000.
6. The system according to claim 3, wherein: the database is
further capable of feeding back the execution result of the batch
to the object.
7. The system according to claim 3, wherein: The object can be a
PreparedStatement.
8. The system according to claim 3, wherein: the number of
instances in the plurality instances is bounded by the maximum size
of the cache holding the plurality of instances.
9. The system according to claim 3, wherein: a feature in the one
or more features of the batch is capable of one of: enabling the
operation of the batch; sorting automatically the database
dependency between the one or more SQL statements in the batch; and
executing the batch against the database in such a way to avoid any
database constraint error.
10. The system according to claim 4, wherein: a feature in the one
or more features of the batch can be delaying the execution of the
batch against the database until the commit time of the
transaction.
11. A method to provide batch operation for container-managed
components, comprising: maintaining a plurality of instances of a
container-managed component in a cache; maintaining a table
corresponding to the container-managed component in a database;
maintaining a batch of one or more SQL statements in an object;
generating an SQL statement based on the plurality of instances;
inserting the SQL statement into the batch of the one or more SQL
statements; executing the batch against a plurality of entries in
the table in the database; and defining one or more features of the
batch.
12. A method to provide batch operation for CMP beans, comprising:
maintaining a plurality of instances of a CMP bean in a cache;
maintaining a table corresponding to the CMP bean in a database;
maintaining a batch of one or more SQL statements in an object;
generating an SQL statement based on the plurality of instances;
inserting the SQL statement into the batch of the one or more SQL
statements; executing the batch against a plurality of entries in
the table in the database; and defining one or more features of the
batch.
13. The method according to claim 12, further comprising:
enrolling, modifying or updating the plurality of instances via a
transaction.
14. The method according to claim 12, further comprising: feeding
back the execution result of the batch from the database.
15. The method according to claim 12, wherein: the SQL statement is
capable of performing at least one of inserting, updating, and
deleting operations against the database.
16. The method according to claim 12, further comprising: bounding
the number of instances in the plurality instances by the maximum
size of the cache holding the plurality of instances.
17. The method according to claim 12, wherein: a feature in the one
or more features of the batch is capable of one of: enabling the
operation of the batch; sorting automatically the database
dependency between the one or more SQL statements in the batch; and
executing the batch against the database in such a way to avoid any
database constraint error.
18. The method according to claim 13, further comprising: delaying
the execution of the batch against the database until the commit
time of the transaction via a feature in the one or more features
of the batch.
19. A machine readable medium having instructions stored thereon
that when executed cause a system to: maintain a plurality of
instances of a container-managed component in a cache; maintain a
table corresponding to the container-managed component in a
database; maintain a batch of one or more SQL statements in an
object; generate an SQL statement based on the plurality of
instances; insert the SQL statement into the batch of the one or
more SQL statements; execute the batch against a plurality of
entries in the table in the database; and define one or more
features of the batch.
20. A machine readable medium having instructions stored thereon
that when executed cause a system to: maintain a plurality of
instances of a CMP bean in a cache; maintain a table corresponding
to the CMP bean in a database; maintain a batch of one or more SQL
statements in an object; generate an SQL statement based on the
plurality of instances; insert the SQL statement into the batch of
the one or more SQL statements; execute the batch against a
plurality of entries in the table in the database; and define one
or more features of the batch.
21. The machine readable medium of claim 20, further comprising
instructions that when executed cause the system to: enroll, modify
or update the plurality of instances via a transaction.
22. The machine readable medium of claim 20, further comprising
instructions that when executed cause the system to: feedback the
execution result of the batch from the database.
23. The machine readable medium of claim 20, wherein: the SQL
statement is capable of performing at least one of inserting,
updating, and deleting operations against the database.
24. The machine readable medium of claim 20, further comprising
instructions that when executed cause the system to: bound the
number of instances in the plurality instances by the maximum size
of the cache holding the plurality of instances.
25. The machine readable medium of claim 20, wherein: a feature in
the one or more features of the batch is capable of one of:
enabling the operation of the batch; sorting automatically the
database dependency between the one or more SQL statements in the
batch; and executing the batch against the database in such a way
to avoid any database constraint error.
26. The machine readable medium of claim 21, further comprising
instructions that when executed cause the system to: delay the
execution of the batch against the database until the commit time
of the transaction via a feature in the one or more features of the
batch.
27. A system to provide batch operation for CMP beans, comprising:
means for maintaining a plurality of instances of a
container-managed component in a cache; means for maintaining a
table corresponding to the container-managed component in a
database; means for maintaining a batch of one or more SQL
statements in an object; means for generating an SQL statement
based on the plurality of instances; means for inserting the SQL
statement into the batch of the one or more SQL statements; means
for executing the batch against a plurality of entries in the table
in the database; and means for defining one or more features of the
batch.
28. A system to provide batch operation for CMP beans, comprising:
means for maintaining a plurality of instances of a CMP bean type
in a cache; means for maintaining a table corresponding to the CMP
bean type in a database; means for maintaining a batch of one or
more SQL statements in an object; means for generating an SQL
statement based on the plurality of instances; means for inserting
the SQL statement into the batch of the one or more SQL statements;
means for executing the batch against a plurality of entries in the
table in the database; and means for defining one or more features
of the batch.
29. A computer data signal embodied in a transmission medium,
comprising: a code segment including instructions to maintain a
plurality of instances of a container-managed component in a cache;
a code segment including instructions to maintain a table
corresponding to the container-managed component in a database; a
code segment including instructions to maintain a batch of one or
more SQL statements in an object; a code segment including
instructions to generate an SQL statement based on the plurality of
instances; a code segment including instructions to insert the SQL
statement into the batch of the one or more SQL statements; a code
segment including instructions to execute the batch against a
plurality of entries in the table in the database; and a code
segment including instructions to define one or more features of
the batch.
30. A computer data signal embodied in a transmission medium,
comprising: a code segment including instructions to maintain a
plurality of instances of a CMP bean type in a cache; a code
segment including instructions to maintain a table corresponding to
the CMP bean type in a database; a code segment including
instructions to maintain a batch of one or more SQL statements in
an object; a code segment including instructions to generate an SQL
statement based on the plurality of instances; a code segment
including instructions to insert the SQL statement into the batch
of the one or more SQL statements; a code segment including
instructions to execute the batch against a plurality of entries in
the table in the database; and a code segment including
instructions to define one or more features of the batch.
Description
CLAIM OF PRIORITY
[0001] This application claims priority from the following
application, which is hereby incorporated by reference in its
entirety:
[0002] U.S. Provisional Patent Application No. 60/573,217, entitled
SYSTEM AND METHOD FOR BATCH OPERATION OF CMP BEANS by Michael Chen,
et al., filed May 21, 2004 (Attorney Docket No. BEAS-01681US0
SRM/DTX).
COPYRIGHT NOTICE
[0003] A portion of the disclosure of this patent document contains
material which is subject to copyright protection. The copyright
owner has no objection to the facsimile reproduction by anyone of
the patent document or the patent disclosure, as it appears in the
Patent and Trademark Office patent file or records, but otherwise
reserves all copyright rights whatsoever.
FIELD OF THE INVENTION
[0004] This invention relates to the field of batch operation on
EJBs.
BACKGROUND
[0005] A container-managed software component relies on the
container to perform persistent data access on behalf of the object
of the component. Here the application component can be an instance
of a programmable class (also referred to as class), which can be
but is not limited to, a Java bean, an Enterprise Java Bean (EJB),
an interface, a module, and other suitable concepts, and
container-managed persistence (CMP) bean will be used to illustrate
the various embodiments of the invention in the following context.
An Enterprise Java Bean (EJB) is a server-side application
component that encapsulates the business logic of an application.
The instances of an EJB are created and managed at runtime by a
container, which runs as part of an application server to provide
enterprise applications with a high level of abstraction. A
container-managed persistence (CMP) bean, especially an entity
bean, relies on the container to perform persistent data access on
behalf of the instances of the EJB. The container transfers data
between an instance of a CMP bean and the underlying data source
(such as a database) as a result of the execution of the methods of
the EJB, such as SQL statements. On the contrary, a bean-managed
persistence (BMP) bean relies on the own methods of the EJB to
perform persistent data access on behalf of the instances of the
BMP bean.
[0006] The CMP bean corresponds to a table in the underlying
database while each instance of the CMP bean often corresponds to
an entry in the table. Here, the database can be a relational
database, an object-oriented database, a DB2, an Informix Database,
an Oracle Database, an SQL Server, a Sybase Database, a Point Base,
and an SQL Server2000, and other suitable database. Multiple
instances of the same type of CMP bean are often modified and/or
updated in a single transaction they are enrolled in. Sometimes, a
transaction needs to update thousands of CMP bean instances, and
causes thousands of database roundtrips as the result. Such process
is not very efficient, and may become a performance bottleneck.
Users would either have to suffer the performance consequence or
use SQL statements directly to update entries in the database,
neither approach is very desirable.
BRIEF DESCRIPTION OF THE DRAWINGS
[0007] FIG. 1 is an illustration of an exemplary in accordance with
one embodiment of the present invention.
[0008] FIG. 2 is a flow chart illustrating a process in accordance
with one embodiment of the present invention.
DETAILED DESCRIPTION
[0009] The invention is illustrated by way of example and not by
way of limitation in the figures of the accompanying drawings in
which like references indicate similar elements. It should be noted
that references to "an" or "one" or "some" embodiment(s) in this
disclosure are not necessarily to the same embodiment, and such
references mean at least one.
[0010] Embodiments of the present invention improve the performance
of storing multiple instances of the same type of CMP bean enrolled
in a transaction by utilizing CMP batch operations to update
multiple entries in a database table in one SQL statement only,
thus avoiding multiple database roundtrips. Here, the term "batch
operation" refers to database update for the follow SQL statements:
"insert", "update", "delete", and other suitable statements. The
batch operation of CMP beans can be enabled by specifying an
<enable-batch-operations> option in a Document Type
Definition (DTD) file such as weblogic-rdbms20-persistence--
710.dtd, which is a specific document defining and constraining
definitions or set of statements that follow the rules of XML. As
part of the batch operation feature, a new option
<order-database-operations&g- t; may be added to the DTD
file as well, enabling the container to delay all database
operations in a transaction until the commit time, automatically
sort the database dependency between the operations, and send these
operations to the database in a way to avoid any potential database
constraint violations.
[0011] The following is a comparison study of database updates with
and without the batch operation being enabled. In this scenario,
"n" rows (ranging from 1 to 20) are updated to a table containing
three columns. The update with batch results in one roundtrip,
while the update without batch results in "n" roundtrips. The
results shown in the table below are measured in milliseconds, and
are averaged over 100 runs.
1 Rows 1 10 20 Without Batch 10.42 127 254 With Batch 10.61 26
32
[0012] As the results show, the time taken with batch operation
enabled increases at a much slower pace than the time taken without
batch, resulting in big performance improvements when a transaction
is enrolling many CMP bean instances. On the other hand, updating a
single row with batch causes less than 1% of performance
degradation than without batch, indicating that batch operation
should be used as default since the performance degradation is
minimal even when only a single row is updated.
[0013] FIG. 1 is an illustration of a system supporting batch
operations for CMP beans in one embodiment of the present
invention. Although this diagram depicts components as functionally
separate, such depiction is merely for illustrative purposes. It
will be apparent to those skilled in the art that the components
portrayed in this figure can be arbitrarily combined or divided
into separate software, firmware and/or hardware components.
Furthermore, it will also be apparent to those skilled in the art
that such components, regardless of how they are combined or
divided, can execute on the same computing device or multiple
computing devices, and wherein the multiple computing devices can
be connected by one or more networks.
[0014] Referring to FIG. 1, an object called PreparedStatement 101
in a container 100 includes a list (batch) of SQL statements 102,
each of which can be a type of one of: insert 103, update 104 and
delete 105. The PreparedStatement is capable of generating the list
of SQL statements based on the CMP instances 108 of the same type
in a EJB instance cache 107, wherein these CMP instances are
enrolled, modified and/or updated by a transaction 109. The
PreparedStatement then adds those statements to a batch and
executes the batch against an underlying database 110 to write
multiple CMP bean instances to entries in a corresponding table in
the database in one roundtrip. The database may feedback the result
of the batch operation back to PreparedStatement. The batch
operation features of the CMP beans can be enabled by a DTD file
106 with certain options activated.
[0015] FIG. 2 is a flow chart illustrating an exemplary batch
operation for CMP beans in accordance to one embodiment of the
invention. Although this figure depicts functional steps in a
particular order for purposes of illustration, the process is not
limited to any particular order or arrangement of steps. One
skilled in the art will appreciate that the various steps portrayed
in this figure could be omitted, rearranged, combined and/or
adapted in various ways.
[0016] Referring to FIG. 2, various features enabling batch
operations of CMP beans are defined in DTD file at step 201. At
step 202, an SQL statement of a certain type (insert, update,
delete) can be generated based on the list of CMP instances that
are enrolled, updated and/or modified by a transaction. Such SQL
statement can then be inserted into a batch at step 203. The batch
of SQL statements is then executed against a database at step 204,
where each SQL statement updates multiple entries in a database
table. The database may feedback the execution of the batch at step
205. If it is determined that the batch operation is not successful
at step 206, the batch may be executed again at step 204.
[0017] In some embodiments, a Java object named PreparedStatement
is utilized, representing one or more precompiled SQL statements
that can then be used to efficiently execute these SQL statements
multiple times as one batch. The setter methods (setShort,
setString, and so on) in a PreparedStatement for setting IN values
of input parameters must specify types that are compatible with the
defined SQL type. For instance, if the IN parameter has SQL type
INTEGER, then the setter method setInt should be used. If arbitrary
parameter type conversions are required, the method setObject
should be used with a target SQL type. In the following example of
setting a parameter, con represents an active connection:
2 PreparedStatement pstmt = con.prepareStatement("UPDATE EMPLOYEES
SET SALARY = ? WHERE ID = ?"); pstmt.setBigDecimal(1, 153833.00)
pstmt.setInt(2, 110592)
[0018] In some embodiments, batch operation (batching) features in
the PreparedStatement, such as addBatch( ) and executeBatch( )
method are used to reduce the number of database roundtrips, both
of the methods are implemented using an JDBC driver to the
underlying database. A given SQL command (statement) is added to
the list of commands in the current PreparedStatement object via
addBatch( ). The commands in the list can then be executed as a
batch by calling the method executeBatch( ). Note that batching
features in the PreparedStatement is not supported by all JDBC
drivers.
[0019] In some embodiments, once a batch of SQL commands is
submitted to the underlying database for execution and if all of
them execute successfully, an array of update counts will be
returned. The int elements of the returned array are ordered to
correspond to the commands in the batch, according to the order in
which the commands were added to the batch. An element in the array
returned by the method executeBatch( ) may be one of the
following:
[0020] 1. A number greater than or equal to zero--indicates that
the command was executed successfully and is an update count giving
the number of rows in the database that were affected by the
execution of the command.
[0021] 2. A value of SUCCESS_NO_INFO--indicates that the command
was executed successfully but that the number of rows affected is
unknown.
[0022] If one of the commands in the list of the batch fails to
execute properly, executeBatch( ) throws a BatchUpdateException,
and a JDBC driver may or may not continue to process the remaining
commands in the batch. However, the behavior of the driver must be
consistent with a particular DBMS, either always continuing to
process commands or never continuing to process commands. If the
driver continues processing after a failure, the array returned by
the method BatchUpdateException.getUpdat- eCounts( ) will contain
as many elements as there are commands in the batch, and at least
one of the elements will be the following:
[0023] 3. A value of EXECUTE_FAILED--indicates that the command
failed to execute successfully, occurring only if a driver
continues to process commands after a command fails.
[0024] In some embodiments, the CMP batch operation of a
PreparedStatement only works when commands in the batch is the same
SQL statement (for the same type of CMP bean) with different
parameter values only. For the same type of CMP bean, it is
possible to have maximum of three SQL commands, "insert", "update",
and "delete". If all three of them are generated for a CMP bean,
they will be executed in that order. Since a CMP batch operation
may include all three SQL commands, three different type of SQL
statements will be generated:
[0025] 1. For "insert", the SQL statement contains the list of all
of the fields that will be generated to make the database
insert.
[0026] 2. For "update", the SQL statement containing the union of
all the changed fields will be generated by iteration through all
modified instances of the CMP bean.
[0027] 3. For "delete", the SQL statement containing the Primary
Key (PK) field of the CMP bean instances will be generated to make
database delete.
[0028] After the SQL statement is created, container will iterate
though the list of modified instances of the CMP bean to set the
values of the fields in the SQL statements, and add these
statements to the batch via addBatch( ). For "update", the
container will iterate the list of modified instances of the CMP
bean twice to create a single SQL statement if the CMP bean having
more than one field modified.
[0029] In some embodiments, different types of CMP beans will
create different SQL statements in different batch operations if
batch operations are enabled for a transaction enrolling multiple
bean instances of different types of CMP beans. Instances of each
CMP bean type may have maximum of three SQL statements in a batch,
one for each type of SQL command. Each bean instance will set the
values of the fields in its SQL statements to be executed in the
batch.
[0030] In some embodiments, the batch operation applies only to
changes within a transaction. The updates within a single
transaction can be executed by one of:
[0031] 1. Using a single server side method to wrap all entity bean
method invocations, for example, a method to wrap all the entity
bean method invocations.
[0032] 2. Setting the transaction boundary explicitly.
[0033] In some embodiments, the total number of the instances
modified in a batch operation can not exceed the limit on the
maximum size of the cache holding instances of a certain type of
CMP bean. Such limit can be the <max-beans-in-cache>
attribute specified in the deployment descriptor of the container.
Since a transaction can not enroll more than
<max-bean-in-cache> number of CMP instances (otherwise, the
transaction will be rolled back), the number of CMP bean instances
in a batch can not exceed <max-bean-in-cache>.
[0034] In some embodiments, a new <enable-batch-operations>
option is added to a DTD file such as
weblogic-rdbms20-persistence-710.dtd to enable the container to
perform batch operations and allow the update of multiple entries
in a database table in one SQL statement.
[0035] <!ELEMENT enable-batch-operations (#PCDATA)>
[0036] The valid values of the option are "true", "True", "false"
or "False" with "true" being the default value. If this option is
set to true, the option of <order-database-operations>
discussed below will be set to true automatically, and EJB
container will delay all of the database operations in a
transaction until the commit time.
[0037] In some embodiments, a new option
<order-database-operations> is added to the
weblogic-rdbms20-persistence-710.dtd too as part of the CMP batch
operation feature.
[0038] <!ELEMENT order-database-operations (#PCDATA)>
[0039] The valid values of the option are "true", "True", "false"
or "False" with "true" being the default value. This option is used
for the container to delay all database operations by the SQL
statements in the batch until the commit time of a transaction that
enrolls the corresponding CMP instances, automatically sort the
database dependency between the operations, and send these
operations to database in such a way to avoid any database
constraint errors, such as the Foreign Key (FK) constraint
error.
[0040] Both <enable-batch-operations> and
<order-database-operati- ons> can be specified in the
<weblogic-rdbms-jar> at Java Archive (JAR) level as
follows:
3 <!ELEMENT weblogic-rdbms-jar ( weblogic-rdbms-bean+,
weblogic-rdbms-relation*, order-database-operations?,
enable-batch-operations?, create-default-dbms-tables?,
validate-db-schema-with?, database-type? )>
[0041] One embodiment may be implemented using a conventional
general purpose or a specialized digital computer or
microprocessor(s) programmed according to the teachings of the
present disclosure, as will be apparent to those skilled in the
computer art. Appropriate software coding can readily be prepared
by skilled programmers based on the teachings of the present
disclosure, as will be apparent to those skilled in the software
art. The invention may also be implemented by the preparation of
integrated circuits or by interconnecting an appropriate network of
conventional component circuits, as will be readily apparent to
those skilled in the art.
[0042] One embodiment includes a computer program product which is
a machine readable medium (media) having instructions stored
thereon/in which can be used to program one or more computing
devices to perform any of the features presented herein. The
machine readable medium can include, but is not limited to, one or
more types of disks including floppy disks, optical discs, DVD,
CD-ROMs, micro drive, and magneto-optical disks, ROMs, RAMs,
EPROMs, EEPROMs, DRAMs, VRAMs, flash memory devices, magnetic or
optical cards, nanosystems (including molecular memory ICs), or any
type of media or device suitable for storing instructions and/or
data.
[0043] Stored on any one of the computer readable medium (media),
the present invention includes software for controlling both the
hardware of the general purpose/specialized computer or
microprocessor, and for enabling the computer or microprocessor to
interact with a human user or other mechanism utilizing the results
of the present invention. Such software may include, but is not
limited to, device drivers, operating systems, execution
environments/containers, and applications.
[0044] The foregoing description of the preferred embodiments of
the present invention has been provided for the purposes of
illustration and description. It is not intended to be exhaustive
or to limit the invention to the precise forms disclosed. Many
modifications and variations will be apparent to the practitioner
skilled in the art. Particularly, while the concept "bean" is used
in the embodiments of the systems and methods described above, it
will be evident that such concept can be interchangeably used with
equivalent concepts such as, class, method, type, interface,
component, object model, and other suitable concepts. While the
concept "instance" is used in the embodiments of the systems and
methods described above, it will be evident that such concept can
be interchangeably used with equivalent concepts such as, object,
and other suitable concepts. While the concept "option" is used in
the embodiments of the systems and methods described above, it will
be evident that such concept can be interchangeably used with
equivalent concepts such as, attribute, field, element, and other
suitable concepts. Embodiments were chosen and described in order
to best describe the principles of the invention and its practical
application, thereby enabling others skilled in the art to
understand the invention, the various embodiments and with various
modifications that are suited to the particular use contemplated.
It is intended that the scope of the invention be defined by the
following claims and their equivalents.
* * * * *