[hibernate-issues] [Hibernate-JIRA] Commented: (HHH-7139) java.sql.SQLException: Invalid argument in JDBC call: parameter index out of range when trying to persist an entity mapped with insertable = false, updatable = false on @Column
Karsten Wutzke (JIRA)
noreply at atlassian.com
Fri Mar 2 11:15:51 EST 2012
[ https://hibernate.onjira.com/browse/HHH-7139?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=45800#comment-45800 ]
Karsten Wutzke commented on HHH-7139:
-------------------------------------
I agree the JPA 2.0 style is much more intuitive, but this is not the point here (not an option in the context).
The point is, using the JPA 1.0 mappings, why read-only on @Column isn't working here, even though it has the @Id. I understand that @Id shouldn't be read-only, but since it's technically possible to specify read-only on @Column and @JoinColumn, why not support both ways? Since only one of the @Column or @JoinColumn may be writable to me it basically doesn't matter where to put this. And because these @Column fields are redundant my argument would have been to put the read-only there. Again, note that going for JPA 2.0 style (or oldschool, native Hibernate if you wish) isn't desired right now.
I probably don't have the in-depth sight that you have, so I'm going to give up.
I think my problems ultimately stem from another bug here https://hibernate.onjira.com/browse/HHH-6221, where I'm still left wondering where to put the read-onlys.
> java.sql.SQLException: Invalid argument in JDBC call: parameter index out of range when trying to persist an entity mapped with insertable = false, updatable = false on @Column
> --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
>
> Key: HHH-7139
> URL: https://hibernate.onjira.com/browse/HHH-7139
> Project: Hibernate ORM
> Issue Type: Bug
> Environment: Hibernate 4.0.0.CR4, HSQLDB 2.0, MySQL 5.1
> Reporter: Karsten Wutzke
> Attachments: hib-readonly-col.zip
>
>
> The following mappings are all JPA 1.0 compatible (no derived identifiers):
> {code:Company.java}
> @Entity
> @Table(name = "Companies")
> public class Company
> {
> @Id
> @Column
> private Integer id;
> @Column
> private String name;
> ...
> }
> {code}
> {code:PQ.java}
> @Entity
> @Table(name = "PQs")
> public class PQ implements Serializable
> {
> @Id
> @Column
> private Integer id;
> @Column
> private String name;
> ...
> }
> {code}
> {code:Partnership.java}
> @Entity
> @Table(name = "Partnerships")
> @IdClass(value = PartnershipId.class)
> public class Partnership implements Serializable
> {
> @Id
> @Column(name = "pq_id", insertable = false, updatable = false)
> private Integer pqId;
> @Id
> @Column(name = "company_id", insertable = false, updatable = false)
> private Integer companyId;
> @Column(name = "ordinal_nbr")
> private Integer ordinalNbr;
> @ManyToOne
> @JoinColumn(name = "pq_id", referencedColumnName = "id")
> private PQ pq;
> @ManyToOne
> @JoinColumn(name = "company_id", referencedColumnName = "id")
> private Company company;
> ...
> }
> {code}
> {code:PartnershipId.java}
> public class PartnershipId implements Serializable
> {
> private Integer pqId;
> private Integer companyId;
> public PartnershipId()
> {
> }
> public PartnershipId(Integer pqId, Integer companyId)
> {
> this.pqId = pqId;
> this.companyId = companyId;
> }
> ...
> }
> {code}
> Note, the insertable = false, updatable = false on @JoinColumn relationships.
> Running the following test code
> {code:Main.java}
> public class Main
> {
> private static String PERSISTENCE_UNIT_NAME = "standalonePu";
> private static EntityManagerFactory emf;
> private static EntityManager em;
> private static EntityTransaction trans;
> public static void main(String[] args)
> {
> setUp(PERSISTENCE_UNIT_NAME);
> trans.begin();
> PQ detachedPq = new PQ(1, "Test PQ");
> Company detachedCompany = new Company(1, "Test Company");
>
> PQ pq = em.merge(detachedPq);
> Company company = em.merge(detachedCompany);
>
> Partnership detachedPartnership = new Partnership(1, 1, 1);
> detachedPartnership.setPQ(pq);
> detachedPartnership.setCompany(company);
>
> Partnership partnership = em.merge(detachedPartnership);
>
> partnership = em.find(Partnership.class, new PartnershipId(1, 1));
>
> System.out.println("Persistent partnership = ("
> + partnership.getPQId() + ", "
> + partnership.getCompanyId() + ", "
> + partnership.getOrdinalNbr() + ")");
>
> trans.commit();
> close();
> }
> private static void setUp(String puName)
> {
> emf = Persistence.createEntityManagerFactory(puName);
> em = emf.createEntityManager();
> trans = em.getTransaction();
> }
> private static void close()
> {
> em.close();
> emf.close();
> }
> }
> {code}
> fails with a really strange exception:
> ERROR: Invalid argument in JDBC call: parameter index out of range: 4
> Exception in thread "main" javax.persistence.RollbackException: Error while committing the transaction
> at org.hibernate.ejb.TransactionImpl.commit(TransactionImpl.java:90)
> at main.Main.main(Main.java:44)
> Caused by: javax.persistence.PersistenceException: org.hibernate.exception.GenericJDBCException: Invalid argument in JDBC call: parameter index out of range: 4
> at org.hibernate.ejb.AbstractEntityManagerImpl.convert(AbstractEntityManagerImpl.java:1347)
> at org.hibernate.ejb.AbstractEntityManagerImpl.convert(AbstractEntityManagerImpl.java:1280)
> at org.hibernate.ejb.TransactionImpl.commit(TransactionImpl.java:78)
> ... 1 more
> Caused by: org.hibernate.exception.GenericJDBCException: Invalid argument in JDBC call: parameter index out of range: 4
> at org.hibernate.exception.internal.SQLStateConverter.handledNonSpecificException(SQLStateConverter.java:148)
> at org.hibernate.exception.internal.SQLStateConverter.convert(SQLStateConverter.java:136)
> at org.hibernate.engine.jdbc.spi.SqlExceptionHelper.convert(SqlExceptionHelper.java:124)
> at org.hibernate.engine.jdbc.spi.SqlExceptionHelper.convert(SqlExceptionHelper.java:109)
> at org.hibernate.engine.jdbc.internal.proxy.AbstractStatementProxyHandler.continueInvocation(AbstractStatementProxyHandler.java:131)
> at org.hibernate.engine.jdbc.internal.proxy.AbstractProxyHandler.invoke(AbstractProxyHandler.java:80)
> at $Proxy12.setInt(Unknown Source)
> at org.hibernate.type.descriptor.sql.IntegerTypeDescriptor$1.doBind(IntegerTypeDescriptor.java:57)
> at org.hibernate.type.descriptor.sql.BasicBinder.bind(BasicBinder.java:82)
> at org.hibernate.type.AbstractStandardBasicType.nullSafeSet(AbstractStandardBasicType.java:305)
> at org.hibernate.type.AbstractStandardBasicType.nullSafeSet(AbstractStandardBasicType.java:300)
> at org.hibernate.type.ComponentType.nullSafeSet(ComponentType.java:358)
> at org.hibernate.persister.entity.AbstractEntityPersister.dehydrate(AbstractEntityPersister.java:2599)
> at org.hibernate.persister.entity.AbstractEntityPersister.insert(AbstractEntityPersister.java:2836)
> at org.hibernate.persister.entity.AbstractEntityPersister.insert(AbstractEntityPersister.java:3276)
> at org.hibernate.action.internal.EntityInsertAction.execute(EntityInsertAction.java:80)
> at org.hibernate.engine.spi.ActionQueue.execute(ActionQueue.java:273)
> at org.hibernate.engine.spi.ActionQueue.executeActions(ActionQueue.java:265)
> at org.hibernate.engine.spi.ActionQueue.executeActions(ActionQueue.java:186)
> at org.hibernate.event.internal.AbstractFlushingEventListener.performExecutions(AbstractFlushingEventListener.java:344)
> at org.hibernate.event.internal.DefaultFlushEventListener.onFlush(DefaultFlushEventListener.java:50)
> at org.hibernate.internal.SessionImpl.flush(SessionImpl.java:1084)
> at org.hibernate.internal.SessionImpl.managedFlush(SessionImpl.java:319)
> at org.hibernate.engine.transaction.internal.jdbc.JdbcTransaction.beforeTransactionCommit(JdbcTransaction.java:100)
> at org.hibernate.engine.transaction.spi.AbstractTransactionImpl.commit(AbstractTransactionImpl.java:173)
> at org.hibernate.ejb.TransactionImpl.commit(TransactionImpl.java:73)
> ... 1 more
> Caused by: java.sql.SQLException: Invalid argument in JDBC call: parameter index out of range: 4
> at org.hsqldb.jdbc.Util.sqlException(Unknown Source)
> at org.hsqldb.jdbc.Util.sqlException(Unknown Source)
> at org.hsqldb.jdbc.Util.sqlException(Unknown Source)
> at org.hsqldb.jdbc.Util.outOfRangeArgument(Unknown Source)
> at org.hsqldb.jdbc.JDBCPreparedStatement.checkSetParameterIndex(Unknown Source)
> at org.hsqldb.jdbc.JDBCPreparedStatement.setInt(Unknown Source)
> at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
> at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
> at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
> at java.lang.reflect.Method.invoke(Method.java:601)
> at org.hibernate.engine.jdbc.internal.proxy.AbstractStatementProxyHandler.continueInvocation(AbstractStatementProxyHandler.java:124)
> ... 22 more
> Caused by: org.hsqldb.HsqlException: Invalid argument in JDBC call: parameter index out of range: 4
> at org.hsqldb.error.Error.error(Unknown Source)
> ... 31 more
>
> I've also tested this with MySQL with the same JDBC exception.
> Note the workaround to resolve this is to put `..., insertable = false, updatable = false` onto the relationships' `@JoinColumn`s (but it's not really what I want).
> Please fix.
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
More information about the hibernate-issues
mailing list