Changeset 7364


Ignore:
Timestamp:
May 17, 2017, 8:54:44 AM (5 years ago)
Author:
Nicklas Nordborg
Message:

References #2084: Upgrade to Hibernate 5.2

Updated SessionWrapper and StatelessSessionWrapper with new API methods. 26 error and 1328 warnings remaining.

Location:
branches/hibernate-5.2/src/core/net/sf/basedb/core/hibernate
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • branches/hibernate-5.2/src/core/net/sf/basedb/core/hibernate/AbstractQueryCache.java

    r5358 r7364  
    2525import java.util.Map;
    2626
    27 import org.hibernate.Query;
     27import org.hibernate.query.Query;
    2828
    2929/**
     
    3737{
    3838
    39   private final Map<String, Query> cache;
     39  private final Map<String, Query<?>> cache;
    4040 
    4141  protected AbstractQueryCache()
    4242  {
    43     this.cache = new HashMap<String, Query>();
     43    this.cache = new HashMap<String, Query<?>>();
    4444  }
    4545 
     
    4949    @return A cached query or null if the query is not cached
    5050  */
    51   protected Query getCachedQuery(String key)
     51  protected Query<?> getCachedQuery(String key)
    5252  {
    5353    return cache.get(key);
     54  }
     55 
     56  /**
     57    @since 3.11
     58  */
     59  @SuppressWarnings("unchecked")
     60  protected <T> Query<T> getCachedQuery(String key, Class<T> resultType)
     61  {
     62    return (Query<T>)cache.get(key);
    5463  }
    5564 
     
    5968    @param query The query to cache
    6069  */
    61   protected void cacheQuery(String key, Query query)
     70  protected void cacheQuery(String key, Query<?> query)
    6271  {
    6372    cache.put(key, query);
  • branches/hibernate-5.2/src/core/net/sf/basedb/core/hibernate/SessionWrapper.java

    r7156 r7364  
    2424import java.io.Serializable;
    2525import java.sql.Connection;
     26import java.util.List;
     27import java.util.Map;
     28
     29import javax.persistence.EntityGraph;
     30import javax.persistence.EntityManagerFactory;
     31import javax.persistence.FlushModeType;
     32import javax.persistence.LockModeType;
     33import javax.persistence.StoredProcedureQuery;
     34import javax.persistence.criteria.CriteriaBuilder;
     35import javax.persistence.criteria.CriteriaDelete;
     36import javax.persistence.criteria.CriteriaQuery;
     37import javax.persistence.criteria.CriteriaUpdate;
     38import javax.persistence.metamodel.Metamodel;
    2639
    2740import org.hibernate.CacheMode;
     
    3447import org.hibernate.LockMode;
    3548import org.hibernate.LockOptions;
     49import org.hibernate.MultiIdentifierLoadAccess;
    3650import org.hibernate.NaturalIdLoadAccess;
    37 import org.hibernate.Query;
    3851import org.hibernate.ReplicationMode;
    39 import org.hibernate.SQLQuery;
    4052import org.hibernate.Session;
    4153import org.hibernate.SessionEventListener;
     
    4961import org.hibernate.jdbc.Work;
    5062import org.hibernate.procedure.ProcedureCall;
     63import org.hibernate.query.Query;
     64import org.hibernate.query.NativeQuery;
    5165import org.hibernate.stat.SessionStatistics;
    5266
     
    130144  @SuppressWarnings("rawtypes")
    131145  @Override
     146  @Deprecated
    132147  public Criteria createCriteria(Class persistentClass, String alias)
    133148  {
     
    137152  @SuppressWarnings("rawtypes")
    138153  @Override
     154  @Deprecated
    139155  public Criteria createCriteria(Class persistentClass)
    140156  {
     
    143159
    144160  @Override
     161  @Deprecated
    145162  public Criteria createCriteria(String entityName, String alias)
    146163  {
     
    149166
    150167  @Override
     168  @Deprecated
    151169  public Criteria createCriteria(String entityName)
    152170  {
     
    155173
    156174  @Override
    157   public Query createFilter(Object collection, String queryString)
     175  public Query<?> createFilter(Object collection, String queryString)
    158176    throws HibernateException
    159177  {
     
    167185  */
    168186  @Override
    169   public Query createQuery(String queryString)
    170     throws HibernateException
    171   {
    172     Query q = getCachedQuery(queryString);
     187  public Query<?> createQuery(String queryString)
     188    throws HibernateException
     189  {
     190    Query<?> q = getCachedQuery(queryString);
    173191    if (q == null)
    174192    {
     
    186204  */
    187205  @Override
    188   public SQLQuery createSQLQuery(String queryString)
    189     throws HibernateException
    190   {
    191     Query q = getCachedQuery(queryString);
    192     if (q == null || !(q instanceof SQLQuery))
     206  @Deprecated
     207  public NativeQuery<?> createSQLQuery(String queryString)
     208    throws HibernateException
     209  {
     210    Query<?> q = getCachedQuery(queryString);
     211    if (q == null || !(q instanceof NativeQuery))
    193212    {
    194213      q = session.createSQLQuery(queryString);
    195214      q.setFetchSize(HibernateUtil.getJdbcFetchSize());
     215      cacheQuery(queryString, q);
    196216    }
    197     return (SQLQuery)q;
     217    return (NativeQuery<?>)q;
    198218  }
    199219
     
    336356
    337357  @Override
    338   public FlushMode getFlushMode()
     358  public FlushModeType getFlushMode()
    339359  {
    340360    return session.getFlushMode();
     
    360380  */
    361381  @Override
    362   public Query getNamedQuery(String queryName)
    363     throws HibernateException
    364   {
    365     Query q = getCachedQuery(queryName);
     382  public Query<?> getNamedQuery(String queryName)
     383    throws HibernateException
     384  {
     385    Query<?> q = getCachedQuery(queryName);
    366386    if (q == null)
    367387    {
     
    611631
    612632  @Override
     633  @Deprecated
    613634  public void setFlushMode(FlushMode flushMode)
    614635  {
     
    668689
    669690  @Override
    670   public SharedSessionBuilder sessionWithOptions()
     691  public SharedSessionBuilder<?> sessionWithOptions()
    671692  {
    672693    return session.sessionWithOptions();
     
    739760  }
    740761
     762  @Override
     763  public Integer getJdbcBatchSize()
     764  {
     765    return session.getJdbcBatchSize();
     766  }
     767
     768  @Override
     769  public void setJdbcBatchSize(Integer size)
     770  {
     771    session.setJdbcBatchSize(size);
     772  }
     773
     774  @Override
     775  public <T> MultiIdentifierLoadAccess<T> byMultipleIds(Class<T> entityClass)
     776  {
     777    return session.byMultipleIds(entityClass);
     778  }
     779
     780  @Override
     781  public MultiIdentifierLoadAccess<?> byMultipleIds(String entityName)
     782  {
     783    return session.byMultipleIds(entityName);
     784  }
     785
     786  @Override
     787  public boolean contains(String entityName, Object entity)
     788  {
     789    return session.contains(entityName, entity);
     790  }
     791
     792  @Override
     793  public <T> Query<T> createNamedQuery(String name, Class<T> resultType)
     794  {
     795    Query<T> q = getCachedQuery(name, resultType);
     796    if (q == null)
     797    {
     798      q = session.createNamedQuery(name, resultType);
     799      cacheQuery(name, q);
     800    }
     801    return q;
     802  }
     803
     804  @SuppressWarnings("rawtypes")
     805  @Override
     806  public Query<?> createQuery(CriteriaDelete criteria)
     807  {
     808    return session.createQuery(criteria);
     809  }
     810
     811  @Override
     812  public <T> Query<T> createQuery(CriteriaQuery<T> criteria)
     813  {
     814    return session.createQuery(criteria);
     815  }
     816
     817  @SuppressWarnings("rawtypes")
     818  @Override
     819  public Query<?> createQuery(CriteriaUpdate criteria)
     820  {
     821    return session.createQuery(criteria);
     822  }
     823
     824  @Override
     825  public <T> Query<T> createQuery(String queryString, Class<T> resultType)
     826  {
     827    Query<T> q = getCachedQuery(queryString, resultType);
     828    if (q == null)
     829    {
     830      q = session.createQuery(queryString, resultType);
     831      q.setFetchSize(HibernateUtil.getJdbcFetchSize());
     832      cacheQuery(queryString, q);
     833    }
     834    return q;
     835  }
     836
     837  @Override
     838  public FlushMode getHibernateFlushMode()
     839  {
     840    return session.getHibernateFlushMode();
     841  }
     842
     843  @Override
     844  public void setHibernateFlushMode(FlushMode flushMode)
     845  {
     846    session.setHibernateFlushMode(flushMode);
     847  }
     848
     849  @Override
     850  public Query<?> createNamedQuery(String queryName)
     851  {
     852    Query<?> q = getCachedQuery(queryName);
     853    if (q == null)
     854    {
     855      q = session.getNamedQuery(queryName);
     856      cacheQuery(queryName, q);
     857    }
     858    return q;
     859  }
     860
     861  @SuppressWarnings({ "rawtypes", "unchecked" })
     862  @Override
     863  public NativeQuery createNativeQuery(String sql, Class resultClass)
     864  {
     865    NativeQuery q = (NativeQuery)getCachedQuery(sql);
     866    if (q == null)
     867    {
     868      q = session.createNativeQuery(sql, resultClass);
     869      cacheQuery(sql, q);
     870    }
     871    return q;
     872  }
     873
     874  @Override
     875  public NativeQuery<?> createNativeQuery(String sql, String resultSetMapping)
     876  {
     877    NativeQuery<?> q = (NativeQuery<?>)getCachedQuery(sql);
     878    if (q == null)
     879    {
     880      q = session.createNativeQuery(sql, resultSetMapping);
     881      cacheQuery(sql, q);
     882    }
     883    return q;
     884  }
     885
     886  @Override
     887  public NativeQuery<?> createNativeQuery(String sql)
     888  {
     889    NativeQuery<?> q = (NativeQuery<?>)getCachedQuery(sql);
     890    if (q == null)
     891    {
     892      q = session.createNativeQuery(sql);
     893      cacheQuery(sql, q);
     894    }
     895    return q;
     896  }
     897
     898  @Override
     899  public NativeQuery<?> getNamedNativeQuery(String queryName)
     900  {
     901    NativeQuery<?> q = (NativeQuery<?>)getCachedQuery(queryName);
     902    if (q == null)
     903    {
     904      q = session.getNamedNativeQuery(queryName);
     905      cacheQuery(queryName, q);
     906    }
     907    return q;
     908  }
     909
     910  @Override
     911  public <T> EntityGraph<T> createEntityGraph(Class<T> rootType)
     912  {
     913    return session.createEntityGraph(rootType);
     914  }
     915
     916  @Override
     917  public EntityGraph<?> createEntityGraph(String graphName)
     918  {
     919    return session.createEntityGraph(graphName);
     920  }
     921
     922  @Override
     923  public StoredProcedureQuery createNamedStoredProcedureQuery(String name)
     924  {
     925    return session.createNamedStoredProcedureQuery(name);
     926  }
     927
     928  @SuppressWarnings("rawtypes")
     929  @Override
     930  public StoredProcedureQuery createStoredProcedureQuery(String procedureName, Class... resultClasses)
     931  {
     932    return session.createStoredProcedureQuery(procedureName, resultClasses);
     933  }
     934
     935  @Override
     936  public StoredProcedureQuery createStoredProcedureQuery(String procedureName, String... resultSetMappings)
     937  {
     938    return session.createStoredProcedureQuery(procedureName, resultSetMappings);
     939  }
     940
     941  @Override
     942  public StoredProcedureQuery createStoredProcedureQuery(String procedureName)
     943  {
     944    return session.createStoredProcedureQuery(procedureName);
     945  }
     946
     947  @Override
     948  public void detach(Object object)
     949  {
     950    session.detach(object);
     951  }
     952
     953  @Override
     954  public <T> T find(Class<T> entityClass, Object primaryKey, LockModeType lockMode, Map<String, Object> properties)
     955  {
     956    return session.find(entityClass, primaryKey, lockMode, properties);
     957  }
     958
     959  @Override
     960  public <T> T find(Class<T> entityClass, Object primaryKey, LockModeType lockMode)
     961  {
     962    return session.find(entityClass, primaryKey, lockMode);
     963  }
     964
     965  @Override
     966  public <T> T find(Class<T> entityClass, Object primaryKey, Map<String, Object> properties)
     967  {
     968    return session.find(entityClass, primaryKey, properties);
     969  }
     970
     971  @Override
     972  public <T> T find(Class<T> entityClass, Object primaryKey)
     973  {
     974    return session.find(entityClass, primaryKey);
     975  }
     976
     977  @Override
     978  public CriteriaBuilder getCriteriaBuilder()
     979  {
     980    return session.getCriteriaBuilder();
     981  }
     982
     983  @Override
     984  public Object getDelegate()
     985  {
     986    return session;
     987  }
     988
     989  @Override
     990  public EntityGraph<?> getEntityGraph(String graphName)
     991  {
     992    return session.getEntityGraph(graphName);
     993  }
     994
     995  @Override
     996  public <T> List<EntityGraph<? super T>> getEntityGraphs(Class<T> entityClass)
     997  {
     998    return session.getEntityGraphs(entityClass);
     999  }
     1000
     1001  @Override
     1002  public EntityManagerFactory getEntityManagerFactory()
     1003  {
     1004    return session.getEntityManagerFactory();
     1005  }
     1006
     1007  @Override
     1008  public LockModeType getLockMode(Object entity)
     1009  {
     1010    return session.getLockMode(entity);
     1011  }
     1012
     1013  @Override
     1014  public Metamodel getMetamodel()
     1015  {
     1016    return session.getMetamodel();
     1017  }
     1018
     1019  @Override
     1020  public Map<String, Object> getProperties()
     1021  {
     1022    return session.getProperties();
     1023  }
     1024
     1025  @Override
     1026  public <T> T getReference(Class<T> entityClass, Object primaryKey)
     1027  {
     1028    return session.getReference(entityClass, primaryKey);
     1029  }
     1030
     1031  @Override
     1032  public boolean isJoinedToTransaction()
     1033  {
     1034    return session.isJoinedToTransaction();
     1035  }
     1036
     1037  @Override
     1038  public void joinTransaction()
     1039  {
     1040    session.joinTransaction();
     1041  }
     1042
     1043  @Override
     1044  public void lock(Object entity, LockModeType lockMode, Map<String, Object> properties)
     1045  {
     1046    session.lock(entity, lockMode, properties);
     1047  }
     1048
     1049  @Override
     1050  public void lock(Object entity, LockModeType lockMode)
     1051  {
     1052    session.lock(entity, lockMode);
     1053  }
     1054
     1055  @Override
     1056  public void refresh(Object entity, LockModeType lockMode, Map<String, Object> properties)
     1057  {
     1058    session.refresh(entity, lockMode, properties);
     1059  }
     1060
     1061  @Override
     1062  public void refresh(Object entity, LockModeType lockMode)
     1063  {
     1064    session.refresh(entity, lockMode);
     1065  }
     1066
     1067  @Override
     1068  public void refresh(Object entity, Map<String, Object> properties)
     1069  {
     1070    session.refresh(entity, properties);
     1071  }
     1072
     1073  @Override
     1074  public void remove(Object entity)
     1075  {
     1076    session.remove(entity);
     1077  }
     1078
     1079  @Override
     1080  public void setFlushMode(FlushModeType flushMode)
     1081  {
     1082    session.setFlushMode(flushMode);
     1083  }
     1084
     1085  @Override
     1086  public void setProperty(String propertyName, Object value)
     1087  {
     1088    session.setProperty(propertyName, value);
     1089  }
     1090
     1091  @SuppressWarnings("unchecked")
     1092  @Override
     1093  public <T> T unwrap(Class<T> cls)
     1094  {
     1095    return cls == this.getClass() ? (T)this : session.unwrap(cls);
     1096  }
     1097
     1098  @Override
     1099  @Deprecated
     1100  public Session getSession()
     1101  {
     1102    return this;
     1103  }
    7411104
    7421105}
  • branches/hibernate-5.2/src/core/net/sf/basedb/core/hibernate/StatelessSessionWrapper.java

    r7156 r7364  
    2828import org.hibernate.HibernateException;
    2929import org.hibernate.LockMode;
    30 import org.hibernate.Query;
    31 import org.hibernate.SQLQuery;
    3230import org.hibernate.Session;
    3331import org.hibernate.StatelessSession;
     
    3533import org.hibernate.internal.StatelessSessionImpl;
    3634import org.hibernate.procedure.ProcedureCall;
     35import org.hibernate.query.Query;
     36import org.hibernate.query.NativeQuery;
    3737
    3838import net.sf.basedb.core.HibernateUtil;
     
    112112  @SuppressWarnings("rawtypes")
    113113  @Override
     114  @Deprecated
    114115  public Criteria createCriteria(Class persistentClass, String alias)
    115116  {
     
    119120  @Override
    120121  @SuppressWarnings("rawtypes")
     122  @Deprecated
    121123  public Criteria createCriteria(Class persistentClass)
    122124  {
     
    125127
    126128  @Override
     129  @Deprecated
    127130  public Criteria createCriteria(String entityName, String alias)
    128131  {
     
    131134
    132135  @Override
     136  @Deprecated
    133137  public Criteria createCriteria(String entityName)
    134138  {
     
    142146  */
    143147  @Override
    144   public Query createQuery(String queryString)
     148  public Query<?> createQuery(String queryString)
    145149    throws HibernateException
    146150  {
    147     Query q = getCachedQuery(queryString);
     151    Query<?> q = getCachedQuery(queryString);
    148152    if (q == null)
    149153    {
     
    161165  */
    162166  @Override
    163   public SQLQuery createSQLQuery(String queryString)
     167  @Deprecated
     168  public NativeQuery<?> createSQLQuery(String queryString)
    164169    throws HibernateException
    165170  {
    166     Query q = getCachedQuery(queryString);
    167     if (q == null || !(q instanceof SQLQuery))
     171    Query<?> q = getCachedQuery(queryString);
     172    if (q == null || !(q instanceof NativeQuery))
    168173    {
    169174      q = session.createSQLQuery(queryString);
    170175      q.setFetchSize(HibernateUtil.getJdbcFetchSize());
    171176    }
    172     return (SQLQuery)q;
     177    return (NativeQuery<?>)q;
    173178  }
    174179
     
    217222  */
    218223  @Override
    219   public Query getNamedQuery(String queryName)
     224  public Query<?> getNamedQuery(String queryName)
    220225    throws HibernateException
    221226  {
    222     Query q = getCachedQuery(queryName);
     227    Query<?> q = getCachedQuery(queryName);
    223228    if (q == null)
    224229    {
     
    316321    return session.createStoredProcedureCall(paramString, paramArrayOfString);
    317322  }
     323
     324  @Override
     325  public Integer getJdbcBatchSize()
     326  {
     327    return session.getJdbcBatchSize();
     328  }
     329
     330  @Override
     331  public boolean isConnected()
     332  {
     333    return session.isConnected();
     334  }
     335
     336  @Override
     337  public boolean isOpen()
     338  {
     339    return session.isOpen();
     340  }
     341
     342  @Override
     343  public void setJdbcBatchSize(Integer batchSize)
     344  {
     345    session.setJdbcBatchSize(batchSize);
     346  }
     347
     348  @SuppressWarnings("unchecked")
     349  @Override
     350  public <R> Query<R> createNamedQuery(String queryName, Class<R> returnType)
     351  {
     352    Query<R> q = (Query<R>)getCachedQuery(queryName);
     353    if (q == null)
     354    {
     355      q = session.createNamedQuery(queryName, returnType);
     356      cacheQuery(queryName, q);
     357    }
     358    return q;
     359  }
     360
     361  @Override
     362  public Query<?> createNamedQuery(String queryName)
     363  {
     364    Query<?> q = getCachedQuery(queryName);
     365    if (q == null)
     366    {
     367      q = session.createNamedQuery(queryName);
     368      cacheQuery(queryName, q);
     369    }
     370    return q;
     371  }
     372
     373  @SuppressWarnings("unchecked")
     374  @Override
     375  public <R> NativeQuery<R> createNativeQuery(String queryString, Class<R> resultClass)
     376  {
     377    NativeQuery<R> q = (NativeQuery<R>)getCachedQuery(queryString);
     378    if (q == null)
     379    {
     380      q = session.createNativeQuery(queryString, resultClass);
     381      cacheQuery(queryString, q);
     382    }
     383    return q;
     384  }
     385
     386  @Override
     387  public NativeQuery<?> createNativeQuery(String queryString, String resultSetMapping)
     388  {
     389    NativeQuery<?> q = (NativeQuery<?>)getCachedQuery(queryString);
     390    if (q == null)
     391    {
     392      q = session.createNativeQuery(queryString, resultSetMapping);
     393      cacheQuery(queryString, q);
     394    }
     395    return q;
     396  }
     397
     398  @Override
     399  public NativeQuery<?> createNativeQuery(String queryString)
     400  {
     401    NativeQuery<?> q = (NativeQuery<?>)getCachedQuery(queryString);
     402    if (q == null)
     403    {
     404      q = session.createNativeQuery(queryString);
     405      cacheQuery(queryString, q);
     406    }
     407    return q;
     408  }
     409
     410  @SuppressWarnings("unchecked")
     411  @Override
     412  public <R> Query<R> createQuery(String queryString, Class<R> resultClass)
     413  {
     414    Query<R> q = (Query<R>)getCachedQuery(queryString);
     415    if (q == null)
     416    {
     417      q = session.createQuery(queryString, resultClass);
     418      cacheQuery(queryString, q);
     419    }
     420    return q;
     421  }
     422
     423  @Override
     424  public NativeQuery<?> getNamedNativeQuery(String queryName)
     425  {
     426    NativeQuery<?> q = (NativeQuery<?>)getCachedQuery(queryName);
     427    if (q == null)
     428    {
     429      q = session.getNamedNativeQuery(queryName);
     430      cacheQuery(queryName, q);
     431    }
     432    return q;
     433  }
     434 
     435 
    318436}
Note: See TracChangeset for help on using the changeset viewer.