Application Note for OpenAccess

Transcription

1 Please contact OpenAccess Sales Application Note for OpenAccess Subject: Using OpenAccess SDK With Java Date: March 2002 Markets: Java Developers Overview Requirements are to be able to expose data stored and or managed by Java environment through ODBC, JDBC, OLE DB, or.net compliant interface. This will allow end users to use standard APIs from Java, UNIX, or Windows applications to access this data. For example, objects stored in the Java environment can be exposed to Microsoft Excel or Crystal Reports. For this application note assume we have a Java application server that implements a data store consisting of a single table with some columns. We want to be able to use ODBC to get this information into Windows applications like Crystal Reports. Assume that Java Application server is running on a Windows NT Server and we want to implement a client/server solution. Java Virtual Machine Crystal Reports O D B C Network JAVA Data Solution Figure 1: ODBC Access to Java Data OpenAccess SDK can be used to implement ODBC, OLE DB, JDBC, or.net compliant access to Java data sources. OpenAccess SDK is written in C but it can work with Java environment using. To facilitate the development of ODBC, OLE DB and JDBC drivers to data sources developed using Java, we supply a layer of code that hides the Java programmer from any C to Java integration issues. The IP developer just implements a class that supports the IP oajava.sql.ip interface. This class uses the JDAM Java class to interface to the DAM. This architecture allows the Java programmer to use the same features they could from C or C++ developed IP.

2 OpenRDA Driver (ODBC, JDBC, OLE DB,.NET) OpenAccess API and C/S Layers TCP/IP JVM Running Your Java App OpenRDA Shared Library (DLL or SO) OpenAccess provides the client/server communications, query parsing and the query processing. SQL Engine (DAM) IP Proxy DAM Proxy Java IP supplied by ATI to facilitate the Java to C interface. IP Proxy routes all IP API calls to the Java Class. The DAM Proxy exposes the DAM to the JDAM Java class the IP class will use. IP Class Your Data JDAM Custom code you write to implement the IP interface to access your data. Figure 2: Client/Server Configuration JVM Loads OpenAccess We support two approaches for the client/server configuration: 1) Embed the OpenAccess server code within the Java application (Figure 2) this way OpenAccess and your data reside in the same JVM process. 2) Have OpenAccess server code load the JVM into this process space at run-time (Figure 3) in this configuration if the data resides in an external file store then Java objects within this JVM can access it. If the data resides in a Java application server then RMI must be used. OpenRDA Driver (ODBC, JDBC, OLE DB,.NET) OpenAccess API and C/S Layers TCP/IP OpenRDA Server for Java SQL Engine (DAM) OpenAccess provides the client/server communications, query parsing and the query processing. IP Proxy DAM Proxy Java Virtual Machine Java IP supplied by ATI to facilitate the Java to C interface. IP Proxy routes all IP API calls to the Java Class. The DAM Proxy exposes the DAM to the JDAM Java class the IP class will use. IP Class JDAM Custom code you write to implement the IP interface to access your data. Your Data Figure 3: Client/Server Configuration OpenAccess Loads JVM 2

3 Approach (1) makes use of OpenAccess s ability to be embedded in a process. This is achieved by building a shared library (DLL on Windows and shared library on Unix) that will contain the OpenRDA Server code, the SQL engine, and the Java IP code and executing it on a thread created by the Java application. The advantage of this approach is that all the processing is done within the same process. The disadvantage is that you are running native code that will generate threads and perform other processing within the JVM process. You must weigh the benefits of speed vs. the possibility of the JVM being affected by errors during ODBC access. In approach (2) the OpenAccess components are compiled into a server process. This server process at run-time loads the JVM and uses it to execute the Java class you register for your IP. If your IP code needs to access Java objects in another JVM then it must use RMI or some other interprocess communications mechanism. The architecture of a local ODBC driver for Java is shown in Figure 4. The OpenRDA ODBC driver for Java is a shrink wrapped component supplied as a DLL. It implements the ODBC API and contains the SQL engine. At run-time it loads the JVM and the class your registered with the OpenRDA administrator for implementing the IP interface. OpenRDA ODBC Driver for Java ODBC API SQL Engine (DAM) Provides the ODBC API processing Query parsing and the query execution. IP Proxy DAM Proxy Java Virtual Machine IP Class JDAM Java IP supplied by ATI to facilitate the Java to C interface. IP Proxy routes all IP API calls to the Java Class. The DAM Proxy exposes the DAM to the JDAM Java class the IP class will use. Custom code you write to implement the IP interface to access your data. Your Data Figure 4: Local ODBC Driver Configuration Conclusion This application note covered how the OpenAccess SDK can be used to implement an ODBC, JDBC, OLE DB, or a.net driver by writing the Interface Provider in Java. Please contact OpenAccess Software at support@openaccesssoftware.com to obtain the Java edition of the OpenAccess SDK. The Java code for Example1 IP is included at the end of this application note. 3

