Progressive Parametric Query Optimization

Abstract:
In this project we approach a new technique called Progressive Parametric Query Optimization. In the Real world, commercial applications usually rely on precompiled parameterized procedures to interact with a database. Unfortunately, executing a procedure with a set of parameters different from those used at compilation time may be arbitrarily suboptimal. Parametric query optimization (PQO) attempts to solve this problem by exhaustively determining the optimal plans at each point of the parameter space at compile time. However, PQO is likely not cost-effective if the query is executed infrequently or if it is executed with values only within a subset of the parameter space. In this paper, we propose instead to progressively explore the parameter space and build a parametric plan during several executions of the same query. We introduce algorithms that, as parametric plans are populated, are able to frequently bypass the optimizer but still execute optimal or near-optimal plans.

Organization Profiles
In this world of increasing globalization, Stupros moves forward to meet the challenges of the future through the development of R & D projects in various domains. R & D project sector attracts the most prominent thinkers and practitioners in a range of fields that impinge on development. The global presence and reach attained by Stupors are not only substantiated by its presence, but also in terms of the training students in R & D project development. Over the decade, Stupors, a Subsidiary of Spiro Technologies & consultant Pvt. Ltd provides a wide range of R & D project development training. Our uniqueness lies in the exclusive R & D project development. Accordingly, we created a setting that is enabling, dynamic and inspiring for the increase of solutions to global problems by R & D project development. Developing appropriate, responsible,

innovative and practical solutions to students, by assisting in R & D project development. All our research is stranded in the need to provide an industry based training for students.

About team
Our team consists of more than 300 enthusiastic experts, drawn from a range of disciplines and experience, supported by infrastructure and facilities, which are world class and distinctively state-of-the-art. The strength of the organization lies in not only identifying and articulating intellectual challenges across a number of disciplines of knowledge but also in mounting research, training and demonstration projects leading to development of specific problem-based advanced technologies. The organization growth has been evolutionary, driven by a vision of the future and ingrained in challenges frightening today. The organization continues to grow in size, spread and intensity of work undertaken. Our experts are involved in a wide range of R & D project development training to student wishing to undertake professional development, or just wanting to learn about a new subject or area of study.

Technologies
We provide training in following domain for R & D project development: Networking Grid Computing Data Mining Image Processing, Neural Network Multimedia Embedded systems Power systems, Power electronics Control systems, communication

Bio Informatics Web Technologies Grid Computing

About R & D
Research and development Training makes students to understand new concepts, understand the strength and far reaching potential of your conception. It helps student to understand and prepare for the future of your technology.

Vision
Our vision doesn't begin and end with the execution of R & D projects. The main intension is to provide world-class training to the students in R & D project development by sharing our knowledge and expertise to create value is our ultimate goal.

Introduction
IN many applications, the values of runtime parameters of the system, data, or queries themselves are unknown when queries are originally optimized. In these scenarios, there are typically two trivial alternatives to deal with the optimization and execution of such parameterized queries. One approach, termed here as OptimizeAlways, is to call the optimizer and generate a new execution plan every time a new instance of the query is invoked. Another trivial approach, termed Optimize-Once, is to optimize the query just once, with some set of parameter values, and reuse the resulting physical plan for any subsequent set of parameters. Both approaches have clear disadvantages. Optimize- Always requires an optimization call for each execution of a query instance. These optimization calls may be a significant part of the total query execution time, especially for simple queries. In addition, Optimize-Always may limit the number of concurrent queries in the system, as the optimization process itself may consume too much memory. On the other hand, Optimize-Once returns a single plan that is used for all points in the parameter space. The chosen plan may be arbitrarily suboptimal for parameter values different from those for which the query was originally optimized.

Existing System:
We propose Progressive Parametric Query Optimization (PPQO), a novel framework to improve the performance of processing parameterized queries. We also propose the Parametric Plan (PP) interface as a way to incorporate PPQO in DBMS.

Limitations of Existing System

The optimization process itself may consume too much memory

Proposed System
We propose instead to progressively explore the parameter space and build a parametric plan during several executions of the same query. We introduce algorithms that, as parametric plans are populated, are able to frequently bypass the optimizer but still execute optimal or near-optimal plans We propose two implementations of PPQO with different goals. On one hand, Bounded has proven optimality guarantees. On the other hand, Ellipse results in higher hit rates and better scalability.

Proposed System Advantages

High Accuracy Performance is High

System Requirements Hardware:

PROCESSOR RAM MONITOR HARD DISK FLOPPY DRIVE CDDRIVE : : : : : : PENTIUM IV 2.6 GHz 512 MB DD RAM 15 COLOR 20 GB 1.44 MB LG 52X

Software:
Front End Back End Server Tools Used : : : : Java, JSP SqlServer 2000 Apache Tomcat 5.5 Net Beans IDE 6.1, Dream viewer

Scope of the Project

In this Project we implement the Optimization Process for Database to reduce the work load of Main Database.

Literature Survey Query optimization

Query optimization is a function of many relational database management a good systems in which multiple query plans for satisfying a query are examined and query plan is identified. This may or not be the absolute best strategy because there are many ways of doing plans. There is a trade off between the amount of time spent figuring out the best plan and the amount running the plan. Different qualities of database management systems have different ways of balancing these two. Cost based query optimizers evaluate the resource footprint of various query plans and use this as the basis for plan selection. Typically the resources which are costed are CPU path length, amount of disk buffer space, disk storage service time, and interconnect usage between units of parallelism. The set of query plans examined is formed by examining possible access paths (e.g., primary index access, secondary index access, full file scan) and various relational table join techniques (e.g., merge join, hash join, product join). The search space can become quite large depending on the complexity of the SQL query. There are two types of optimization. These consist of logical optimization which generates a sequence of relational algebra to solve the query. In addition there is physical optimization which is used to determine the means of carrying out each operation. The goal is to eliminate as many unneeded tuples, or rows as possible. The following is a look at relational algebra as it eliminates unneeded tuples. The project operator is straightforward to implement if <attribute list> contains a key to relation R. If it does not include a key of R, it must be eliminated. This must be done by sorting (see sort methods below) and eliminating duplicates. This method can also use hashing to eliminate duplicates Hash table.

SQL command distinct: this does not change the actual data. This just eliminates the duplicates from the results. Set operations: Database management heavily relies on the mathematical principles of set theory which is key in comprehending these operations. Union: This displays all that appear in both sets, each listed once. These must be union compatible. This means all sequences of selected columns must designate the same number of columns. The data types of the corresponding columns must thereby comply with the conditions valid for comparability. Each data type can be compared to itself. Columns of data type CHAR with the different ASCII and EBCDIC code attributes can be compared to each other, whereby they are implicitly adapted. Columns with the ASCII code attribute can be compared to date, time, and timestamp specifications. All numbers can be compared to each other. In ANSI SQL mode, it is not enough for the data types and lengths of the specified columns to be compatible: they must match. Moreover, only column specifications or * may be specified in the selected columns of the QUERY specifications linked with UNION. Literals may not be specified (wisc). Intersection: This only lists items whose keys appear in both lists. This too must be union compatible. See above for definition. Set difference: This lists all items whose keys appear in the first list but not the second. This too must be union compatible. Cartesian Product: Cartesian products (R * S) takes a lot of memory because its result contains a record for each combination of records from R and S.

Adaptive optimization
Adaptive optimization is a technique in computer science that performs dynamic recompilation of portions of a program based on the current execution profile. With a simple implementation, an adaptive optimizer may simply make a trade-off between Justin-time compilation and interpreting instructions. At another level, adaptive optimization

may take advantage of local data conditions to optimize away branches and to use inline expansion to decrease convarchar switching. Consider a hypothetical banking application that handles transactions one after another. These transactions may be checks, deposits, and a large number of more obscure transactions. When the program executes, the actual data may consist of clearing tens of thousands of checks without processing a single deposit and without processing a single check with a fraudulent account number. An adaptive optimizer would compile assembly code to optimize for this common case. If the system then started processing tens of thousands of deposits instead, the adaptive optimizer would recompile the assembly code to optimize the new common case. This optimization may include inlining code or moving error processing code to secondary cache.

Query Optimizer
The query optimizer is the component of a database management system that attempts to determine the most efficient way to execute a query. The optimizer considers the possible query plans for a given input query, and attempts to determine which of those plans will be the most efficient. Cost-based query optimizers assign an estimated "cost" to each possible query plan, and choose the plan with the smallest cost. Costs are used to estimate the runtime cost of evaluating the query, in terms of the number of I/O operations required, the CPU requirements, and other factors determined from the data dictionary. The set of query plans examined is formed by examining the possible access paths (e.g. index scan, sequential scan) and join algorithms (e.g. sort-merge join, hash join, nested loops). The search space can become quite large depending on the complexity of the SQL query. Generally, the query optimizer cannot be accessed directly by users: once queries are submitted to database server, and parsed by the parser, they are then passed to the query optimizer where optimization occurs. However, some database engines allow guiding the query optimizer with hints.

