Interface to support state-dependent web applications accessing a relational database

• US 6,038,562 A
• Filed: 09/05/1996
• Issued: 03/14/2000
• Est. Priority Date: 09/05/1996
• Status: Expired due to Term

• Current Assignee: International Business Machines Corporation
• Original Assignee: International Business Machines Corporation
• Inventors: Srinivasan, Venkatachary, Anjur, Vaishnavi, Iyer, Balakrishna Raghavendra, Chadha, Atul, Goel, Piyush, Watts, Steven John
• Primary Examiner(s): Lintz, Paul R.
• Application Number:
  US08/708,512
• Time in Patent Office: 1,286 Days
• Field of Search: 345/182.18, 707/10, 707/202, 707/2, 707/101
• US Class Current: 1/1
• CPC Class Codes: G06F 16/284 Relational databases
• CPC Class Codes: Y10S 707/99932 Access augmentation or optimizing
• CPC Class Codes: Y10S 707/99942 Manipulating data structure, e.g. compression, compaction, compilation
• CPC Class Codes: Y10S 707/99953 Recoverability

Abstract

Many web applications require access to a relational database. The requirements of such web applications are different from conventional applications that access a database. Web applications need to have selective recoverability and need to have support for different transaction structures, other than the flat transaction structure of conventional database applications, including nested and chained transactions. To achieve this, an interface between the application and database has the following functional features: 1) the interface to the database is connection oriented, i.e., the connection is retained across several invocations of the application; 2) the backend of the interface is long living, i.e., it exists across multiple invocations; 3) state information about a session in progress is maintained, and more specifically, it is distributed between the backend of the interface and the hidden fields of the HTML output document.

Claims

1. A method for interacting with data in a database by a browser through an application frontend interface to a database management system (DBMS), the method comprising:

passing parsed parameters, by the application, of a transaction initiated by a browser, to an interface backend interfacing with the DBMS;

retaining, by the interface backend, a connection with the DBMS across a plurality of invocations of the application; and

processing recoverable transactions and irrecoverable transactions by the interface backend whereby a first function of supporting selective recoverability is provided by the interface backend.

2. The method of claim 1 wherein the step of processing recoverable transactions and irrecoverable transactions further comprises:

initiating a separate first transaction thread for each one of a plurality of recoverable updates and a second transaction thread for all irrecoverable updates;

generating and maintaining, by each separate first transaction thread, an identifier and a compensating update for each one of the plurality of recoverable updates; and

passing the identifier to the application for subsequent use in a selective recoverability request.

3. The method of claim 2 further comprising:

executing a corresponding compensating update for an unidentified recoverable update in a first scope of the explicit COMMIT request; and

executing a commit operation for an unidentified recoverable update in a second scope of the explicit ROLLBACK request.

4. The method of claim 1 whereby a second function of supporting complex transaction structures is provided through an identification of recoverable and irrecoverable transactions within a scope associated with a commit or rollback operation.

5. The method of claim 1 further comprising a step of maintaining, transparently to a user using the browser, data exchanged between the browser and the backend.

6. The method of claim 5 further comprising supporting a plurality of browser standards through a use of the data exchanged between the browser and the backend.

7. The method of claim 1 further comprising a step of identifying each unique transaction with a transaction identifier.

8. A method for interacting with data in a database by a browser through an application frontend interface to a database management system (DBMS), the method comprising:

identifying each unique transaction from an invoking browser with a corresponding transaction identifier;

invoking the application for each transaction from the invoking browser for parsing a plurality of parameters from the transaction;

passing the parsed parameters, by the application, to a backend interface to the database;

processing, by the backend interface, recoverable and irrecoverable transactions whereby a first function of supporting selective recoverability is provided by the interface backend;

maintaining, by the backend interface, a connection with the database across a plurality of invocations of the application to interact with data in the database by using the corresponding transaction identifier for each transaction; and

receiving results, generated by the DBMS, of the transaction at the invoking browser based upon the transaction identifier.

9. A method for interacting with data in a database through an application interface to a database management system, the method comprising:

interacting with the data in the database, from the application through a backend interface to a database management system, in a plurality of sessions;

altering, by the backend interface, among a plurality of different functional features provided to the application for each one of the plurality of sessions depending upon a requirement of each one of the sessions; and

processing recoverable transactions and irrecoverable transactions by the interface backend whereby a first function of supporting selective recoverability is provided by the interface backend.

10. A method for an application, invoked by a browser, to interact with data in a database, the method comprising:

parsing, by the application, a self-describing file, from the browser, containing a transaction having at least one request to the database;

identifying each transaction with a transaction identifier;

transmitting the parsed file to a backend for interfacing with a database management system and for handling a recoverable update within the transaction;

transmitting back, by the backend, to the application, a generated update identifier for a recoverable update;

inserting, by the application, the transaction identifier and the update identifier in a field of the self-describing file, transparent to the user of the browser, to identify future requests.

11. A method for interacting with data in a database by a browser through an application frontend interface to a database management system DBMS), the method comprising:

identifying each unique transaction from an invoking browser with a corresponding transaction identifier;

passing parsed parameters of a transaction, having a first transaction identifier, from the application to a backend interface having a capability of maintaining a connection with the database management system across a plurality of invocations of the application and a capability of supporting selective recoverability of transactions; and

prefetching and caching, by the backend, a plurality of additional rows for the transaction having the first transaction identifier when maintaining an open cursor for the transaction.

12. A method for interacting with data in a database by a browser, the method comprising:

parsing, by a frontend interface, requests from the browser;

transmitting the parsed requests by the frontend interface to a backend interface;

retaining a connection, by the backend, with a database management system (DBMS) across a plurality of invocations of the frontend interface;

distributing state information between the backend and data exchanged between the browser and the backend;

providing support, by the backend, for selective recoverability of a plurality of transactions;

providing support, by the backend, for a complex transaction structure; and

providing support, through the data exchanged between the browser and the backend, for various formats of a self-describing file containing the requests from the browser.

13. The method of claim 12 further comprising maintaining an open cursor for a query.

14. The method of claim 12 wherein the step of distributing further comprises maintaining private state information by the backend and maintaining public state information in the data exchanged between the browser and the backend.

15. A method for interacting with data in a database by a browser through an application frontend interface to a database management system, the method comprising:

processing recoverable transactions and irrecoverable transactions by an interface backend whereby a first function of supporting selective recoverability is provided by the interface backend;

dynamically altering at least one function provided by the interface backend to the application interface depending upon at least one requirement of the application interface;

supporting scrollable cursors by maintaining an open cursor at the interface backend; and

pre-fetching and caching results of a query that require the open cursor to be maintained.

16. The method of claim 15 wherein the step of pre-fetching and caching further comprises:

maintaining, by the backend, a cache of a plurality of first rows returned to the application interface for maintaining an open cursor;

prefetching, by the backend, into the cache a plurality of second rows in anticipation of future requests; and

satisfying, by the backend, a subsequent request, from the application interface, using the cache.

17. A system for interacting with data in a database by a browser through an application frontend interface to a database management system (DBMS), the system comprising:

means for retaining, by a long living interface backend between the application and the DBMS, a connection with the DBMS across a plurality of invocations of the application;

means for maintaining, transparently to a user of the browser, data exchanged between the browser and the backend; and

means for activating, via the exchanged data, program logic in the backend to support selective recoverability of interactions.

18. The system of claim 17 further comprising means for activating program logic in the backend to support complex transaction structures.

19. The system of claim 17 further comprising means for interpreting received data from the browser by self-describing fields.

20. A system for interacting with data in a database by a browser through an application interface to a database management system, the system comprising:

a flexible interface backend for receiving parsed interactions from the application interface, the backend interface having a capability to dynamically alter functionality requirements delivered to the application interface based upon at least one requirement of the application interface and a capability of supporting selective recoverability of transactions;

means for supporting a transaction across a plurality of invocations of the application interface;

means for supporting scrollable cursors by maintaining an open cursor at the backend; and

means for pre-fetching and caching of a result of a query requiring the open cursor to be maintained.

21. A system for interacting with data in a database by a browser through an application interface to a database management system (DBMS), the system comprising:

means for processing recoverable transactions and irrecoverable transactions by an interface backend interfacing with the DBMS whereby a first function of supporting selective recoverability is provided by the interface backend;

means for interacting with data in the database, from the application interface through a backend interface to the database management system, in a plurality of sessions; and

means for altering, by the backend interface, among a plurality of different functional features provided to the application interface for each one of the plurality of sessions depending upon a requirement of the application during each one of the sessions.

22. The system of claim 21 wherein the means for altering provides different functionality within a duration of one of the sessions.

23. The system of claim 21 wherein the different functional features include 1) a connection oriented interaction between the application and the database management system wherein a connection with the database management system is retained across a plurality of invocations of the application interface, 2) a connectionless interaction between the application and the database management system wherein the connection with the database management system is established and destroyed each time the application interface is invoked, 3) means for maintaining state information, 4) means for not maintaining state information, 5) a transient backend interface to the database management system wherein the backend interface terminates after each invocation of the application, and 6) a long living backend interface to the database management system wherein the backend interface exists across multiple invocations.

24. The system of claim 21 wherein the backend interface provides a connectionless interaction and means for not maintaining state information when the application does not require support for a plurality of sessions or recoverability of actions.

25. The system of claim 21 wherein the backend interface provides a connectionless interaction and means for maintaining state information in a self-describing file from the browser when the application requires support for a plurality of sessions without a consistent database view being guaranteed.

26. The system of claim 21 wherein the backend interface provides a connection oriented interaction, means for not maintaining state information, and a long living backend when the application requires support for a plurality of sessions but does not require selective recoverability.

27. The system of claim 21 wherein the backend interface provides a connection oriented interaction, means for maintaining state information, and a long living backend when the application requires support for a plurality of sessions, consistent database views, and recoverability of interactions.