4 Sample Code Below is the IP code in Java that accesses the MDB Java class to walk through the records and for each record obtain the column values. This example implements a class example1 that supports the oajava.sql.ip interface. /* example1.java * * (c) OpenAccess Software, Inc. * * Programer(s): * * * Description: This example IP * - is implemented in "JAVA" * - supports static schema * - supports single column indexe on column NAME * - supports SELECT operations */ package oajava.ip; import java.util.date; import java.util.calendar; import oajava.sql.*; /* define the class Example1 to implement the sample IP */ public class example1 implements oajava.sql.ip private int m_tmhandle = 0; private int m_inumresrows; private StringBuffer stablename; /* Name of the table being queried (char [DAM_MAX_ID_LEN+1] )*/ private static mdb m_pmdb = null; /* index information */ private StringBuffer sindexname; /* char [DAM_MAX_ID_LEN+1] */ private xo_int hindex; /* DAM_HINDEX */ private xo_int hset_of_condlist; /* DAM_HSET_OF_CONDLIST */ /* column handles */ private int hcolname, hcolintval, hcoldoubleval, hcoltime; /* DAM_HCOL */ public example1() m_tmhandle = 0; m_inumresrows = 0; stablename = new StringBuffer(ip.DAM_MAX_ID_LEN + 1); sindexname = new StringBuffer(ip.DAM_MAX_ID_LEN + 1); hcolname = 0; hcolintval = 0; hcoldoubleval = 0; hcoltime = 0; hindex= new xo_int(0); hset_of_condlist = new xo_int(0); /*create one instance of the mdb object */ if(m_pmdb == null) m_pmdb = new mdb(); public String ipgetinfo(int iinfotype) String str = ""; switch (iinfotype) case IP_INFO_QUALIFIER_NAME: str = "SCHEMA"; case IP_INFO_FILTER_VIEWS_WITH_QUALIFIER_NAME: str = "0"; /* false */ break; 4

5 return str; /* this version does not use this method */ public int ipgetsupport(int isupporttype) return(0); /*ipconnect is called immediately after an instance of this object is created. You should *perform any tasks related to connecting to your data source */ public int ipconnect(int tmhandle,int dam_hdbc,string sdbname, String susername, String spassword) /* Save the trace handle */ m_tmhandle = tmhandle; jdam.tm_trace(m_tmhandle, UL_TM_F_TRACE,"ipConnect called\n"); /* Code to connect to your data source source. for our sample MDB database no need to connect */ public int ipdisconnect(int dam_hdbc) /* disconnect from the data source */ jdam.tm_trace(m_tmhandle, UL_TM_F_TRACE,"ipDisonnect called\n"); public int ipstarttransaction(int dam_hdbc) /* start a new transaction */ jdam.tm_trace(m_tmhandle, UL_TM_F_TRACE,"ipStartTransaction called\n"); public int ipendtransaction(int dam_hdbc,int itype) /* end the transaction */ jdam.tm_trace(m_tmhandle, UL_TM_F_TRACE,"ipEndTransaction called\n"); if (itype == DAM_COMMIT) else if (itype == DAM_ROLLBACK) public int ipexecute(int dam_hstmt, int istmttype, int hsearchcol,xo_int pinumresrows) int iretcode; jdam.tm_trace(m_tmhandle, UL_TM_F_TRACE,"ipExecute called\n"); /* get the table information */ jdam.dam_describetable(dam_hstmt, null, null, stablename,null, null); /* get the column handles */ hcolname = jdam.dam_getcol(dam_hstmt,"name"); hcolintval = jdam.dam_getcol(dam_hstmt,"intval"); hcoldoubleval = jdam.dam_getcol(dam_hstmt,"floatval"); hcoltime = jdam.dam_getcol(dam_hstmt,"time"); /* initialize the result */ m_inumresrows = 0; /* process the query based on the type */ if (istmttype == DAM_SELECT) /* get the index information and process the query*/ iretcode = jdam.dam_getoptimalindexandconditions(dam_hstmt, hindex, hset_of_condlist); if (iretcode!= DAM_SUCCESS) return IP_FAILURE; /* return on error */ /* use index information for optimized query processing - cases where NAME='Joe' type of conditions appear in the query*/ if(hindex.getval() > 0) jdam.tm_trace(m_tmhandle, UL_TM_MAJOR_EV,"Using optimized processing\n"); 5