Most query optimizers represent query plans as a tree of "plan nodes". A plan node encapsulates a single operation that is required to execute the query. The nodes are arranged as a tree, in which intermediate results flow from the bottom of the tree to the top. Each node has zero or more child nodes -- those are nodes whose output is fed as input to the parent node. For example, a join node will have two child nodes, which represent the two join operands, whereas a sort node would have a single child node (the input to be sorted). The leaves of the tree are nodes which produce results by scanning the disk, for example by performing an index scan or a sequential scan.

Join ordering
The performance of a query plan is determined largely by the order in which the tables are joined. For example, when joining 3 tables A, B, C of size 10 rows, 10,000 rows, and 1,000,000 rows, respectively, a query plan that joins B and C first can take several orders-of-magnitude more time to execute than one that joins A and C first. Most query optimizers determine join order via a dynamic programming algorithm pioneered by IBM's System R database project. This algorithm works in two stages: 1. First, all ways to access each relations in the query are computed. Every relation in the query can be accessed via a sequential scan. If there is an index on a relation that can be used to answer a predicate in the query, an index scan can also be used. For each relation, the optimizer records the cheapest way to scan the relation, as well as the cheapest way to scan the relation that produces records in a particular sorted order. 2. The optimizer then considers combining each pair of relations for which a join condition exists. For each pair, the optimizer will consider the available join algorithms implemented by the DBMS. It will preserve the cheapest way to join each pair of relations, in addition to the cheapest way to join each pair of relations that produces its output according to a particular sort order. 3. Then all three-relation query plans are computed, by joining each two-relation plan produced by the previous phase with the remaining relations in the query.

In this manner, a query plan is eventually produced that joins all the queries in the relation. Note that the algorithm keeps track of the sort order of the result set produced by a query plan, also called an interesting order. During dynamic programming, one query plan is considered to beat another query plan that produces the same result, only if they produce the same sort order. This is done for two reasons. First, a particular sort order can avoid a redundant sort operation later on in processing the query. Second, a particular sort order can speed up a subsequent join because it clusters the data in a particular way. Historically, System-R derived query optimizers would often only consider leftdeep query plans, which first join two base tables together, then join the intermediate result with another base table, and so on. This heuristic reduces the number of plans that need to be considered (n! instead of 4^n), but may result in not considering the optimal query plan. This heuristic is drawn from the observation that join algorithms such as nested loops only require a single tuple (aka row) of the outer relation at a time. Therefore, a left-deep query plan means that fewer tuples need to be held in memory at any time: the outer relation's join plan need only be executed until a single tuple is produced, and then the inner base relation can be scanned (this technique is called "pipelining"). Subsequent query optimizers have expanded this plan space to consider "bushy" query plans, where both operands to a join operator could be intermediate results from other joins. Such bushy plans are especially important in parallel computers because they allow different portions of the plan to be evaluated independently.

Cost estimation models

Cost estimation models are mathematical algorithms or parametric equations used to estimate the costs of a product or project. The results of the models are typically necessary to obtain approval to proceed, and are factored into business plans, budgets, and other financial planning and tracking mechanisms. These algorithms were originally performed manually but now are almost universally computerized. They may be standardized (available in published varchars or

purchased commercially) or proprietary, depending on the type of business, product, or project in question. Simple models may use standard spreadsheet products. Models typically function through the input of parameters that describe the attributes of the product or project in question, and possibly physical resource requirements. The model then provides as output various resources requirements in cost and time. Cost modeling practitioners often have the titles of cost estimators, cost engineers, or parametric analysts.

Software Descriptions The Java Language What Is Java?

Java is two things: a programming language and a platform. The Java Programming Language Java is a high-level programming language that is all of the following: Simple Object-oriented Distributed Interpreted Robust Secure Architecture-neutral Portable High-performance Multithreaded Dynamic

Java is also unusual in that each Java program is both compiled and interpreted. With a compiler, you translate a Java program into an intermediate language called Java byte codes--the platform-independent codes interpreted by the Java interpreter. With an interpreter, each Java byte code instruction is parsed and run on the computer. Compilation happens just once; interpretation occurs each time the program is executed. This figure illustrates how this works.

Java byte codes can be considered as the machine code instructions for the Java Virtual Machine (Java VM). Every Java interpreter, whether it's a Java development tool or a Web browser that can run Java applets, is an implementation of the Java VM. The Java VM can also be implemented in hardware. Java byte codes help make "write once, run anywhere" possible. The Java program can be compiled into byte codes on any platform that has a Java compiler. The byte codes can then be run on any implementation of the Java VM. For example, the same Java program can run on Windows NT, Solaris, and Macintosh.

The Java Platform

A platform is the hardware or software environment in which a program runs. The Java platform differs from most other platforms in that it's a software-only platform that runs on top of other, hardware-based platforms. Most other platforms are described as a combination of hardware and operating system. The Java platform has two components:

The Java Virtual Machine (Java VM) The Java Application Programming Interface (Java API) The Java API is a large collection of ready-made software components that

provide many useful capabilities, such as graphical user interface (GUI) widgets. The Java API is grouped into libraries (packages) of related components. The following figure depicts a Java program, such as an application or applet, that's running on the Java platform. As the figure shows, the Java API and Virtual Machine insulates the Java program from hardware dependencies.

As a platform-independent environment, Java can be a bit slower than native code. However, smart compilers, well-tuned interpreters, and just-in-time byte code compilers can bring Java's performance close to that of native code without threatening portability.

What Can Java Do?

Probably the most well-known Java programs are Java applets. An applet is a Java program that adheres to certain conventions that allow it to run within a Java-enabled browser. However, Java is not just for writing cute, entertaining applets for the World Wide Web ("Web"). Java is a general-purpose, high-level programming language and a powerful software platform. Using the generous Java API, we can write many types of programs. The most common types of programs are probably applets and applications, where a Java application is a standalone program that runs directly on the Java platform. How does the Java API support all of these kinds of programs? With packages of software components that provide a wide range of functionality. The core API is the API included in every full implementation of the Java platform. The core API gives you the following features:

The Essentials: Objects, strings, threads, numbers, input and output, data structures, system properties, date and time, and so on. Applets: The set of conventions used by Java applets. Networking: URLs, TCP and UDP sockets, and IP addresses. Internationalization: Help for writing programs that can be localized for users worldwide. Programs can automatically adapt to specific locales and be displayed in the appropriate language.

Security: Both low-level and high-level, including electronic signatures, public/private key management, access control, and certificates. Software components: Known as JavaBeans, can plug into existing component architectures such as Microsoft's OLE/COM/Active-X architecture, OpenDoc, and Netscape's Live Connect.

Object serialization: Allows lightweight persistence and communication via Remote Method Invocation (RMI).

Java Database Connectivity (JDBC): Provides uniform access to a wide range of relational databases. Java not only has a core API, but also standard extensions. The standard

extensions define APIs for 3D, servers, collaboration, telephony, speech, animation, and more.

How Will Java Change My Life? Java is likely to make your programs better and requires less effort than other languages. We believe that Java will help you do the following:

Get started quickly: Although Java is a powerful object-oriented language, it's easy to learn, especially for programmers already familiar with C or C++. Write less code: Comparisons of program metrics (class counts, method counts, and so on) suggest that a program written in Java can be four times smaller than the same program in C++.

Write better code: The Java language encourages good coding practices, and its garbage collection helps you avoid memory leaks. Java's object orientation, its JavaBeans component architecture, and its wide-ranging, easily extendible API let you reuse other people's tested code and introduce fewer bugs.

Develop programs faster: Your development time may be as much as twice as fast versus writing the same program in C++. Why? You write fewer lines of code with Java and Java is a simpler programming language than C++.

Avoid platform dependencies with 100% Pure Java: You can keep your program portable by following the purity tips mentioned throughout this book and avoiding the use of libraries written in other languages.

Write once, run anywhere: Because 100% Pure Java programs are compiled into machine-independent byte codes, they run consistently on any Java platform.

Distribute software more easily: You can upgrade applets easily from a central server. Applets take advantage of the Java feature of allowing new classes to be loaded "on the fly," without recompiling the entire program. We explore the java.net package, which provides support for networking. Its creators have called Java programming for the Internet. These networking classes encapsulate the socket paradigm pioneered in the Berkeley Software Distribution (BSD) from the University of California at Berkeley.

About J2ee
The J2EE platform uses a multitiered distributed application model. Application logic is divided into components according to function, and the various application components that make up a J2EE application are installed on different machines depending on the tier in the multitiered J2EE environment to which the application component belongs. Figure 1-1 shows two multitiered J2EE applications divided into the tiers described in the following list. The J2EE application parts shown in Figure 1-1 are presented in J2EE Components.

Client-tier components run on the client machine. Web-tier components run on the J2EE server. Business-tier components run on the J2EE server. Enterprise information system (EIS)-tier software runs on the EIS server. Although a J2EE application can consist of the three or four tiers shown in