28. The system of claim 27 wherein the means for altering further comprises means for activating additional program logic in the backend when the application has a complex transaction structure.

29. The system of claim 25 wherein the means for altering further comprises means for activating additional program logic in the backend interface when the application has a complex transaction structure and requires selective recoverability.

30. The system of claim 21 wherein the means for altering further comprises means for enabling additional program logic in the backend when a subtransaction in the application has a complex transaction structure or requires selective recoverability and means for disabling the additional program logic code in the backend for a duration of a second subtransaction when the second subtransaction has a flat transaction structure.

31. A system for interacting with data in a database by a browser through an application interface to a database management system, the system comprising:

a self-describing file containing a set of requirements of the application interface and at least one interaction to the database;

a flexible interface backend having a capability to provide different functionality to the application interface depending upon the set of requirements of the application;

means for parsing the self-describing file, by the application interface, and transmitting each parsed interaction to an appropriate process in the backend; and

means for binding the appropriate backend process to a session to deliver the functionality required by the session.

32. The system of claim 31 further comprising:

means for transmitting back, by the backend interface, to the application interface, a generated update identifier for a recoverable update;

means for generating, by the application, a session identifier for a new session;

means for inserting the session identifier and the update identifier in a field, transparent to a user of the browser, of the self-describing file to identify future interactions.

33. The system of claim 31 further comprising:

means for maintaining, by the backend interface, a cache of a plurality of first rows returned to the application interface if an open cursor is to be maintained;

means for prefetching, by the backend, a plurality of second rows in anticipation of future interactions; and

means for satisfying a subsequent interaction from the cache.

34. A system for interacting with data in a database by a browser, the system comprising:

an application interface frontend for parsing requests contained within a self-describing file generated from the browser;

means for sending the parsed requests by the interface frontend to a backend interface;

means for retaining a connection, by the backend interface, with a database management system across a plurality of invocations of the interface frontend;

means for providing support, through data exchanged between the browser and the backend, for various formats of the self-describing file;

means for distributing state information between the backend interface and the data exchanged between the browser and the backend;

means for providing for selective recoverability of a plurality of transactions; and

means for providing support for a complex transaction structure.

35. The system of claim 34 further comprising means for maintaining, by a database, an open cursor for a query.

36. The system of claim 34 wherein private state information is maintained by the backend and public state information is maintained in the data exchanged between the browser and the backend interface.

37. A program interface on a computer usable medium comprising:

means for retaining a connection to a database management system across a plurality of invocations of an application which parses requests from a browser for interacting with data in a database; and

means for processing recoverable updates selectable from the browser whereby a first function of supporting selective recoverability is provided by the interface backend.

38. A program interface on a computer usable medium comprising:

means for retaining a connection to a database management system (DBMS) across a plurality of invocations of an application which parses requests from a browser for interacting with data in a database;

means for dynamically altering among a plurality of functions provided to the application depending upon at least one requirement of the application during a session; and

means for processing recoverable transactions and irrecoverable transactions by an interface backend interfacing with the DBMS whereby a first function of supporting selective recoverability is provided by the interface backend.

39. The program interface of claim 38 wherein the means for altering further comprises means for activating program code when the application has a complex transaction structure and requires selective recoverability.

40. The program interface of claim 38 wherein the plurality of functions include 1) a connection oriented interaction between the application and the database management system wherein a connection with the database management system is retained across a plurality of invocations of the application, 2) a connectionless interaction between the application and the database management system wherein the connection with the database management system is established and destroyed each time the application is invoked, 3) means for maintaining state information, 4) means for not maintaining state information, 5) a transient backend interface to the database wherein the backend terminates after each invocation of the application, and 6) a long living backend interface to the database wherein the backend exists across multiple invocations.

41. The program interface of claim 38 further comprising:

means for initiating a separate first transaction thread to handle each one of at least one recoverable updates and a second transaction thread to handle all of at least one irrecoverable updates;

means for generating and maintaining, by each separate first transaction thread, an identifier and a compensating update for each one of the at least one recoverable updates; and

means for passing the identifier to the application for subsequent use in a selective recoverability request.

42. The program interface of claim 41 further comprising:

means for executing a corresponding compensating update for an unidentified recoverable update in a first scope of an explicit COMMIT request; and

means for executing a commit operation for an unidentified recoverable update in a second scope of an explicit ROLLBACK request.

43. The program interface of claim 42 whereby the explicit COMMIT and ROLLBACK requests allow selection of updates that are to be committed or rolled backed for selective recoverability.

44. The program interface of claim 42 whereby the first scope and second scope enables support for nested and chained transaction structures.

45. A program interface on a computer usable medium, comprising:

means for processing recoverable transactions and irrecoverable transactions by an interface backend interfacing with a database management system whereby a first function of supporting selective recoverability is provided by the interface backend;

means for dynamically altering among a plurality of functions provided to an application, which parses requests from a browser for interacting with data in a database, depending upon at least one requirement of the application;

means for supporting scrollable cursors by maintaining an open cursor; and

means for pre-fetching and caching results of a query that require the open cursor to be maintained.