Vo.findByKey(..) BUG

Question

Why can the newly added row not be found but the allready existing ?????
Using the HR user on a 9.2.0.1.0 db with jdev 9.0.3.1035
The example assumes you've created:
1. A package named mypackage3
2. A Departments entity object
3. A DepartmentsView view object with its attributes referencing the Department entity object and the attribute DepartmentName set as Key Attribute in View Object Wizard
4. An application module named Mypackage3Module which references an instance of DepartmentsView
The output should be:
--- found the existing row by 1st key
--- the keys of the row are: oracle.jbo.Key[200 Operations ]
DepartmentId = 200
DepartmentName = Operations
--- found the existing row by 2nd key
--- the keys of the row are: oracle.jbo.Key[200 Operations ]
DepartmentId = 200
DepartmentName = Operations
--- found the newly inserted row by 1st key
--- the keys of the row are: oracle.jbo.Key[4444 AName ]
DepartmentId = 4444
DepartmentName = AName
--- did not find the newly inserted row by 2nd key
Here is the code:
package mypackage3;
import java.util.*;
import javax.naming.*;
import oracle.jbo.*;
import oracle.jbo.domain.Number;
public class FindByKeyClient {
public static void main(String s[]) {
ApplicationModule am = FindByKeyClient.create("mypackage3.Mypackage3Module","jdbc:oracle:thin:hr/[email protected]:1521:HGDB02");
ViewObject departmentsVO = am.findViewObject("DepartmentsView");
//create new row and add to vo
Row newRow = departmentsVO.createRow();
newRow.setAttribute("DepartmentId",new Number(4444));
newRow.setAttribute("DepartmentName","AName");
departmentsVO.insertRow(newRow);
Object[] keyVals;
Row[] result;
// find a existing row
//try to find a row that is not newly inserted by 1st key
keyVals = new Object[1];
keyVals[0] = new Number(200);
result = departmentsVO.findByKey(new Key(keyVals), -1);
FindByKeyClient.showInfo(result, "the existing row by 1st key");
//try to find a row that is not newly inserted by 2nd key
keyVals = new Object[2];
keyVals[1] = "Operations";
result = departmentsVO.findByKey(new Key(keyVals), -1);
FindByKeyClient.showInfo(result, "the existing row by 2nd key");
// do the same but with a new row
//try to find newly inserted row by 1st key
keyVals = new Object[1];
keyVals[0] = new Number(4444);
result = departmentsVO.findByKey(new Key(keyVals), -1);
FindByKeyClient.showInfo(result, "the newly inserted row by 1st key");
//try to find newly inserted row by 2nd
keyVals = new Object[2];
keyVals[1] = "AName";
result = departmentsVO.findByKey(new Key(keyVals), -1);
FindByKeyClient.showInfo(result, "the newly inserted row by 2nd key");
private static void showInfo(Row[] result, String infoTxt) {
if(result.length > 0) {
System.out.println("--- found "+infoTxt);
System.out.println("--- the keys of the row are: "+result[0].getKey());
System.out.println("DepartmentId = "+ result[0].getAttribute("DepartmentId"));
System.out.println("DepartmentName = "+ result[0].getAttribute("DepartmentName")+"\n");
} else {
System.out.println("--- did not find "+infoTxt);
public static ApplicationModule create(String amDefName, String jdbcConnStr) throws ApplicationModuleCreateException {
ApplicationModule am = null;
try {
Hashtable env = new Hashtable(2);
env.put(Context.INITIAL_CONTEXT_FACTORY, JboContext.JBO_CONTEXT_FACTORY);
env.put(JboContext.DEPLOY_PLATFORM, JboContext.PLATFORM_LOCAL);
Context ic = new InitialContext(env);
am = ((ApplicationModuleHome)ic.lookup(amDefName)).create();
am.getTransaction().connect(jdbcConnStr);
} catch (javax.naming.NamingException nex) {
throw new ApplicationModuleCreateException(nex);
return am;
}

Answer 1

Sven:
For proper operation of findByKey, the PK of the VO should be a composition of the PKs of the EO(s) that make up the VO. In other words, if a VO is made up of EO1 and EO2, its PK should be (EO1's PK + EO2's PK).
In your case, it seems the VO's PK does not match the EO's PK (VO's PK has an extra attr, DepartmentsName). That is causing the incorrect behavior.
When you issue findByKey, we decompose the incoming key into EO keys. In the above example, where the VO is made up of EO1 and EO2, the key is decomposed into key for EO1 and key for EO2.
Then, we use EO1's key (if it is not null) to look into the entity cache to find the row. This action will find new rows as well as old. If not enough rows are found through this, we go out to database, issuing a SQL statement.
Thus, I would try your test where the VO's PK matches EO's PK. Then,you should see the expected results.
Thanks.
Sung