Figure 1-1, J2EE multitiered applications are generally considered to be three-tiered applications because they are distributed over three different locations: client machines, the J2EE server machine, and the database or legacy machines at the back end. Threetiered applications that run in this way extend the standard two-tiered client and server model by placing a multithreaded application server between the client application and back-end storage.

Figure 1-1 Multitiered Applications

J2EE Components
J2EE applications are made up of components. A J2EE component is a selfcontained functional software unit that is assembled into a J2EE application with its related classes and files and that communicates with other components. The J2EE specification defines the following J2EE components:

Application clients and applets are components that run on the client. Java Servlet and Java Server Pages Enterprise JavaBeans (EJB (JSP ) technology components are Web

components that run on the server.

) components (enterprise beans) are business

components that run on the server.

J2EE components are written in the Java programming language and are compiled in the same way as any program in the language. The difference between J2EE components and "standard" Java classes is that J2EE components are assembled into a J2EE application, verified to be well formed and in compliance with the J2EE specification, and deployed to production, where they are run and managed by the J2EE server.

J2EE Clients
A J2EE client can be a Web client or an application client.

Web Clients
A Web client consists of two parts: dynamic Web pages containing various types of markup language (HTML, XML, and so on), which are generated by Web components running in the Web tier, and a Web browser, which renders the pages received from the server. A Web client is sometimes called a thin client. Thin clients usually do not do things like query databases, execute complex business rules, or connect to legacy applications. When you use a thin client, heavyweight operations like these are offloaded to enterprise beans executing on the J2EE server where they can leverage the security, speed, services, and reliability of J2EE server-side technologies.

Applets
A Web page received from the Web tier can include an embedded applet. An applet is a small client application written in the Java programming language that executes in the Java virtual machine installed in the Web browser. However, client systems will likely need the Java Plug-in and possibly a security policy file in order for the applet to successfully execute in the Web browser.

Web components are the preferred API for creating a Web client program because no plug-ins or security policy files are needed on the client systems. Also, Web components enable cleaner and more modular application design because they provide a way to separate applications programming from Web page design. Personnel involved in Web page design thus do not need to understand Java programming language syntax to do their jobs.

Application Clients
A J2EE application client runs on a client machine and provides a way for users to handle tasks that require a richer user interface than can be provided by a markup language. It typically has a graphical user interface (GUI) created from Swing or Abstract Window Toolkit (AWT) APIs, but a command-line interface is certainly possible. Application clients directly access enterprise beans running in the business tier. However, if application requirements warrant it, a J2EE application client can open an HTTP connection to establish communication with a servlet running in the Web tier.

JavaBeans

Component Architecture

The server and client tiers might also include components based on the JavaBeans component architecture (JavaBeans component) to manage the data flow between an application client or applet and components running on the J2EE server or between server components and a database. JavaBeans components are not considered J2EE components by the J2EE specification. JavaBeans components have instance variables and get and set methods for accessing the data in the instance variables. JavaBeans components used in this way are typically simple in design and implementation, but should conform to the naming and design conventions outlined in the JavaBeans component architecture.

J2EE Server Communications

Figure 1-2 shows the various elements that can make up the client tier. The client communicates with the business tier running on the J2EE server either directly or, as in the case of a client running in a browser, by going through JSP pages or servlets running in the Web tiers. Your J2EE application uses a thin browser-based client or thick application client. In deciding which one to use, you should be aware of the trade-offs between keeping functionality on the client and close to the user (thick client) and off-loading as much functionality as possible to the server (thin client). The more functionality you off-load to the server, the easier it is to distribute, deploy, and manage the application; however, keeping more functionality on the client can make for a better perceived user

experience.

Figure 1-2 Server Communications

Web Components

J2EE Web components can be either servlets or JSP pages. Servlets are Java programming language classes that dynamically process requests and construct responses. JSP pages are text-based documents that execute as servlets but allow a more natural approach to creating static content. Static HTML pages and applets are bundled with Web components during application assembly, but are not considered Web components by the J2EE specification. Server-side utility classes can also be bundled with Web components and, like HTML pages, are not considered Web components. Like the client tier and as shown in Figure 1-3, the Web tier might include a JavaBeans component to manage the user input and send that input to enterprise beans running in the business tier for processing.

Business Components
Business code, which is logic that solves or meets the needs of a particular business domain such as banking, retail, or finance, is handled by enterprise beans running in the business tier. Figure 1-4 shows how an enterprise bean receives data from client programs, processes it (if necessary), and sends it to the enterprise information system tier for storage. An enterprise bean also retrieves data from storage, processes it

(if

necessary),

and

sends

it

back

to

the

client

program.

Figure 1-3 Web Tier and J2EE Application

Figure 1-4 Business and EIS Tiers There are three kinds of enterprise beans: session beans, entity beans, and message-driven beans. A session bean represents a transient conversation with a client. When the client finishes executing, the session bean and its data are gone. In contrast, an entity bean represents persistent data stored in one row of a database table. If the client terminates or if the server shuts down, the underlying services ensure that the entity bean data is saved. A message-driven bean combines features of a session bean and a Java Message Service ("JMS") message listener, allowing a business component to receive JMS messages asynchronously. This tutorial describes entity beans and session beans.

Packaging
J2EE components are packaged separately and bundled into a J2EE application for deployment. Each component, its related files such as GIF and HTML files or server-side utility classes, and a deployment descriptor are assembled into a module and added to the J2EE application. A J2EE application is composed of one or more enterprise bean, Web, or application client component modules. The final enterprise solution can use one J2EE application or be made up of two or more J2EE applications, depending on design requirements. A J2EE application and each of its modules has its own deployment descriptor. A deployment descriptor is an XML document with an .xml extension that describes a component's deployment settings. An enterprise bean module deployment descriptor, for example, declares transaction attributes and security authorizations for an enterprise bean. Because deployment descriptor information is declarative, it can be changed

without modifying the bean source code. At run time, the J2EE server reads the deployment descriptor and acts upon the component accordingly. A J2EE application with all of its modules is delivered in an Enterprise Archive (EAR) file. An EAR file is a standard Java Archive (JAR) file with an .ear extension. In the GUI version of the J2EE SDK application deployment tool, you create an EAR file first and add JAR and Web Archive (WAR) files to the EAR. If you use the command line packager tools, however, you create the JAR and WAR files first and then create the EAR files, and related Each EJB JAR file contains a deployment descriptor, the Each application client JAR file contains a deployment descriptor, the class files Each WAR file contains a deployment descriptor, the Web component files, and

enterprise bean files. for the application client, and related files. related resources. Using modules and EAR files makes it possible to assemble a number of different J2EE applications using some of the same components. No extra coding is needed; it is just a matter of assembling various J2EE modules into J2EE EAR files.

Development Roles
Reusable modules make it possible to divide the application development and deployment process into distinct roles so that different people or companies can perform different parts of the process. The first two roles involve purchasing and installing the J2EE product and tools. Once software is purchased and installed, J2EE components can be developed by application component providers, assembled by application assemblers, and deployed by application deployers. In a large organization, each of these roles might be executed by different individuals or teams. This division of labor works because each of the earlier roles outputs a portable file that is the input for a subsequent role. For example,

in the application component development phase, an enterprise bean software developer delivers EJB JAR files. In the application assembly role, another developer combines these EJB JAR files into a J2EE application and saves it in an EAR file. In the application deployment role, a system administrator at the customer site uses the EAR file to install the J2EE application into a J2EE server. The different roles are not always executed by different people. If you work for a small company, for example, or if you are prototyping a sample application, you might perform the tasks in every phase.

J2EE Product Provider

The J2EE product provider is the company that designs and makes available for purchase the J2EE platform, APIs, and other features defined in the J2EE specification. Product providers are typically operating system, database system, application server, or Web server vendors who implement the J2EE platform according to the Java 2 Platform, Enterprise Edition Specification.

Tool Provider
The tool provider is the company or person who creates development, assembly, and packaging tools used by component providers, assemblers, and deployers. See the section Tools for information on the tools available with J2EE SDK version 1.3.

Application Component Provider

The application component provider is the company or person who creates Web components, enterprise beans, applets, or application clients for use in J2EE applications.

Enterprise Bean Developer

An enterprise bean developer performs the following tasks to deliver an EJB JAR file that contains the enterprise bean:

Writes and compiles the source code Specifies the deployment descriptor

Web Component Developer

A Web component developer performs the following tasks to deliver a WAR file containing the Web component:

Writes and compiles servlet source code Writes JSP and HTML files Specifies the deployment descriptor for the Web component Bundles the .class, .jsp, .html, and deployment descriptor files in the WAR

file.

J2EE Application Client Developer

An application client developer performs the following tasks to deliver a JAR file containing the J2EE application client:

Writes and compiles the source code Specifies the deployment descriptor for the client Bundles the .class files and deployment descriptor into the JAR file

