| Oracle® Database Application Developer's Guide - Fundamentals 10g Release 1 (10.1) Part Number B10795-01 |
|
|
View PDF |
| Oracle® Database Application Developer's Guide - Fundamentals 10g Release 1 (10.1) Part Number B10795-01 |
|
|
View PDF |
This chapter contains these topics:
As an application developer, you have many choices when it comes to writing a program to interact with the database.
In a traditional client/server program, the code of your application runs on a machine other than the database server. Database calls are transmitted from this client machine to the database server. Data is transmitted from the client to the server for insert and update operations, and returned from the server to the client for query operations. The data is processed on the client machine. Client/server programs are typically written using precompilers, where SQL statements are embedded within the code of another language such as C, C++, or COBOL.
You can develop application logic that resides entirely inside the database, using triggers that are executed automatically when changes occur in the database, or stored procedures that are called explicitly. Off-loading the work from your application lets you reuse code that performs verification and cleanup, and control database operations from a variety of clients. For example, by making stored procedures callable through a Web server, you can construct a Web-based user interface that performs the same functions as a client/server application.
Client/server computing is often referred to as a two-tier model: your application communicates directly with the database server. In the three-tier model, another server (known as the application server) processes the requests. The application server might be a basic Web server, or might perform advanced functions like caching and load-balancing. Increasing the processing power of this middle tier lets you lessen the resources needed by client systems, resulting in a thin client configuration where the client machine might need only a Web browser or other means of sending requests over the TCP/IP or HTTP protocols.
The interface that your application displays to end users depends on the technology behind the application, as well as the needs of the users themselves. Experienced users might enter SQL commands that are passed on to the database. Novice users might be shown a graphical user interface that uses the graphics libraries of the client system (such as Windows or X-Windows). Any of these traditional user interfaces can also be provided in a Web browser using HTML and Java.
In traditional client/server applications, the application can keep a record of user actions and use this information over the course of one or multiple sessions. For example, past choices can be presented in a menu so that they do not have to be entered again. When the application is able to save information like this, we refer to the application as stateful.
Web or thin-client applications that are stateless are easier to develop. This means that they gather all the required information, process it using the database, and then start over from the beginning with the next user. This is a popular way to process single-screen requests such as customer registration.
There are many ways to add stateful behavior to Web applications that are stateless by default. For example, an entry form on one Web page can pass information on to subsequent Web pages, allowing you to construct a wizard-like interface that remembers the user's choices through several different steps. Cookies can be used to store small items of information on the client machine, and retrieve them when the user returns to a Web site. Servlets can be used to keep a database session open and store variables between requests from the same client.
PL/SQL is Oracle's procedural extension to SQL, the standard database access language. An advanced 4GL (fourth-generation programming languageFoot 1), PL/SQL offers seamless SQL access, tight integration with Oracle Database and associated tools, portability, security, and modern software engineering features such as data encapsulation, overloading, exception handling, and information hiding.
With PL/SQL, you can manipulate data with SQL statements, and control program flow with procedural constructs such as IF-THEN and LOOP. You can also declare constants and variables, define procedures and functions, use collections and object types, and trap run-time errors.
Applications written using any of the Oracle programmatic interfaces can call PL/SQL stored procedures and send blocks of PL/SQL code to the server for execution. 3GL (third-generation programming languageFoot 2) applications can access PL/SQL scalar and composite datatypes through host variables and implicit datatype conversion.
Because it runs inside the database, PL/SQL code is very efficient for data-intensive operations, and minimizes network traffic in client/server applications.
PL/SQL's tight integration with Oracle Developer lets you develop the client and server components of your application in the same language, then partition the components for optimal performance and scalability. Also, Oracle's Web Forms lets you deploy your applications in a multitier Internet or intranet environment without modifying a single line of code.
The procedure debit_account takes money from a bank account. It accepts an account number and an amount of money as parameters. It uses the account number to retrieve the account balance from the database, then computes the new balance. If this new balance is less than zero, the procedure jumps to an error routine; otherwise, it updates the bank account.
PROCEDURE debit_account (acct_id INTEGER, debit_amount REAL) IS old_balance REAL; new_balance REAL; overdrawn EXCEPTION; BEGIN SELECT bal INTO old_balance FROM accts WHERE acct_no = acct_id; new_balance := old_balance - debit_amount; IF new_balance < 0 THEN RAISE overdrawn; ELSE UPDATE accts SET bal = new_balance WHERE acct_no = acct_id; END IF; COMMIT; EXCEPTION WHEN overdrawn THEN -- handle the error END debit_account;
PL/SQL is a completely portable, high-performance transaction processing language that offers the following advantages:
PL/SQL lets you use all the SQL data manipulation, cursor control, and transaction control commands, as well as all the SQL functions, operators, and pseudocolumns. So, you can manipulate Oracle Database data flexibly and safely. PL/SQL fully supports SQL datatypes, reducing conversions as data is passed between applications and the database.
Dynamic SQL is a programming technique that lets you build and process SQL statements "on the fly" at run time. It gives PL/SQL flexibility comparable to scripting languages such as Perl, Korn shell, and Tcl.
PL/SQL supports all the SQL datatypes. Combined with the direct access that SQL provides, these shared datatypes integrate PL/SQL with the Oracle Database data dictionary.
The %TYPE and %ROWTYPE attributes let your code adapt as table definitions change. For example, the %TYPE attribute declares a variable based on the type of a database column. If the column's type changes, your variable uses the correct type at run time. This provides data independence and reduces maintenance costs.
If your application is database intensive, you can use PL/SQL blocks to group SQL statements before sending them to Oracle Database for execution. This can drastically reduce the communication overhead between your application and Oracle Database.
PL/SQL stored procedures are compiled once and stored in executable form, so procedure calls are quick and efficient. A single call can start a compute-intensive stored procedure, reducing network traffic and improving round-trip response times. Executable code is automatically cached and shared among users, lowering memory requirements and invocation overhead.
PL/SQL adds procedural capabilities, such as Oracle Forms and Oracle Reports. For example, you can use an entire PL/SQL block in an Oracle Forms trigger instead of multiple trigger steps, macros, or user exits.
PL/SQL is the same in all environments. As soon as you master PL/SQL with one Oracle tool, you can transfer your knowledge to others, and so multiply the productivity gains. For example, scripts written with one tool can be used by other tools.
PL/SQL stored procedures increase scalability by centralizing application processing on the server. Automatic dependency tracking helps you develop scalable applications.
The shared memory facilities of the shared server (formerly known as Multi-Threaded Server or MTS) enable Oracle Database to support many thousands of concurrent users on a single node. For more scalability, you can use the Oracle Connection Manager to multiplex network connections.
Once validated, a PL/SQL stored procedure can be used with confidence in any number of applications. If its definition changes, only the procedure is affected, not the applications that call it. This simplifies maintenance and enhancement. Also, maintaining a procedure on the server is easier than maintaining copies on various client machines.
An object type is a user-defined composite datatype that encapsulates a data structure along with the functions and procedures needed to manipulate the data. The variables that form the data structure are called attributes. The functions and procedures that characterize the behavior of the object type are called methods, which you can implement in PL/SQL.
Object types are an ideal object-oriented modeling tool, which you can use to reduce the cost and time required to build complex applications. Besides allowing you to create software components that are modular, maintainable, and reusable, object types allow different teams of programmers to develop software components concurrently.
A collection is an ordered group of elements, all of the same type (for example, the grades for a class of students). Each element has a unique subscript that determines its position in the collection. PL/SQL offers two kinds of collections: nested tables and varrays (short for variable-size arrays).
Collections work like the set, queue, stack, and hash table data structures found in most third-generation programming languages. Collections can store instances of an object type and can also be attributes of an object type. Collections can be passed as parameters. So, you can use them to move columns of data into and out of database tables or between client-side applications and stored subprograms. You can define collection types in a PL/SQL package, then use the same types across many applications.
Applications written in PL/SQL can run on any operating system and hardware platform where Oracle Database runs. You can write portable program libraries and reuse them in different environments.
PL/SQL stored procedures let you divide application logic between the client and the server, to prevent client applications from manipulating sensitive Oracle Database data. Database triggers written in PL/SQL can prevent applications from making certain updates, and can audit user queries.
You can restrict access to Oracle Database data by allowing users to manipulate it only through stored procedures that have a restricted set of privileges. For example, you can grant users access to a procedure that updates a table, but not grant them access to the table itself.
| See Also:
Oracle Database Security Guide for details on database security features |
DBMS_PIPE is used to communicate between sessions.DBMS_ALERT is used to broadcast alerts to users.DBMS_LOCK and DBMS_TRANSACTION are used for lock and transaction management.DBMS_AQ is used for Advanced Queuing.DBMS_LOB is used to manipulate large objects.DBMS_ROWID is used for employing ROWID values.UTL_RAW is the RAW facility.UTL_REF is for work with REF values.These provide access to snapshots, advanced replication, conflict resolution, deferred transactions, and remote procedure calls.
This section gives an overview of built-in database features that support Java applications. The database includes the core JDK libraries such as java.lang, java.io, and so on. The database supports client-side Java standards such as JDBC and SQLJ, and provides server-side JDBC and SQLJ drivers that allow data-intensive Java code to run within the database.
See Also:
|
Oracle JVM, the Java Virtual Machine provided with the Oracle Database, is compliant with the J2SE version 1.4.x specification and supports the database session architecture.
Any database session can activate a dedicated JVM. All sessions share the same JVM code and statics; however, private states for any given session are held, and subsequently garbage collected, in an individual session space.
This design provides the following benefits:
Oracle JVM works consistently with every platform supported by Oracle Database. Java applications that you develop using Oracle JVM can be ported to any supported platform easily.
Oracle JVM includes a deployment-time native compiler that enables Java code to be compiled once, stored in executable form, shared among users, and invoked more quickly and efficiently.
Security features of the database are also available using Oracle JVM. Java classes must be loaded in a database schema (using Oracle JDeveloper, a third-party IDE, SQL*Plus, or the loadjava utility) before they can be invoked. Java class invocation is secured and controlled through database authentication and authorization, Java 2 security, and invoker's or definer's rights.
JDBC (Java Database Connectivity) is an API (Applications Programming Interface) that allows Java to send SQL statements to an object-relational database such as Oracle Database.
The JDBC standard defines four types of JDBC drivers:
JDBC is based on the X/Open SQL Call Level Interface, and complies with the SQL92 Entry Level standard.
You can use JDBC to do dynamic SQL. Dynamic SQL means that the embedded SQL statement to be executed is not known before the application is run, and requires input to build the statement.
The drivers that are implemented by Oracle have extensions to the capabilities in the JDBC standard that was defined by Sun Microsystems. Oracle's implementations of JDBC drivers are described next. Oracle Database support of and extensions to various levels of the JDBC standard are described in "Oracle Database Extensions to JDBC Standards".
The JDBC thin driver is a Type 4 (100% pure Java) driver that uses Java sockets to connect directly to a database server. It has its own implementation of a Two-Task Common (TTC), a lightweight implementation of TCP/IP from Oracle Net. It is written entirely in Java and is therefore platform-independent.
The thin driver does not require Oracle software on the client side. It does need a TCP/IP listener on the server side. Use this driver in Java applets that are downloaded into a Web browser, or in applications where you do not want to install Oracle client software. The thin driver is self-contained, but it opens a Java socket, and thus can only run in a browser that supports sockets.
The OCI driver is a Type 2 JDBC driver. It makes calls to the OCI (Oracle Call Interface) which is written in C, to interact with Oracle Database, thus using native and Java methods.
The OCI driver allows access to more features than the thin driver, such as Transparent Application Fail-Over, advanced security, and advanced LOB manipulation.
The OCI driver provides the highest compatibility between the different Oracle Database versions, from 7 to 9i. It also supports all installed Oracle Net adapters, including IPC, named pipes, TCP/IP, and IPX/SPX.
Because it uses native methods (a combination of Java and C) the OCI driver is platform-specific. It requires a client Oracle8i or later installation including Oracle Net (formerly known as Net8), OCI libraries, CORE libraries, and all other dependent files. The OCI driver usually executes faster than the thin driver.
The OCI driver is not appropriate for Java applets, because it uses a C library that is platform-specific and cannot be downloaded into a Web browser. It is usable in J2EE components running in middle-tier application servers, such as Oracle Application Server. Oracle Application Server provides middleware services and tools that support access between applications and browsers.
The JDBC server-side internal driver is a Type 2 driver that runs inside the database server, reducing the number of round-trips needed to access large amounts of data. The driver, the Java server VM, the database, the Java native compiler which speeds execution by as much as 10 times, and the SQL engine all run within the same address space.
This driver provides server-side support for any Java program used in the database: SQLJ stored procedures, functions, and triggers, and Java stored procedures. You can also call PL/SQL stored procedures, functions, and triggers.
The server driver fully supports the same features and extensions as the client-side drivers.
Oracle Database includes the following extensions to the JDBC 1.22 standard:
DatabaseMetaData callsOracle Database supports all APIs from the JDBC 2.0 standard, including the core APIs, optional packages, and numerous extensions. Some of the highlights include datasources, JTA and distributed transactions.
Oracle Database supports these features from the JDBC 3.0 standard:
The following example shows the recommended technique for looking up a data source using JNDI in JDBC 2.0:
// import the JDBC packages import java.sql.*; import javax.sql.*; import oracle.jdbc.pool.*; ... InitialContext ictx = new InitialContext(); DataSource ds = (DataSource)ictx.lookup("jdbc/OracleDS"); Connection conn = ds.getConnection(); Statement stmt = conn.createStatement(); ResultSet rs = stmt.executeQuery("SELECT ename FROM emp"); while ( rs.next() ) { out.println( rs.getString("ename") + "<br>"); } conn.close();
The following source code registers an Oracle JDBC thin driver, connects to the database, creates a Statement object, executes a query, and processes the result set.
The SELECT statement retrieves and lists the contents of the ENAME column of the EMP table.
import java.sql.* import java.math.* import java.io.* import java.awt.* class JdbcTest { public static void main (String args []) throws SQLException { // Load Oracle driver DriverManager.registerDriver (new oracle.jdbc.OracleDriver()); // Connect to the local database Connection conn = DriverManager.getConnection ("jdbc:oracle:thin:@myhost:1521:orcl", "scott", "tiger"); // Query the employee names Statement stmt = conn.createStatement (); ResultSet rset = stmt.executeQuery ("SELECT ENAME FROM EMP"); // Print the name out while (rset.next ()) System.out.println (rset.getString (1)); // Close the result set, statement, and the connection rset.close(); stmt.close(); conn.close(); } }
One Oracle Database extension to the JDBC drivers is a form of the getConnection() method that uses a Properties object. The Properties object lets you specify user, password, and database information as well as row prefetching and execution batching.
To use the OCI driver in this code, replace the Connection statement with:
Connection conn = DriverManager.getConnection ("jdbc:oracle:oci8:@MyHostString", "scott", "tiger");
where MyHostString is an entry in the TNSNAMES.ORA file.
If you are creating an applet, the getConnection() and registerDriver() strings will be different.
JDBC code and SQLJ code (see "Overview of Oracle SQLJ") interoperate, allowing dynamic SQL statements in JDBC to be used with both static and dynamic SQL statements in SQLJ. A SQLJ iterator class corresponds to the JDBC result set.
| See Also:
Oracle Database JDBC Developer's Guide and Reference for more information on JDBC |
SQLJ is an ANSI SQL-1999 standard for embedding SQL statements in Java source code. SQLJ provides a simpler alternative to JDBC for both client-side and server-side SQL data access from Java.
A SQLJ source file contains Java source with embedded SQL statements. Oracle SQLJ supports dynamic as well as static SQL. Support for dynamic SQL is an Oracle extension to the SQLJ standard.
|
Note: The term "SQLJ," when used in this manual, refers to the Oracle SQLJ implementation, including Oracle SQLJ extensions. |
Oracle Database provides a translator and a run time driver to support SQLJ. The SQLJ translator is 100% pure Java and is portable to any JVM that is compliant with JDK version 1.1 or higher.
The Oracle SQLJ translator performs the following tasks:
Oracle Database supports SQLJ stored procedures, functions, and triggers which execute in the Oracle JVM. SQLJ is integrated with JDeveloper. Source-level debugging support for SQLJ is available in JDeveloper.
Here is an example of a simple SQLJ executable statement, which returns one value because empno is unique in the emp table:
String name; #sql { SELECT first_name INTO :name FROM employees WHERE employee_id=112 }; System.out.println("Name is " + name + ", employee number = " + employee_id);
Each host variable (or qualified name or complex Java host expression) included in a SQL expression is preceded by a colon (:). Other SQLJ statements are declarative (they declare Java types). For example, you can declare an iterator (a construct related to a database cursor) for queries that retrieve many values, as follows:
#sql iterator EmpIter (String EmpNam, int EmpNumb);
| See Also:
For more examples and details on Oracle SQLJ syntax:
|
Oracle SQLJ extensions to Java allow rapid development and easy maintenance of applications that perform database operations through embedded SQL.
In particular, Oracle SQLJ:
ROWID, REF CURSOR, VARRAY, nested table, user-defined object types, RAW, and NUMBER.JDBC provides a complete dynamic SQL interface from Java to databases. It gives developers full control over database operations. SQLJ simplifies Java database programming to improve development productivity.
JDBC provides fine-grained control of the execution of dynamic SQL from Java, while SQLJ provides a higher-level binding to SQL operations in a specific database schema. Here are some differences:
fun, to have the following syntax. (This examples shows SQL92 and Oracle JDBC syntaxes. Both are allowed.)
prepStmt.prepareCall("{call fun(?,?)}"); //stored procedure SQL92 prepStmt.prepareCall("{? = call fun(?,?)}"); //stored function SQL92 prepStmt.prepareCall("begin fun(:1,:2);end;"); //stored procedure Oracle prepStmt.prepareCall("begin :1 := fun(:2,:3);end;");//stored func Oracle
Here is the SQLJ equivalent:
#sql {call fun(param_list) }; //Stored procedure // Declare x ... #sql x = {VALUES(fun(param_list)) }; // Stored function // where VALUES is the SQL construct
The following benefits are common to SQLJ and JDBC:
SQLJ applications can be stored and executed in the server. To do so, you can use the following techniques:
loadjava utility. The classes are typically stored in a Java archive (.jar) file.loadjava, where it is translated and compiled by the server's embedded translator.
| See Also:
Oracle Database JPublisher User's Guide for more information on using stored procedures with Oracle SQLJ |
Oracle JPublisher is a code generator that automates the process of creating database-centric Java classes by hand. Oracle JPublisher is a client-side utility and is built into the database system. You can run Oracle JPublisher from the command-line or directly from the Oracle JDeveloper IDE.
Oracle JPublisher inspects PL/SQL packages and database object types such as SQL object types, VARRAY types, and nested table types; then generates a Java class that is a wrapper around the PL/SQL package with corresponding fields and methods.
The generated Java class can be incorporated and used by Java clients or J2EE components to exchange and transfer object type instances to and from the database transparently.
Java stored procedures allow you to implement programs that run in the database server, independent from programs that run in the middle tier. Structuring your applications in this way reduces complexity and increases reuse, security, performance, and scalability.
For example, you can create a Java stored procedure that performs operations that require data persistence and a separate program to perform presentation or business logic operations.
Java stored procedures interface with SQL using a similar execution model as PL/SQL.
Web services represent a distributed computing paradigm for Java application development that is an alternative to earlier Java protocols such as JDBC. It allows application-to-application interaction using XML and Web protocols. The key technologies used in Web services are:
Web services can use a variety of techniques and protocols. For example, dispatching can happen in a synchronous (typical) or asynchronous manner, invocation can be performed in RPC-style (a single operation with arguments is sent and a response returned) or in message style (a one-way SOAP document exchange), and different encoding rules can be used (literal or encoded). When calling a Web service, you may know everything about it beforehand (static invocation), or you can discover its operations and transport endpoints on the fly (dynamic invocation).
The database can function as either a Web service provider or as a Web service consumer. When used as a Web services provider, the database enables sharing and disconnected access to stored procedures, data, metadata, and other database resources such as the queuing and messaging systems.
As a Web service provider, the database provides a disconnected and heterogeneous environment that:
In some situations, the database functions as a Web service consumer.
For example, when business data is available dynamically from an external Web service, your database application might need to:
You write these named blocks and then define them using the loadjava command or SQL CREATE FUNCTION, CREATE PROCEDURE, or CREATE PACKAGE statements. These Java methods can accept arguments and are callable from:
CALL statements.CALL statements.INSERT, UPDATE, DELETE, and SELECT).A database trigger is a stored procedure that Oracle Database invokes ("fires") automatically when certain events occur, for example, when a DML operation modifies a certain table. Triggers enforce business rules, prevent incorrect values from being stored, and reduce the need to perform checking and cleanup operations in each application.
The Pro*C/C++ precompiler is a software tool that allows the programmer to embed SQL statements in a C or C++ source file. Pro*C/C++ reads the source file as input and outputs a C or C++ source file that replaces the embedded SQL statements with Oracle runtime library calls, and is then compiled by the C or C++ compiler.
When there are errors found during the precompilation or the subsequent compilation, modify your precompiler input file and re-run the two steps.
Here is a simple code fragment from a C source file that queries the table EMP which is in the schema SCOTT:
... #define UNAME_LEN 10 ... int emp_number; /* Define a host structure for the output values of a SELECT statement. */ /* No declare section needed if precompiler option MODE=ORACLE */ struct { VARCHAR emp_name[UNAME_LEN]; float salary; float commission; } emprec; /* Define an indicator structure to correspond to the host output structure. */ struct { short emp_name_ind; short sal_ind; short comm_ind; } emprec_ind; ... /* Select columns ename, sal, and comm given the user's input for empno. */ EXEC SQL SELECT ename, sal, comm INTO :emprec INDICATOR :emprec_ind FROM emp WHERE empno = :emp_number; ...
The embedded SELECT statement is only slightly different from an interactive (SQL*Plus) SELECT statement. Every embedded SQL statement begins with EXEC SQL. The colon (:), precedes every host (C) variable. The returned values of data and indicators (set when the data value is NULL or character columns have been truncated) can be stored in structs (such as in the preceding code fragment), in arrays, or in arrays of structs. Multiple result set values are handled very simply in a manner that resembles the case shown, where there is only one result, because of the unique employee number. You use the actual names of columns and tables in embedded SQL.
Use the default precompiler option values, or you can enter values which give you control over the use of resources, how errors are reported, the formatting of output, and how cursors (which correspond to a particular connection or SQL statement) are managed. Cursors are used when there are multiple result set values.
Enter the options either in a configuration file, on the command line, or in-line inside your source code with a special statement that begins with EXEC ORACLE. If there are no errors found, you can then compile, link, and execute the output source file, like any other C program that you write.
Use the precompiler to create server database access from clients that can be on many different platforms. Pro*C/C++ allows you the freedom to design your own user interfaces and to add database access to existing applications.
Before writing your embedded SQL statements, you may want to test interactive versions of the SQL in SQL*Plus. You then make only minor changes to start testing your embedded SQL application.
The following is a short subset of the capabilities of Pro*C/C++. For complete details, see the Pro*C/C++ Precompiler Programmer's Guide.
VARRAY, are supported with a set of SQL statements that allow a high degree of control over data.CLOB, NCLOB, and BFILE datatypes) are accessed by another set of SQL statements.The Pro*COBOL precompiler is a software tool that allows the programmer to embed SQL statements in a COBOL source code file. Pro*COBOL reads the source file as input and outputs a COBOL source file that replaces the embedded SQL statements with Oracle Database runtime library calls, and is then compiled by the COBOL compiler.
When there are errors found during the precompilation or the subsequent compilation, modify your precompiler input file and re-run the two steps.
Here is a simple code fragment from a source file that queries the table EMP which is in the schema SCOTT:
... WORKING-STORAGE SECTION. * * DEFINE HOST INPUT AND OUTPUT HOST AND INDICATOR VARIABLES. * NO DECLARE SECTION NEEDED IF MODE=ORACLE. * 01 EMP-REC-VARS. 05 EMP-NAME PIC X(10) VARYING. 05 EMP-NUMBER PIC S9(4) COMP VALUE ZERO. 05 SALARY PIC S9(5)V99 COMP-3 VALUE ZERO. 05 COMMISSION PIC S9(5)V99 COMP-3 VALUE ZERO. 05 COMM-IND PIC S9(4) COMP VALUE ZERO. ... PROCEDURE DIVISION. ... EXEC SQL SELECT ENAME, SAL, COMM INTO :EMP-NAME, :SALARY, :COMMISSION:COMM-IND FROM EMP WHERE EMPNO = :EMP_NUMBE END-EXEC. ...
The embedded SELECT statement is only slightly different from an interactive (SQL*Plus) SELECT statement. Every embedded SQL statement begins with EXEC SQL. The colon (:) precedes every host (COBOL) variable. The SQL statement is terminated by END-EXEC. The returned values of data and indicators (set when the data value is NULL or character columns have been truncated) can be stored in group items (such as in the preceding code fragment), in tables, or in tables of group items. Multiple result set values are handled very simply in a manner that resembles the case shown, where there is only one result, given the unique employee number. You use the actual names of columns and tables in embedded SQL.
Use the default precompiler option values, or enter values that give you control over the use of resources, how errors are reported, the formatting of output, and how cursors are managed (cursors correspond to a particular connection or SQL statement).
Enter the options in a configuration file, on the command line, or in-line inside your source code with a special statement that begins with EXEC ORACLE. If there are no errors found, you can then compile, link, and execute the output source file, like any other COBOL program that you write.
Use the precompiler to create server database access from clients that can be on many different platforms. Pro*COBOL allows you the freedom to design your own user interfaces and to add database access to existing COBOL applications.
The embedded SQL statements available conform to an ANSI standard, so that you can access data from many databases in a program, including remote servers networked through Oracle Net.
Before writing your embedded SQL statements, you may want to test interactive versions of the SQL in SQL*Plus. You then make only minor changes to start testing your embedded SQL application.
The following is a short subset of the capabilities of Pro*COBOL.
| See Also:
Pro*COBOL Programmer's Guide for complete details |
The Oracle Call Interface (OCI) and Oracle C++ Call Interface (OCCI) are application programming interfaces (APIs) that allow you to create applications that use native procedures or function calls of a third-generation language to access Oracle Database and control all phases of SQL statement execution. These APIs provide:
OCI lets you manipulate data and schemas in a database using a host programming language, such as C. OCCI is an object-oriented interface suitable for use with C++. These APIs provide a library of standard database access and retrieval functions in the form of a dynamic runtime library (OCILIB) that can be linked in an application at runtime. This eliminates the need to embed SQL or PL/SQL within 3GL programs.
OCI provides significant advantages over other methods of accessing Oracle Database:
INSERTs, UPDATEs, and DELETEs.The OCI encompasses four main sets of functionality:
The Oracle Call Interface (OCI) lets you develop applications that combine the non-procedural data access power of Structured Query Language (SQL) with the procedural capabilities of most programming languages, including C and C++.
The combination of both non-procedural and procedural language elements in an OCI program provides easy access to Oracle Database in a structured programming environment.
The OCI supports all SQL data definition, data manipulation, query, and transaction control facilities that are available through Oracle Database. For example, an OCI program can run a query against Oracle Database. The queries can require the program to supply data to the database using input (bind) variables, as follows:
SELECT name FROM employees WHERE empno = :empnumber
In the preceding SQL statement,:empnumber is a placeholder for a value that will be supplied by the application.
You can alternatively use PL/SQL, Oracle's procedural extension to SQL. The applications you develop can be more powerful and flexible than applications written in SQL alone. The OCI also provides facilities for accessing and manipulating objects in Oracle Database.
As Figure 1-1 shows, you compile and link an OCI program in the same way that you compile and link a non-database application. There is no need for a separate preprocessing or precompilation step.
Text description of the illustration adfns089.gif
Oracle Data Provider for .NET (ODP.NET) is an implementation of a data provider for Oracle Database.
ODP.NET uses APIs native to Oracle Database to offer fast and reliable access from any .NET application to database features and data. It also uses and inherits classes and interfaces available in the Microsoft .NET Framework Class Library.
For programmers using Oracle Provider for OLE DB, ADO (ActiveX Data Objects) provides an automation layer that exposes an easy programming model. ADO.NET provides a similar programming model, but without the automation layer, for better performance. More importantly, the ADO.NET model allows native providers such as ODP.NET to expose specific features and datatypes specific to Oracle Database.
The following is a simple C# application that connects to Oracle Database and displays its version number before disconnecting.
using System; using Oracle.DataAccess.Client; class Example { OracleConnection con; void Connect() { con = new OracleConnection(); con.ConnectionString = "User Id=scott;Password=tiger;Data Source=oracle"; con.Open(); Console.WriteLine("Connected to Oracle" + con.ServerVersion); } void Close() { con.Close(); con.Dispose(); } static void Main() { Example example = new Example(); example.Connect(); example.Close(); } }
Oracle Objects for OLE (OO4O) is a product designed to allow easy access to data stored in Oracle Database with any programming or scripting language that supports the Microsoft COM Automation and ActiveX technology. This includes Visual Basic, Visual C++, Visual Basic For Applications (VBA), IIS Active Server Pages (VBScript and JavaScript), and others.
See the OO4O online help for detailed information about using OO4O.
Oracle Objects for OLE consists of the following software layers:
Figure 1-2, "Software Layers" illustrates the OO4O software components.
Text description of the illustration adfns090.gif
The OO4O Automation Server is a set of COM Automation objects for connecting to Oracle Database, executing SQL statements and PL/SQL blocks, and accessing the results.
Unlike other COM-based database connectivity APIs, such as Microsoft ADO, the OO4O Automation Server has been developed and evolved specifically for use with Oracle Database.
It provides an optimized API for accessing features that are unique to Oracle Database and are otherwise cumbersome or inefficient to use from ODBC or OLE database-specific components.
OO4O provides key features for accessing Oracle Database efficiently and easily in environments ranging from the typical two-tier client/server applications, such as those developed in Visual Basic or Excel, to application servers deployed in multitiered application server environments such as Web server applications in Microsoft Internet Information Server (IIS) or Microsoft Transaction Server (MTS).
Features include:
The Oracle Objects for OLE object model is illustrated in Figure 1-3, "Objects and Their Relations".
Text description of the illustration adfns092.gif
An OraSession object manages collections of OraDatabase, OraConnection, and OraDynaset objects used within an application.
Typically, a single OraSession object is created for each application, but you can create named OraSession objects for shared use within and between applications.
The OraSession object is the top-most object for an application. It is the only object created by the CreateObject VB/VBA API and not by an Oracle Objects for OLE method. The following code fragment shows how to create an OraSession object:
Dim OraSession as Object Set OraSession = CreateObject("OracleInProcServer.XOraSession")
OraServer represents a physical network connection to Oracle Database.
The OraServer interface is introduced to expose the connection-multiplexing feature provided in the Oracle Call Interface. After an OraServer object is created, multiple user sessions (OraDatabase) can be attached to it by invoking the OpenDatabase method. This feature is particularly useful for application components, such as Internet Information Server (IIS), that use Oracle Objects for OLE in n-tier distributed environments.
The use of connection multiplexing when accessing Oracle Database with a large number of user sessions active can help reduce server processing and resource requirements while improving server scalability.
OraServer is used to share a single connection across multiple OraDatabase objects (multiplexing), whereas each OraDatabase obtained from an OraSession has its own physical connection.
An OraDatabase interface adds additional methods for controlling transactions and creating interfaces representing of Oracle object types. Attributes of schema objects can be retrieved using the Describe method of the OraDatabase interface.
In releases prior to Oracle8i, an OraDatabase object is created by invoking the OpenDatabase method of an OraSession interface. The Oracle Net alias, user name, and password are passed as arguments to this method. In Oracle8i and later, invocation of this method results in implicit creation of an OraServer object.
An OraDatabase object can also be created using the OpenDatabase method of the OraServer interface.
Transaction control methods are available at the OraDatabase (user session) level. Transactions may be started as Read-Write (default), Serializable, or Read-only. Transaction control methods include:
For example:
UserSession.BeginTrans(OO4O_TXN_READ_WRITE) UserSession.ExecuteSQL("delete emp where empno = 1234") UserSession.CommitTrans
An OraDynaset object permits browsing and updating of data created from a SQL SELECT statement.
The OraDynaset object can be thought of as a cursor, although in actuality several real cursors may be used to implement the semantics of OraDynaset. An OraDynaset object automatically maintains a local cache of data fetched from the server and transparently implements scrollable cursors within the browse data. Large queries may require significant local disk space; application developers are encouraged to refine queries to limit disk usage.
An OraField object represents a single column or data item within a row of a dynaset.
If the current row is being updated, then the OraField object represents the currently updated value, although the value may not yet have been committed to the database.
Assignment to the Value property of a field is permitted only if a record is being edited (using Edit) or a new record is being added (using AddNew). Other attempts to assign data to a field's Value property results in an error.
An OraMetaData object is a collection of OraMDAttribute objects that represent the description information about a particular schema object in the database.
The OraMetaData object can be visualized as a table with three columns:
Metadata Attribute NameMetadata Attribute ValueFlag specifying whether the Value is another OraMetaData objectThe OraMDAttribute objects contained in the OraMetaData object can be accessed by subscripting using ordinal integers or by using the name of the property. Referencing a subscript that is not in the collection results in the return of a NULL OraMDAttribute object.
An OraParameter object represents a bind variable in a SQL statement or PL/SQL block.
OraParameter objects are created, accessed, and removed indirectly through the OraParameters collection of an OraDatabase object. Each parameter has an identifying name and an associated value. You can automatically bind a parameter to SQL and PL/SQL statements of other objects (as noted in the object descriptions), by using the parameter name as a placeholder in the SQL or PL/SQL statement. Such use of parameters can simplify dynamic queries and increase program performance.
An OraParamArray object represents an array-type bind variable in a SQL statement or PL/SQL block, as opposed to a scalar-type bind variable represented by the OraParameter object.
OraParamArray objects are created, accessed, and removed indirectly through the OraParameters collection of an OraDatabase object. Each OraParamArray object has an identifying name and an associated value.
An OraSQLStmt object represents a single SQL statement. Use the CreateSQL method to create an OraSQLStmt object from an OraDatabase object.
During create and refresh, OraSQLStmt objects automatically bind all relevant, enabled input parameters to the specified SQL statement, using the parameter names as placeholders in the SQL statement. This can improve the performance of SQL statement execution without re-parsing the SQL statement.
The OraSQLStmt object can be used later to execute the same query using a different value for the :SALARY placeholder. This is done as follows (updateStmt is the OraSQLStmt object here):
OraDatabase.Parameters("SALARY").value = 200000 updateStmt.Parameters("ENAME").value = "KING" updateStmt.Refresh
An OraAQ object is instantiated by invoking the CreateAQ method of the OraDatabase interface. It represents a queue that is present in the database.
Oracle Objects for OLE provides interfaces for accessing Oracle Advanced Queuing (AQ) feature. It makes AQ accessible from popular COM-based development environments such as Visual Basic. For a detailed description of Oracle Advanced Queuing, refer to Oracle Streams Advanced Queuing User's Guide and Reference.
The OraAQMsg object encapsulates the message to be enqueued or dequeued. The message can be of any user-defined or raw type.
For a detailed description of Oracle Advanced Queuing, refer to Oracle Streams Advanced Queuing User's Guide and Reference.
The OraAQAgent object represents a message recipient and is only valid for queues that allow multiple consumers. It is a child of OraAQMsg.
An OraAQAgent object can be instantiated by invoking the AQAgent method. For example:
Set agent = qMsg.AQAgent(name)
An OraAQAgent object can also be instantiated by invoking the AddRecipient method. For example:
Set agent = qMsg.AddRecipient(name, address, protocol).
Oracle Objects for OLE provides full support for accessing and manipulating instances of object datatypes and LOBs in Oracle Database. Figure 1-4, "Supported Oracle Datatypes" illustrates the datatypes supported by OO4O.
Instances of these types can be fetched from the database or passed as input or output variables to SQL statements and PL/SQL blocks, including stored procedures and functions. All instances are mapped to COM Automation Interfaces that provide methods for dynamic attribute access and manipulation.
Text description of the illustration adfns091.gif
The OraBlob and OraClob interfaces in Oracle Objects for OLE provide methods for performing operations on large database objects of datatype BLOB, CLOB, and NCLOB. BLOB, CLOB, and NCLOB datatypes are also referred to here as LOB datatypes.
LOB data is accessed using Read and the CopyToFile methods.
LOB data is modified using Write, Append, Erase, Trim, Copy, CopyFromFile, and CopyFromBFile methods. Before modifying the content of a LOB column in a row, a row lock must be obtained. If the LOB column is a field of an OraDynaset, object, then the lock is obtained by invoking the Edit method.
The OraBFile interface in Oracle Objects for OLE provides methods for performing operations on large database objects of datatype BFILE.
BFILE objects are large binary data objects stored in operating system files outside of the database tablespaces.
Oracle Data Control (ODC) is an ActiveX Control that is designed to simplify the exchange of data between Oracle Database and visual controls such edit, text, list, and grid controls in Visual Basic and other development tools that support custom controls.
ODC acts as an agent to handle the flow of information from Oracle Database and a visual data-aware control, such as a grid control, that is bound to it. The data control manages various user interface (UI) tasks such as displaying and editing data. It also executes and manages the results of database queries.
Oracle Data Control is compatible with the Microsoft data control included with Visual Basic. If you are familiar with the Visual Basic data control, learning to use Oracle Data Control is quick and easy. Communication between data-aware controls and a Data Control is governed by a protocol that has been specified by Microsoft.
Oracle Objects for OLE C++ Class Library is a collection of C++ classes that provide programmatic access to the Oracle Object Server. Although the class library is implemented using OLE Automation, neither the OLE development kit nor any OLE development knowledge is necessary to use it. This library helps C++ developers avoid the chore of writing COM client code for accessing the OO4O interfaces.
For detailed information about Oracle Objects for OLE refer to the online help provided with the OO4O product:
To view examples of how to use Oracle Objects for OLE, see the samples located in the ORACLE_HOME\OO4O directory of the Oracle Database installation. Additional OO4O examples can be found in the following Oracle publications:
To choose a programming environment for a new development project:
The following examples illustrate easy choices:
Precompiler applications typically contain less code than equivalent OCI applications, which can help productivity.
Some situations require detailed control of the database and are suited for OCI applications (either pure OCI or a precompiler application with embedded OCI calls):
Both Java and PL/SQL have built-in packages and libraries.
PL/SQL and Java interoperate in the server. You can execute a PL/SQL package from Java or wrap a PL/SQL class with a Java wrapper so that it can be called from distributed CORBA and EJB clients. The following table shows PL/SQL packages and their Java equivalents:
Both Java and PL/SQL can be used to build applications in the database. Here are some guidelines for their use:
PL/SQL uses the same datatypes as SQL. SQL datatypes are thus easier to use and SQL operations are faster than with Java, especially when a large amount of data is involved, when mostly database access is done, or when bulk operations are used.
PL/SQL is an extension to SQL offering data encapsulation, information hiding, overloading, and exception-handling.
Some advanced PL/SQL capabilities are not available for Java in Oracle9i. Examples are autonomous transactions and the dblink facility for remote databases. Code development is usually faster in PL/SQL than in Java.
Java has inheritance, polymorphism, and component models for developing distributed systems. PL/SQL has inheritance and type evolution, the ability to change methods and attributes of a type while preserving subtypes and table data that use the type.
Java has a richer type system than PL/SQL and is an object-oriented language. Java can use CORBA (which can have many different computer languages in its clients) and EJB. PL/SQL packages can be called from CORBA or EJB clients.
You can run XML tools, the Internet File System, or JavaMail from Java.
Many Java-based development tools are available throughout the industry.
1 4GL: An "application specific" language, with built-in treatment of an application domain. PL/SQL and SQL have built-in treatment of the database domain.
2 3GL: A language designed to be easier than assembler language for a human to understand. It includes things like named variables. Unlike 4GL, it is not specific to a particular application domain.
|
 Copyright © 1996, 2003 Oracle Corporation All Rights Reserved. |
|