6 */ jdam.dam_describeindex(hindex.getval(), null, sindexname, null, null, null); iretcode = java_optimize_exec(dam_hstmt, hindex, hset_of_condlist,istmttype,pinumresrows); jdam.dam_freesetofconditionlist(hset_of_condlist.getval()); /* free the set of condition list if (iretcode!= IP_SUCCESS) /* check for errors */ return IP_FAILURE; else /* non-optimized query processing -- cases where no WHERE clause or conditions on columns otther than NAME. */ jdam.tm_trace(m_tmhandle, UL_TM_MAJOR_EV,"Doing a full table scan\n"); iretcode = java_exec(dam_hstmt,istmttype,pinumresrows); if (iretcode!= IP_SUCCESS) return iretcode; else return IP_FAILURE; /* this example uses static schema so this function is not called */ public int ipschema(int dam_hdbc,int itype, int plist, int psearchobj) return 0; // Utility functions int java_optimize_exec(int dam_hstmt, xo_int hindex, xo_int hset_of_condlist,int istmttype, xo_int pinumresrows) int hcur_condlist; /* DAM_HCONDLIST */ int hcond; /* DAM_HCOND */ int hrow; /* DAM_HROW */ int iretcode; m_inumresrows = 0; pinumresrows.setval(0); /* get the conditions on index columns */ hcur_condlist = jdam.dam_getfirstcondlist(hset_of_condlist.getval()); while (hcur_condlist!= 0) xo_int ileftop = new xo_int(0); xo_int ileftvaltype = new xo_int(0); String pleftdata; int imdbindex; xo_int irc = new xo_int(dam_success); /* Each condition list will have only one condition, since its a single column index */ hcond = jdam.dam_getfirstcond(dam_hstmt, hcur_condlist); /* get details of the condition. since this example does not support BETWEEN, we do not need to get the values for RIGHT part of condition */ iretcode = jdam.dam_describecond(hcond, ileftop,ileftvaltype, null, null); if (iretcode!= DAM_SUCCESS) return IP_FAILURE; /* return on error */ pleftdata = (String) jdam.dam_getcondval(hcond); /* build result rows that match current index condition */ imdbindex = m_pmdb.finditembyname(pleftdata); if (imdbindex > 0) /* found a match */ String sname; int iintval; double ddoubleval; long ltime; /* read row from the memory database */ m_pmdb.readrow(imdbindex - 1); /* Get the field values from the Row */ sname = m_pmdb.getname(); iintval = m_pmdb.getintval(); ddoubleval = m_pmdb.getdval(); ltime = m_pmdb.gettime(); /* build the DAM row with the values read from memory database */ 6