Application Assembler
The application assembler is the company or person who receives application component JAR files from component providers and assembles them into a J2EE application EAR file. The assembler or deployer can edit the deployment descriptor directly or use tools that correctly add XML tags according to interactive selections. A

software developer performs the following tasks to deliver an EAR file containing the J2EE application:

Assembles EJB JAR and WAR files created in the previous phases into a J2EE Specifies the deployment descriptor for the J2EE application. Verifies that the contents of the EAR file are well formed and comply with the

application (EAR) file.

J2EE specification.

Application Deployer and Administrator

The application deployer and administrator is the company or person who configures and deploys the J2EE application, administers the computing and networking infrastructure where J2EE applications run, and oversees the runtime environment. Duties include such things as setting transaction controls and security attributes and specifying connections to databases. During configuration, the deployer follows instructions supplied by the application component provider to resolve external dependencies, specify security settings, and assign transaction attributes. During installation, the deployer moves the application components to the server and generates the container-specific classes and interfaces. A deployer/system administrator performs the following tasks to install and configure a J2EE application:

Adds the J2EE application (EAR) file created in the preceding phase to the J2EE Configures the J2EE application for the operational environment by modifying Verifies that the contents of the EAR file are well formed and comply with the Deploys (installs) the J2EE application EAR file into the J2EE server.

server.

the deployment descriptor of the J2EE application.

J2EE specification.

Reference Implementation Software

The J2EE SDK is a noncommercial operational definition of the J2EE platform and specification made freely available by Sun Microsystems for demonstrations, prototyping, and educational use. It comes with the J2EE application server, Web server, relational database, J2EE APIs, and complete set of development and deployment tools. The purpose of the J2EE SDK is to allow product providers to determine what their implementations must do under a given set of application conditions, and to run the J2EE Compatibility Test Suite to test that their J2EE products fully comply with the specification. It also allows application component developers to run their J2EE applications on the J2EE SDK to verify that applications are fully portable across all J2EE products and tools.

Database Access
The relational database provides persistent storage for application data. A J2EE implementation is not required to support a particular type of database, which means that the database supported by different J2EE products can vary. See the Release Notes included with the J2EE SDK download for a list of the databases currently supported by the reference implementation.

JDBC API 2.0

The JDBC API lets you invoke SQL commands from Java programming language methods. You use the JDBC API in an enterprise bean when you override the default container-managed persistence or have a session bean access the database. With container-managed persistence, database access operations are handled by the container, and your enterprise bean implementation contains no JDBC code or SQL commands. You can also use the JDBC API from a servlet or JSP page to access the database directly without going through an enterprise bean.

The JDBC API has two parts: an application-level interface used by the application components to access a database, and a service provider interface to attach a JDBC driver to the J2EE platform.

Java Servlet Technology 2.3

Java Servlet technology lets you define HTTP-specific servlet classes. A servlet class extends the capabilities of servers that host applications accessed by way of a request-response programming model. Although servlets can respond to any type of request, they are commonly used to extend the applications hosted by Web servers.

Java Server Pages Technology 1.2

Java Server Pages technology lets you put snippets of servlet code directly into a text-based document. A JSP page is a text-based document that contains two types of text: static template data, which can be expressed in any text-based format such as HTML, WML, and XML, and JSP elements, which determine how the page constructs dynamic content.

J2EE Connector Architecture 1.0

The J2EE Connector architecture is used by J2EE tools vendors and system integrators to create resource adapters that support access to enterprise information systems that can be plugged into any J2EE product. A resource adapter is a software component that allows J2EE application components to access and interact with the underlying resource manager. Because a resource adapter is specific to its resource manager, there is typically a different resource adapter for each type of database or enterprise information system.

Tools

The J2EE reference implementation provides an application deployment tool and an array of scripts for assembling, verifying, and deploying J2EE applications and managing your development and production environments.

Application Deployment Tool

The J2EE reference implementation provides an application deployment tool (deploytool) for assembling, verifying, and deploying J2EE applications. There are two versions: command line and GUI. The GUI tool includes wizards for:

Packaging, configuring, and deploying J2EE applications Packaging and configuring enterprise beans Packaging and configuring Web components Packaging and configuring application clients Packaging and configuring resource adaptors

In addition, configuration information can be set for each component and module type in the tabbed inspector panes.

Introduction jsp
The goal of the java server page specification is to simplify the creation and management of dynamic web page by separating content and presentation jsp as basically files that combine html and new scripting tags. the jsp there look somewhat like HTML but they get translated into java servlet the first time are invoked by a client. The resulting servlet is a combination of the html from the jsp file and embedded dynamic content specified by the new tag.

For our example in this c:/projavaserver/chapter11/jsp example hold our web application save the above in the file called simple jsp. Jsp and place it in the root of the web application (in the words save it as) C:/localhost/project folder name/sourcename.jsp You should output similar to the following. In other words the first time jsp is loaded by the jsp container (also called the jsp ehgine) The servlet code necessary to fulfill the jsp tages is automatically generated compiled and loaded into the servlet container. From then on as long as the jsp source for the page is not modified this compiled servlet process any browser request for the jsp page. If you modify the mouse source code for the jsp it is automatically recompiled and relocated the next time that page is request

The nuts and bolts

The structure of a jsp page is a cross between a servlet and a html page with java code enclosed between the html.

DIRECTIVES these affect the overall structure of the servlet that

result from translation Scripting elements these let you insert java code into the jsp page. Action these are special tags available jsp You can also write your own tags as we shall

Some general rule of JSP page:

JSP tag are case sensitive Directive and scripting element have a syntax which is not based on xml

alternative page. Tags based on html Syntax is also available. If the URL does not start with a it is interpreted relative to the current jsp.

The page directive

The page directive is used to define and manipulate a number of important page dependent attributed that affect the whole jsp the enter compiled class file and communication these attributed to the jsp container. The page can contain any number of page directive in any jsp. They are all assimilated during translated and applied together to the page.

Language: define the scripting language to be used for future use if jsp containers support multiple language. java.

Import: comma separated list of package of class just like import statement in usual java code. omitted by default session .the page http session when true the import object session and can be java. servlet. Http session is available for page. true

The http protocol

In distributed application development, the application level or wire level communication protocol determines the nature of client and servers. This is true in the case of web based application as well. The complexity of feature possible in your web browser and on the web server(say the on line store you frequent)

depends on

the underlying protocol that is the HYPER TEXT TRANSFER

PROTOCOL(HTTP).

Http Request Methods

As an application level protocol, HTTP defines types of request that clients can send to server .The protocol also specifies how the request and responses be structured. HTTP specifies three type of request method GET,POST and HEAD has addition request meet most of the common application development needs.

The Get Request Method

Of all types of request the GET request the simplest and most frequently used Method for accessing static resource such as HTML document image etc. Get Request can also be used to retrieve dynamic information, by using additional query parameter in the request URL. For instance, you can send a parameter name= joe appended to a URL as http://www.domain.com?name=joe. The web server can use this parameter name=joe, to send content to joe.

The Post Request Method

The post method is commonly used for accessing dynamic resource.

Typically, POST request are meant to transmit information that is request dependent, and are used when you need to send large amount of complex

information to the server. The POST request allows the encapsulation of multipart message into the request body. For example you can use POST REQUEST TO UPLOAD TEXT OR BINARY FILES. Similarly, you can use POST you can use

POST request in your applets to send serializable java objects, or even to the web server . POST REQUEST THEREFORE OFFER A WIDER CHOICE IN TERMS of the request.

Http response

In responses to a HTTP request, the server responds with the status of the responses, all these are part of the response header. Except for the case of the HEAD request, the server also sends the body content that corresponds to the resource specified in the request. In the http://java.sun.com/index.html URL, your Browser receives the method of the index file as part of the message and renders, the body is typical interested.

Features of Http HTTP is very simple and lightweight protocol. In the protocol the client always initiate request the server can never make a

callback connection to the client. The HTTP requires the client to establish connection prior to each request

and the server to close the connection after sending the response this guarantees

that the client cannot hold on to a connection even after receiving the request .Also note that either the client or the server can premature terminate a connection.

Script lets
A script lets is a block of java code that is executed during the request processing time and is enclosed between <% and %> tags. What the scriptlets actually does depends on the code itself and can include producing output for the client. Multiple script are combination in the generation servlet class in the order they appear in the JSP. Scriptlets like any other java code block or method can modify object inside then as a result of method invocation.

JSP provider certain implicit object based on the servlet API. These objects are accessed using standard variable and are automatically available for use in your JSP without writing any extra code. The impact objects available in a JSP page are. request response page context session application out config page

Request Object
The request object represent the request that the server invocation. It is the http servlet request that provided access to the incoming HTTP header request type and request parameter, among other thing. Strictly speaking the Object itself will be a protocol and implement specific subclass of javax. Servlet servlet request but few containers currently support on HTTP servlet. It has request scope.

