If your array contains Oracle objects, then you can use a type map to associate the objects in the array with the corresponding Java class. If you do not specify a type map, or if the type map does not contain an entry for a particular Oracle object, then each element is returned as an oracle.sql.STRUCT object.

If you want the type map to determine the mapping between the Oracle objects in the array and their associated Java classes, then you must add an appropriate entry to the map.

- create a Oracle Object Type specular to the Java Class implemented by the elements your Java Array,
- specify a Map where you put an entry to specify the correspondence between the java class and the Oracle Object Type.

If you want to create custom object classes for your Oracle objects, then you must define entries in the type map that specify the custom object classes that the drivers will instantiate for the corresponding Oracle objects.

You must also provide a way to create and populate instances of the custom object class from the Oracle object and its attribute data. The driver must be able to read from a custom object class and write to it. In addition, the custom object class can provide getXXX and setXXX methods corresponding to the attributes of the Oracle object, although this is not necessary. To create and populate the custom classes and provide these read/write capabilities, you can choose between the following interfaces:

The JDBC standard SQLData interface
The ORAData and ORADataFactory interfaces provided by Oracle

The custom object class you create must implement one of these interfaces. The ORAData interface can also be used to implement the custom reference class corresponding to the custom object class. However, if you are using the SQLData interface, then you can use only weak reference types in Java, such as java.sql.Ref or oracle.sql.REF. The SQLData interface is for mapping SQL objects only.

Understanding the ORAData Interface

One of the choices in making an Oracle object and its attribute data available to Java applications is to create a custom object class that implements the oracle.sql.ORAData and oracle.sql.ORADataFactory interfaces. The ORAData and ORADataFactory interfaces are supplied by Oracle and are not a part of the JDBC standard.

Understanding ORAData Features

The ORAData interface has the following advantages:
-It recognizes Oracle extensions to the JDBC. ORAData uses oracle.sql.Datum types directly.
-It does not require a type map to specify the names of the Java custom classes you want to create.
-It provides better performance. ORAData works directly with Datum types, the internal format the driver uses to hold Oracle objects.

The ORAData and ORADataFactory interfaces do the following:

-The toDatum method of the ORAData class transforms the data into an oracle.sql.* representation.
-ORADataFactory specifies a create method equivalent to a constructor for your custom object class. It creates and returns an ORAData instance. The JDBC driver uses the create method to return an instance of the custom object class to your Java application or applet. It takes as input an oracle.sql.Datum object and an integer indicating the corresponding SQL type code as specified in the OracleTypes class.

ORAData and ORADataFactory have the following definitions:

public interface ORAData 
{ 
    Datum toDatum (OracleConnection conn) throws SQLException;
} 
 
public interface ORADataFactory 
{ 
    ORAData create (Datum d, int sql_Type_Code) throws SQLException; 
} 

Where conn represents the Connection object, d represents an object of type oracle.sql.Datum and sql_Type_Code represents the SQL type code of the Datum object.

create type try_obj as object (
		field_a number,
		field_b varchar2(10)
	)
/

create type try_obj_tab as table of try_obj
/

import java.sql.*;
import java.util.*;

import oracle.jdbc.*;
import oracle.jdbc.pool.OracleDataSource;
import oracle.sql.*;


public class JTryObj implements ORADataFactory,ORAData{
	private NUMBER field1;
	private CHAR field2;
	
	public JTryObj(OracleConnection conn,int n,String c) throws SQLException {
		field1 = new NUMBER(n);
		field2 = new CHAR(c,oracle.sql.CharacterSet.make(conn.getStructAttrCsId()));
	}
	
	public JTryObj(NUMBER n, CHAR c) {
		field1 = n;
		field2 = c;
	}
	public JTryObj(Object[] attributes) {
		this(
				(NUMBER) attributes[0],
				(CHAR) attributes[1]
			);
	}
	public JTryObj(Datum d) throws SQLException {
		this(((STRUCT) d).getOracleAttributes());
	}

	@Override
	public ORAData create(Datum d, int sqlType) throws SQLException {
		if (d == null)
			return null;
		else {
			return new JTryObj(d);
		}
	}
	
	public STRUCT toSTRUCT(Connection conn) throws SQLException  {
		StructDescriptor sd =
			StructDescriptor.createDescriptor("TRY_OBJ", conn);
		Object [] attributes = { field1,field2 };
		return new STRUCT(sd, conn, attributes);
	}
	@Override
	public Datum toDatum(Connection conn) throws SQLException {
		return toSTRUCT(conn); 
	}
	
	
	public static void main(String args[]) throws SQLException, ClassNotFoundException {
		// initialize the connection
		OracleConnection conn = null;
		OracleDataSource ods = new OracleDataSource();
		ods.setDriverType("oci8");
		ods.setUser(args[0]);
		ods.setPassword(args[1]);
		ods.setTNSEntryName(args[2]);
		conn = (OracleConnection) ods.getConnection();
		
		// create the java array
		JTryObj javaArray[] = {new JTryObj(conn,1,"abc"),new JTryObj(conn,2,"dce")};
		
		// Map the java class to the Oracle type
		Map map = conn.getTypeMap();
		map.put("TRY_OBJ", Class.forName("JTryObj"));
		ArrayDescriptor jTryObjArrayDesc = ArrayDescriptor.createDescriptor (
				"TRY_OBJ_TAB",
				conn
			);
		
		// create the Callable statement		
		OracleCallableStatement stat = (OracleCallableStatement) conn.prepareCall("select * from table(:tab)");
		
		// create an Oracle collection on client side to use as parameter
		ARRAY oracleCollection = new ARRAY(jTryObjArrayDesc,conn,javaArray);
		
		// bind the collection
		stat.setArrayAtName("tab", oracleCollection);
		
		// execute the statement and print results
		ResultSet rset = stat.executeQuery();
		while (rset.next()) {
			System.out.println(String.format("Row = %d %s",rset.getInt("FIELD_A"),rset.getString("FIELD_B")));
		}
	}
}

Row = 1 abc
Row = 2 dce