New Oracle9i Data Access Features



























The primary
  means of accessing Oracle9i is via the Oracle Call Interface.  The Oracle
  Call Interface (OCI) is a C call interface to Oracle9i 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 Oracle9i, 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.





OCI Enhancements


A number of enhancements
to OCI improve performance and ease development of applications. 
These enhancements include scrollable cursors, connection pooling, and improved globalization
support.  
Scrollable
Cursors



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.  
Connection
Pooling
When
using Oracle9i, 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 Oracle9i 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: 




  


      Creating, accessing, locking, deleting, copying and flushing objects
  
Getting references to the objects and navigating through references 




JDBC Enhancements
Oracle9i 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:

  
Improved connection management
  
Proxy authentication

  
Transparent Application Failover Callbacks

Improved connection management
As mentioned ealier,
Oracle9i 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.
Proxy authentication
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 Oracle9i,
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.

Summary

Oracle9i data
access provides many important benefits to the application developer and
database administrator.  

  
New OCI features
    provide richer functionality and better performance while reducing the
    development effort.

  
OCCI simplifies the
    development of object-based applications, enabling the performance and
    scalability benefits of OCI while supporting the object paradigm of C++
  
The enhanced JDBC
    driver improves connection management, security, and failover of java
    applications.


 










KEY FEATURES








OCI





Scrollable cursors 





Connection pooling 






Improved globalization
support 





  JDBC
  

  
Improved connection management
  
Proxy authentication
  
Transparent Application Failover Callbacks
  






OCCI





C++ API to Oracle based on
OCI





Easy-to-use C++ classes and
templates for Oracle database access






Associative access of
relational data 





Navigational access of objects


















Top

of Page |Copyright and Corporate Info