The Response Object

The response object is the http servlet response instance that response

instance that the server to the request. It is legal to set HTTP status code and header in the JSP page once output has been sent to the client since the output stream is buffered . Again the object itself javax. Servlet. Servlet response. It has page scope.

The Session Object

The object represent the session create for the request client. Session are created automatically and this variable is available even is no incoming session have used a session = false attribute in the page directive in which case this variable javax. Servlet .http . http session and has session scope.

The Application Object

The application object represent the servlet context obtained from the servlet configuration object. It is of type javax. Servlet context and has application scope.

The Out Object

The out object is the that write into the output stream to the client . To make the represent usefull this is a buffered version of the java . io . print writer class of type the buffer size can be adjusted via the buffer attribute of the page directive.

The Config Object

The config object is the servlet config for this JSP and has page scope. It is of type javax. Servlet servlet config.

Tomcat Server
Tomcat is a web server which can be used to execute the j2EE components. Tomcat provides many new and changed features, including the following: Dynamic reloading and compilation - You can configure Tomcat to dynamically recompile and reload servlets, servlet helper classes, and JavaServer Page (JSP) helper classes when a servlet or JSP is called. When the compile and reload features are enabled, Tomcat dynamically recompiles and reloads a servlet when it is called. Tomcat also dynamically recompiles and reloads classes in the WEB-INF/classes directory and tag library classes when they are called by a servlet or

JSP. This feature is disabled by default. For more information, see Tomcat Assembly and Deployment Guide. Dynamic creation of database tables for entity beans - When you deploy an entity bean and its required database tables do not yet exist, Tomcat generates tables for you if you configured the appropriate settings in the Tomcat deployment descriptor. For more information, see Tomcat Programmers Guide. JRun Management Console (JMC) - The redesigned, JMX-enabled JMC provides an easy-to-use, intuitive graphical user interface for managing your local and remote JRun servers. Web server configuration tool - JRun provides

JAVA DATABASE CONNECTIVITY (JDBC) JDBC AND ODBC IN JAVA:

Most popular and widely accepted database connectivity called Open Database Connectivity (ODBC) is used to access the relational databases. It offers the ability to connect to almost all the databases on almost all platforms. Java applications can also use this ODBC to communicate with a database. Then we need JDBC why? There are several reasons: ODBC API was completely written in C language and it makes an extensive use of pointers. Calls from Java to native C code have a number of drawbacks in the security, implementation, robustness and automatic portability of applications. ODBC is hard to learn. It mixes simple and advanced features together, and it has complex options even for simple queries. ODBC drivers must be installed on clients machine.

Architecture of JDBC:
JDBC Architecture contains three layers:

JDBC Application

JDBC Drivers

JDBC Drivers

Application Layer: Java program wants to get a connection to a database. It needs the information from the database to display on the screen or to modify the existing data or to insert the data into the table. Driver Manager: The layer is the backbone of the JDBC architecture. When it receives a connection-request form. The JDBC Application Layer: It tries to find the appropriate driver by iterating through all the available drivers, which are currently registered with Device Manager. After finding out the right driver it connects the application to appropriate database. JDBC Driver layers: This layer accepts the SQL calls from the application and converts them into native calls to the database and vice-versa. A JDBC Driver is responsible for ensuring that an application has consistent and uniform m access to any database. when a request received by the application, the JDBC driver passes the request to the ODBC driver, the ODBC driver communicates with the database and sends the request and gets the results. The results will be passed to the JDBC driver and in turn to the application. So, the JDBC driver has no knowledge about the actual database, it knows how to pass the application request o the ODBC and get the results from the ODBC.

The JDBC and ODBC interact with each other, how? The reason is both the JDBC API and ODBC are built on an interface called Call Level Interface (CLI). Because of this reason the JDBC driver translates the request to an ODBC call. The ODBC then converts the request again and presents it to the database. The results of the request are then fed back through the same channel in reverse.

Structured Query Language (SQL)

SQL (Pronounced Sequel) is the programming language that defines and manipulates the database. SQL databases are relational databases; this means simply the data is store in a set of simple relations. A database can have one or more table. You can define and manipulate data in a table with SQL commands. You use the data definition language (DDL) commands to creating and altering databases and tables. You can update, delete or retrieve data in a table with data manipulation commands (DML). DML commands include commands to alter and fetch data. The most common SQL commands include commands is the SELECT command, which allows you to retrieve data from the database. In addition to SQL commands, the oracle server has a procedural language called PL/SQL. PL/SQL enables the programmer to program SQL statement. It allows you to control the flow of a SQL program, to use variables, and to write error-handling procedures

Literature Review Bloom Filter

The Bloom filter, conceived by Burton H. Bloom in 1970, is a space-efficient data structure that is used to test whether an element is a member of a set. False positives are possible, but false negatives are not. Elements can be added to the set, but not removed (though this can be addressed with a counting filter). The more elements that are added to the set, the larger the probability of false positives. An empty Bloom filter is a bit array of m bits, all set to 0. There must also be k different hash functions defined, each of which maps or hashes some set element to one of the m array positions with a uniform random distribution.

To add an element, feed it to each of the k hash functions to get k array positions. Set the bits at all these positions to 1. To query for an element (test whether it is in the set), feed it to each of the k hash functions to get k array positions. If any of the bits at these positions are 0, the element is not in the set if it were, then all the bits would have been set to 1 when it was inserted. If all are 1, then either the element is in the set, or the bits have been set to 1 during the insertion of other elements. The requirement of designing k different independent hash functions can be prohibitive for large k. For a good hash function with a wide output, there should be little if any correlation between different bit-fields of such a hash, so this type of hash can be used to generate multiple "different" hash functions by slicing its output into multiple bit fields. Alternatively, one can pass k different initial values (such as 0, 1, ..., k-1) to a hash function that takes an initial value; or add (or append) these values to the key. For larger m and/or k, independence among the hash functions can be relaxed with negligible increase in false positive rate). Specifically, Dillinger & Manolios (2004b) show the effectiveness of using enhanced double hashing or triple hashing, variants of double hashing, to derive the k indices using simple arithmetic on two or three indices computed with independent hash functions. Unfortunately, removing an element from this simple Bloom filter is impossible. The element maps to k bits, and although setting any one of these k bits to zero suffices to remove it, this has the side effect of removing any other elements that map onto that bit, and we have no way of determining whether any such elements have been added. Such removal would introduce a possibility for false negatives, which are not allowed. Removal of an element from a Bloom filter can be simulated by having a second Bloom filter that contains items that have been removed. However, false positives in the second filter become false negatives in the composite filter, which are not permitted. This approach also limits the semantics of removal since re-adding a previously removed item is not possible.

However, it is often the case that all the keys are available but are expensive to enumerate (for example, requiring many disk reads). When the false positive rate gets too high, the filter can be regenerated; this should be a relatively rare event.

Data quality
Data quality is the quality of data. Data are of high quality "if they are fit for their intended uses in operations, decision making and planning". Alternatively, the data are deemed of high quality if they correctly represent the real-world construct to which they refer. These two views can often be in disagreement, even about the same set of data used for the same purpose. Before the rise of the inexpensive server, massive mainframe computers were used to maintain name and address data so that the mail could be properly routed to its destination. The mainframes used business rules to correct common misspellings and typographical errors in name and address data, as well as to track customers who had moved, died, gone to prison, married, divorced, or experienced other life-changing events. Government agencies began to make postal data available to a few service companies to cross-reference customer data with the National Change of Address registry (NCOA). This technology saved large companies millions of dollars compared to manually correcting customer data. Large companies saved on postage, as bills and direct marketing materials made their way to the intended customer more accurately. Initially sold as a service, data quality moved inside the walls of corporations, as low-cost and powerful server technology became available. Companies with an emphasis on marketing often focus their quality efforts on name and address information, but data quality is recognized as an important property of all types of data. Principles of data quality can be applied to supply chain data, transactional data, and nearly every other category of data found in the enterprise. For example, making supply chain data conform to a certain standard has value to an organization by: 1) avoiding overstocking of similar but slightly different stock; 2)

improving the understanding of vendor purchases to negotiate volume discounts; and 3) avoiding logistics costs in stocking and shipping parts across a large organization. While name and address data has a clear standard as defined by local postal authorities, other types of data have few recognized standards. There is a movement in the industry today to standardize certain non-address data. The non-profit group GS1 is among the groups spearheading this movement. For companies with significant research efforts, data quality can include developing protocols for research methods, reducing measurement error, bounds checking of the data, cross tabulation, modeling and outlier detection, verifying data integrity, etc.

