Technologies:

I. MySQL Database: Features Of MySQL
The following list describes some of the important Features of MySQL Database Software.
• Internals and Portability
o Written in C and C++.
o Tested with a broad range of different compilers.
o Works on many different platforms.
o Uses GNU Automake, Autoconf, and Libtool for portability.
o APIs for C, C++, Eiffel, Java, Perl, PHP, Python, Ruby, and Tcl are available.
o Fully multi-threaded using kernel threads. It can easily use multiple CPUs if they are available.
o Provides transactional and non-transactional storage engines.
o Uses very fast B-tree disk tables (MyISAM) with index compression.
o Relatively easy to add another storage engine. This is useful if you want to add an SQL interface to an in-house database.
o A very fast thread-based memory allocation system.
o Very fast joins using an optimized one-sweep multi-join.
o In-memory hash tables, which are used as temporary tables.
o SQL functions are implemented using a highly optimized class library and should be as fast as possible. Usually there is no memory allocation at all after query initialization.
o The MySQL code is tested with Purify (a commercial memory leakage detector) as well as with Valgrind, a GPL tool
o The server is available as a separate program for use in a client/server networked environment. It is also available as a library that can be embedded (linked) into standalone applications. Such applications can be used in isolation or in environments where no network is available.
• Column Types
o Many column types: signed/unsigned integers 1, 2, 3, 4, and 8 bytes long, FLOAT, DOUBLE, CHAR, VARCHAR, TEXT, BLOB, DATE, TIME, DATETIME, TIMESTAMP, YEAR, SET, ENUM, and OpenGIS spatial types.
o Fixed-length and variable-length records.
• Statements and Functions
o Full operator and function support in the SELECT and WHERE clauses of queries. For example:
mysql> SELECT CONCAT(first_name, ' ', last_name) -> FROM citizen -> WHERE income/dependents > 10000 AND age > 30;
Brief Company Information
o Full support for SQL GROUP BY and ORDER BY clauses. Support for group functions (COUNT(), COUNT(DISTINCT ...), AVG(), STD(), SUM(), MAX(), MIN(), and GROUP_CONCAT()).
o Support for LEFT OUTER JOIN and RIGHT OUTER JOIN with both standard SQL and ODBC syntax.
o Support for aliases on tables and columns as required by standard SQL.
o DELETE, INSERT, REPLACE, and UPDATE return the number of rows that were changed (affected). It is possible to return the number of rows matched instead by setting a flag when connecting to the server.
o The MySQL-specific SHOW command can be used to retrieve information about databases, database engines, tables, and indexes. The EXPLAIN command can be used to determine how the optimizer resolves a query.
o Function names do not clash with table or column names. For example, ABS is a valid column name. The only restriction is that for a function call, no spaces are allowed between the function name and the '(' that follows it.
o You can mix tables from different databases in the same query (as of MySQL 3.22).
• Security
o A privilege and password system that is very flexible and secure, and that allows host-based verification. Passwords are secure because all password traffic is encrypted when you connect to a server.
• Scalability and Limits
o Handles large databases. We use MySQL Server with databases that contain 50 million records. We also know of users who use MySQL Server with 60,000 tables and about 5,000,000,000 rows.
o Up to 64 indexes per table are allowed (32 before MySQL 4.1.2). Each index may consist of 1 to 16 columns or parts of columns. The maximum index width is 1000 bytes (500 before MySQL 4.1.2). An index may use a prefix of a column for CHAR, VARCHAR, BLOB, or TEXT column types.
• Connectivity
o Clients can connect to the MySQL server using TCP/IP sockets on any platform. On Windows systems in the NT family (NT, 2000, XP, or 2003), clients can connect using named pipes. On Unix systems, clients can connect using Unix domain socket files.
o In MySQL versions 4.1 and higher, Windows servers also support shared-memory connections if started with the --shared-memory option. Clients can connect through shared memory by using the --protocol=memory option.
o The Connector/ODBC (MyODBC) interface provides MySQL support for client programs that use ODBC (Open Database Connectivity) connections. For example, you can use MS Access to connect to your MySQL server. Clients can be run on Windows or Unix. MyODBC source is available. All ODBC 2.5 functions are supported, as are many others.
o The Connector/J interface provides MySQL support for Java client programs that use JDBC connections. Clients can be run on Windows or Unix. Connector/J source is available.
• Localization
o The server can provide error messages to clients in many languages.
o Full support for several different character sets, including latin1 (ISO-8859-1), german, big5, ujis, and more. For example, the Scandinavian characters 'â', 'ä' and 'ö' are allowed in table and column names. Unicode support is available as of MySQL 4.1.
Brief Company Information
o All data is saved in the chosen character set. All comparisons for normal string columns are case-insensitive.
o Sorting is done according to the chosen character set (using Swedish collation by default). It is possible to change this when the MySQL server is started. To see an example of very advanced sorting, look at the Czech sorting code. MySQL Server supports many different character sets that can be specified at compile time and runtime.
• Clients and Tools
o The MySQL server has built-in support for SQL statements to check, optimize, and repair tables. These statements are available from the command line through the mysqlcheck client. MySQL also includes myisamchk, a very fast command-line utility for performing these operations on MyISAM tables.
o All MySQL programs can be invoked with the --help or -? options to obtain online assistance.
II. Java™ 2 Platform Application, Enterprise Edition Features
Enterprises today need to extend their reach, reduce their costs, and lower their response times by providing easy-to-access services to their customers, partners, employees, and suppliers.
Typically, applications that provide these services must combine existing enterprise information systems (EIS) with new business functions that deliver services to a broad range of users. These services need to be:
• Highly available, to meet the needs of today’s global business environment.
• Secure, to protect the privacy of users and the integrity of enterprise data.
• Reliable and scalable, to insure that business transactions are accurately and promptly processed.
For a variety of reasons, these services are generally architected as distributed applications consisting of several tiers, including clients on the front end, data resources on the back end, and one or more middle tiers between them where the majority of the application development work is done. The middle tier implements the new services that integrate existing EISs with the business functions and data of the new service. The middle tier shields the client tier from the complexity of the enterprise and takes advantage of rapidly maturing Internet technologies to minimize user administration and training.
The Java 2 platform, Enterprise Edition reduces the cost and complexity of developing these multi-tier services, resulting in services that can be rapidly deployed and easily enhanced as the enterprise responds to competitive pressures.
The Java 2 platform, Enterprise Edition (J2EE) achieves these benefits by defining a standard architecture that is delivered as the following elements:
• J2EE Application Programming Model - A standard programming model for developing multi-tier, thin-client applications.
• J2EE Platform - A standard platform for hosting J2EE applications, specified as a set of required APIs and policies.
Brief Company Information
• J2EE Compatibility Test Suite - A suite of compatibility tests for verifying that a J2EE platform product is compatible with the J2EE platform standard.
• J2EE Reference Implementation - A reference implementation for demonstrating the capabilities of J2EE and for providing an operational definition of the J2EE platform.
The following sections of this document describe each of these elements in greater detail.
J2EE Application Model
J2EE is designed to support applications that implement enterprise services for customers, employees, suppliers, partners, and others who make demands on or contributions to the enterprise. Such applications are inherently complex, potentially accessing data from a variety of sources and distributing applications to a variety of clients.
To better control and manage these applications, the business functions to support these various users are conducted in the middle tier. The middle tier represents an environment that is closely controlled by an enterprise’s information technology department. The middle tier is typically run on dedicated server hardware and has access to the full services of the enterprise.
J2EE applications often rely on the EIS-Tier to store the enterprise’s business-critical data. This data and the systems that manage it are at the inner-core of the enterprise.
Originally, the two-tier, client-server application model promised improved scalability and functionality. Unfortunately, the complexity of delivering EIS services directly to every user and the administrative problems caused by installing and maintaining business logic on every user machine have proved to be major limitations.
These two-tier limitations are avoided by implementing enterprise services as multitier applications. Multi-tier applications provide the increased accessibility that is now demanded by all elements of an enterprise. This shift is driving major investments in the development of middle-tier software.
Developing multi-tier services has been complicated by the need to develop both the service’s business function and the more complex infrastructure code required to access databases and other system resources. Because each multi-tier server product had its own application model, it was difficult to hire and train an experienced development staff. In addition, as service volume increased it was
Brief Company Information
often necessary to change the whole multi-tier infrastructure, resulting in major porting costs and delays.
The J2EE application model defines an architecture for implementing services as multi-tier applications that avoid these problems and deliver the scalability, accessibility, and manageability that is needed.
The J2EE application model partitions the work needed to implement a multi-tier service into two parts: the business and presentation logic to be implemented by the developer, and the standard system services provided by the J2EE platform. The developer can rely on the platform to provide the solutions for the hard systemslevel problems of developing a middle-tier service.
The J2EE application model provides the benefits of Write Once, Run Anywhere™ portability and scalability for multi-tier applications. This standard model minimizes the cost of developer training while providing the enterprise with a broad choice of J2EE servers and development tools.
The J2EE application model is a major step forward in simplifying and expediting application development, by minimizing the complexity of building multi-tier applications.
Java Technology Foundation
The J2EE application model begins with the Java programming language and the Java virtual machine. The proven portability, security, and developer productivity they provide forms the basis of the application model.
The application model also includes the JavaBeans™ component model. JavaBeans components make it easy to componentize the Java technology-based code for common functions, then customize and combine these components visually with JavaBeans development tools.
Security
While other enterprise application models require platform-specific security measures in each application, the J2EE platform’s security environment enables security constraints to be defined at deployment time. By shielding applications from the complexity of implementing security, the J2EE platform makes them portable to a wide variety of security implementations.
The J2EE platform defines standard declarative access control rules to be defined by the application programmer/assembler and interpreted when the application is deployed on the enterprise platform. J2EE also requires platform vendors to supply standard login mechanisms so applications do not have to incorporate these mechanisms into their logic. The same program works in a variety of different security environments without change to the source code.
As an example, a J2EE application developer can specify several levels of security (say user, super-user, and administrator), then write code to check the current user’s permission level when accessing secure operations. At deployment time, the
Application Deployer assigns groups of users to the appropriate security levels, enabling the application to easily verify permission level before performing the restricted operations.
Brief Company Information
The Middle Tier
The major benefit of the J2EE application model is in the middle tiers of multi-tier applications. In the J2EE platform, middle-tier business functions are implemented as Enterprise JavaBean™ components, as shown in FIGURE 2. These enterprise beans allow service developers to concentrate on the business logic and let the EJB server handle the complexities of delivering a reliable, scalable service.
JavaServer Pages™ technology and servlets present middle-tier functions to the client tier as simple-to-access Internet-style services. JavaServer Pages (JSP) technology makes it easy for user interface developers to present dynamically generated pages to anyone with a browser. Servlets give more sophisticated developers of Java technology-based applications the freedom to implement dynamic presentations completely in the Java programming language.
The Client Tier
The J2EE platform supports several types of clients. Many J2EE services will be designed to support web browser clients. These services interact with their clients via dynamically generated HTML pages and forms.
More sophisticated services will interact with their first-tier clients by directly exchanging business data. Here, JSPs and Servlets are used to format this business data in a way that is easy for J2EE clients to work with. These clients can be both Java applets running in a web browser and Java technology-based programs.
It is important to note that security is a key part of all multi-tier services. In J2EE, security is handled almost entirely by the platform and its administrators. In most cases, neither the service nor its clients require developer-written security logic.
Brief Company Information
HTML Page Based Clients
A service can be presented directly to a user’s web browser as dynamically generated HTML pages. JavaServer Pages technology is an easy way to dynamically compose these pages using a familiar scripting paradigm that combines HTML and Java technology-based code, as shown in FIGURE 3. In some cases, a service may require some fairly complex code. This can be handled by placing code in a JavaBeans component and calling it from a JSP. A service can also be directly programmed in the Java programming language using a servlet.
HTTP Content Based Clients
It is often useful to provide functionality directly at the client that helps a user organize and interact with the service’s information. In this case, the service exchanges raw content with the client instead of HTML pages. This content is typically in the form of XML documents that are exchanged between the client and the service using the HTTP protocol.
Typically this XML content is handled in the first-tier by JavaBeans components that are provided by the service in an applet that is automatically downloaded into a user’s browser, as shown in FIGURE 4. To avoid problems caused by old or nonstandard versions of the Java runtime environment in a user’s browser, the J2EE application model provides special support for automatically downloading and installing the Java Plug-in, Sun’s Java runtime environment that can be dynamically loaded into the most popular browsers. This content can also be handled by a Java technology-based program acting as a J2EE client. This flexible client model provides the developer with a broad range of choices for presenting a distributed application’s user interface on the internet.
Brief Company Information
Intranet Clients
Both HTML page based services and HTTP content based services can be effectively used on an enterprise’s intranet as well as the Internet.
In addition, the intranet provides the extra infrastructure that allows Java programs to directly access EJBs within the intranet domain.
Other Client Types
J2EE services presented via standard HTTP, HTML and XML are easily accessible to all clients including Microsoft clients such as Visual Basic and Office 2000.
One goal of Enterprise JavaBeans technology is to define CORBA standard RMI-IIOP as the required interoperability mechanism. This will make any J2EE service available to any CORBA client, ensuring more complete integration between the J2EE platform and existing enterprise information systems. While most elements of this standard are complete there are a few items that are still in progress. After the final work is complete, J2EE will add this interoperability requirement. In the interim, many J2EE vendors will support the parts of the standard that are available.
In conjunction with J2EE, Sun will provide white papers and technology demonstrations that illustrate techniques for integrating Microsoft COM objects with EJBs using RMI-IIOP. These will cover how to access EJBs from first-tier clients such as Visual Basic and Windows 2000 via COM, as well as using EJBs in combination with middle-tier functions implemented in Microsoft Transaction Server.