United States Patent (19)
`Andersen
`
`USOO5999941A
`Patent Number:
`11
`(45) Date of Patent:
`
`5,999,941
`Dec. 7, 1999
`
`54) DATABASE ACCESS USING ACTIVE
`SERVER PAGES
`
`75 Inventor: Todd Andersen, Meridian, Id.
`73 Assignee: Micron Electronics, Inc., Nampa, Id.
`
`21 Appl. No.: 08/978,032
`22 Filed:
`Nov. 25, 1997
`6
`51 Int. Cl. ........................................... TNT, Goof 17/30
`52)
`707/103; 707/103; 707/104
`58 Field of Search ..................................... 707/103,104,
`707/10
`
`56)
`
`References Cited
`U.S. PATENT DOCUMENTS
`4/1993 Khoyi et al. ............................ 395/650
`5,206,951
`5,659,729 8/1997 Nielsen ...
`... 707/3
`5,778,356 7/1998 Heiny ...
`... 707/2
`5,809,502 9/1998 Burrows ...................................... 707/7
`5,864,863
`1/1999 Burrows ...
`... 707/103
`5,878,418 3/1999 Polcyn et al. ............................. 707/10
`
`Primary Examiner Paul R. Lintz
`ASSistant Examiner Jean Bolte Fleurantin
`Attorney, Agent, or Firm Seed and Berry LLP
`57
`ABSTRACT
`A method and System for accessing a database management
`System running on a server computer from within a JAVA
`applet running on a client computer. The JAVA applet
`prepares a URL to address an active Server page on the
`Server computer, embedding a database query within the
`URL. The JAVA applet then accesses the active Server page
`using the prepared URL. The Server computer, upon receiv
`ing a request for access to the active Server page, executes
`a Script Stored within the active Server page that receives the
`database query embedded within the URL, passes the query
`to the database management System, receives from the
`database management system the query results, creates a
`HTML document, and stores the query results in the HTML
`document. The server computer then returns the HTML
`document to the client computer, where the JAVA applet
`reads the query results from the HTML document
`
`22 Claims, 4 Drawing Sheets
`
`
`
`206
`
`STOCK PRICES
`Acme....................... 110.36
`General Tools............. 36.21
`Wholsome Foods........ 53.06
`Quality Aircraft........... 77.00
`
`
`
`208
`
`(
`
`
`
`
`
`2O3
`
`201
`
`
`
`SERVER
`
`HTML
`
`DATA
`STORAGE
`
`BROWSER
`
`APPLET
`
`204
`
`215
`
`217
`
`20g
`
`OS
`
`214 l
`
`
`
`
`
`OS
`
`210
`
`Lenovo Exhibit 1012
`
`Page 1
`
`

`

`U.S. Patent
`
`Dec. 7, 1999
`
`Sheet 1 of 4
`
`5,999,941
`
`9 / /
`
`CONTROLLER
`
`CONTROLLER
`
`CONTROLLER
`
`S0 LUT
`
`CONTROLLER
`
`
`
`
`
`
`
`
`
`
`
`
`
`Page 2
`
`

`

`U.S. Patent
`
`Dec. 7, 1999
`
`Sheet 2 of 4
`
`5,999,941
`
`
`
`
`
`
`
`01 Z.
`
`
`
`CONTR OLLER
`
`3
`
`CONTROLLER
`
`CONTROLLER
`
`CONTROLLER
`
`90%
`
`
`
`
`
`
`
`
`
`Page 3
`
`

`

`U.S. Patent
`
`Dec. 7, 1999
`
`Sheet 3 of 4
`
`5,999,941
`
`APPLET
`DB ACCESS
`
`301
`
`302
`
`303
`
`CONSTRUCT URL
`INCLUDING ARGUMENTS
`TO ASP
`
`
`
`
`
`OPEN, AS A FILE
`THE ASP DESCRIBED
`BY THE URL
`
`FOR EACH LINE OF
`THE HTML FILE
`PRODUCED BY THE
`SERVER EXECUTING
`THE ASP, STARTING
`WITH THE FIRST
`
`
`
`
`
`304
`
`READ THE LINE
`AND PAUSE IT
`ACCORDING TO
`PRE-DETERMINED
`FORMAT
`
`
`
`306
`
`REMAINING
`APPLET TASK
`
`Fig. 3
`
`Page 4
`
`

`

