Upload
others
View
1
Download
0
Embed Size (px)
Citation preview
The Pennsylvania State University The Graduate School
Capital College
A Simple Web-enabled System for Database Management
A Master's paper in Computer Science
By Ping Wang
@2000 Ping Wang
December 2000
Abstract
A database management system (DBMS) is used to provide an environment that lets people store
and retrieve information conveniently and efficiently. The World Wide Web is the most popular and
widespread information service on the Internet. This paper describes a program that connects to a
database system and allows database managers and database users to collect and access data
through the Web. In our system, most complicated and redundant work is transparent to database
managers and users. Also, the system provides friendly interfaces. This allows people with limited
training to work with our database system. The system is a CGI application developed using the Perl
programming language.
Table of Contents
1. Introduction 1
2. System Description and Implementation 7
<2.1> General information about the implementation 7
<2.2> Running the CGI program on the Internet 13
<2.3> Implementation review 26
3. Conclusion 34
References 38
Table of Figures
Figure 1. Diagram of Qingru Zhang's system 3
Figure 2. Diagram of our system 4
Figure 3. Example of an input text file 11
Figure 4. Login page 13
Figure 5. Example of an error message page 14
Figure 6. Welcome page 15
Figure 7. Manager page 17
Figure 8. Create table page 18
Figure 9. Create query page 29
Figure 10. Result page from deleting a query 20
Figure 11. User page 22
Figure 12. Table value input page 23
Figure 13. Query result page 24
Figure 14. Query variable entry page 25
- 1
1. Introduction
Web-enabled applications provide solutions for education, business, entertainment and many other
application areas. For example, global education allows students around the world to take the
same class on the Web. In most such applications, a Web browser provides a front end to existing
database systems. Web servers are responsible for the other end of the connection, listening for
incoming requests and transmitting the desired document back to the browser. Web documents
often correspond to real, physical files stored on one of the server's disks. When a request comes
in, the server finds the corresponding document on its disk drive and sends it off. However, Web
documents don't have to be static files. To deal with dynamic documents, Common Gateway
Interface (CGI) scripts are used on the server's side. These allow designers of Web sites to create
dynamic documents that change every time they are accessed or in response to different user
requests [Harr99].
ODBiC (Open Database Internet Connector) is an example [Harr99]. It has many unique built-in
functions to simplify some common requirements. For example:
• Automatic HTML table generation from database queries.
• Automatic "query by example" queries generated from an input.
• Automatic HTML forms and SQL statements for database INSERT and UPDATE
operations.
- 2
• Automatic HTML "pull-down choice lists" with choices selected from the database.
• Easy "loop" processing for multiple rows selected by a query.
• Easy multiple-level "master/detail" or "category" grouping of query results.
In addition to database access, ODBiC provides many other functions for creating dynamic Web
pages. It is a consumer product for Web-enabled database management.
Database interface is the primary purpose of such applications, and is fundamental to today’s
booming electronic B2C (Business to Customer) and B2B (Business to Business) marketplaces.
This paper introduces a Web-enabled database management system -- a CGI application
implemented using Perl. Our system is a simple and easy to use database Internet connector. It is
similar to ODBiC and is based on a system developed by Qingru Zhang. In Zhang's paper "A
system to generate a simple and reusable Web-enabled solution for database queries"[Zhang00],
she explained how to implement a specific system that generates a CGI program for database
users (shown in Figure 1). To use her system, one needs to do the following:
1. Create an input text file that contains table and query information
2. Run a translation program that reads this text file and generates a target CGI program
and a standard file (called, for example, Xfile) which contains statements for creating
tables
3. Create the tables in the database (for example, using the DB2 command "db2 -f
- 3
Xfile").
4. Use the target program to provide a user-friendly interface to add values and execute
queries on the Internet
Run generating program
Access target CGI program
Create tables
Add records
Execute queries
Database
Figure 1. Diagram of Qingru Zhang's system
Zhang's system works well if the database is very stable, which means the tables and queries in the
database file do not need to be changed after they are created. Otherwise, to make changes, the
text file has to be regenerated, the old tables must be dropped from the database and the new
tables must be created in the database. Then the target CGI program can be run. This process is
Create text file
- 4
inconvenient and must be done by a database manager.
We wanted to design a system that makes changing the database and querying easier. Also, we
want our system to be portable, transparent, simple and easy to use. A diagram of our system is
shown in Figure 2. We have integrated the database management part into our system. Compared
to Zhang's system, our system includes several new features as follows:
CGI program
Welcome page
Manager page
User page
Create and delete tables
Create and delete queries * Grant and revoke privileges
Add records
Execute queries Display results
Database
- 5
Figure 2. Diagram of our system (* no connection to the database)
1. A database manager does not need to generate a target CGI program. Our program itself is
a CGI program.
2. A database manager does not need to generate a standard file that contains statements for
creating tables. Also, he doesn't need to create tables in the database. Our system does this
automatically.
3. A database manager can create and delete tables, create and delete queries in an existing
input text file.
4. A database manager can create a new input text file.
5. A database manager can grant and revoke privileges to users.
6. A database user can select values for records while adding data and for variables while
executing queries.
Our system is portable. The connection from the program to a database system is implemented
using the database interface (DBI) package. DBI makes calls to modules called DBDs (database
drivers), which are specific to a database vendor and drive the native vendor API (Application
Programming Interface) for a particular database system. The reason we chose DBI is that DBI is
not related to any one specific database. It serves as an intermediary between a program and one
- 6
or more DBD driver modules. The DBI package API completely isolates the application from the
internal implementation of the underlying databases. One can connect to different database systems
using a different DBD driver module [Husa96]. For example, our system uses the DBI and
DBD::DB2 combination, but could use any DBD driver module needed to port to a different
database system.
Our system is relatively easy to implement. This is due to using a scripting language, which means
the program does not have to deal with complex formatting or function/procedure or
object/method structures to accomplish its task. Scripting languages provide quick turnaround,
dynamic user interfaces, good facilities for text handling, run-time evaluation, and good connections
to database and networks [Srin97].
Our system is designed to be easy to use and learn. The interface between our system and the
database system is transparent to both managers and users. Our system provides friendly interfaces
for both database managers and users. People who have limited training can handle our system
without significant difficulties.
There are several issues we needed to consider during the design of our system. The main issues
included how to build dynamic hash tables from an input text file, how to connect to an existing
database system, how to design a friendly interface, how to deal with the variables in the queries
- 7
and how to make the system transparent to both database managers and users. These issues will
be described in the following sections of this paper.
- 8
2. System Description and Implementation
<2.1> General information about the implementation
There are several programming languages that can be used as scripting languages. Scripts are
external programs that the server runs in response to a browser's request. When a user requests a
URL that points to a script, the server executes it. Any output that the script produces is returned
to the user's browser for display. We chose Perl as our scripting language because it is easy to
learn and because it is optimized for text processing.
Perl is an interpreted language optimized for scanning arbitrary text files, extracting information
from those text files, and printing reports based on that information [Stei97]. The key to Perl's
power over text is its implementation of regular expression. A regular expression is a pattern that
describes a set of strings. A job done using a single pattern match in Perl can cost lines of code in a
different language. "Pattern matches, especially when combined with Perl's handling of strings and
lists, provide capabilities that are very difficulty to mimic in other programming languages"
[Brow99]. Perl is available for most operating systems and Perl's code is far more compact than
most other languages.
Our system is Web-enabled, which means it is an HTML-based application. In such an interactive
HTML-based application, a client program, such as a browser, sends information to an HTTP
- 9
server using the HTTP protocol, and vice versa. An HTTP server handles requests in different
ways. If the requested resource is a file, the server locates the file and sends it back to the client, or
sends a relevant error message if the file is unavailable. If the requested resource is complex, such
as an access to a database, servers do not do this processing themselves. Because such tasks are
largely customized to the applications running on a particular Web site, most servers let other
programs handle such complex tasks. Those programs are called gateway programs. They are
designed for special processing and run separately from the HTTP server. The communication
protocol between HTTP servers and these gateway programs is called the Common Gateway
Interface (CGI) [Grah97]. It defines three basic ways (environment variables, standard input,
command line) that information can be passed from a server to a program and one way (print
statements) that information can be passed from the program to the server [Patc98]. Perl is the
most popular language for writing CGI programs.
Our system is implemented to handle <FORM> HTTP requests, which use standard input to pass
the information from the server to the program. HTTP forms are used to store feedback
information, send simple or complex queries to a specific database, and deliver query results
[Titt96].
Several methods can be used by programs to receive data, such as GET, HEAD and POST. Our
CGI program uses the POST method. Compared to other methods, the POST method is more
- 10
secure and can deal with unlimited length URLs [Deep96].
The DBI package API is designed specifically for use with Perl. Our system uses the DBI package
to connect to a database system.
$dbh = DBI->connect ($databasename, $username, $password);
DBI->connect( ) returns a database handle, which represents the connection to a specific
database. There are several other functions we use to execute our basic SQL queries, such as:
$sth = $dbh->prepare( $sql_query); # send the query $sth->execute( ); # execute the query
$sth->bind_param($id, $value); # bind values to variables within the query
Once a statement is prepared and executed, the DBI package stores the information as attributes
of the statement handle. For example:
$sth->{NUM_FIELD} # the number of fields returned $sth->{NAME} # column names returned by the query
All DBI statements return undef on failure. The error strings can be obtained from
$dbh->errstr, which contains the errors from the last executed DBI statement [Srin97].
The cgi-lib.pl library is the standard library for creating CGI scripts in the Perl language. We
- 11
use the &ReadParse() function from the cgi-lib.pl library to help us get the value of a
variable from its name.
require 'cgi-lib.pl'; &ReadParse ( ); <input type="text" name=$input_name value=$in{$input_name}>
$input_value = $in{$input_name};
We pass a parameter to &ReadParse( ), for example &ReadParse(*array), in order to
use a different variable as the hash table name, such as "%array", instead of "%in" which is
the default hash table name.
Our system is designed to create, read and modify the input text file. The input text file is used to
store and retrieve information about the tables in the database and the queries on these tables. The
format of the file is based on Zhang's input text file. We modified Zhang's file and made it simpler
and more transparent. Figure 3 is an example of our text file format.
user pxw138 dbname qxz110 table people attri Identity, SSN, integer, yes, yes attri Name, name, char(20), yes, no attri BirthDay, birthday, date, yes, no attri Address, address, char(20), no, no attri PhoneNo, phoneno, char(20), no, no @ table position attri JobID, jobid, char(10), yes, yes
- 12
attri Location, location, char(20), yes, no attri Title, title, char(20), yes, no attri Department, department, char(20), yes, no attri RoomNo, roomno, char(10), yes, no attri EmployeeID, SSN, integer, yes, no attri AdviserName, adviser, char(20), no, no @ query Find all information in table people select * from pxw138.people @ query Find all information in table position select * from pxw138.position @ query Find person by name and birthday select * from pxw138.people where name =:name and birthday =:day @ query Find all information about a person by adviser select * from pxw138.people, pxw138.position where adviser = :ad and people.SSN = position.SSN @
Figure 3. Example of an input text file
The first line in the file contains a user's account name. This account name is used to indicate that all
the tables specified in this file are created by that user. The second line contains the database name.
This specifies which database the program uses. The rest of the file is filled with table and query
specifications.
- 13
For each table, the format is as follows:
The first line is the keyword "table " followed by "table_name".
The last line is the character "@".
The rest of the lines define table attributes. Each line has the format:
"attri description_attr, attr_name, type, yes/no, yes/no"
This part has the same format as Zhang's text files[Zhang00]. The "description_attr" is a description
of the attribute. It is not necessary but provides more information about the attribute. The
"attr_name" stands for attribute name. The first yes/no is to indicate if this attribute can be null or
not. If the attribute can be null, the value is no; otherwise, it is yes. The second yes/no is to indicate
if the attribute is a primary key attribute or not. If the attribute is part of the primary key, the value
is yes.
For each query, the format is as follows:
The first line is the keyword "query " followed by "query_name".
The last line is the character "@".
The rest of the lines are a standard SQL query.
This part is simpler and more transparent than Zhang's. If the query has variables, the character ":"
- 14
is placed just before each variable's name. This will help our CGI program find the variables in the
query.
We will talk more about the implementation detail later in section <2.3>.
- 15
<2.2> Running the CGI program on the Internet
To run our CGI program, first one must connect to the Internet, then connect to the URL:
http://richert.cac.psu.edu/cgi-bin/wahls/db2.cgi. The login page (Figure 4) will then appear on the
screen.
Figure 4. Login page
- 16
Here, richert.cac.psu.edu is the hostname for the Web server and the location of our program.
Generally, our system can be placed on any suitable server.
On the login page, the user name and password should be entered. If the account information is
valid for the database (such as DB2 in our system), the login succeeds. Otherwise, an error
message page will appear (as shown in Figure 5).
Figure 5. Example of an error message page
- 17
Figure 6. Welcome page
The first page after login is the welcome page (Figure 6). On this page, one should type the name
of the input text file, and then select either "Manager" or "User" to use the input file chosen.
- 18
If the input text file entered does not exist, two different things can happen. If one selects
"Manager", the system will create a new input file as named. Also, there is a message that appears
at the top of the manager page (Figure 7) as below:
"$file_name is a New Input Text File." If one selects "User", the warning message below will appear and reentry is allowed.
"! ! ! The Input Text File You Entered Does Not Exist. Try Again! Please Enter a Correct File Name."
While on the manager page (Figure 7), one has the opportunity to create and delete tables, create
and delete queries and grant and revoke privileges to other users. For example, to create a table
with 5 attributes, one should enter the number of attributes, then click the "create new table"
button. The "create table" page (Figure 8) will appear.
In the "create table" page, one would then enter the table name and attribute information, then click
"Finish". If well defined, the table is stored into the database system and into the input text file, and
the program goes back to the manager interface. Otherwise an error page similar to that shown in
Figure 5 will appear.
- 21
Figure 9. Create query page
As with the "create table" page, the "create query" page (Figure 9) is easy to use. One should type
the name of the query, and then implement the query using SQL. After one clicks "Complete", the
program will go back to the manager interface.
When creating queries, it is vital that the userid of the owner of a table (the person who created it)
be attached to the table name, i.e. select * from pxw138.people, where pxw138 is the
- 22
owner of the people table. Otherwise the query does not work if anyone except the creator runs it.
When comparing a variable with an attribute in an SQL query such as:
attribute_name =:variable_name
the attribute_name must be unique among all the tables specified in the input file. Otherwise, the
specific table name of this attribute must be added to this SQL query as follows:
table_name.attribute_name =:variable_name
Adding the table name to a non-unique attribute name makes it unique. Otherwise, the "select
variable value" function will not work. But one still can enter the variable value using priority choice,
as shown in Figure 14.
Figure 10. Result page from deleting a query
- 23
If one selects a table to delete and clicks "delete table", the following message will appear in the
"Result page from deleting a table" page:
Table "table_name" is deleted from the input file "file_name" and
from the database.
If one selects a query to delete and clicks "delete query", the following message will appear (Figure
10):
Query "query_name" is deleted from the input file "file_name".
Then one can click "Manager" to go back to the manager page.
While in the user page (Figure 11), one has the opportunity to insert values into tables (if this
privilege has been granted) and submit queries (this privilege is granted by default). This part is
similar to Zhang's system. We modified Zhang's interface and attempted to make it more friendly
for users.
- 24
Figure 11. User page
To insert a record, one simply selects the "table name" from the list, and then clicks the "insert table
value" button to get the "insert table value" page (Figure 12). We added the type of attribute after
the definition of the attribute name to help the user enter a correct value. Also, we added the select
feature that will show all the values of the attribute in the database. For frequently used values, such
as the name of states (for addresses), a department name, etc., the necessary value most likely
already exists in the database and can simply be selected. In this case, the "Enter value" field should
be left as "*empty*". Otherwise, the value entered will be the priority choice and the value selected
will be ignored.
- 25
After inputting or selecting the values, one should click "Done". If the value for each attribute is of
the correct type and the new record does not violate the primary key or not null constraints, the
record is successfully inserted into the selected table in the database system. The user page with
the message " Table values are successfully added to the database."
shows at the top will then appear. Otherwise, an error page will appear.
Figure 12. Table value input page
One can submit a query by selecting the query and clicking "submit query". The system checks
whether the query needs variables or not.
- 26
If the query is simple and no variables are needed, a result page (Figure 13) will appear.
Figure 13. Query result page
If the system finds that variables are needed, the variable definition page (Figure 14) will appear. In
the same way that one uses the record input page, one can either enter the variable value or select
the value from a list of values.
- 27
Figure 14. Query variable entry page
Actually, the situation here is more complex. In the record input page, all the record values for the
drop-down lists are from the same table. Here the variables may be compared with attributes
belonging to different tables.
If the same variable name is compared with more than one attribute, all the attributes' values can
be selected from the drop-down list of the variable. We explain the details of this in the next
section.
- 28
<2.3> Implementation review
In our CGI program we use many hash structures to store and retrieve data from the input text file.
Because the file may change frequently, generating these dynamic hashes becomes an important
issue.
Usually, a hash table is built in Perl with the format shown below (for creating a hash
%privileges to store the possible database privileges):
% privileges = qw{ 1 insert 2 update 3 delete 4 select
};
While generating dynamic hashes, we can not use this format. For example, our CGI program uses
dynamic hash tables to store and retrieve information from the input text file. Each time the CGI
program runs, the subroutine &make_hash in our program reads the input text file and generates
the hash tables that will be used later. The following code is used in our program to read the input
file and build the hash tables for the tables in the file:
while (<INPUT>){ $n = 1; if (/^table/i .. /\@/) { # recognize table definition part if ($_ =~ /^table\s+(\S+)/i){ # recognize table name
- 29
$tables{$n} = $1; # build hash %tables $n++; $tablename =$1; } # recognize attribute name if ($_ =~ /attri\s+(\S+),\s*(\S+),\s*(\S+),\s*(\S+),\s*(\S+)/) { $$tablename{$2} = $3; # build hash %$tablename } }#for table .. @ }
This code builds dynamic hash tables containing the table information from the input text file. These
hash tables include a %table that contains all the tables in the file with keys from 1 to n and values
of each table name. It has the same functionality as the regular static hash table shown below.
%table = qw (
1 table_name_1 2 table_name_2 … n table_name_n );
Also each table has a hash table %$tablename that contains keys with actual attribute name and
values with the type of the attribute.
These hash tables provide an efficient data structure for storing data about tables and allow our
CGI program to retrieve this data easily. For example, there are many drop-down lists in our
interface that can be built from these hash tables as follows:
print "<TD><SELECT NAME=TABLE_INDEX>"; print "<OPTION VALUE=" ">select your table";
- 30
foreach $table (sort keys (%tables)) { print"<OPTION VALUE = \"$table\"> $useraccount.$tables{$table}\n"; } print "</SELECT> </TD>";
The code above builds a drop-down list of all table names. If the keyword "sort" appears before
keys or values, the list is in sorted order. Otherwise, the list is in no specific order.
In our implementation, we use Perl's powerful regular expressions to retrieve information from the
text file and to add/delete specific statements into/from the text file. Perl's regular expressions are
not difficult to learn but not easy to master. The more one learns about regular expressions, the
more one feels their power and the less one feels helpless.
In Perl's regular expressions, the "^" character is guaranteed to match at only the beginning of the
string, the "$" character is guaranteed to match at only the end (or before the new line at the end),
and Perl does certain optimizations with the assumption that the string contains only one line.
Below are two examples of using "^" and "$".
Our CGI program uses the pattern "/^table\s+(\S+)/i../\@/" to find the table
name to build hash %tables. Without the "^" character in the pattern, there may be more
matches than expected. For example, the word "table" in a query statement would be selected.
The reason is that the word "table" within the query statement matches the pattern.
- 31
Also, without the "$" character in the pattern
"/^query\s*$query_name\s*$/i../\@/" that is used to find the query
statement, there may be more than one match. For example, executing the "delete query"
operation with the query statement "Find all flies" will delete both "Find all flies by name and color"
and "Find all flies", because both query statements contain "Find all flies".
In order to make a friendly interface for users to add records to the database and to submit
queries with variables, we designed our system to give users the opportunity to either select or
enter the values of records/variables.
In the beginning, we tried to design the system to let users select frequently used values, such as
state names and the department names. The problem is that we did not know what kinds of values
would be needed because the system allows database managers to create input text files and
tables. We can build some hashes with fixed information such as Countries, States and Oceans.
But most information in the database is not fixed. In order to provide users with a convenient
interface, our system retrieves all the values from appropriate records already in the database and
lets users select from these values or enter their choice.
This design is convenient for users but more time is needed by the system to retrieve all previously
- 32
entered values from the database and then to build hash tables for storing and retrieving the data,
especially when dealing with a database that has many records.
On the record input page, all the information needed is within a specific table. It is relatively easy to
retrieve the record for an attribute of the table using the SQL query:
"select distinct $attribute_name from $useraccount.$table_name" # $useraccount is the table creator's account name
On the variable entry page, things are more complex. The variables may be compared with
attributes belonging to different tables, so we don't have a specific table name as used in the
previous SQL query. The SQL query used to retrieve the values for the attribute that is compared
with the variable is more complex. The basic SQL query is:
"select distinct $attribute_name from $alltables" # $alltables is the join of all the tables
and below is the code to build the from clause above with the variable $alltables.
$alltables = "";
foreach $table ( keys (%tables)) { if ($alltable eq ""){
$alltables = "$useraccount.$tables{$table}"; }
else { $alltables .= ", $useraccount.$tables{$table}";
} }
- 33
If the variable is compared with an attribute that is not unique (some other table has an attribute
with the same name), one should add the table name to this attribute name when defining the query
(we mentioned this before in how to create queries on page 23). Otherwise, the query is illegal.
If the same variable is compared with different attributes, all attributes' values can be selected from
the drop-down list. To implement this part, first we attempted to use attribute names as keys to
retrieve the corresponding variables. This did not work. Using attributes as keys provides more
than one input or selection for one variable if the variable is compared with more than one
attribute. The reason is that our CGI program uses &ReadParse(*array) to get the input
data. This way, we input or select the same variable's value more than one time. All values for that
variable are concatenated, and so do not match any values in the database correctly. For example,
if we have a variable compared with two attributes:
# variable1 compared with attribute1 and attribute2 # get variable1's value from input or select # (assume the value is a string "red") $array{'attribute1'} = "red"; $array{'attribute2'} = "red"; # system retrieves the wrong variable value as below $array{'variable1'} = "redred";
That is why we use variables as the key to get values. The easy way is to build a hash table that
stores variables and associated attributes. When the variables are used as the key to retrieve the
corresponding attributes and build a drop-down list, only one of the attribute's values appear on
- 34
the list, because Perl chooses only one if there are multiple identical keys. This will miss other
attributes' values in the drop-down list but will still provide the select feature.
To solve this problem and make all attributes' values appear in the drop-down list, we build two
hash tables instead of one. One hash table stores the variables with unique numbers as keys, and
the other stores the corresponding attributes with the same unique numbers as keys. Every variable
appearing in the query has a list containing its corresponding attribute (the attribute it is compared
with). For example, if the variable name "SSN" appears twice in the query, there should be two
original lists:
@varattr2 = ($attri_name{2}); # list for variable "SSN" @varattr4 = ($attri_name{4}); # list for variable "SSN" # %attri_name is the hash table that stores the attributes
Then we compare the variable values with the information retrieved from the hash table that stores
the variables. If two identical values are found, the corresponding attribute is removed from one
variable's list and put into the other variable's list. For example, after comparing the variable values,
the above two lists would become:
@varattr2 = ($attri_name{2},$attri_name{4}); @varattr4 = ( ); # two list for variable "SSN"
Using these lists, the system can retrieve all the appropriate attributes' values and build a drop-
- 35
down list without missing any values.
We now show some code from our CGI program that builds hash tables for queries having
variables. To do this, we give each query a unique number, and if the query has variables, we use
this unique number to build hash tables for this query to store the attribute names and the variable
names.
if ($_ =~ /^query\s+(\S+)/){ # recognize description sentence
... $m++; # a unique number for this query $num = 1; # to order attributes and variables } if ($_=~/\.*:\.*/){ #find variable $c=$m-1; $attri_name = attrname.$c; #define hash name $var_name = varname.$c; @and=split(/\s+and\s+/, $_); #split between "and" foreach $and(@and){ if ($and=~/\.*(\S+)\s*[\=\>\<][\=]*\s*\:(\S+)/){ $$attri_name{$num} = $1; $$var_name{$num} = $2; #add hash contains $num++; } @or=split(/\s+or\s+/,$and); #split between "or" foreach $or(@or){ if ($or =~ /\.*(\S+)\s*[\=\>\<][\=]*\s*\:(\S+)/
and $or ne $or[0]){ $$attri_name{$num} = $1; $$var_name{$num} = $2; $num++; } } } }
The split of "and" and "or" above helps the system to get all the variables in the query. Using these
- 36
dynamic hash tables, the program creates a list for each variable containing its corresponding
attributes.
$numb = 0; foreach $z (keys %var_name){ # $z is a unique number $varattr = varattr.$z; @$varattr = ($attri_name{$z}); # create original list $numb++; }
After comparing with every variable's value, all the attributes compared with the same variable are
put into the same list (in the code shown below). All the values of those attributes appear in the
drop-down list for that variable.
for ($x = 1; $x < $numb; $x++){
for ($y = $x+1; $y <= $numb; $y++){ if ($var_name{$x} eq $var_name{$y}){ $varattr = varattr.$x; $varattr2 = varattr.$y; if ($#$varattr >= 0){ push (@$varattr, $attri_name{$y}); pop (@$varattr2); } } } }
3. Conclusion
- 37
In this paper we introduced a simple Web-enabled system for database management. In our
system, the CGI program handles the various tasks as much as possible. Our program builds drop-
down lists that eliminate redundant work such as entering repeated values in table, and provides a
friendly interface for both database managers and users. The main work which database managers
and users do is simply to select and submit.
The following sequence of events shows the flow of our CGI program and how HTML pages are
created when a client (database manager or user) requests operations.
1. Clients use a Web browser to select the operations by clicking on a link or pressing a button.
These operations include the following:
• Login and logout
• Create/open input text files
• Create and delete tables
• Create and delete queries
• Grant and revoke privileges
• Add records
• Submit queries
2. The program accepts these requests for operation execution on behalf of the Web server and
handles the requests. The operations can modify the input text file and send SQL queries and
- 38
statements to the database.
3. In the database, SQL statements and queries are executed.
4. A dynamic HTML page is created that includes the statement or query result.
5. The HTML page is returned to the Web server.
6. The Web server finishes the request by returning the page to the browser.
Our CGI program runs as a simple database management system. To make it more powerful and
more practical, there are several things we can do, including:
• Implementing a Web-enabled database monitor, which provides comprehensive information
about the database system.
• Implementing more database operations in the system. One example would be an operation to
add a column to an existing table using the SQL command:
"ALTER TABLE $table_name ADD COLUMN $attr_name type"
• Implementing a message send and receive feature within the system. The messages could be
either in a text file or dynamically selected from the database with a query. For example, the
query results can be sent to people who can not access our database but need some
information from the database.
- 39
• Implementing a Web-enabled database director, such as a graphical hierarchical tree structure
that can deal with more complex and heavy duty database management tasks.
The Internet has changed the way we manage databases. Software tools that simplify the
integration of SQL-based databases into Web sites that provide WWW access to the contents of
databases are becoming popular. There are more and more of these software tools being created,
such as WDB, a Web to Database Interface [Fres00] and ODBiC, Open Database Internet
Connector [Harr99].
As with our system, WDB and ODBiC are CGI programs that are executed by a Web server.
They all produce standard HTML web pages and interact with databases. They all have SQL
statements to SELECT, INSERT, or DELETE data in databases. WDB deals with a simple
database which stores addresses. ODBiC is more complex, as it produces both HTML formatted
text and JavaScript, and provides many other useful data processing functions in addition to its
SQL interface. Our system is simple but can deal with all of the basic operations on databases. In
comparison with WDB and ODBiC, the feature of selecting values and variables makes our
system easier to handle. The drop-down select lists provide an integrated view of the information
in the database and make it easy to insert values into the database and execute queries with
variables. Also our system is portable, transparent, and allows people with limited training to work
- 40
with a database management system.
With the rapid development of the Internet, Web-enabled applications have become the best
choice for many organizations. They provide a platform that enables an organization to work more
closely and efficiently with its customers, partners, and suppliers without the barriers of geography
and time differences. Our Web-enabled database management system is an example of such an
application. With a friendly interface and clear directions, it provides database managers and users
an easy way to access databases wherever and whenever they have Internet access.
- 41
References
[Brow99] Brown, M., Bellew, C., Livingston, D. Essential Perl 5 for Web Professionals. Prentice-Hall, Inc., 1999. 163p. [Cham1996] Chamberlin, D. Using the New DB2. Morgan Kaufmann Publishers, Inc., 1996. [Deep96] Deep, J., Holfelder, P. Developing CGI Applications with Perl. John Wiley & Sons, Inc., 1996. 299p. [Fres00] Frese, B. WDB - A Web to DataBase Interface, 2000 <http://www.i-con.dk/wdb/>. [Grah97] Graham, I. S. HTML Sourcebook. Third Edition. John Wiley & Sons, Inc., 1997. 620p. [Harr99] Harris, R. Open DataBase Internet Connector. Copyright ©1997-1999, <http://www.odbic.com/odbic/>. [Husa96] Husain, K., Breedlove, R. F. Perl5 Unleashed. Sams, 1996. 797p. [Patc98] Patchett, C., Wright, M. CGI/Perl Cookbook. John Wiley & Sons, Inc., 1998. 622p. [Srin97] Srinivasan, S. Advanced Perl Programming. Sebastopol, CA. O'Reilly, 1997. 161p. [Stei97] Stein, L. D. How to Set Up and Maintain a Web Site. Addison Wesley Longman, Inc., 1997. 793p. [Stei00] Stein, L. D. CGI.pm - a Perl5 CGI Library, Version 2.74, 2000, <http://stein.cshl.org/WWW/software/CGI/cgi_docs.html>. [Titt96] Tittel, E., Madden, M., Smith, D. B. Building Windows NT Web Servers. IDG Books Worldwide, Inc., 1996. 298p. [Zhang00] Zhang, Q. A System to Generate a Simple and Reusable Web-enabled Solution For database Queries. Master's paper, The Pennsylvania State University, 2000.