7 hrow = java_build_row(dam_hstmt, sname, iintval, ddoubleval, ltime); if (hrow == 0) return IP_FAILURE; /* return on error */ /* process the row */ iretcode = java_process_row(dam_hstmt, istmttype,hrow); if (iretcode!= IP_SUCCESS) return iretcode; /* return on error */ hcur_condlist = jdam.dam_getnextcondlist(hset_of_condlist.getval()); pinumresrows.setval(m_inumresrows); /* this function is called to do a full table scan */ public int java_exec(int dam_hstmt, int istmttype, xo_int pinumresrows) int hrow; /* DAM_HROW */ int iretcode; int iintval; double ddoubleval; long ltime; boolean bfound = false; String sname; m_inumresrows = 0; pinumresrows.setval(0); /* read row from the memory database */ bfound = m_pmdb.firstrow(); while (bfound) /* Get the Row */ sname = m_pmdb.getname(); iintval = m_pmdb.getintval(); ddoubleval = m_pmdb.getdval(); ltime = m_pmdb.gettime(); /* build the DAM row with the values read from memory database */ hrow = java_build_row(dam_hstmt, sname, iintval, ddoubleval, ltime); if (hrow == 0) return IP_FAILURE; /* return on error */ /* process the row */ iretcode = java_process_row(dam_hstmt, istmttype,hrow); if (iretcode!= IP_SUCCESS) return iretcode; /* return on error */ /* read next row from the memory database */ bfound = m_pmdb.nextrow(); pinumresrows.setval(m_inumresrows); /* given the raw values, build a DAM ROW structure */ public int java_build_row(int dam_hstmt, String sname, int iintval, double ddoubleval, long ltime) int hrow = 0; int iretcode; xo_tm xotime; /* allocate a new row */ hrow = jdam.dam_allocrow(dam_hstmt); /* change the column values to data types accepted by DAM*/ xotime = java_cvrt_time_to_xotm(ltime); if(xotime == null) return 0; /* set values for columns of the row */ iretcode = jdam.dam_addcharvaltorow(dam_hstmt, hrow, hcolname,sname,xo_nts); if (iretcode!= DAM_SUCCESS) return 0; iretcode = jdam.dam_addintvaltorow(dam_hstmt, hrow, hcolintval, iintval,0); if (iretcode!= DAM_SUCCESS) return 0; iretcode = jdam.dam_adddoublevaltorow(dam_hstmt, hrow, hcoldoubleval,ddoubleval,0); if (iretcode!= DAM_SUCCESS) return 0; iretcode = jdam.dam_addtimestampvaltorow(dam_hstmt, hrow, hcoltime,xotime,0); if (iretcode!= DAM_SUCCESS) return 0; return hrow; int java_process_row(int dam_hstmt, int istmttype,int hrow) switch (istmttype) 7

8 case DAM_SELECT: if (jdam.dam_istargetrow(dam_hstmt, hrow) == DAM_TRUE) jdam.dam_addrowtotable(dam_hstmt, hrow); m_inumresrows++; else jdam.dam_freerow(hrow); break; default: break; xo_tm java_cvrt_time_to_xotm(long ltime) Date dt = new Date(lTime * 1000); Calendar ptm = Calendar.getInstance(); xo_tm pxotm = new xo_tm(); if(pxotm == null ptm == null dt == null) return null; ptm.settime(dt); /* copy the local time to xo_tm variable */ pxotm.setval(xo_tm.second,ptm.get(calendar.second)); pxotm.setval(xo_tm.minute,ptm.get(calendar.minute)); pxotm.setval(xo_tm.hour,ptm.get(calendar.hour_of_day)); pxotm.setval(xo_tm.day_of_month,ptm.get(calendar.day_of_month)); pxotm.setval(xo_tm.month,ptm.get(calendar.month)); pxotm.setval(xo_tm.year,ptm.get(calendar.year)); pxotm.setval(xo_tm.day_of_week,ptm.get(calendar.day_of_week)); pxotm.setval(xo_tm.day_of_year,ptm.get(calendar.day_of_year)); if(calendar.dst_offset > 0) pxotm.setval(xo_tm.is_dst,1); else pxotm.setval(xo_tm.is_dst,0); pxotm.setval(xo_tm.fraction,ptm.get(calendar.millisecond) * ); return pxotm; 8