[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
Steve Ebersole (JIRA)
noreply at atlassian.com
Fri Mar 2 11:00:49 EST 2012
[ https://hibernate.onjira.com/browse/HHH-7139?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=45798#comment-45798 ]
Steve Ebersole commented on HHH-7139:
-------------------------------------
I totally agree we ought to "step back" here. The first thing I always like to step back to is: "does this make sense?". And IMO this does not make sense. Why is it you think it makes any sense to insert a primary key value through something other than the id mapping?
And I don't think its "just another barrier". If I define something as @Id (explicitly a mapping of a primary key value) I fully expect those things values to be inserted during creation. That JustMakesSense. This mapping you are trying to do, on the other hand, is completely counter-intuitive IMO.
And yes, lets "put aside any JPA 2.0". How is this:
{code:borderStyle=solid}
@Id
@ManyToOne
@JoinColumn(name = "pq_id", referencedColumnName = "id")
private PQ pq;
@Id
@ManyToOne
@JoinColumn(name = "company_id", referencedColumnName = "id")
private Company company;
{code}
simply not (1) more simple, (2) more elegant and (3) more intuative? Again, that is something Hibernate has supported WAY before even JPA 1. So dismissing it as "JPA 2.0 black magic" does not hold water.
Short story is that we can go around and around about this all day long. But I am not going to add support for this. I think its wrong and counter-intuitive.
> 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