Search Images Maps Play YouTube News Gmail Drive More »
Sign in
Screen reader users: click this link for accessible mode. Accessible mode has the same essential features but works better with your reader.

Patents

  1. Advanced Patent Search
Publication numberUS20040107183 A1
Publication typeApplication
Application numberUS 10/308,792
Publication dateJun 3, 2004
Filing dateDec 3, 2002
Priority dateDec 3, 2002
Also published asUS7149752, US8321467, US20070143337
Publication number10308792, 308792, US 2004/0107183 A1, US 2004/107183 A1, US 20040107183 A1, US 20040107183A1, US 2004107183 A1, US 2004107183A1, US-A1-20040107183, US-A1-2004107183, US2004/0107183A1, US2004/107183A1, US20040107183 A1, US20040107183A1, US2004107183 A1, US2004107183A1
InventorsJohn Mangan
Original AssigneeJp Morgan Chase Bank
Export CitationBiBTeX, EndNote, RefMan
External Links: USPTO, USPTO Assignment, Espacenet
Method for simplifying databinding in application programs
US 20040107183 A1
Abstract
A method for communicating between an application and a database by using a lightweight stored procedure data-binding framework for applications written in object oriented programming languages such as Java, significantly reduces the coding effort required to communicate with a relational database. Once the developer specifies the needed tabular data, the inventive framework generates all needed data objects and stored procedures to accomplish the interaction with that database data. The automatically generated code is then used by the application via a run-time component. This means the developer need only make simple calls in a few lines of code for database interaction. The encapsulated data model deals only with persistence and retrieval issues and is therefore de-coupled from the business model. The developer can therefore concentrate on implementing a complex business object model. And, changes to the business object models have no direct impact on the underlying persistence model. Automatic code generation reduces a developer's coding time by up to 90%. Moreover, coding errors are virtually eliminated since the generated code is not prone to manual coding errors. Thus, testing time is reduced as well.
Images(4)
Previous page
Next page
Claims(17)
We claim:
1. A method of communicating between an application and a database comprising the steps of:
providing a database;
providing an application;
providing a databinding framework;
generating databinding files to bind the database data to the application program; and
providing a run-time component to integrate the generated databinding files into the application when the application is run.
2. The method of claim 1 wherein providing the database comprises providing a relational database.
3. The method of claim 1 wherein providing the database comprises providing a relational Sybase database.
4. The method of claim 1 wherein providing the database comprises providing a relational Microsoft SQL Server database.
5. The method of claim 1 wherein providing the database comprises providing a relational Oracle database.
6. The method of claim 1 wherein providing the application comprises providing an application written in an object oriented language.
7. The method of claim 1 wherein providing the application comprises providing an application written in Java.
8. The method of claim 1 wherein providing the application comprises providing an application written in C++.
9. A method of databinding a relational database to an application comprising the steps of:
providing a relational database residing on a tangible computer readable medium;
providing an application written in an object oriented computer language residing on the tangible computer medium;
providing a databinding framework;
identifying tables to persist data in the database;
generating a table of metadata from the identified tables;
generating stored procedures from the metadata;
generating Value Objects (VO) from the metadata;
generating an XML binding definition from the metadata;
providing Data Access Objects (DAO); and
running the application with a run-time component that integrates the stored procedures, VOs, XML binding definitions and DAOs.
10. The method of claim 9 wherein generating the Value Objects comprises generating JavaBeans.
11. The method of claim 9 wherein providing the relational database comprises providing a relational Sybase database.
12. The method of claim 9 wherein providing the relational database comprises providing a relational Microsoft SQL server database.
13. The method of claim 9 wherein providing the relational database comprises providing a relational Oracle database.
14. The method of claim 9 wherein providing the application written in an object oriented computer language comprises providing an application written in Java.
15. The method of claim 9 wherein providing the application written in an object oriented computer language comprises providing an application written in C++.
16. The method of claim 9 wherein providing the databinding framework comprises providing an SPBinder framework.
17. The method of claim 9 wherein running the application with a run-time component comprises running the application with a run-time component comprising the subcomponents of SPBinder Manager, SPConnection, SPCaller, and SPCacheManager.
Description
    FIELD OF THE INVENTION
  • [0001]
    This invention relates to a method for the exchange of data between an application program and a database using a framework, and in particular to a method, using a databinding framework, that automatically generates computer code for reducing the number of lines of application code that need to be written by the developer for database operations. The method is particularly useful with complex business and financial application programs.
  • BACKGROUND OF THE INVENTION
  • [0002]
    Computer programs (applications) can be very complex. Such applications might perform calculations needed for financial transactions. For example, financial applications can facilitate the buying or selling of business or financial instruments such as derivatives. The complexity involves the number and type of calculations performed by the application, the large volume of data on which the application bases those calculations and the computed data representing the results of the application's computations. Software developers generally write these applications in a high level computer programming language. Object Oriented languages, such as Sun's Java and its various versions as J2EE (the “enterprise edition”) are particularly well suited for very large complex applications.
  • [0003]
    The data that represents the inputs and outputs of the application can be voluminous. And, in large companies and financial institutions, it is likely that the data is shared by several applications. In such large and complex systems, the data representing all of the information needed by the application (inputs) and processed information (outputs) is generally stored on one or more databases that are semiautonomous of the application, i.e. the application does not directly read and write information to the databases. It communicates with the database through a database management program. Sybase, Microsoft SQL Server, and Oracle are exemplary of such commercial database products.
  • [0004]
    One aspect of database programs is that the data is stored, read, and written in the form of tables. Database data is typically grouped in tables by similar characteristics, and the database program maintains the relationships between the tables. For example, the characteristics of a particular financial instrument might be found in one table while it's trading history can be found in another table. These tables can be then be related by the identifier of the instrument. Table based database systems are known as relational databases. Relational database programs are optimized for searching, for reporting selected data from the database, and for writing data to selected data tables.
  • [0005]
    Communication with commercial databases is typically done via a structured query language (SQL). SQL lines can use variable input parameters, such as the name of a financial instrument, or a date, or range of dates. Many lines of SQL code may be required for a given database operation. Stored procedures are lists of SQL code that allow for input parameters and generate tabular result sets. The stored procedures are generally stored in the database.
  • [0006]
    By contrast, applications are usually written in high level object oriented languages. Object oriented languages such as J2EE offer very powerful and computationally efficient computing environments for solving business calculations. (The calculations are typically presented to the application developer as a set of rules known as the business model). Object Oriented languages are designed to work with objects. Objects are programming structures of the application that contain both functions and the corresponding data for a given computational task. They are generally focused on solving a particular problem.
  • [0007]
    An application runs on one or more computers. During “runtime” it typically reads and writes large volumes of information in the form of data. After a particular run, the program needs to save a great deal of information so that the next time it runs, it continues one or more calculations from the previous ending state. Also, some data within objects simply needs to be saved in the database. Persistence refers to the ability of the application to save various conditions of the application and data at the end of a run so that it is available to the application at the beginning of the next run.
  • [0008]
    Object oriented languages are becoming ever more rich in their ability to interact with other systems and programs such as commercial database programs. They do this by offering a suite of libraries that provide pre-written application programming interfaces (API) for application developers. For example J2EE offers tools to communicate with database programs such as Sybase. Even with these tools, the Java programmer still must write many lines of Java code and then many lines of SQL code (stored procedures) to perform a given database operation. Depending on the complexity of the interaction, it can literally take weeks for a programmer to write all of the needed code for an interaction between the application and the database, as between Java and Sybase. And, because the stored procedures can comprise many lines of very detailed SQL code, there is a very good chance for coding errors. Proof reading such code is difficult and time consuming.
  • [0009]
    Because the application handles information as part of its objects, and the database handles information as tables, the data structures must be converted for the two programs to communicate with each other. One approach is to provide a system that maps tabular data to objects in a way that is transparent to the programmer writing the application. This system of binding tabular data to objects is called databinding. In databinding, objects can be written that deal only with the information to be exchanged. Similarly, stored procedures can be written to only carry out the corresponding database interactions. The stored procedures are “lightweight” in the sense that they do not perform any business calculations. A method, or framework, to manage data for an application is ideally “encapsulated”. That is, it is isolated from the application's business calculations (the business model).
  • [0010]
    What is needed is a method that implements a lightweight stored procedure framework whereby the applications programmer solving a business model need only specify a few simple lines of code to communicate with the tabular data in a relational database.
  • SUMMARY OF THE INVENTION
  • [0011]
    A method for communicating between an application and a database by using a lightweight stored procedure data-binding framework for applications written in object oriented programming languages such as Java. The method significantly reduces the coding effort required to communicate with a relational database. Once the developer specifies the needed tabular data, the inventive framework generates all needed data objects and stored procedures to accomplish the interaction with that database data. The automatically generated code is then used by the application via a run-time component. This means the developer need only make simple calls in a few lines of code for database interaction.
  • [0012]
    The encapsulated data model deals only with persistence and retrieval issues and is therefore de-coupled from the business model. The developer can therefore concentrate on implementing a complex business object model. And, changes to the business object models have no direct impact on the underlying persistence model. The encapsulated method provides a generic configurable means of persisting and retrieving objects to and from a relational database. While it is described in a Java-Sybase environment embodiment, the method is applicable to other object oriented languages and database programs.
  • [0013]
    Automatic code generation reduces a developer's coding time by up to 90%. Moreover, coding errors are virtually eliminated since the generated code is not prone to manual coding errors. Thus, testing time is reduced as well.
  • BRIEF DESCRIPTION OF THE DRAWINGS
  • [0014]
    The advantages, nature and various additional features of the invention will appear more fully upon consideration of the illustrative embodiments now to be described in detail in connection with the accompanying drawings. In the drawings:
  • [0015]
    [0015]FIG. 1 is a simplified block diagram showing the databinding framework.
  • [0016]
    [0016]FIG. 2 is a simplified block diagram of the framework's generator component.
  • [0017]
    [0017]FIG. 3 is a simplified block of the framework's run-time components.
  • [0018]
    It is to be understood that the drawings are for the purpose of illustrating the concepts of the invention, and except for the graphs, are not to scale. It is also understood that all application code, other framework code, the database program, and data reside on tangible computer readable media and run on one or more computer systems.
  • DESCRIPTION
  • [0019]
    The application is divided into two parts. Part I discusses the invention as a general framework solution for object oriented applications that access data from database programs using a structured query language (SQL) and groups of SQL calls as stored procedures. Part II of the application, for those skilled in the art, is an example of the inventive framework for the Java J2EE and Sybase programming environments.
  • [0020]
    Part I: A Lightweight Stored Procedure Data-Binding Framework For Business And Financial Applications
  • [0021]
    The inventive framework comprises two distinct components. A code generator is used during program development to automatically generate required stored procedures, Java code, and an XML data exchange and documentation middle layer. A second component, the run-time component integrates the generated code into the running business application as library routines so that the business program can retrieve, store, and persist data with very minimal Java code, usually with only one or two lines of Java code.
  • [0022]
    The method of databinding database relational tables to application objects shown in FIG. 1. In Block A, the application is provided and in Block B, the database. The framework discussed in Parts I and II is provided in Block C. Using the method, first databinding files are generated in Block D, and finally those databinding files are integrated into the application at run-time by the run-time component of the framework provided in Block E.
  • [0023]
    The Code Generator of the Framework:
  • [0024]
    The code generator is shown in FIG. 2. The developer supplies a list 101 of needed data specified as database table names. By way of example, the developer here is interacting with table “table_one” 102. The data (information) corresponding to table_one resides in relational database 103. The generating tool initially parses the required tabular data and generates table meta-data 104 in the form of database 102 primary keys, columns, and data types.
  • [0025]
    Based on meta-data 104, the code generator creates three types of output files, all of which are used later during the running of the business or financial application (hereinafter “application”) via the framework's run-time component. The generated stored procedures 105 are the part of the framework that communicate most directly with the relational database.
  • [0026]
    The generated XML files 106 create a “middle layer” of the framework. They are written in the eXtensible Markup Language (XML). These files act as the “glue” by defining what each stored procedure is called, and what its input and output parameters are. At run-time, the XML documents (configuration files) reside between the stored procedures that directly access database 102 and the Java code of the application. The XML documents can be read directly as text documents. Because XML documents are structured and nested, they are also self-explanatory and self-documenting.
  • [0027]
    The code generator also writes value objects 107. The value objects, generated “beans” in Java, are part of an object class for exchanging data with the database. They provide the final links that ultimately map the tables of relational database 102 to the application written in an object oriented language such as Java. Following the philosophy of frameworks created in object oriented programming environments, the value objects perform only functions related to information exchange between database 102 and the application. No business rules are calculated in these objects. Business rules can be computed solely by the application.
  • [0028]
    Blocks 108 to 110 further illustrate the roles of the each of the three generated sections of code. Block 108 shows the generated stored procedures 105. The stored procedures 105 of block 108 communicate via the generated XML configuration files of XML code 106, as shown by block 109, with the application. The generated value objects 107, for example JavaBeans, complete the databinding by providing the final mapped data in a form suitable for use in the run-time object oriented environment of the application, as shown by block 110. Thus the stored procedures of block 108 are “connected” to the value objects of block 110 by the generated XML middle layer 109.
  • [0029]
    The Run-Time Component of the Framework:
  • [0030]
    [0030]FIG. 3 shows the run-time component 200 of the framework. It illustrates the method by which the code generated by the code generation component is used during the running (run-time) of application. Computations of business rules 205 are done as part of objects 206 in the Business Model Tier 207. Information (data) exchange is done in Data Access Tier 208.
  • [0031]
    Data Access Tier 208 comprises the code generated by the code generator. Run-time component 200 integrates the generated code into the application. The generated stored procedures 108, generated XML middle layer 109, and generated value objects 110 are tied together by run-time component 200. Data Access Objects (DAOs) 204 are the simplified lines of code (calls) from the objected oriented application. DAOs 204 are hand written into the application by the developer.
  • [0032]
    Run-time component 200 comprises subcomponents 201-204. Caller 201 provides interaction to the database via a unique identifier for each XML binding document. Connection manager 202 provides for physical connections to the database. Binder Manager 203 maps the stored procedures to the value objects during application startup. And, Cache Manager 204 can cache store procedure results as list of value objects in memory for a time for quicker application access.
  • [0033]
    Using the inventive framework, the developer starts with an existing relational data model. Then the tables that will be used to persist the application's data are identified. A table of metadata is generated from the list of table names by the code generator from which the code generator creates the Load, Save, Delete, LoadList Stored Procedures, the Value Objects (i.e. JavaBeans) and, XML binding definitions. Finally, the developer writes the Data Access Objects business model interface by-hand in just a few lines of application code.
  • [0034]
    The benefits of the inventive framework are manifold. It generates both application code and stored procedures. In the best practices of object oriented programming, the stored procedures and value objects contain no business logic. And, the business model is de-coupled from the underlying persistence model. There is simplified data access interface i.e. load, loadList, save, delete. In the case of a Java solution, it wraps the clunky Java DataBase Connectivity (JDBC) Stored Procedure interface. And, a very important feature is that the framework significantly reduces error-prone, mundane data access, stored procedure development. Thus, the development effort gains more time to focus on the business model code because the data access build effort and cost are now 10% of what they would have been without the inventive framework. Also, stored procedure logging can be easily implemented in this framework. And finally, run-time can be improved by built-in memory caching.
  • [0035]
    Furthermore, since routing human coding errors are virtually eliminated there is far less required data access testing. As will be shown in the example, the framework is easily integrated into standalone Java applications or J2EE enterprise applications.
  • [0036]
    While the inventive framework can be adapted to all known-business class object oriented languages and commercial database systems, the embodiment of the example was coded using Java (JavaBean, JDBC, Reflection), XML, XML schema, Castor, Sybase database, Apache Commons, and Apache Log4J.
  • [0037]
    Part II:
  • An Example Framework in Java and Sybase with an XML Middle Layer
  • [0038]
    The embodiment described here is called SPBinder. SPBinder is a lightweight Stored Procedure data-binding framework for Java. Its main function is to significantly reduce the coding effort required to call database Stored Procedures by encapsulating the clunky Java DataBase Connectivity (JDBC) interface and providing a generic configurable means of persisting/retrieving Java objects to/from a relational database. The main advantage of encapsulating the data model is that it purely deals with persistence and retrieval and therefore becomes de-coupled from the business model. This means the developer can concentrate on implementing a complex business object model without directly impacting the underlying persistence model. The SPBinder framework has two main components—a code generation component for developers called GenUtils and run-time component called SPBinder.
  • [0039]
    GenUtils
  • [0040]
    The GenUtils component is set of code generation utilities that take a list of database table names (new or legacy) as input and extracts the table metadata directly from a database where the tables are defined to generate associated, JavaBeans (Value Objects), stored procedures (loadList, load, save and delete), and XML data-binding definition documents.
  • [0041]
    The XML data-binding document (see Appendix for schema) describes the relationship between stored procedure input/output parameters, resultsets and associated JavaBeans (Value Objects). This means that at run-time, Stored Procedure input parameters can be mapped directly from Java Object attributes, and stored procedure resultsets can be mapped to a list of Java Objects.
  • [0042]
    Example of XML Data-Binding Definition Document:
    <?xml version=“1.0” encoding=“UTF-8”?>
    <!-- edited with XML Spy v4.0.1 U (http://www.xmlspy.com) by
    John Mangan (JPMorganChase) -->
    <!--Sample XML file generated by XML Spy v4.0.1 U
    (http://www.xmlspy.com)-->
    <StoredProcBinder>
    <StoredProcs jdbcConnectionResource=
    “com.jpmorgan.eqeis.spbinder.database.test.jdbc_conn”>
    <StoredProc name=“sp_who” id=“Who”>
    <InputParams>
    <Param column=“ ®loginname”
    property=“name” javaType=“java.lang.String”/>
    </InputParams>
    <ResultSetParams model=
    “com.jpmorgan.eqeis.spbinder.database.test.IdObject”>
    <Param column=“spid” property=“id”/>
    <Param column=“loginname” property=“name”/>
    </ResultSetParams>
    </StoredProc>
    </StoredProcBinder>
  • [0043]
    SPBinder
  • [0044]
    SPBinder is the run-time component, which uses the XML binding document and JavaBean (Value Objects) and encapsulates communication to the database via JDBC.
  • [0045]
    It consists of four main components, SPBinderManager, SPConnection, SPCaller and SPCacheManager.
  • [0046]
    SPBinderManager
  • [0047]
    SPBinderManager normally reads in the XML binding document once during application start-up and builds a data-binding mapping in memory using the unique identifier to reference each Stored Procedure and associated data-binding JavaBean (Value Object). This unique identifier can then be used by SPCaller to do the actual database access.
  • [0048]
    Example:
    static SPBinderManager spBM = SPBinderManager.getInstance( );
    spBM.loadXMLConfigResource
    (“com/jpmorgan/eqeis/spbinder/database/test/SPBindings.xml”);
  • [0049]
    SPConnection
  • [0050]
    The SPConnection component handles the physical database connections and associated transaction management. It can also handle connection pooling in a J2EE environment.
  • [0051]
    SPCaller
  • [0052]
    SPCaller uses the unique identifier defined in the XML binding document to access the database and load, save or delete data. The data is automatically extracted from or populated in the JavaBean (Value Objects) where appropriate. Using the XML definition above, the example below shows how to load a list of users and their spids (Sybase process Id's):
  • [0053]
    Example:
    try {
    SPCaller spCaller = new SPCaller( );
    List list = spCaller.loadList (“Who”, null); //
    execute sp_who and returns a list of
    spids & names
    Iterator iter = list.iterator ( );
    while (iter.hasNext ( )) {
    IdObject idObj = (IdObject) iter.next ( );
    System.out.println(“Spid:” + idObj.getId( ) +
    “ Name: ” + idObj.getName ( ));
    }
    }
    catch (SPBinderException e) {
    System.error.println(e.getMessage ( ));
    }
  • [0054]
    The SPCaller component has built-in logging, which can be used to trace Stored Procedure calls, input parameters and resultsets.
  • [0055]
    SPCacheManager
  • [0056]
    SPCacheManager is a component, which manages a read-only time-expiry cache of list based data. This can be used to cache Stored Procedure resultsets as lists of JavaBean (Value Beans) in memory for a period of time. The time to expire variable can be configured per Stored Procedure in the XML data-binding document.
  • Appendix
  • [0057]
    StoredProcBinder.xsd
    <?xml version=“1.0” encoding=“UTF-8”?>
    <!-- edited with XML Spy v4.0.1 U (http://www.xmlspy.com) by John Mangan (JPMorganChase) -->
    <!--W3C Schema generated by XML Spy v3.5 NT (http://www.xmlspy.com)-->
    <xs:schema xmlns:xs=“http://www.w3.org/2001/XMLSchema” elementFormDefault=“qualified”
    attributeFormDefault=“unqualified”>
    <xs:annotation>
    <xs:documentation>SPBinder (Stored Proc to JavaBean databinding definition) Castor generation -
    com.jpmorgan.eqeis.spbinder.database.xml</xs:documentation>
    </xs:annotation>
    <xs:element name=“StoredProcBinder”>
    <xs:complexType>
    <xs:sequence>
    <xs:element ref=“StoredProcs” minOccurs=“0”/>
    </xs:sequence>
    </xs:complexType>
    </xs:element>
    <xs:element name=“StoredProcs”>
    <xs:complexType>
    <xs:sequence>
    <xs:element ref=“StoredProc” minOccurs=“0” maxOccurs=“unbounded”/>
    </xs:sequence>
    <xs:attribute name=“jdbcConnectionResource” type=“xs:string” use=“required”/>
    </xs:complexType>
    </xs:element>
    <xs:element name=“StoredProc”>
    <xs:complexType>
    <xs:sequence>
    <xs:element name=“InputParams” type=“Params” minOccurs=“0”/>
    <xs:element name=“ResultSetParams” type=“Params” minOccurs=“0”/>
    </xs:sequence>
    <xs:attribute name=“name” type=“xs:string” use=“required”/>
    <xs:attribute name=“id” type=“xs:string” use=“optional”/>
    <xs:attribute name=“jdbcConnectionResource” type=“xs:string” use=“optional”/>
    <xs:attribute name=“cacheable” type=“xs:boolean” use=“optional”/>
    <xs:attribute name=“cachetimeout” type=“xs:integer” use=“optional”/>
    </xs:complexType>
    </xs:element>
    <xs:complexType name=“Params”>
    <xs:sequence>
    <xs:element ref=“Param” minOccurs=“0” maxOccurs=“unbounded”/>
    </xs:sequence>
    <xs:attribute name=“model” type=“xs:string” use=“optional”/>
    </xs:complexType>
    <xs:element name=“Param”>
    <xs:complexType>
    <xs:attribute name=“column” type=“xs:string” use=“required”/>
    <xs:attribute name=“property” type=“xs:string” use=“required”/>
    <xs:attribute name=“output” type=“xs:boolean” use=“optional”/>
    <xs:attribute name=“value” type=“xs:string” use=“optional”/>
    <xs:attribute name=“javaType” type=“xs:string” use=“optional”/>
    </xs:complexType>
    </xs:element>
    </xs:schema>
Patent Citations
Cited PatentFiling datePublication dateApplicantTitle
US4445173 *Sep 11, 1981Apr 24, 1984Data General CorporationImproved system for saving and restoring state in call and return operations
US4751702 *Feb 10, 1986Jun 14, 1988International Business Machines CorporationImproving availability of a restartable staged storage data base system that uses logging facilities
US5027269 *Apr 27, 1989Jun 25, 1991International Business Machines CorporationMethod and apparatus for providing continuous availability of applications in a computer network
US5301320 *Jun 28, 1991Apr 5, 1994Digital Equipment CorporationWorkflow management and control system
US5325527 *Jan 19, 1993Jun 28, 1994Canon Information Systems, Inc.Client/server communication system utilizing a self-generating nodal network
US5499371 *Mar 22, 1995Mar 12, 1996Persistence Software, Inc.Method and apparatus for automatic generation of object oriented code for mapping relational data to objects
US5539885 *Aug 31, 1993Jul 23, 1996Hitachi, Ltd.Distributed information processing system providing a resume function and resume method for the distributed information processing system
US5553235 *May 1, 1995Sep 3, 1996International Business Machines CorporationSystem and method for maintaining performance data in a data processing system
US5594863 *Jun 26, 1995Jan 14, 1997Novell, Inc.Method and apparatus for network file recovery
US5630047 *Sep 12, 1995May 13, 1997Lucent Technologies Inc.Method for software error recovery using consistent global checkpoints
US5630173 *Dec 21, 1992May 13, 1997Apple Computer, Inc.Methods and apparatus for bus access arbitration of nodes organized into acyclic directed graph by cyclic token passing and alternatively propagating request to root node and grant signal to the child node
US5673403 *Nov 13, 1992Sep 30, 1997International Business Machines CorporationMethod and system for displaying applications of different operating systems on a single system using the user interface of the different operating systems
US5712971 *Dec 11, 1995Jan 27, 1998Ab Initio Software CorporationMethods and systems for reconstructing the state of a computation
US5734887 *Sep 29, 1995Mar 31, 1998International Business Machines CorporationMethod and apparatus for logical data access to a physical relational database
US5737592 *Jun 19, 1995Apr 7, 1998International Business Machines CorporationAccessing a relational database over the Internet using macro language files
US5761499 *Dec 21, 1995Jun 2, 1998Novell, Inc.Method for managing globally distributed software components
US5768119 *Apr 12, 1996Jun 16, 1998Fisher-Rosemount Systems, Inc.Process control system including alarm priority adjustment
US5784557 *Dec 20, 1996Jul 21, 1998Apple Computer, Inc.Method and apparatus for transforming an arbitrary topology collection of nodes into an acyclic directed graph
US5790809 *Nov 17, 1995Aug 4, 1998Mci CorporationRegistry communications middleware
US5801689 *Jan 22, 1996Sep 1, 1998Extended Systems, Inc.Hypertext based remote graphic user interface control system
US5806075 *Jan 14, 1997Sep 8, 1998Oracle CorporationMethod and apparatus for peer-to-peer data replication
US5899990 *Mar 31, 1997May 4, 1999Sun Microsystems, Inc.Java-to-Database Connectivity Server
US5926637 *Aug 20, 1997Jul 20, 1999Bea Systems, Inc.Service interface repository code generation data
US5930768 *Feb 6, 1996Jul 27, 1999Supersonic Boom, Inc.Method and system for remote user controlled manufacturing
US5937198 *Aug 12, 1998Aug 10, 1999Extended Systems, Inc.Field configurable embedded computer system
US5937402 *Jun 19, 1997Aug 10, 1999Ontos, Inc.System for enabling access to a relational database from an object oriented program
US5946458 *Mar 24, 1997Aug 31, 1999Xerox CorporationNetwork printing system for responding to remote print-related requests
US6011916 *May 12, 1998Jan 4, 2000International Business Machines Corp.Java I/O toolkit for applications and applets
US6046742 *Oct 1, 1997Apr 4, 2000Micron Electronics, Inc.Display of system information
US6052456 *Dec 23, 1997Apr 18, 2000Alcatel Usa Sourcing, L.P.Graphical shelf navigator for a telecommunications switch management system
US6065009 *Jan 20, 1998May 16, 2000International Business Machines CorporationEvents as activities in process models of workflow management systems
US6101489 *Dec 22, 1998Aug 8, 2000Ac Properties, B.V.System, method and article of manufacture for a goal based system utilizing a time based model
US6101601 *Apr 20, 1998Aug 8, 2000International Business Machines CorporationMethod and apparatus for hibernation within a distributed data processing system
US6108698 *Jul 29, 1998Aug 22, 2000Xerox CorporationNode-link data defining a graph and a tree within the graph
US6173439 *Sep 24, 1998Jan 9, 2001International Business Machines CorporationInterface mechanism and method for accessing non-object oriented data from within an object oriented framework
US6178409 *Jun 17, 1996Jan 23, 2001Verifone, Inc.System, method and article of manufacture for multiple-entry point virtual point of sale architecture
US6184996 *Jun 18, 1997Feb 6, 2001Hewlett-Packard CompanyNetwork printer with remote print queue control procedure
US6185613 *Feb 24, 1998Feb 6, 2001Netvision, Inc.System and method for global event notification and delivery in a distributed computing environment
US6188400 *Mar 31, 1997Feb 13, 2001International Business Machines CorporationRemote scripting of local objects
US6195676 *Jan 11, 1993Feb 27, 2001Silicon Graphics, Inc.Method and apparatus for user side scheduling in a multiprocessor operating system program that implements distributive scheduling of processes
US6230319 *Jun 30, 1998May 8, 2001Webtv Networks, Inc.Managing interruption while downloading data over a network
US6246410 *Jan 19, 1996Jun 12, 2001International Business Machines Corp.Method and system for database access
US6249877 *Apr 28, 1989Jun 19, 2001Hitachi, Ltd.Method and apparatus for recovering data for a file in a plurality of equipments
US6253193 *Dec 9, 1998Jun 26, 2001Intertrust Technologies CorporationSystems and methods for the secure transaction management and electronic rights protection
US6256635 *May 8, 1998Jul 3, 2001Apple Computer, Inc.Method and apparatus for configuring a computer using scripting
US6272556 *Jul 1, 1996Aug 7, 2001Sun Microsystems, Inc.Object-oriented system, method and article of manufacture for migrating a client-server application (#5)
US6282698 *Dec 4, 1998Aug 28, 2001Lucent Technologies Inc.Detecting similarities in Java sources from bytecodes
US6363363 *Aug 24, 1999Mar 26, 2002Verifone, Inc.System, method and article of manufacture for managing transactions in a high availability system
US6363499 *Sep 21, 1998Mar 26, 2002Microsoft CorporationMethod and system for restoring a computer to its original state after an unsuccessful installation attempt
US6381609 *Jul 2, 1999Apr 30, 2002Lucent Technologies Inc.System and method for serializing lazy updates in a distributed database without requiring timestamps
US6430556 *Nov 1, 1999Aug 6, 2002Sun Microsystems, Inc.System and method for providing a query object development environment
US6438749 *Mar 3, 1999Aug 20, 2002Microsoft CorporationMethod and system for restoring a computer to its original state after an unsuccessful patch installation attempt
US6442533 *Oct 28, 1998Aug 27, 2002William H. HinkleMulti-processing financial transaction processing system
US6442748 *Aug 31, 1999Aug 27, 2002Accenture LlpSystem, method and article of manufacture for a persistent state and persistent object separator in an information services patterns environment
US6505238 *Aug 19, 1999Jan 7, 2003International Business Machines CorporationMethod and system for implementing universal login via web browser
US6510352 *Jul 28, 2000Jan 21, 2003The Foxboro CompanyMethods and apparatus for object-based process control
US6518983 *Mar 20, 2000Feb 11, 2003International Business Machines CorporationDisplay of messages from a plurality of processes running in parallel
US6526571 *Mar 16, 1999Feb 25, 2003International Business Machines CorporationMethod for identifying calls in java packages whose targets are guaranteed to belong to the same package
US6539337 *Jun 15, 2000Mar 25, 2003Innovative Technology Licensing, LlcEmbedded diagnostic system and method
US6546419 *May 7, 1999Apr 8, 2003Richard HumplemanMethod and apparatus for user and device command and control in a network
US6553428 *Nov 18, 1997Apr 22, 2003International Business Machines CorporationDistributed object instantiation of native objects in java
US6557039 *Nov 12, 1999Apr 29, 2003The Chase Manhattan BankSystem and method for managing information retrievals from distributed archives
US6571389 *Apr 27, 1999May 27, 2003International Business Machines CorporationSystem and method for improving the manageability and usability of a Java environment
US6578068 *Aug 31, 1999Jun 10, 2003Accenture LlpLoad balancer in environment services patterns
US6584497 *Jul 28, 1999Jun 24, 2003International Business Machines CorporationMethod, system, and program for returning a file requested through a network connection
US6590587 *Nov 30, 1999Jul 8, 2003Agilent Technologies, Inc.Monitoring system and method implementing navigation interface logic
US6675228 *Oct 29, 1999Jan 6, 2004International Business Machines CorporationMethod and apparatus in a data processing system for generating alternative views of client applications
US6681380 *Feb 15, 2000Jan 20, 2004International Business Machines CorporationAggregating constraints and/or preferences using an inference engine and enhanced scripting language
US6697835 *Oct 28, 1999Feb 24, 2004Unisys CorporationMethod and apparatus for high speed parallel execution of multiple points of logic across heterogeneous data sources
US6701514 *Mar 27, 2000Mar 2, 2004Accenture LlpSystem, method, and article of manufacture for test maintenance in an automated scripting framework
US6714219 *Dec 31, 1998Mar 30, 2004Microsoft CorporationDrag and drop creation and editing of a page incorporating scripts
US20020010867 *Dec 21, 2000Jan 24, 2002Schaefer Robert G.Performance path method and apparatus for exchanging data among systems using different data formats
US20020046239 *Aug 29, 2001Apr 18, 2002Schneider AutomationCommunication system of an automation equipment based on the soap protocol
US20020062475 *Jun 1, 2001May 23, 2002Jose IborraAutomatic software production system
US20020069192 *Dec 4, 2001Jun 6, 2002Aegerter William CharlesModular distributed mobile data applications
US20020078115 *Jun 20, 2001Jun 20, 2002Poff Thomas C.Hardware accelerator for an object-oriented programming language
US20020103835 *Jan 30, 2001Aug 1, 2002International Business Machines CorporationMethods and apparatus for constructing semantic models for document authoring
US20020109718 *Feb 14, 2001Aug 15, 2002Mansour Peter M.Platform-independent distributed user interface server architecture
US20020111995 *Feb 14, 2001Aug 15, 2002Mansour Peter M.Platform-independent distributed user interface system architecture
US20020111999 *Jul 9, 2001Aug 15, 2002Andersson Anders Jorgen MikaelSystem and method for remote control of software and an attached device
US20020116205 *May 4, 2001Aug 22, 2002Ankireddipally Lakshmi NarasimhaDistributed transaction processing system
US20020120685 *Apr 10, 2002Aug 29, 2002Alok SrivastavaSystem for dynamically invoking remote network services using service descriptions stored in a service registry
US20030009323 *Jul 6, 2001Jan 9, 2003Max AdeliApplication platform for developing mono-lingual and multi-lingual systems and generating user presentations
US20030027561 *Jul 27, 2001Feb 6, 2003Bellsouth Intellectual Property CorporationAutomated script generation to update databases
US20030028555 *Jul 31, 2001Feb 6, 2003Young William J.Database migration
US20030033121 *Jun 13, 2002Feb 13, 2003Sbc Technology Resources, Inc.Rule based capacity management system for an inter office facility
US20030033159 *Nov 30, 2001Feb 13, 2003Piero AltomareInterface module for document-based electronic business processes based on transactions
US20030036809 *Aug 20, 2001Feb 20, 2003Silicon Graphics IncTransparent distribution and execution of data in a multiprocessor environment
US20030046317 *Apr 19, 2001Mar 6, 2003Istvan CseriMethod and system for providing an XML binary format
US20030050897 *Nov 30, 2001Mar 13, 2003Piero AltomareInterface module for document-based electronic business processes based on transactions
US20030069907 *Jun 26, 2002Apr 10, 2003Jean-Jacques MoreauMethod and device for processing a computer document in a computer system
US20030084067 *Oct 30, 2002May 1, 2003Chudi ObiayaMethod and apparatus for asset management
US20030093574 *Oct 1, 2002May 15, 2003Youenn FabletMethod and device for executing a function with selection and sending of multiple results in a client-server environment
US20030097383 *Apr 5, 2002May 22, 2003Alexis SmirnovEnterprise privacy system
US20030140045 *Jul 8, 2002Jul 24, 2003Troy HeningerProviding a server-side scripting language and programming tool
US20030160813 *Feb 25, 2002Aug 28, 2003Raju Narayan D.Method and apparatus for a dynamically-controlled remote presentation system
US20030163603 *Nov 26, 2002Aug 28, 2003Chris FrySystem and method for XML data binding
US20050030555 *May 17, 2004Feb 10, 2005Phenix John KevinJob processing framework
Referenced by
Citing PatentFiling datePublication dateApplicantTitle
US7505990May 5, 2005Mar 17, 2009International Business Machines CorporationMethod for defining and generating document management applications for model-driven document management
US7698310May 13, 2005Apr 13, 2010Oracle International CorporationSystem for allowing object metadata to be shared between cursors for concurrent read write access
US7860894 *May 11, 2005Dec 28, 2010Oracle International CorporationTemplate driven type and mode conversion
US8005792 *May 13, 2005Aug 23, 2011Oracle International CorporationSystem and method for managing versions of metadata
US8010576 *Aug 30, 2011Oracle International CorporationInventory and configuration management
US8024701Mar 27, 2007Sep 20, 2011Microsoft CorporationVisual creation of object/relational constructs
US8032439Jan 7, 2003Oct 4, 2011Jpmorgan Chase Bank, N.A.System and method for process scheduling
US8037039Aug 14, 2007Oct 11, 2011Microsoft CorporationRuntime class database operation
US8095659May 17, 2004Jan 10, 2012Jp Morgan Chase BankService interface
US8214797Feb 1, 2007Jul 3, 2012Microsoft CorporationVisual association creation for object relational class development
US8255883Nov 14, 2007Aug 28, 2012Microsoft CorporationTranslating late bound LINQ expressions into database queries
US8321467Dec 11, 2006Nov 27, 2012Jp Morgan Chase BankSystem and method for communicating between an application and a database
US20040215604 *Apr 24, 2003Oct 28, 2004International Business Machines CorporationSystem and method for querying a data source
US20040215725 *Aug 22, 2003Oct 28, 2004Lorraine LoveSystem and method for multi-platform queue queries
US20040230587 *Sep 22, 2003Nov 18, 2004Andrew DoddingtonSystem and method for specifying application services and distributing them across multiple processors using XML
US20040230602 *Sep 22, 2003Nov 18, 2004Andrew DoddingtonSystem and method for decoupling data presentation layer and data gathering and storage layer in a distributed data processing system
US20040254824 *Jan 7, 2003Dec 16, 2004Alex LoucaidesSystem and method for process scheduling
US20050144174 *Jun 15, 2004Jun 30, 2005Leonid PesensonFramework for providing remote processing of a graphical user interface
US20050222990 *Jul 12, 2004Oct 6, 2005Milne Kenneth TMethods and systems for using script files to obtain, format and disseminate database information
US20060004755 *May 13, 2005Jan 5, 2006Oracle International CorporationSystem for allowing object metadata to be shared between cursors for concurrent read write access
US20060004886 *May 13, 2005Jan 5, 2006Oracle International CorporationSystem for managing versions of cached metadata
US20060005138 *May 11, 2005Jan 5, 2006Oracle International Corporation, A Corporation Of The State Of CaliforniaTemplate driven type and mode conversion
US20060031586 *Apr 25, 2005Feb 9, 2006Jp Morgan Chase BankSystem and method for routing messages
US20060041567 *May 3, 2005Feb 23, 2006Oracle International CorporationInventory and configuration management
US20060253490 *May 5, 2005Nov 9, 2006International Business Machines CorporationSystem and method for defining and generating document management applications for model-driven document management
US20060253497 *May 3, 2005Nov 9, 2006Bulent AbaliSystem and method for associating computational procedures with stored data objects
US20070143337 *Dec 11, 2006Jun 21, 2007Mangan John PMethod For Simplifying Databinding In Application Programs
US20070294056 *Jan 12, 2007Dec 20, 2007Jpmorgan Chase Bank, N.A.Method and system for monitoring non-occurring events
US20080120270 *Nov 19, 2007May 22, 2008LlinxxDatabase system
US20080189311 *Feb 1, 2007Aug 7, 2008Microsoft CorporationVisual controls for stored procedure and object relational class development
US20080189677 *Feb 1, 2007Aug 7, 2008Microsoft CorporationVisual association creation for object relational class development
US20080244510 *Mar 27, 2007Oct 2, 2008Microsoft CorporationVisual creation of object/relational constructs
US20080263063 *Nov 14, 2007Oct 23, 2008Microsoft CorporationTranslating late bound linq expressions into database queries
US20080263078 *Aug 14, 2007Oct 23, 2008Microsoft CorporationRuntime class database operation
US20080263531 *Aug 29, 2007Oct 23, 2008Microsoft CorporationAutomatic runtime control binding
Classifications
U.S. Classification1/1, 707/999.002
International ClassificationG06F17/30
Cooperative ClassificationY10S707/99932, Y10S707/99944, G06F17/3056
European ClassificationG06F17/30S8R
Legal Events
DateCodeEventDescription
Apr 1, 2003ASAssignment
Owner name: JP MORGAN CHASE BANK, NEW YORK
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:MANGAN, JOHN PATRICK;REEL/FRAME:013931/0751
Effective date: 20030128
Dec 14, 2009FPAYFee payment
Year of fee payment: 4
Dec 12, 2013FPAYFee payment
Year of fee payment: 8