HibernateTemplate::find conflict with POJO by Hibernate RE

MyEclipse Archived

Database Tools (DB Explorer, Hibernate, etc.)

This topic has 1 reply, 1 voice, and was last updated 13 years, 7 months ago by hoteagle.

Viewing 2 posts - 1 through 2 (of 2 total)

Author

Posts
April 14, 2011 at 2:09 am #316029 Reply
hoteagle
Member
“Hibernate RE” in the title means Hibernate Reverse Engineer.
I just build a small demo to test the Hibernate Reverse Engineer’s results. I mostly follows the steps in the tutorial for “Hibernate & Spring” at http://www.myeclipseide.com/documentation/quickstarts/hibernateandspring/.
I changed the sample a little with two tables contains foreign key.
I find errors during just a simple queryByName search based on the generated DAO&POJO. It seems like getHibernateTemplate().find cannot correctly return a List<Entity> where Entity is a POJO generated by Hibernate Reverse Engineer.
Since Foreign key constrain is very common in DB and this might be a critical problem for Hibernate Reverse Engineering if my usage is not wrong.

I bought the MyEclipse for Spring and using version 8.6 and 9.0 both on MAC os 10.6.7. I use Hibernate 3.3 and Spring 3.0 in the project below. DB used MySql (version > 5.0). No annotation used.

The detailed descriptions:

The difference is that I create two tables with a simple foreign key constrain. In the following two tables, the entity contains a ‘Type’ which is mapped as many-to-one to “etype” in table codeentitytype
```
DROP TABLE IF EXISTS `codeentitytype`;
CREATE TABLE `codeentitytype` (
  `code` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT '',
  `etype` varchar(255) NOT NULL DEFAULT '',
  PRIMARY KEY (`code`),
  UNIQUE KEY `etype` (`etype`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=latin1;

DROP TABLE IF EXISTS `entity`;
CREATE TABLE `entity` (
  `EntityID` int(11) NOT NULL AUTO_INCREMENT,
  `Name` varchar(200) DEFAULT NULL,
  `Type` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`EntityID`),
  KEY `Name` (`Name`),
  KEY `Type` (`Type`),
  CONSTRAINT `entity_ibfk_1` FOREIGN KEY (`Type`) REFERENCES `codeentitytype` (`etype`) ON DELETE NO ACTION ON UPDATE CASCADE
  ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=latin1;
```
Then I write a simple query.
```
// BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
        ApplicationContext ctx = new ClassPathXmlApplicationContext ("applicationContext.xml");
        Persistence persistenceLayer = (Persistence) ctx.getBean("persistence");
                 List<Entity> entLst = persistenceLayer.findEntityByName("dna1");
        ListIterator<Entity> iter = entLst.listIterator();
        while(iter.hasNext()){
            Entity ent = iter.next();
            Integer id = ent.getEntityId();
            System.out.println("Find entity with name as " + name + " with id = " + id);
        }
```
Then it comes with the following errors. It seems query is done but error happens during translate the rows obtained back to POJO Class like “Entity”. The Entity class generated by Hibernate reverse engineer contains a property like “private Codeentitytype codeentitytype;” but not “String Type“, which is due to the foreign key definition.
I guess the error might due to some mismatch between the returned String like ‘DNA’ in the row found by getHibernateTemplate().find and the properties in Entity as Codeentitytype codeentitytype. Note that the first property in Class Codeentitytype is “Integer code”, which is int type.
In order to prove my guess, I faked the table a little to change the “Integer code” property to be as “String code” which is no more as “int” type. The changed table is like:
```
DROP TABLE IF EXISTS `codeentitytype`;
CREATE TABLE `codeentitytype` (
  `code` varchar(255) NOT NULL,
  `name` varchar(255) DEFAULT '',
  `etype` varchar(255) NOT NULL DEFAULT '',
  PRIMARY KEY (`code`),
  UNIQUE KEY `etype` (`etype`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=latin1;

DROP TABLE IF EXISTS `entity`;
CREATE TABLE `entity` (
  `EntityID` int(11) NOT NULL AUTO_INCREMENT,
  `Name` varchar(200) DEFAULT NULL,
  `Type` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`EntityID`),
  KEY `Name` (`Name`),
  KEY `Type` (`Type`),
  CONSTRAINT `entity_ibfk_1` FOREIGN KEY (`Type`) REFERENCES `codeentitytype` (`etype`) ON DELETE NO ACTION ON UPDATE CASCADE
  ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=latin1;
```
Then the original simple query codes will pass with correct result (one entity id is found and printed). However, it doesn’t mean the problem is gone. Just try to print more about the Codeentitytype type and it will report error again.
```
        List<Entity> entLst = persistenceLayer.findEntityByName(name);
        ListIterator<Entity> iter = entLst.listIterator();
        while(iter.hasNext()){
            Entity ent = iter.next();
            Integer id = ent.getEntityId();
            Codeentitytype type = ent.getCodeentitytype();
            System.out.println("Find entity with name as " + name + " with id = " + id + " type = " + type.getEtype() );
        }
```
The error below shows that it might try to use the String “DNA” found within the return row to match with the “Codeentitytype” but failed.
Please help me on this issue. I have lots of table with some foreign keys defined and wish to depend on Hibernate’s Reverse Engineering ability to manage it.[/list]

BTW, I also tried with tables w/o foreign key and the whole story above works well. So the errors are most possibly caused by foreign key.
April 14, 2011 at 2:15 am #316031 Reply

hoteagle
Member

this poster is wrongly repeatedly posted. Please help to delete it!
Author

Posts

Viewing 2 posts - 1 through 2 (of 2 total)