Web mining
Web mining - is the application of data mining techniques to discover patterns from the Web. Without any doubt we certainly can declare that the Internet is the worlds largest data repository, considering the fact that the available data is increasing exponentially we can conclude that there is a huge potential to collect data through the web than any other means. The ever increasing number of individuals connecting to the Internet adds up to the factor. This technology is chiefly used to improve the intelligence of search engines and web marketing. Web usage mining is the application that uses data mining to analyse and discover interesting patterns of users usage data on the web. The usage data records the users behaviour when the user browses or makes transactions on the web site. It is an activity that involves the automatic discovery of patterns from one or more Web servers. Organizations often generate and collect large volumes of data; most of this information is usually generated automatically by Web servers and collected in server log. Analyzing such data can help these organizations to determine the value of particular customers, cross marketing strategies across products and the effectiveness of promotional campaigns, etc.

The first web analysis tools simply provided mechanisms to report user activity as recorded in the servers. Using such tools, it was possible to determine such information as the number of accesses to the server, the times or time intervals of visits as well as the domain names and the URLs of users of the Web server. However, in general, these tools provide little or no analysis of data relationships among the accessed files and directories within the Web space. Now more sophisticated techniques for discovery and analysis of patterns are emerging. These tools fall into two main categories: Pattern Discovery Tools and Pattern Analysis Tools. Another interesting application of Web Usage Mining is Web Link recommendation. One of the last trends is represented by the online monitoring of page accesses to render personalized pages on the basis of similar visit patterns.

Link Analysis
The separation of an intellectual or material whole into its constituent parts for individual study. The study of such constituent parts and their interrelationships in making up a whole. A spoken or written presentation of such study: published an analysis of poetic meter.

Module
1. Designing web pages 2. Authentication Process 3. Query Optimization Process -add Plan -get Plan 4. Efficient retrieval of data

Module Description 1. Designing web pages

In this module we design all WebPages required for online insurance management system. There are various number of WebPages need to be designed. These Web pages are designed by using JSP, HTML. We also used java script and Ajax for client side validation.

2. Authentication Process
In this module we implement authentication process for all kind of phases like policy holder phase, agent phase, admin phase using server side scripting languages like servlets, beans and JSP.

3. Query Optimization Process -add Plan

In this process we implement add plan architecture by creating procedure in SQLSERVER2005 by adding query and its cost in add Plan Procedure..,

-get Plan
In this process we implement get Plan architecture by Creating Procedure in SQLSERVER2005 and retrieve the efficient query based upon the query and its query cost..,

4. Efficient retrieval of data

After implementation of Query Optimization we use that procedure in our project to efficiently process the query and retrieve the relational data from the database.

Module Diagram 1. Designing web pages

Home

Admin

Agent

Policy Holder

View or give authorization

View agent details i.e his own details

View his own details

Modify

View client details registered under his account

Delete

2. Authentication Process

Agent

Policy

Validate/A uthenticate By Admin

Data base

Policyholder

3. Query Optimization Process

Query

No Get plan AddPlan

Yes

Execution

4. Efficient retrieval of data

Query

Retrieve the efficient query

Optimization

Technique Used or Algorithm used Query optimization

Query optimization is a function of many relational database management systems in which multiple query plans for satisfying a query are examined and a good query plan is identified. This may or not be the absolute best strategy because there are many ways of doing plans. There is a trade off between the amount of time spent figuring out the best plan and the amount running the plan. Different qualities of database management systems have different ways of balancing these two. Cost based query optimizers evaluate the resource footprint of various query plans and use this as the basis for plan selection. Typically the resources which are costed are CPU path length, amount of disk buffer space, disk storage service time, and interconnect usage between units of parallelism. The set of query plans examined is formed by examining possible access paths (e.g., primary index access, secondary index access, full file scan) and various relational table join techniques (e.g., merge join, hash join, product join). The search space can become quite large depending on the complexity of the SQL query. There are two types of optimization. These consist of logical optimization which generates a sequence of relational algebra to solve the query. In addition there is physical optimization which is used to determine the means of carrying out each operation. The goal is to eliminate as many unneeded tuples, or rows as possible. The following is a look at relational algebra as it eliminates unneeded tuples.The project operator is straightforward to implement if <attribute list> contains a key to relation R. If it does not include a key of R, it must be eliminated. This must be done by sorting (see sort methods below) and eliminating duplicates. This method can also use hashing to eliminate duplicates Hash table .SQL command distinct: this does not change the actual data. This just eliminates the duplicates from the results. Set operations: Database management heavily relies on the mathematical principles of set theory which is key in comprehending these operations.

Union: This displays all that appear in both sets, each listed once. These must be union compatible. This means all sequences of selected columns must designate the same number of columns. The data types of the corresponding columns must thereby comply with the conditions valid for comparability. Each data type can be compared to itself. Columns of data type CHAR with the different ASCII and EBCDIC code attributes can be compared to each other, whereby they are implicitly adapted. Columns with the ASCII code attribute can be compared to date, time, and timestamp specifications. All numbers can be compared to each other. In ANSI SQL mode, it is not enough for the data types and lengths of the specified columns to be compatible: they must match. Moreover, only column specifications or * may be specified in the selected columns of the QUERY specifications linked with UNION. Literals may not be specified (wisc). Intersection: This only lists items whose keys appear in both lists. This too must be union compatible. See above for definition. Set difference: This lists all items whose keys appear in the first list but not the second. This too must be union compatible. Cartesian product: Cartesian products (R * S) takes a lot of memory because its result contains a record for each combination of records from R and S.

Database Design Ag_reg table

Field name Name ID Credit card No D-O-B Sex Occupation Annual Income Address Email Data type Varchar Varchar Varchar Varchar Varchar Varchar Varchar Varchar Varchar Size 100 100 100 100 100 100 100 100 100

Agent table
Field name Agent id Password Amount Data type Varchar Varchar Varchar Size 100 100 100

Assign_agent table
Field name Agent id Name Data type Varchar Varchar Size 100 100

Bank table

Field name Credit card Pin code Amount

Data type Varchar Varchar Varchar

Size 100 100 100

Claim table
Field name Policy holder id Policy holder name Policy name Claim Reason Claim date Data type Varchar Varchar Varchar Varchar Varchar Varchar Size 100 100 100 100 100 100

Login table
Field name Username Password Data type Varchar Varchar Size 100 100

Policy table
Field name Policy Name Policy code Data type Varchar Varchar Size 100 100

Week interest Month interest Quarter interest Half interest Yearly interest

Varchar Varchar Varchar Varchar Varchar

100 100 100 100 100

System Design Use case diagram

Login existing user/Register new user Agent

v iew agent details

v iew policy holder details Policy holder

v iew policy details

claim policy admin

modif y policy /policy holder/agent

giv e authorization to agent/policy holder

Class diagram

insureJDBC String tablename String check va String delquery vector insertinfo vector modifyinfo setTablename() getTablename() setTablevalue() getTablevalue() setInsertInfo() getInsertInfo() setModifyInfo() getModifyInfo()

BeanInsure String agentname String agentcreditcard String agentDob String agentSex String agentincome String agentoccupation String agentDesignation setAgentName() setAgcc() setAgdob() setAgsex() setAgincome() setAgentOccu() setAgentDesignation() insertData()

AddAgentBean String agid String agname String agpassword String agentcreditcard String agentamount String agentSex String agentincome String agentoccupation String agendesignation setAgid() setAgname() setAgcc() setAgdob() setAgsex() setAgincome() setAgoccupation() setAgdesignation()

v i e w

AgentRegistratio n boolean value execute()

AddAgentRegist ration boolean value execute()

Object diagram

JDBCbean getinsertinfo() setinsertinfo()

bean setinsert info() getinseri info()

bean setinsert info() getinseri info()

Actionservlet VIEW contoller() opname2()

State diagram

login

Agent

Policy holder

Admin

Desired functions

Query

getPlan

Activity diagram

Query

addPlan

getplan NO

Y ES

Execution plan

Sequence diagram

user

servlet

action

jsp

service

Data

Database

URL

getPlan

addPlan

execute() retrieve the data function() new plan

get exists plan

ActionForward

query

return

forward return

html page

Collaboration diagram

1: URL user servlet

2: execute() action 8: ActionForward

13: html page 11: forward 12: return jsp getPlan 9: query 6: exists plan 4: new plan 7: retrieve the data Data 5: get

10: return function() 3:

service

addPlan

Databas e

Component diagram
designing webpages Authorization Query Optimization

Data flow diagram

Home

Admin View or give authorizatio n Modify

Agent View agent details i.e his own details View client details registered under his account

Policy Holder

View his own details

Delete

Query

Efficient query retrieval No Get plan Yes AddPlan

Execution

E-R Diagram

User Login

New User

Registration

Admin

Valida tion

View all details

Agent

New User

Viw his/policy holder details

System architecture

Index page

Admin page

Agent page

Policy Holder page

View page

View page

View page

Modify page

View page

Delete page

Project flow Diagram

User Login

Check With databa se

NO

Registration

Yes

View admin/policy/policy holder/agent details

Modify admin/policy/policy holder/agent details Optimization Process Delete admin/policy/policy holder/agent details

Data Base

Sample Coding Module 1