`U.S. Patent
`
`Dec. 7, 1999
`
`Sheet 4 of 4
`
`5,999,941
`
`
`
`
`
`
`
`
`
`
`
`
`
`ASP SCRIPT
`
`40f
`
`402
`
`40.3
`
`404
`
`RECEIVE ARGUMENTS
`PAUSED FROM URL
`
`OPEN NEW
`HTML FILE
`
`CONSTRUCT DATABASE
`QUERY USING
`RECEIVED ARGUMENTS
`AND EXECUTE QUERY
`
`FOR EACH ROW
`RETURNED AS A
`RESULT OF QUERY,
`STARTING WITH
`FIRST ROW
`
`405
`
`FORMAT DATA IN
`ROW ACCORDING TO
`PRE-DETERMINED
`FORMAT AND WRITE
`FORMATTED DATA
`TO HTML FILE
`
`
`
`MOVE
`RETURNED
`ROWS
`
`407
`
`Fig. 4
`
`
`
`
`
`
`
`Page 5
`
`

`

`1
`DATABASE ACCESS USING ACTIVE
`SERVER PAGES
`
`5,999,941
`
`25
`
`35
`
`2
`a list of stocks and prices 101 on a display monitor 102 of
`a personal computer 103. The processes executing on the
`personal computer include the operating System 104, a
`browser 105, and the JAVA applet executing under control of
`the browser 106 that acquires the stock prices and directs
`their display. The Stock prices are Stored on a data Storage
`device 107 managed by a database management system 108
`on a server computer 109. In order to obtain the stock prices,
`the applet needs to direct the browser 105 to, in turn, direct
`the operating System of the personal computer 104 to request
`a connection to a Server proceSS 110 running on the Server
`computer. Once a connection has been established, the
`applet 106 then directs the browser to transmit one or more
`Stock price database queries to the Server process 110 which
`forwards the queries to the database management System
`108. The database management System executes the queries
`against Stock price data Stored in the data Storage device 107
`in order to obtain the response Stock price data, and then
`directs the server process 110 to transfer the response stock
`price data back to the applet 106. Finally, the applet directs
`the browser via the operating System of the personal com
`puter to display the response Stock price data in a Stock price
`report on the display monitor. The data transfer between the
`personal computer and the Server computer occurs through
`network controller hardware devices 111 and 112 over
`telephone lines, a local area network 113 or a wide area
`network. Additional controllers 114 and 115 mediate transfer
`of data from the personal computer to the display monitor of
`the personal computer and from the data Storage device to
`the Server operating System.
`Because the applet is restricted in its ability to access
`resources, including the database management System,
`devising a general acceSS Strategy for accessing database
`management Systems from an applet, as in the above
`example, has proved to be a difficult problem. There is, for
`example, no Standard method for an applet to employ
`TCP/IP Sockets in order to acceSS remote database manage
`ment systems. While access using TCP/IP is possible, a
`TCP/IP based server process would need to be developed to
`run on the Server computers that contain the database
`management Systems. Development of Such a server process
`requires careful attention to details involved in handling
`error conditions that arise because of network and database
`errors. In addition, careful attention would be required to
`considerations of the number of connections allowable on a
`Server and to considerations of the practical limitations to
`connectivity arising from database management Systems and
`from bandwidth limitations of the local area network or
`telephone lines by which data is transferred. Another pos
`sible method is the JDBC-ODBC bridge. JDBC was devel
`oped for JAVA and allows JAVA applets to access a database
`management System using a driver written in JAVA for each
`particular type of database management System. This
`method has the drawback that development of the drivers
`can be quite difficult, code writing and debugging under
`JDBC can be complex, additional software needs to be
`added to the personal computer that uses native calls that are
`not compatible with all browsers, and the applet must adhere
`to a number of Security requirements. Because applets have
`relatively free access to HTML pages unconstrained by
`Security requirements, a third method might employ placing
`the Stock price data into HTML pages rather than into a
`database management System, So that the applet could
`access the data directly. The disadvantage in this method is
`that Storing the Stock price data in Static HTML pages can be
`quite inefficient, and data Stored in this manner is not
`amenable to incremental updates and easy and efficient ad
`
`15
`
`TECHNICAL FIELD
`The present invention relates to computer database acceSS
`and, in particular, to access to a database on one computer
`by a JAVA applet running on a Second computer.
`BACKGROUND OF THE INVENTION
`The development of communications networks, personal
`computers, and client-Server network applications has led to
`frequent access of data Stored in database management
`Systems on Server computers by application to programs
`running on client computerS. Commonly, a client computer
`establishes a TCP/IP connection to the server computer on
`which the database management System runs and then Sends
`queries to the database management System and receives
`responses to those queries via the TCP/IP protocol. The
`server computer includes a process which listens for TCP/IP
`connection requests, establishes TCP/IP connections in
`response to those requests, and establishes connections to
`the database management System corresponding to the TCP/
`IP connections. The proceSS forwards incoming queries from
`client computers through the TCP/IP connections to the
`corresponding database connections, collects data furnished
`by the database management System in response to the
`queries, and forwards the collected data back to the corre
`sponding client computers through the TCP/IP connections.
`With the rapid increase in the use of the Internet, web
`browser applications have become a very common and
`convenient means for client computer users to acceSS infor
`mation stored on Server computers. Initially, web browsers
`were capable of retrieving hypertext markup language
`(“HTML') documents from a remote server over the Inter
`net and graphically displaying the HTML documents to the
`web browser user. AS web browsers have become more
`Sophisticated, they can now not only receive HTML docu
`ments from Server computers, but can also receive JAVA
`programs from Server computers and execute the JAVA
`40
`programs on the client computer under the direction and
`monitoring of the web browser. These JAVA programs,
`known as applets, can provide a far more interactive and
`dynamic display of information than that achieved by dis
`playing static HTML documents. However, JAVA applets
`give rise to a number of Serious administrative and Security
`problems. If the applet was able to have free access to the
`full range of operating System calls accessed by application
`programs, then a web browser user could inadvertently
`download from the Internet a capricious program that dis
`rupts the State of the client computer, including changing the
`client computer's configuration Settings, that damages or
`destroys the client computer's file System and the contents of
`the client computer's files, or that rifles the contents of the
`client computer and transmit those contents back to an even
`more capricious program running on a Server computer. For
`these reasons, the executing applet is closely guarded and
`monitored by the web browser, and its access to client and
`Server resources is Severely restricted.
`It has become very desirable for JAVA applet developers
`to be able to write applets that can acceSS database infor
`mation from Server computers. FIG. 1 displays a Stock price
`quoting System implemented using a JAVA applet. This
`Stock price quoting System demonstrates both the need for
`access to Server database management Systems by a JAVA
`65
`applet and the problems that currently make Such acceSS
`difficult to achieve. The Stock price quoting System displayS
`
`45
`
`50
`
`55
`
`60
`
`Page 6
`
`

`

