<table> <tr> <td> </td> <td> New Oracle9 i Data Access Features </td> </tr> <tr> <td> <hr></td> </tr> </table> <table> <tr> <td> <blockquote> The primary means of accessing Oracle9 i is via the Oracle Call Interface. The Oracle Call Interface (OCI) is a C call interface to Oracle9 i that gives developers the greatest degree of control over program execution and SQL processing. Most other access methods, for example, ODBC and JDBC OCI driver, are all built on top of OCI. In Oracle9 i, there have been a number of enhancements made to OCI, and higher level access methods, that increase developer productivity and application performance. OCCI, an interface for C++ applications, now makes it easier for C++ developers to access the database and manipulate objects. JDBC enhancements improve efficiency and extend functionality for Java developers. Finally, OCI is now the underlying infrastructure used in server-to-server communications, improving the performance of distributed SQL and database links. </blockquote>false ,,,,,,,,,,,,,,,
A number of enhancements to OCI improve performance and ease development of applications. These enhancements include scrollable cursors, connection pooling, and improved globalization support.
Cursors are used in Oracle to manage result sets from SQL operations. Traditionally, OCI has supported only a forward scrolling cursor. With a forward scrolling cursor, records are fetched in a set order, and the application cannot move backward to access a record. A scrollable cursor, however, can move forward and backward, and can seek any desired record in the cursor. Such operations are common in applications that present results sets in scrolling windows. With a scrollable cursor, application developers do not need to create and manage their own buffer for the records.
When using Oracle9 i, applications can use connection pooling to make more efficient use of connections to the database. An application process can now create a pool of connections, and a free connection can be used by any thread in that process. Threads can call OCI functions using a server handle that represents many connections to the database. OCI automatically utilizes a free connection. There is no need for the developer to manage the pool of connections. This feature is useful when multiple components share a process space, for example Apache mods and Oracle Applications.
Many multithreaded, middle tier applications often require connections to the database by a large number of threads for a relatively short duration. Opening a connection to the database for every thread would result in inefficient utilization of connections and poor performance. With connection pooling, Oracle creates a small number of open connections, dynamically selects one of the free connections to execute a statement, and then releases the connection immediately after the execution. This relieves an application from creating complex mechanisms to handle connections, and optimizes performance.
Improved Globalization Support
OCI in Oracle9 i provides improved globalization support. OCI now supports bind and define variables for character data and lobs encoded in UTF-16. This drastically simplifies the development of global applications that must support multi-byte character sets.
Oracle C++ Call Interface (OCCI)
OCCI is a high-performance and scalable API for C++ built on top of OCI. Because it is built on top of OCI, it inherits the performance and control benefits of OCI, for example, reduced round-trips, minimized data copying, caching, connection pooling, pre-fetching, array operations and thread safety. The OCCI API is modeled after JDBC, and uses simple JDBC-like constructs.
OCCI takes full advantage of advances in the latest C++ language standard. With an extensive collection of easy-to-use C++ classes and templates, OCCI enables a C++ program to connect to a database, execute SQL statements, insert/update values in database tables, retrieve results of a query, execute stored procedures in the database, and access the metadata of database schema objects. Along with the OTT/C++ (Object Type Translator for C++) utility, OCCI provides a seamless interface to manipulate objects of user-defined types as C++ class instances. It also provides built-in thread-safety features to simplify the construction of highly demanding mid-tier applications.
OCCI Associative Access of Relational Data
OCCI supports high performance features for associative access of relational data in Oracle databases by executing SQL statements and PL/SQL procedures. This allows applications to manipulate data to on the server side without incurring the cost of transporting the data to the client side. OCCI supports all SQL data definition, data manipulation, query, and transaction control facilities that are available through an Oracle database server. For example, an OCCI program can run a query against an Oracle database. The queries can require the program to supply data to the database using input (bind) variables.
OCCI Navigational Access of Objects
OCCI supports both associative and navigational styles of data access for object-relational data. Similar to relational data access, OCCI supports associative access to objects by letting users execute SQL statements and PL/SQL procedures that manipulate object data. There is also a strong demand for navigational access by object-oriented programs. In the object-oriented programming paradigm, applications model their objects as a set of inter-related objects that form trees or graphs of objects. The relationships among objects are implemented as references (REFs). An application processes objects by starting at some initial set of objects, using the references in these initial objects to traverse the remaining objects and perform computations on each object. This style of access to objects is known as navigational access to objects. OCCI provides an API for navigational access to objects. Through OCCI object navigational interface, an application can perform the following functions on Oracle objects:
<ul> <li> Creating, accessing, locking, deleting, copying and flushing objects</li> <li>Getting references to the objects and navigating through references </li> </ul>
Oracle9 i provides several enhancements to the JDBC OCI driver. This driver uses OCI and realizes the scalability and performance benefits of OCI. Some features new to Oracle9i, or enabled for the JDBC driver in this release include: <ul> <li> Improved connection management</li> <li> Proxy authentication</li> <li> Transparent Application Failover Callbacks</li> </ul>
Improved connection management
As mentioned ealier, Oracle9 i introduces a new connection pooling feature. This feature can be utilized by Java applications using the JDBC-OCI driver. With this feature, multiple application connections can share a pool of connections to the database, reducing JDBC connection resources and improving scalability.
JDBC-OCI now supports proxy authentication. Proxy authentication allows users in a three-tier environment to connect to the database via a middle-tier, yet retain their identity. Proxy authentication creates multiple, scalable lightweight database sessions to carry the identity of the Web user, enabling fine-grained access control and fine-grained auditing of the Web user.
Transparent Application Failover Callbacks
With Oracle9 i, JDBC-OCI supports Transparent Application Failover callbacks. Administrators can now register a callback function to be executed in the event a failure is detected and failover is initiated. This application can use the callback to display a message to the user informing them of the delay due to failover, and to restore lost session state after failover is complete.
Oracle9 i data access provides many important benefits to the application developer and database administrator. <ul> <li> New OCI features provide richer functionality and better performance while reducing the development effort.</li> <li> OCCI simplifies the development of object-based applications, enabling the performance and scalability benefits of OCI while supporting the object paradigm of C++</li> <li> The enhanced JDBC driver improves connection management, security, and failover of java applications.
</li> </ul> <blockquote> <table> <tr> <td>
KEY FEATURES </td> </tr> <tr> <td> OCI <ul> <li> Scrollable cursors </li> <li> Connection pooling </li> <li> Improved globalization support </li> </ul> JDBC <ul> <li> Improved connection management</li> <li> Proxy authentication</li> <li> Transparent Application Failover Callbacks</li> </ul> </td> <td> OCCI <ul> <li> C++ API to Oracle based on OCI</li> <li> Easy-to-use C++ classes and templates for Oracle database access</li> <li> Associative access of relational data </li> <li> Navigational access of objects</li> </ul> </td> </tr> </table> </blockquote> <center> Top of Page | Copyright and Corporate Info </center> </td> </tr> </table>