<%@ page import ="java.io.*,java.sql.*,java.util.*" %> <html> <head> <meta http-equiv="Content-Language" content="en-us"> <meta name="GENERATOR" content="Microsoft FrontPage 5.0"> <meta name="ProgId" content="FrontPage.Editor.Document"> <meta http-equiv="Content-Type" content="text/html; charset=windows-1252"> <title>New Page 1</title> </head> <body > <!--<form method="POST" action="--WEBBOT-SELF--"> <!--webbot bot="SaveResults" u-file="C:\Program Files\Apache Software Foundation\Tomcat 5.0\webapps\jsp-examples\insurance\_private\form_results.csv" sformat="TEXT/CSV" s-label-fields="TRUE" --> <form action="loginresponse.jsp" method="post"> <div align="center"> <center> <p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&n bsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nb sp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbs p;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp ;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <font color="#0000FF"><b><a target="_top" href="index.jsp">Back</a></b></font></p> <p>&nbsp;</p> <p>&nbsp;</p> <table border="" cellpadding="0" cellspacing="0" style="border-collapse: collapse" bordercolor="#6898d0" width="50%" id="AutoNumber1" height="210"> <tr> <td colspan="3" height="17" bgcolor="#6898d0" bordercolor="#6898d0"> <p align="left"> <% String s = request.getParameter("er");

if( s != null) { out.println(s); } %>

</td> </tr> <tr> <td colspan="3" height="20" bgcolor="#6898d0" bordercolor="#6898d0"> <p align="center"><font color="#000080" face="Garamond" size="+1"><b> Login</b></font></td> </tr> <tr bgcolor="#FFFFFF"><td height="25" colspan="3" ></td> </tr> <tr bgcolor="#FFFFFF"> <td width="298" height="45" align="right" bordercolor="#FFFFFF">

<b> <font color="#000080" face="Garamond">User Name</font></b> </td> <td width="51" bordercolor="#FFFFFF"></td> <td width="302" bordercolor="#FFFFFF"><input type="text" name="uname" size="20"> </td> </tr> <tr bgcolor="#FFFFFF"> <td width="298" height="43" align="right" bordercolor="#FFFFFF"> <font color="#000080" face="Garamond"><b>Password</b></font> </td> <td width="51" bordercolor="#FFFFFF"></td> <td width="302" bordercolor="#FFFFFF"><input type="password" name="pword" size="20"> </td> </tr> <tr bgcolor="#FFFFFF"><td colspan="3" ><table align="center"><tr><td width="81" height="47"><input type="submit" value="Submit" name="submit" style="color: #000080; font-weight: bold;width:75px"></td><td width="16"></td> <td width="75"><input type="reset" value="Reset" name="reset" style="color: #000080; font-weight: bold;width:75px"></td></tr></table></td></tr> </table> </center> </div>

</form> </form> </body> </html> <% String choice = request.getParameter("adminch"); out.println(" <table>"); out.println("<tr><td class=boldornge><a href=viewagreg.jsp><font color=\"#000080\" face=\"Garamond\">View Agent Registration</font></a></td></tr>"); out.println("<tr><td class=boldornge><a href=viewphreg.jsp><font color=\"#000080\" face=\"Garamond\">View Policy Holder Registration</font></a></td></tr>"); out.println("<tr><td class=boldornge><a href=viewclaim.jsp><font color=\"#000080\" face=\"Garamond\">View Claim Info</font></a></td></tr>"); out.println("</table>"); System.out.println("<----->"+choice); if(choice != null) { System.out.println("----->"+choice); if (choice.equals("Policy")) { out.println(" <table>"); out.println("<tr><td class=boldornge><a href=viewpo.jsp><font color=\"#000080\" face=\"Garamond\">View Policy</font></a></td></tr>"); out.println("<tr><td class=boldornge><a href=addpo.jsp><font color=\"#000080\" face=\"Garamond\">Add Policy</font></a></td></tr>"); out.println("<tr><td class=boldornge><a href=modifypolicy.jsp><font color=\"#000080\" face=\"Garamond\">Modify Policy</font></a></td> </tr>"); out.println("<tr><td class=boldornge><a href=deletepo.jsp><font color=\"#000080\" face=\"Garamond\">Delete Policy</font></a></td> </tr>"); out.println("</table>"); } if (choice.equals("Agent")) { out.println(" <table >");

out.println("<tr><td class=boldornge><a href=viewag.jsp><font color=\"#000080\" face=\"Garamond\">View Agent</font></a></td></tr>"); out.println("<tr><td class=boldornge><a href=authorizeagent.jsp><font color=\"#000080\" face=\"Garamond\">Add Agent</font></a></td></tr>"); out.println("<tr><td class=boldornge><a href=modifyagent.jsp><font color=\"#000080\" face=\"Garamond\">Modify Agent</font></a></td> </tr>"); out.println("<tr><td class=boldornge><a href=deleteag.jsp><font color=\"#000080\" face=\"Garamond\">Delete Agent</font></a></td> </tr>"); out.println("</table>"); } if (choice.equals("Policy Holder")) { out.println(" <table>"); out.println("<tr><td class=boldornge><a href=viewph.jsp><font color=\"#000080\" face=\"Garamond\">View Policy Holder</font></a></td></tr>"); out.println("<tr><td class=boldornge><a href=addph.jsp><font color=\"#000080\" face=\"Garamond\">Add Policy Holder</font></a></td></tr>"); out.println("<tr><td class=boldornge><a href=modifypholder.jsp><font color=\"#000080\" face=\"Garamond\">Modify Policy Holder</font></a></td> </tr>"); out.println("<tr><td class=boldornge><a href=deleteph.jsp><font color=\"#000080\" face=\"Garamond\">Delete Policy Holder</font></a></td> </tr>"); out.println("</table>"); } } %>

Authorize Agent

<%@ page import="java.sql.*" %> <%@ page import="java.io.*" %> <%@ page import="java.util.*" %> <html> <head> <meta http-equiv="Content-Language" content="en-us"> <meta name="GENERATOR" content="Microsoft FrontPage 5.0" > <meta name="ProgId" content="FrontPage.Editor.Document"> <meta http-equiv="Content-Type" content="text/html; charset=windows-1252"> <title>Applied Agents</title> </head> <body> <!--<form method="POST" action="--WEBBOT-SELF--"enctype="multipart/formdata"> <!--webbot bot="SaveResults" u-file="C:\Program Files\Apache Software Foundation\Tomcat 5.0\webapps\jsp-examples\insurance\_private\form_results.csv" sformat="TEXT/CSV" s-label-fields="TRUE" --> <form action="addag.do" method="post" > <% String id = request.getParameter("agid"); String agid = ""; String agname = ""; String agcc = ""; String agdob = ""; String agsex = ""; String agoccu = ""; String aginc = ""; String agaddr = ""; String agmobile = ""; String agmail = ""; %> <jsp:useBean id="database" scope="page" class="insureBean.insureJDBC" /> <jsp:setProperty name="database" property="tablename" value="ag_reg" /> <%

ResultSet rs = database.getResult(); ResultSetMetaData rsmd = rs.getMetaData(); try { while(rs.next()) { String temp=rs.getString(1).trim(); System.out.println("----->"+temp); if(id.equals(temp)) { System.out.println("-----> 1"+temp); agid = temp; agname = rs.getString(2); agcc = rs.getString(3); agdob = rs.getString(4); agsex = rs.getString(5); agoccu = rs.getString(6); aginc = rs.getString(7); agaddr = rs.getString(8); agmobile = rs.getString(9); agmail = rs.getString(10); } } } catch(Exception e) { out.println(e); } %> <div align="center"> <center> <p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nb sp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbs p;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp ;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <font color="#0000FF"><b><a target="_top" href="index.jsp">Logout</a>&nbsp;&nbsp; <a href="authorizeagent.jsp">Back</a></b></font></p>

<table border="1" cellpadding="0" cellspacing="0" style="border-collapse: collapse" bordercolor="#6898d0" width="75%" id="AutoNumber1" height="482"> <tr> <td height="29" colspan="3" bgcolor="#6898d0"> <p align="center"><font color="#FFFFFF" size="+2" face="Garamond"><b>Auhorization of Registered Agent</b></font></td> </tr> <tr> <td width="467" height="45" align="right" bordercolor="#FFFFFF"> <font color="#000080" face="Garamond">Agent Id</font></td> <td width="33" bordercolor="#FFFFFF"></td> <td width="468" bordercolor="#FFFFFF"> <input type="hidden" name="agid" size="20" style="background-color:#C7DDF3 " value="<%=agid%>"> <label><font color="#000080" face="Garamond"><strong><%=agid %></strong></font></label> </td> </tr> <tr> <td width="467" height="45" align="right" bordercolor="#FFFFFF"> <font color="#CC3333" face="Garamond" ><strong>Password&nbsp;*</strong></font></td> <td width="33" bordercolor="#FFFFFF"></td> <td width="468" bordercolor="#FFFFFF"> <input name="pword" size="20" type="password" > </td> </tr> <tr> <td width="467" height="45" align="right" bordercolor="#FFFFFF"> <font color="#CC3333" face="Garamond" ><strong>ConfirmPassword&nbsp;*</strong></font></td> <td width="33" bordercolor="#FFFFFF"></td> <td width="468" bordercolor="#FFFFFF"> <input name="pword" size="20" type="password" > </td> </tr> <tr> <td width="467" height="45" align="right" bordercolor="#FFFFFF"> <font color="#000080" face="Garamond">Agent Name&nbsp;</font></td> <td width="33" bordercolor="#FFFFFF"></td>