`5,999,941
`
`3
`hoc Searching and manipulation. A need has therefore been
`recognized for a technique that allows an applet running on
`a client computer to easily access a database management
`System running on a server computer.
`
`SUMMARY OF THE INVENTION
`An embodiment of the present invention provides a
`method and System for accessing a database management
`System running on a Server computer from within a JAVA
`applet running on a client computer. The JAVA applet
`prepares a uniform resource locator (“URL') with which to
`address an active Server page on the Server computer,
`embedding within the URL a database query. The JAVA
`applet then accesses the active Server page using the pre
`15
`pared URL as an address in the same way that the JAVA
`applet would access a HTML page. Upon receiving the
`request for access to the active Server page, the Server
`computer executes a Script Stored within the active Server
`page that receives from the Server computer the database
`query embedded within the URL, passes the database query
`to the database management System, receives from the
`database management System the query results, creates a
`HTML document, and stores the query results in the HTML
`document. The server computer then returns the HTML
`25
`document to the client computer, where the JAVA applet
`opens the returned HTML document and reads the query
`results from the HTML document in the same manner as the
`JAVA applet would open and read data from a text file.
`
`BRIEF DESCRIPTION OF THE DRAWINGS
`FIG. 1 displays a Stock price quoting System implemented
`using a JAVA applet.
`FIG. 2 displays the Stock price quoting System imple
`mented using a JAVA applet and active Server pages.
`FIG. 3 displays a flow control diagram for the database
`access portion of a JAVA applet.
`FIG. 4 displays a flow control diagram for a simple active
`Server page Script implementation for a Stock price quoting
`System.
`
`35
`
`40
`
`4
`to the applet. The applet then reads the query response data
`that it has requested from the database management System
`from the returned HTML page. The query response data is
`formatted in a predetermined format by the active Server
`page program and can be read from the HTML page in the
`Same fashion that lines are read from a normal text file. In
`other words, the applet does not need to cause the HTML
`page to be displayed by the browser, but can access the
`HTML page only in order to extract from the HTML page
`the query response data.
`The Security problems that would arise from an attempt to
`directly connect to the database management System from
`within a JAVA applet are thus completely avoided in the
`active Server page implementation. Only well-known func
`tions for requesting an HTML document via a URL from a
`client computer and well-known functions for reading the
`contents of a text file need be employed to achieve database
`acceSS from within the JAVA applet. The active Server page
`functionality is a standard feature of the Microsoft Web
`Server Software. To create the active Server page that allows
`for database access from a JAVA applet, a developer need
`use only a Standard Scripting language, Such as Visual Basic,
`and common database access tools embedded within Such
`Scripting languages.
`FIG. 2 displays the Stock price quoting System imple
`mented using active Server pages. AS in FIG. 1, the Stock
`price quoting System comprises a personal computer 201
`that includes an operating System 202 process, a web
`browser 203 process, and a Stock price quoting System
`applet 204 process. AS in FIG. 1, Stock prices are formatted
`and transmitted by the applet 204 via the operating System
`202 and a hardware controller 205 to the display monitor of
`the personal computer 206. The applet obtains the stock
`prices from a database management System 207 running on
`a server computer 208. The server computer includes device
`controllers 209 and 210, a data storage device 211, an
`operating System 212, and a Server process 213 which
`monitors incoming data requests from client computers over
`the Internet or telephone lines 214. An active Server page
`215 is Stored on the data Storage device and is instantiated
`in memory 216 by the Server process via the operating
`System. When the applet 204 requests the active Server page
`using a URL for that active Server page, the Server instan
`tiates the active Server page in memory and causes the Script
`within the active Server page to be executed on the Server
`computer. Execution of the script produces an HTML docu
`ment 217. The server then transmits that HTML document
`via the operating System and the Internet or telephone lines
`through the operating System and network device controller
`of the server computer to the network device controller 215
`on the personal computer from which the data corresponding
`to the HTML document is collected by the operating system
`and passed through the browser back to the applet.
`There are many advantages to this technique of providing
`database access to JAVA applets via active Server pages. The
`applet portion of the technique can be developed using pure
`JAVA language facilities. No additions to the JAVA language
`are needed nor is there a need for embedding calls to
`functionality external to JAVA. The active Server page
`facility on the Server computer is a Standard feature of the
`Windows NT operating system, and therefore requires no
`development. Active Server page Scripts are easily
`developed, debugged and tested using powerful and com
`monly available development tools for the Visual Basic
`Scripting language. There are no Security issues, Since the
`applet makes no attempt to access resources other than
`HTML pages via normal URL-specified access. Finally,
`
`45
`
`55
`
`DETAILED DESCRIPTION OF THE
`INVENTION
`An embodiment of the present invention provides a
`technique for accessing database management Systems run
`ning on Server computer from within a JAVA applet running
`on a client computer. This technique avoids the general
`Security issues involved in accessing resources from a JAVA
`applet and is efficient from a development Standpoint. This
`50
`technique may employ the MicroSoft active Server page
`technology that was created to allow client computers to
`launch tasks on Server computers and to receive the results
`from execution of those tasks. The JAVA applet accesses an
`active Server page on the Server computer in the same
`fashion as it would normally access an HTML page. The
`applet can pass a database query to the active Server page on
`a Server computer by including the database query within the
`URL by which the applet addresses the active Server page.
`The Server computer receives the query and passes it to a
`program contained in the active Server page. The active
`Server page is essentially a file containing a program written
`in a Script language Such as Visual Basic. That program
`executes the query by passing the query to a database
`management System, receives the result from the query, and
`formats the result into an HTML page. The server returns the
`HTML page constructed by the active Server page program
`
`60
`
`65
`
`Page 7
`
`

`

`S
`applets developed using this technique can be imported and
`run by any web browser.
`FIG. 3 displays a flow control diagram for the database
`access portion of a JAVA applet. The JAVA applet constructs
`a URL for an active Server page that includes a database
`query, requests a HTML file from a Server computer using
`the URL, and reads the query results from the HTML file
`returned by the server computer. In step 301, the applet
`constructs a URL to address the active Server page devel
`oped to facilitate database access. The applet formats argu
`ments to be passed to the active Server page into the
`character string representation of the URL. In step 302, the
`applet uses Standard JAVA functions to open the active
`Server page, addressed by the URL, as a file. Either this Step,
`or the first execution of step 304, below, launches a request
`message from the client computer to the Server computer in
`response to which the serve computer returns an HTML
`document containing the results of the database query. Steps
`303-305 represent a loop in which the applet processes each
`line of the HTML document returned by the server computer
`in response to the access of the active Server page by the
`applet. In step 304, the applet reads a line from the returned
`HTML document and parses it according to a predetermined
`format in which data from the database query response was
`placed into the HTML file by execution of the script of the
`active Server page. Either in this Step, or in Step 306, the
`applet uses the data parsed from the received HTML file in
`Some application dependent manner. For example, in the
`Stock price quoting System described in FIG. 2, the applet
`would format the name and price of the Stock into the format
`of the Stock prices report and would direct the display
`monitor to display a list of the formatted names and prices
`received from the server computer.
`FIG. 4 displays a flow control diagram for an active server
`page Script implementation of the Server Side of the Stock
`price quoting System. The Script prepares a database query,
`passes the database query to a database management System
`for execution, and prepares a HTML page that includes the
`results of the database query execution returned to the Script
`by the database management System. In Step 401, the active
`Server page Script uses Standard Script language features to
`receive arguments that were packed into the URL by the
`applet. In Step 402, the active Server page Script opens a new
`HTML file into which it will place data returned by the
`database management System in response to a query. In Step
`403, the active Server page Script uses Standard Script
`language features to construct a database query from the
`received arguments and to execute that query against a
`database management System running on the Server com
`50
`puter. Steps 404–406 represent a loop in which the active
`Server page Script receives each row returned as a result of
`the execution of the query, in the case of a relational
`database System, formats the data in the manner expected by
`the applet which will receive the data, and writes the
`formatted data to the HTML file. When the active server
`page script finishes, in step 407, the HTML file prepared by
`the Script is returned by the Server operating System and
`communication modules to the requesting applet.
`The following pseudocode routine "stock report' dem
`60
`onstrates an implementation of the client or applet Side of the
`Stock price quoting System:
`
`15
`
`25
`
`35
`
`40
`
`45
`
`55
`
`1 public void stock report()
`2 {
`3
`
`String res;
`
`65
`
`5,999,941
`
`6
`-continued
`
`String url address = "http://stock queries/
`database.asp?QUERY =
`SELECT NAME, PRICE FROM STOCKPRICES;
`
`URLu;
`InputFile inp;
`Output out;
`
`u = new URL (url address);
`inp = u.openInput;
`out.printTitle (“Stock Prices');
`while (res = imp. NextLine() = null)
`{
`out.printentry (res, “ ”);
`
`4
`
`5
`6
`7
`8
`9
`1O
`11
`12
`13
`14
`15
`16
`
`Online 4, the URL, with which the active server page on the
`Server will be addressed by the applet, is constructed by
`Stock report and placed in the String url address. Note that
`the portion of the URL following the question mark repre
`sents an argument or a parameter, called “QUERY,” that will
`be passed to the script that will be run by the server computer
`in response to access of the active Server page. Stock report
`employs Several generalized classes, including classes for
`URL-mediated access to Server pages, for input from an
`HTML file, and for output to the display monitor, instanti
`ated as objects “u” on line 5, “inp” on line 6, and “out' on
`line 7, respectively. On line 9, Stock report prepares to
`access the active Server page via the URL by instantiating
`the URL object “u.” Online 10, stock report sends the URL
`String "url address' to the Server, requesting access to the
`active server page described by the URL, and directs the
`input object “inp” to read input from the HTML page
`returned by the server in response to the request for access
`to the active Server page. Online 11, the Stock report prints
`out the title “Stock Prices” to the display monitor. In the loop
`on lines 12-15, stock report reads each line of the HTML
`file returned in response to access of the active Server page
`by Stock-report and prints out an entry on the display
`monitor for the particular Stock and price contained in the
`line.
`The following pseudocode Script represents the Server
`Side implementation of the Stock price quoting System:
`
`Database DB
`HTML File ht
`String query
`ht.Open()
`query = GetArg (QUERY)
`DB.Connect (“stock report database')
`DB.Execute (query)
`while (DB.ResultSetEmpty())
`10 {
`ht.WriteLine (DB. GetNextRow())
`11
`12
`13 ht. Close()
`
`In this pseudo Script language routine, a database object
`“DB,” an HTML file “ht,” and a string “query,” are declared
`on lines 1-3. On line 5, the script opens the HTML file. On
`line 6, the script calls a built-in function “GetArg” to retrieve
`the parameter “QUERY” from the URL by which the active
`Server page is addressed. Online 7, the Script connects to the
`database “stock report database.” On line 8, the script
`executes the query obtained as a parameter from the URL.
`In the loop represented by lines 9-12, the script retrieves
`each row from the set of rows that represents the result of
`query execution from the database management System, and
`
`Page 8
`
`

`

`5,999,941
`
`5
`
`15
`
`2O
`
`35
`
`40
`
`7
`on line 11, formats and writes out those rows to the HTML
`file. The script closes the HTML file on line 13 and returns.
`Once the Script has ended, the operating System transferS the
`HTML file prepared by the script back to the requesting
`applet.
`Although the present invention has been described in
`terms of one embodiment, it is not intended that the inven
`tion be limited to this embodiment. Modifications within the
`spirit of the invention will be apparent to those skilled in the
`art. For example, the active Server page can be implemented
`in any of the Script languages Supported by the MicroSoft
`active Server page facility. The queries and the responses to
`those queries can be formatted in any manner conducive to
`Storage within an HTML page. More than one query can be
`Sent during a single access to any given active Server page.
`The active Server page can be implemented to use an
`existing database connection which is kept open over the
`lifetime of the Server process, or can connect to the database
`management System each time a query is processed. Param
`eters encoded within the URL string may direct the active
`Server page to connect to any number of different databases.
`The scope of the present invention is defined by the claims
`that follow.
`What is claimed is:
`1. A method for accessing a database management System
`running on a Server computer from within a JAVA applet
`running on a client computer, the method comprising:
`within the JAVA applet on the client computer,
`constructing a uniform resource locator that identifies
`an active Server page on the Server computer, the
`uniform resource locator including a database query
`encoded as an argument, and
`Sending to the Server computer a request to access the
`active server page identified by the uniform resource
`locator;
`on the Server computer,
`receiving from the client computer the request to acceSS
`the active Server page identified by the uniform
`resource locator,
`extracting the argument that encodes the database
`Guery,
`executing a Script stored in the active Server page,
`passing to Script the extracted argument,
`under control of the Script,
`passing the query encoded in the extracted argument
`to the database management System,
`receiving query results from the database manage
`ment System, and
`producing a hyper text markup language document
`that includes the query result, and
`returning the produced hyper text markup language
`document to the client computer; and
`within the JAVA applet on the client computer,
`receiving the returned hyper text markup language
`document from the Server computer and reading
`from the hyper text markup language document the
`query result.
`2. The method of claim 1 wherein the database manage
`ment System is a relational database management System.
`3. The method of claim 1 wherein the script stored in the
`active Server page is a Visual Basic Script.
`4. The method of claim 1 wherein the returned hyper text
`markup language document is opened and read by the JAVA
`applet in the same way that the JAVA applet would open and
`read a text file.
`5. A System that provides to a JAVA applet running on a
`client computer access to a database management System
`running on a Server computer, the System comprising:
`
`8
`the JAVA applet on the client computer that
`constructs a uniform resource locator that includes an
`argument that encodes a database query, the uniform
`resource locator used to address an active Server
`page on the Server computer,
`uses the constructed uniform resource locator to request
`from the Server computer access to the active Server
`page, and
`reads query results from a hyper text markup language
`document returned by the Server computer in
`response to the access request; and
`the active Server page on the Server computer containing
`a Script that is executed by the Server computer that
`receives from the Server computer the encoded data
`base query,
`passes the database query to the database management
`System,
`receives query results from the database management
`System, and
`produces the hyper text markup language document
`that includes the query result.
`6. A method for accessing a database management System
`running on a Server computer from within a program run
`ning on a client computer that was transferred to the client
`25 computer from the server computer, the method comprising:
`constructing a uniform resource locator that identifies an
`active Server page on the Server computer, the uniform
`resource locator including a database query encoded as
`an argument,
`Sending to the Server computer a request to access the
`active Server page identified by the uniform resource
`locator, the Sending of the request causing the Server to
`invoke ascript within the active Server page that causes
`the database query to be executed and that packages
`results from the database query execution into a hyper
`text markup language document and causing the Server
`computer to return the hyper text markup language
`document containing the results from the database
`query execution to the program; and
`receiving the returned hyper text markup language docu
`ment from the Server computer and reading from the
`hyper text markup language document the results of the
`database query execution.
`7. The method of claim 6 wherein the program running on
`the client computer is a JAVA applet.
`8. A System that provides to a program running on a first
`computer access to data produced by an application program
`running on a Second computer, the program running on the
`first computer transferred to the first computer from the
`Second computer, the System comprising:
`the program running on the first computer that
`constructs a uniform resource locator that identifies an
`active Server page on the Second computer, the
`uniform resource locator including a request to the
`application program encoded as an argument,
`Sends to the Second computer a request to access the
`active Server page identified by the uniform resource
`locator, and
`receives the application data from the Second computer
`in a hyper text markup language document returned
`by the Second computer in response to the access
`request, and
`the active Server page on the Second computer containing
`a Script that is executed by the Second computer that
`receives the request to the application program
`included in the uniform resource locator,
`
`45
`
`50
`
`55
`
`60
`
`65
`
`Page 9
`
`

`

`9
`passes the request to the application program,
`receives the data that results from execution of the
`request by the application program, and
`produces the hyper text markup language document
`that includes the data.
`9. A method for providing results of a database query
`executed on a Server computer to a program running on a
`client computer that was transferred to the client computer
`from the Server computer, the method comprising:
`receiving by the Server computer a request from the
`program running on the client computer to access an
`active Server page addressed by a uniform resource
`locator;
`extracting from the uniform resource locator an argument
`that encodes the database query;
`launching execution of a Script contained in the accessed
`active Server page;
`passing the extracted argument that encodes a database
`query to the Script which, in turn, passes the database
`query to a database management System, receives the
`results of the database query back from the database
`management System, and prepares a hyper text markup
`language document that includes the results from the
`database query; and
`returning the hyper text markup language document to the
`program running on the client computer.
`10. A System that provides to a program running on a first
`computer access to data produced by an application program
`running on a Second computer, the System comprising:
`a program running on the first computer t