<td width="468" bordercolor="#FFFFFF"> <input type="hidden" name="agname" size="20" style="backgroundcolor:#C7DDF3 " disabled="disabled" value="<%=agname%>"> <label><font color="#000080" face="Garamond"><strong><%=agname %></strong></font></label> </td> </tr> <tr> <td width="467" height="45" align="right" bordercolor="#FFFFFF"> <font color="#000080" face="Garamond">Credit Card No</font></td> <td width="33" bordercolor="#FFFFFF"></td> <td width="468" bordercolor="#FFFFFF"> <input type="hidden" name="agcc" size="20" style="background-color:#C7DDF3 "disabled="disabled" value="<%=agcc%>"> <label><font color="#000080" face="Garamond"><strong><%=agcc %></strong></font></label> </td> </tr> <tr> <td width="467" height="45" align="right" bordercolor="#FFFFFF"> <font color="#000080" face="Garamond">Date Of Birth</font></td> <td width="33" bordercolor="#FFFFFF"></td> <td width="468" bordercolor="#FFFFFF"> <input type="hidden" name="agdob" size="20" style="background-color:#C7DDF3 " disabled="disabled" value="<%=agdob%>"> <label><font color="#000080" face="Garamond"><strong><%=agdob %></strong></font></label></td> </tr> <tr> <td width="467" height="45" align="right" bordercolor="#FFFFFF"><p> <font color="#000080" face="Garamond">Sex</font></td> <td width="33" bordercolor="#FFFFFF"></td> <td width="468" bordercolor="#FFFFFF"> <input type="hidden" disabled="disabled" size="20" style="backgroundcolor:#C7DDF3" value="<%=agsex%>"></p> <label><font color="#000080" face="Garamond"><strong><%=agsex %></strong></font></label> </td> </tr> <tr> <td width="467" height="45" align="right" bordercolor="#FFFFFF"> <font color="#000080" face="Garamond">Occupation</font></td> <td width="33" bordercolor="#FFFFFF"></td> <td width="468" bordercolor="#FFFFFF"> <input type="hidden" name="agoccu" size="20" style="background-color:#C7DDF3 " disabled="disabled" value="<%=agoccu%>">

<label><font color="#000080" face="Garamond"><strong><%=agoccu %></strong></font></label></td> </tr> <tr> <td width="467" height="45" align="right" bordercolor="#FFFFFF"> <font color="#000080" face="Garamond">Annual Income</font></td> <td width="33" bordercolor="#FFFFFF"></td> <td width="468" bordercolor="#FFFFFF"> <input type="hidden" name="agincome" size="20" style="backgroundcolor:#C7DDF3 " disabled="disabled" value="<%=aginc%>"> <label><font color="#000080" face="Garamond"><strong><%=aginc %></strong></font></label></td> </tr> <tr> <td width="467" height="45" align="right" bordercolor="#FFFFFF"> <font color="#000080" face="Garamond">Address</font></td> <td width="33" bordercolor="#FFFFFF"></td> <td width="468" bordercolor="#FFFFFF"> <input type="hidden" name="agaddr" size="20" style="background-color:#C7DDF3 " disabled="disabled" value="<%=agaddr%>"> <label><font color="#000080" face="Garamond"><strong><%=agaddr %></strong></font></label></td> </tr> <tr> <td width="467" height="45" align="right" bordercolor="#FFFFFF"> <font color="#000080" face="Garamond">Mobile No</font></td> <td width="33" bordercolor="#FFFFFF"></td> <td width="468" bordercolor="#FFFFFF"> <input type="hidden" name="agmobile" size="20" style="backgroundcolor:#C7DDF3 " disabled="disabled" value="<%=agmobile%>"> <label><font color="#000080" face="Garamond"><strong><%=agmobile %></strong></font></label></td> </tr> <tr> <td width="467" height="45" align="right" bordercolor="#FFFFFF"> <font color="#000080" face="Garamond">Mail ID</font></td> <td width="33" bordercolor="#FFFFFF"></td> <td width="468" bordercolor="#FFFFFF"> <input type="hidden" name="agmail" size="20" style="background-color:#C7DDF3 " disabled="disabled" value="<%=agmail%>"> <label><font color="#000080" face="Garamond"><strong><%=agmail %></strong></font></label></td> </tr> <tr> <td width="467" height="45" align="right" bordercolor="#FFFFFF">

<font color="#CC3333" face="Garamond"><strong>Amount *</strong></font></td> <td width="33" bordercolor="#FFFFFF"></td> <td width="468" bordercolor="#FFFFFF"> <input type="text" name="amt" size="20"> </td> </tr> <tr><td colspan="3" ><table align="center"><tr><td><input type="submit" value="Authorize" name="submit" style="color: #000080; font-weight: bold;width:75px"></td><td width="22"></td> <td><input type="reset" value="Reset" name="button1" style="color: #000080; fontweight: bold;width:75px"></td></tr></table></td></tr> </table> </center> </div> </form> </form> </body> </html>

Modify Policy
<%@ page import ="java.io.*,java.sql.*,java.util.*" %> <%@ page import="java.util.*"%> <%@ page import="insureBean.insureJDBC"%> <jsp:useBean id="database" scope="page" class="insureBean.insureJDBC" /> <jsp:setProperty name="database" property="tablename" value="policy" /> <% ResultSet rs = database.getResult(); int i=0; String name; String bgcolor="#99ccff"; boolean bflag=true; out.println("<br><br><br>"); out.println("<center><table border=0 cellspacing=1><tr bgcolor=" + bgcolor +" class=bolddeepblue>"); out.println("<td>Policy Name"); out.println("<td>Policy ID"); out.println("<td> Weekly Intrest"); out.println("<td> Monthly Intrest"); out.println("<td> Quarter Intrest"); out.println("<td> Half Intrest"); out.println("<td> Year Intrest"); out.println("<td> Modification"); out.println("<td>"); while(rs.next()) { if (bflag ) { bgcolor = "#fffff"; bflag = false; } else { bgcolor = "#99ccff"; bflag = true; } out.println("<tr class=newsarticlesmall height=21 bgcolor="+bgcolor+">"); // out.println("<td>"+(i+1) );

out.println("<td>" +rs.getString(1)); String id=rs.getString(2); out.println("<td>" +id); out.println("<td>" +rs.getString(3)); out.println("<td>" +rs.getString(4)); out.println("<td>" +rs.getString(5)); out.println("<td>" +rs.getString(6)); out.println("<td>" +rs.getString(7)); out.println("<td> <a href=modifypo.jsp? poid="+id+">Modify</a>" ); out.println("<td>"); i = i+1; } out.println("</table><center>"); %>

Screen Shot

Advantages
High Accuracy Progressive parametric Query y Optimizations Performance is High when compare to existing system

Applications

This Optimization process applicable for All High Dimensional applications

Future Enhancements
In future we implement the indexing structure for Parametric plan interface

Conclusion Reference or Bibliography

[1] S. Babu and P. Bizarro, Adaptive Query Processing in the Looking Glass, Proc. Second Biennial Conf. Innovative Data Systems Research (CIDR), 2005. [2] R.L. Cole and G. Graefe, Optimization of Dynamic Query Evaluation Plans, Proc. ACM SIGMOD, 1994. [3] D. Harish, P. Darera, and J. Haritsa, On the Production of Anorexic Plan Diagrams, Proc. 33rd Intl Conf. Very Large Data Bases (VLDB), 2007. [4] A. Deshpande, Z. Ives, and V. Raman, Adaptive Query Processing, Foundations and Trends in Databases, vol. 1, no. 1, pp. 1-140, 2007. [5] S. Ganguly, Design and Analysis of Parametric Query Optimization Algorithms, Proc. 24th Intl Conf. Very Large Data Bases (VLDB), 1998. [6] A. Ghosh, J. Parikh, V.S. Sengar, and J.R. Haritsa, Plan Selection Based on Query Clustering, Proc. 28th Intl Conf. Very Large Data Bases (VLDB), 2002. [7] G. Graefe and K. Ward, Dynamic Query Evaluation Plans, Proc. ACM SIGMOD, 1989. [8] A. Hulgeri and S. Sudarshan, Parametric Query Optimization for Linear and Piecewise Linear Cost Functions, Proc. 28th Intl Conf. Very Large Data Bases (VLDB), 2002.