Changeset 7363


Ignore:
Timestamp:
May 16, 2017, 12:55:21 PM (5 years ago)
Author:
Nicklas Nordborg
Message:

References #2084: Upgrade to Hibernate 5.2

Updated QueryWrapper and EntityQueryWrapper to use the new org.hibernate.query.Query interface. Down to 95 errors and 1398 warnings.

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

Legend:

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

    r6875 r7363  
    2424import java.util.Collection;
    2525
     26import javax.persistence.Parameter;
     27
    2628import net.sf.basedb.core.UnsavedItemException;
    2729import net.sf.basedb.core.data.IdentifiableData;
    2830
    2931import org.hibernate.HibernateException;
    30 import org.hibernate.Query;
     32import org.hibernate.query.Query;
     33import org.hibernate.query.QueryParameter;
    3134import org.hibernate.type.Type;
    3235
     
    4245  @base.modified $Date$
    4346*/
    44 public class EntityQueryWrapper
    45   extends QueryWrapper
     47public class EntityQueryWrapper<R>
     48  extends QueryWrapper<R>
    4649{
    47   public EntityQueryWrapper(Query query)
     50  public EntityQueryWrapper(Query<R> query)
    4851  {
    4952    super(query);
     
    5154 
    5255  @Override
    53   public Query setEntity(int position, Object val)
     56  @Deprecated
     57  public Query<R> setEntity(int position, Object val)
    5458  {
    5559    if (val instanceof IdentifiableData)
     
    6165 
    6266  @Override
    63   public Query setEntity(String name, Object val)
     67  @Deprecated
     68  public Query<R> setEntity(String name, Object val)
    6469  {
    6570    if (val instanceof IdentifiableData)
     
    7176 
    7277  @Override
    73   public Query setParameter(int position, Object val)
     78  public Query<R> setParameter(int position, Object val)
    7479    throws HibernateException
    7580  {
     
    8287 
    8388  @Override
    84   public Query setParameter(String name, Object val)
     89  public Query<R> setParameter(String name, Object val)
    8590    throws HibernateException
    8691  {
     
    9398 
    9499  @Override
    95   public Query setParameter(int position, Object val, Type type)
     100  public Query<R> setParameter(int position, Object val, Type type)
    96101  {
    97102    if (val instanceof IdentifiableData)
     
    103108 
    104109  @Override
    105   public Query setParameter(String name, Object val, Type type)
     110  public Query<R> setParameter(String name, Object val, Type type)
    106111  {
    107112    if (val instanceof IdentifiableData)
     
    114119  @SuppressWarnings("rawtypes")
    115120  @Override
    116   public Query setParameterList(String name, Collection vals)
     121  public Query<R> setParameterList(String name, Collection vals)
    117122    throws HibernateException
    118123  {
     
    121126  }
    122127 
    123   @Override
    124   public Query setParameterList(String name, Object[] vals)
     128 
     129  @Override
     130  public Query<R> setParameterList(String name, Object[] vals)
    125131    throws HibernateException
    126132  {
     
    131137  @SuppressWarnings("rawtypes")
    132138  @Override
    133   public Query setParameterList(String name, Collection vals, Type type)
     139  public Query<R> setParameterList(String name, Collection vals, Type type)
    134140    throws HibernateException
    135141  {
     
    139145 
    140146  @Override
    141   public Query setParameterList(String name, Object[] vals, Type type)
     147  public Query<R> setParameterList(String name, Object[] vals, Type type)
    142148    throws HibernateException
    143149  {
     
    146152  }
    147153 
     154  @Override
     155  public <T> Query<R> setParameter(Parameter<T> param, T val)
     156  {
     157    if (val instanceof IdentifiableData)
     158    {
     159      checkEntity((IdentifiableData)val);
     160    }
     161    return super.setParameter(param, val);
     162  }
     163
     164
     165  @Override
     166  public <P> Query<R> setParameter(QueryParameter<P> param, P val, Type type)
     167  {
     168    if (val instanceof IdentifiableData)
     169    {
     170      checkEntity((IdentifiableData)val);
     171    }
     172    return super.setParameter(param, val, type);
     173  }
     174
     175  @Override
     176  public <T> Query<R> setParameter(QueryParameter<T> param, T val)
     177  {
     178    if (val instanceof IdentifiableData)
     179    {
     180      checkEntity((IdentifiableData)val);
     181    }
     182    return super.setParameter(param, val);
     183  }
     184
     185  @Override
     186  public <P> Query<R> setParameterList(QueryParameter<P> param, Collection<P> values)
     187  {
     188    if (param.getType().isEntityType()) checkEntityCollection(values);
     189    return super.setParameterList(param, values);
     190  }
     191
    148192  private void checkEntity(IdentifiableData entity)
    149193  {
  • branches/hibernate-5.2/src/core/net/sf/basedb/core/hibernate/QueryWrapper.java

    r6875 r7363  
    2525import java.math.BigDecimal;
    2626import java.math.BigInteger;
     27import java.time.Instant;
     28import java.time.LocalDateTime;
     29import java.time.OffsetDateTime;
     30import java.time.ZonedDateTime;
    2731import java.util.Calendar;
    2832import java.util.Collection;
     
    3236import java.util.Locale;
    3337import java.util.Map;
     38import java.util.Optional;
     39import java.util.Set;
     40import java.util.stream.Stream;
     41
     42import javax.persistence.FlushModeType;
     43import javax.persistence.LockModeType;
     44import javax.persistence.Parameter;
     45import javax.persistence.TemporalType;
    3446
    3547import org.hibernate.CacheMode;
     
    3850import org.hibernate.LockMode;
    3951import org.hibernate.LockOptions;
    40 import org.hibernate.Query;
     52import org.hibernate.query.ParameterMetadata;
     53import org.hibernate.query.Query;
     54import org.hibernate.query.QueryParameter;
     55import org.hibernate.query.QueryProducer;
    4156import org.hibernate.ScrollMode;
    4257import org.hibernate.ScrollableResults;
     58import org.hibernate.engine.spi.RowSelection;
    4359import org.hibernate.transform.ResultTransformer;
    4460import org.hibernate.type.Type;
     
    5268  @base.modified $Date$
    5369*/
    54 public class QueryWrapper
    55   implements Query
     70public class QueryWrapper<R>
     71  implements Query<R>
    5672{
    5773
    58   protected final Query query;
     74  protected final Query<R> query;
    5975 
    60   public QueryWrapper(Query query)
     76  public QueryWrapper(Query<R> query)
    6177  {
    6278    this.query = query;
     
    7187
    7288  @Override
     89  @Deprecated
    7390  public String[] getNamedParameters()
    7491    throws HibernateException
     
    84101
    85102  @Override
     103  @Deprecated
    86104  public String[] getReturnAliases()
    87105    throws HibernateException
     
    91109
    92110  @Override
     111  @Deprecated
    93112  public Type[] getReturnTypes()
    94113    throws HibernateException
     
    98117
    99118  @Override
     119  @Deprecated
    100120  public boolean isReadOnly()
    101121  {
     
    103123  }
    104124
     125  @Override
     126  @Deprecated
     127  public Iterator<R> iterate()
     128    throws HibernateException
     129  {
     130    return query.iterate();
     131  }
     132
     133  @Override
     134  public List<R> list()
     135    throws HibernateException
     136  {
     137    return query.list();
     138  }
     139
     140  @Override
     141  public ScrollableResults scroll()
     142    throws HibernateException
     143  {
     144    return query.scroll();
     145  }
     146
     147  @Override
     148  public ScrollableResults scroll(ScrollMode scrollMode)
     149    throws HibernateException
     150  {
     151    return query.scroll(scrollMode);
     152  }
     153
     154  @Override
     155  @Deprecated
     156  public Query<R> setBigDecimal(int position, BigDecimal number)
     157  {
     158    query.setBigDecimal(position, number);
     159    return this;
     160  }
     161
     162  @Override
     163  @Deprecated
     164  public Query<R> setBigDecimal(String name, BigDecimal number)
     165  {
     166    query.setBigDecimal(name, number);
     167    return this;
     168  }
     169
     170  @Override
     171  @Deprecated
     172  public Query<R> setBigInteger(int position, BigInteger number)
     173  {
     174    query.setBigInteger(position, number);
     175    return this;
     176  }
     177
     178  @Override
     179  @Deprecated
     180  public Query<R> setBigInteger(String name, BigInteger number)
     181  {
     182    query.setBigInteger(name, number);
     183    return this;
     184  }
     185
     186  @Override
     187  @Deprecated
     188  public Query<R> setBinary(int position, byte[] val)
     189  {
     190    query.setBinary(position, val);
     191    return this;
     192  }
     193
     194  @Override
     195  @Deprecated
     196  public Query<R> setBinary(String name, byte[] val)
     197  {
     198    query.setBinary(name, val);
     199    return this;
     200  }
     201
     202  @Override
     203  @Deprecated
     204  public Query<R> setBoolean(int position, boolean val)
     205  {
     206    query.setBoolean(position, val);
     207    return this;
     208  }
     209
     210  @Override
     211  @Deprecated
     212  public Query<R> setBoolean(String name, boolean val)
     213  {
     214    query.setBoolean(name, val);
     215    return this;
     216  }
     217
     218  @Override
     219  @Deprecated
     220  public Query<R> setByte(int position, byte val)
     221  {
     222    query.setByte(position, val);
     223    return this;
     224  }
     225
     226  @Override
     227  @Deprecated
     228  public Query<R> setByte(String name, byte val)
     229  {
     230    query.setByte(name, val);
     231    return this;
     232  }
     233
     234  @Override
     235  public Query<R> setCacheMode(CacheMode cacheMode)
     236  {
     237    query.setCacheMode(cacheMode);
     238    return this;
     239  }
     240
     241  @Override
     242  public Query<R> setCacheRegion(String cacheRegion)
     243  {
     244    query.setCacheRegion(cacheRegion);
     245    return this;
     246  }
     247
     248  @Override
     249  public Query<R> setCacheable(boolean cacheable)
     250  {
     251    query.setCacheable(cacheable);
     252    return this;
     253  }
     254
     255  @Override
     256  @Deprecated
     257  public Query<R> setCalendar(int position, Calendar calendar)
     258  {
     259    query.setCalendar(position, calendar);
     260    return this;
     261  }
     262
     263  @Override
     264  @Deprecated
     265  public Query<R> setCalendar(String name, Calendar calendar)
     266  {
     267    query.setCalendar(name, calendar);
     268    return this;
     269  }
     270
     271  @Override
     272  @Deprecated
     273  public Query<R> setCalendarDate(int position, Calendar calendar)
     274  {
     275    query.setCalendarDate(position, calendar);
     276    return this;
     277  }
     278
     279  @Override
     280  @Deprecated
     281  public Query<R> setCalendarDate(String name, Calendar calendar)
     282  {
     283    query.setCalendarDate(name, calendar);
     284    return this;
     285  }
     286
     287  @Override
     288  @Deprecated
     289  public Query<R> setCharacter(int position, char val)
     290  {
     291    query.setCharacter(position, val);
     292    return this;
     293  }
     294
     295  @Override
     296  @Deprecated
     297  public Query<R> setCharacter(String name, char val)
     298  {
     299    query.setCharacter(name, val);
     300    return this;
     301  }
     302
     303  @Override
     304  public Query<R> setComment(String comment)
     305  {
     306    query.setComment(comment);
     307    return this;
     308  }
     309
     310  @Override
     311  @Deprecated
     312  public Query<R> setDate(int position, Date date)
     313  {
     314    query.setDate(position, date);
     315    return this;
     316  }
     317
     318  @Override
     319  @Deprecated
     320  public Query<R> setDate(String name, Date date)
     321  {
     322    query.setDate(name, date);
     323    return this;
     324  }
     325
     326  @Override
     327  @Deprecated
     328  public Query<R> setDouble(int position, double val)
     329  {
     330    query.setDouble(position, val);
     331    return this;
     332  }
     333
     334  @Override
     335  @Deprecated
     336  public Query<R> setDouble(String name, double val)
     337  {
     338    query.setDouble(name, val);
     339    return this;
     340  }
     341
     342  @Override
     343  @Deprecated
     344  public Query<R> setEntity(int position, Object val)
     345  {
     346    query.setEntity(position, val);
     347    return this;
     348  }
     349
     350  @Override
     351  @Deprecated
     352  public Query<R> setEntity(String name, Object val)
     353  {
     354    query.setEntity(name, val);
     355    return this;
     356  }
     357
     358  @Override
     359  public Query<R> setFetchSize(int fetchSize)
     360  {
     361    query.setFetchSize(fetchSize);
     362    return this;
     363  }
     364
     365  @Override
     366  public Query<R> setFirstResult(int firstResult)
     367  {
     368    query.setFirstResult(firstResult);
     369    return this;
     370  }
     371
     372  @Override
     373  @Deprecated
     374  public Query<R> setFloat(int position, float val)
     375  {
     376    query.setFloat(position, val);
     377    return this;
     378  }
     379
     380  @Override
     381  @Deprecated
     382  public Query<R> setFloat(String name, float val)
     383  {
     384    query.setFloat(name, val);
     385    return this;
     386  }
     387
     388  @Override
     389  @Deprecated
     390  public Query<R> setFlushMode(FlushMode flushMode)
     391  {
     392    query.setFlushMode(flushMode);
     393    return this;
     394  }
     395
     396  @Override
     397  @Deprecated
     398  public Query<R> setInteger(int position, int val)
     399  {
     400    query.setInteger(position, val);
     401    return this;
     402  }
     403
     404  @Override
     405  @Deprecated
     406  public Query<R> setInteger(String name, int val)
     407  {
     408    query.setInteger(name, val);
     409    return this;
     410  }
     411
     412  @Override
     413  @Deprecated
     414  public Query<R> setLocale(int position, Locale locale)
     415  {
     416    query.setLocale(position, locale);
     417    return this;
     418  }
     419
     420  @Override
     421  @Deprecated
     422  public Query<R> setLocale(String name, Locale locale)
     423  {
     424    query.setLocale(name, locale);
     425    return this;
     426  }
     427
     428  @Override
     429  public Query<R> setLockMode(String alias, LockMode lockMode)
     430  {
     431    query.setLockMode(alias, lockMode);
     432    return this;
     433  }
     434 
     435  @Override
     436  public Query<R> setLockOptions(LockOptions lockOptions)
     437  {
     438    query.setLockOptions(lockOptions);
     439    return this;
     440  }
     441
     442  @Override
     443  @Deprecated
     444  public Query<R> setLong(int position, long val)
     445  {
     446    query.setLong(position, val);
     447    return this;
     448  }
     449
     450  @Override
     451  @Deprecated
     452  public Query<R> setLong(String name, long val)
     453  {
     454    query.setLong(name, val);
     455    return this;
     456  }
     457
     458  @Override
     459  public Query<R> setMaxResults(int maxResults)
     460  {
     461    query.setMaxResults(maxResults);
     462    return this;
     463  }
     464
     465  @Override
     466  public Query<R> setParameter(int position, Object val)
     467    throws HibernateException
     468  {
     469    query.setParameter(position, val);
     470    return this;
     471  }
     472
     473  @Override
     474  public Query<R> setParameter(String name, Object val)
     475    throws HibernateException
     476  {
     477    query.setParameter(name, val);
     478    return this;
     479  }
     480
     481  @Override
     482  public Query<R> setParameter(int position, Object val, Type type)
     483  {
     484    query.setParameter(position, val, type);
     485    return this;
     486  }
     487
     488  @Override
     489  public Query<R> setParameter(String name, Object val, Type type)
     490  {
     491    query.setParameter(name, val, type);
     492    return this;
     493  }
     494
    105495  @SuppressWarnings("rawtypes")
    106496  @Override
    107   public Iterator iterate()
    108     throws HibernateException
    109   {
    110     return query.iterate();
     497  public Query<R> setParameterList(String name, Collection vals)
     498  {
     499    query.setParameterList(name, vals);
     500    return this;
     501  }
     502
     503  @Override
     504  public Query<R> setParameterList(String name, Object[] vals)
     505  {
     506    query.setParameterList(name, vals);
     507    return this;
    111508  }
    112509
    113510  @SuppressWarnings("rawtypes")
    114511  @Override
    115   public List list()
    116     throws HibernateException
    117   {
    118     return query.list();
    119   }
    120 
    121   @Override
    122   public ScrollableResults scroll()
    123     throws HibernateException
    124   {
    125     return query.scroll();
    126   }
    127 
    128   @Override
    129   public ScrollableResults scroll(ScrollMode scrollMode)
    130     throws HibernateException
    131   {
    132     return query.scroll(scrollMode);
    133   }
    134 
    135   @Override
    136   public Query setBigDecimal(int position, BigDecimal number)
    137   {
    138     query.setBigDecimal(position, number);
    139     return this;
    140   }
    141 
    142   @Override
    143   public Query setBigDecimal(String name, BigDecimal number)
    144   {
    145     query.setBigDecimal(name, number);
    146     return this;
    147   }
    148 
    149   @Override
    150   public Query setBigInteger(int position, BigInteger number)
    151   {
    152     query.setBigInteger(position, number);
    153     return this;
    154   }
    155 
    156   @Override
    157   public Query setBigInteger(String name, BigInteger number)
    158   {
    159     query.setBigInteger(name, number);
    160     return this;
    161   }
    162 
    163   @Override
    164   public Query setBinary(int position, byte[] val)
    165   {
    166     query.setBinary(position, val);
    167     return this;
    168   }
    169 
    170   @Override
    171   public Query setBinary(String name, byte[] val)
    172   {
    173     query.setBinary(name, val);
    174     return this;
    175   }
    176 
    177   @Override
    178   public Query setBoolean(int position, boolean val)
    179   {
    180     query.setBoolean(position, val);
    181     return this;
    182   }
    183 
    184   @Override
    185   public Query setBoolean(String name, boolean val)
    186   {
    187     query.setBoolean(name, val);
    188     return this;
    189   }
    190 
    191   @Override
    192   public Query setByte(int position, byte val)
    193   {
    194     query.setByte(position, val);
    195     return this;
    196   }
    197 
    198   @Override
    199   public Query setByte(String name, byte val)
    200   {
    201     query.setByte(name, val);
    202     return this;
    203   }
    204 
    205   @Override
    206   public Query setCacheMode(CacheMode cacheMode)
    207   {
    208     query.setCacheMode(cacheMode);
    209     return this;
    210   }
    211 
    212   @Override
    213   public Query setCacheRegion(String cacheRegion)
    214   {
    215     query.setCacheRegion(cacheRegion);
    216     return this;
    217   }
    218 
    219   @Override
    220   public Query setCacheable(boolean cacheable)
    221   {
    222     query.setCacheable(cacheable);
    223     return this;
    224   }
    225 
    226   @Override
    227   public Query setCalendar(int position, Calendar calendar)
    228   {
    229     query.setCalendar(position, calendar);
    230     return this;
    231   }
    232 
    233   @Override
    234   public Query setCalendar(String name, Calendar calendar)
    235   {
    236     query.setCalendar(name, calendar);
    237     return this;
    238   }
    239 
    240   @Override
    241   public Query setCalendarDate(int position, Calendar calendar)
    242   {
    243     query.setCalendarDate(position, calendar);
    244     return this;
    245   }
    246 
    247   @Override
    248   public Query setCalendarDate(String name, Calendar calendar)
    249   {
    250     query.setCalendarDate(name, calendar);
    251     return this;
    252   }
    253 
    254   @Override
    255   public Query setCharacter(int position, char val)
    256   {
    257     query.setCharacter(position, val);
    258     return this;
    259   }
    260 
    261   @Override
    262   public Query setCharacter(String name, char val)
    263   {
    264     query.setCharacter(name, val);
    265     return this;
    266   }
    267 
    268   @Override
    269   public Query setComment(String comment)
    270   {
    271     query.setComment(comment);
    272     return this;
    273   }
    274 
    275   @Override
    276   public Query setDate(int position, Date date)
    277   {
    278     query.setDate(position, date);
    279     return this;
    280   }
    281 
    282   @Override
    283   public Query setDate(String name, Date date)
    284   {
    285     query.setDate(name, date);
    286     return this;
    287   }
    288 
    289   @Override
    290   public Query setDouble(int position, double val)
    291   {
    292     query.setDouble(position, val);
    293     return this;
    294   }
    295 
    296   @Override
    297   public Query setDouble(String name, double val)
    298   {
    299     query.setDouble(name, val);
    300     return this;
    301   }
    302 
    303   @Override
    304   public Query setEntity(int position, Object val)
    305   {
    306     query.setEntity(position, val);
    307     return this;
    308   }
    309 
    310   @Override
    311   public Query setEntity(String name, Object val)
    312   {
    313     query.setEntity(name, val);
    314     return this;
    315   }
    316 
    317   @Override
    318   public Query setFetchSize(int fetchSize)
    319   {
    320     query.setFetchSize(fetchSize);
    321     return this;
    322   }
    323 
    324   @Override
    325   public Query setFirstResult(int firstResult)
    326   {
    327     query.setFirstResult(firstResult);
    328     return this;
    329   }
    330 
    331   @Override
    332   public Query setFloat(int position, float val)
    333   {
    334     query.setFloat(position, val);
    335     return this;
    336   }
    337 
    338   @Override
    339   public Query setFloat(String name, float val)
    340   {
    341     query.setFloat(name, val);
    342     return this;
    343   }
    344 
    345   @Override
    346   public Query setFlushMode(FlushMode flushMode)
     512  public Query<R> setParameterList(String name, Collection vals, Type type)
     513  {
     514    query.setParameterList(name, vals, type);
     515    return this;
     516  }
     517
     518  @Override
     519  public Query<R> setParameterList(String name, Object[] vals, Type type)
     520  {
     521    query.setParameterList(name, vals, type);
     522    return this;
     523  }
     524
     525  @Override
     526  @Deprecated
     527  public Query<R> setParameters(Object[] values, Type[] types)
     528  {
     529    query.setParameters(values, types);
     530    return this;
     531  }
     532
     533  @Override
     534  public Query<R> setProperties(Object bean)
     535    throws HibernateException
     536  {
     537    query.setProperties(bean);
     538    return this;
     539  }
     540
     541  @SuppressWarnings("rawtypes")
     542  @Override
     543  public Query<R> setProperties(Map bean)
     544    throws HibernateException
     545  {
     546    query.setProperties(bean);
     547    return this;
     548  }
     549
     550  @Override
     551  public Query<R> setReadOnly(boolean readOnly)
     552  {
     553    query.setReadOnly(readOnly);
     554    return this;
     555  }
     556
     557  @Override
     558  @Deprecated
     559  public Query<R> setResultTransformer(ResultTransformer transformer)
     560  {
     561    query.setResultTransformer(transformer);
     562    return this;
     563  }
     564
     565  @Override
     566  @Deprecated
     567  public Query<R> setSerializable(int position, Serializable val)
     568  {
     569    query.setSerializable(position, val);
     570    return this;
     571  }
     572
     573  @Override
     574  @Deprecated
     575  public Query<R> setSerializable(String name, Serializable val)
     576  {
     577    query.setSerializable(name, val);
     578    return this;
     579  }
     580
     581  @Override
     582  @Deprecated
     583  public Query<R> setShort(int position, short val)
     584  {
     585    query.setShort(position, val);
     586    return this;
     587  }
     588
     589  @Override
     590  @Deprecated
     591  public Query<R> setShort(String name, short val)
     592  {
     593    query.setShort(name, val);
     594    return this;
     595  }
     596
     597  @Override
     598  @Deprecated
     599  public Query<R> setString(int position, String val)
     600  {
     601    query.setString(position, val);
     602    return this;
     603  }
     604
     605  @Override
     606  @Deprecated
     607  public Query<R> setString(String name, String val)
     608  {
     609    query.setString(name, val);
     610    return this;
     611  }
     612
     613  @Override
     614  @Deprecated
     615  public Query<R> setText(int position, String val)
     616  {
     617    query.setText(position, val);
     618    return this;
     619  }
     620
     621  @Override
     622  @Deprecated
     623  public Query<R> setText(String name, String val)
     624  {
     625    query.setText(name, val);
     626    return this;
     627  }
     628
     629  @Override
     630  @Deprecated
     631  public Query<R> setTime(int position, Date date)
     632  {
     633    query.setTime(position, date);
     634    return this;
     635  }
     636
     637  @Override
     638  @Deprecated
     639  public Query<R> setTime(String name, Date date)
     640  {
     641    query.setTime(name, date);
     642    return this;
     643  }
     644
     645  @Override
     646  public Query<R> setTimeout(int timeout)
     647  {
     648    query.setTimeout(timeout);
     649    return this;
     650  }
     651
     652  @Override
     653  @Deprecated
     654  public Query<R> setTimestamp(int position, Date date)
     655  {
     656    query.setTimestamp(position, date);
     657    return this;
     658  }
     659
     660  @Override
     661  @Deprecated
     662  public Query<R> setTimestamp(String name, Date date)
     663  {
     664    query.setTimestamp(name, date);
     665    return this;
     666  }
     667
     668  @Override
     669  public R uniqueResult()
     670    throws HibernateException
     671  {
     672    return query.uniqueResult();
     673  }
     674
     675  @Override
     676  @Deprecated
     677  public FlushModeType getFlushMode()
     678  {
     679    return query.getFlushMode();
     680  }
     681
     682  @Override
     683  public CacheMode getCacheMode()
     684  {
     685    return query.getCacheMode();
     686  }
     687
     688  @Override
     689  @Deprecated
     690  public boolean isCacheable()
     691  {
     692    return query.isCacheable();
     693  }
     694
     695  @Override
     696  public String getCacheRegion()
     697  {
     698    return query.getCacheRegion();
     699  }
     700
     701  @Override
     702  @Deprecated
     703  public Integer getTimeout()
     704  {
     705    return query.getTimeout();
     706  }
     707
     708  @Override
     709  public Integer getFetchSize()
     710  {
     711    return query.getFetchSize();
     712  }
     713
     714  @Override
     715  public int getMaxResults()
     716  {
     717    return query.getMaxResults();
     718  }
     719
     720  @Override
     721  public int getFirstResult()
     722  {
     723    return query.getFirstResult();
     724  }
     725
     726  @Override
     727  public LockOptions getLockOptions()
     728  {
     729    return query.getLockOptions();
     730  }
     731
     732  @Override
     733  public String getComment()
     734  {
     735    return query.getComment();
     736  }
     737
     738  @Override
     739  public Query<R> addQueryHint(String hint)
     740  {
     741    query.addQueryHint(hint);
     742    return this;
     743  }
     744
     745  @Override
     746  public Map<String, Object> getHints()
     747  {
     748    return query.getHints();
     749  }
     750
     751  @Override
     752  public LockModeType getLockMode()
     753  {
     754    return query.getLockMode();
     755  }
     756
     757  @Override
     758  public <T> Parameter<T> getParameter(int position, Class<T> type)
     759  {
     760    return query.getParameter(position, type);
     761  }
     762
     763  @Override
     764  public Parameter<?> getParameter(int position)
     765  {
     766    return query.getParameter(position);
     767  }
     768
     769  @Override
     770  public <T> Parameter<T> getParameter(String name, Class<T> type)
     771  {
     772    return query.getParameter(name, type);
     773  }
     774
     775  @Override
     776  public Parameter<?> getParameter(String name)
     777  {
     778    return query.getParameter(name);
     779  }
     780
     781  @Override
     782  public Object getParameterValue(int position)
     783  {
     784    return query.getParameterValue(position);
     785  }
     786
     787  @Override
     788  public <T> T getParameterValue(Parameter<T> param)
     789  {
     790    return query.getParameterValue(param);
     791  }
     792
     793  @Override
     794  public Object getParameterValue(String name)
     795  {
     796    return query.getParameterValue(name);
     797  }
     798
     799  @Override
     800  public Set<Parameter<?>> getParameters()
     801  {
     802    return query.getParameters();
     803  }
     804
     805  @Override
     806  public boolean isBound(Parameter<?> param)
     807  {
     808    return query.isBound(param);
     809  }
     810
     811  @SuppressWarnings("unchecked")
     812  @Override
     813  public <T> T unwrap(Class<T> cls)
     814  {
     815    return cls == this.getClass() ? (T)this : query.unwrap(cls);
     816  }
     817
     818  @Override
     819  @Deprecated
     820  public Type determineProperBooleanType(int position, Object value, Type type)
     821  {
     822    return query.determineProperBooleanType(position, value, type);
     823  }
     824
     825  @Override
     826  @Deprecated
     827  public Type determineProperBooleanType(String name, Object value, Type type)
     828  {
     829    return query.determineProperBooleanType(name, value, type);
     830  }
     831
     832  @Override
     833  public FlushMode getHibernateFlushMode()
     834  {
     835    return query.getHibernateFlushMode();
     836  }
     837
     838  @Override
     839  public ParameterMetadata getParameterMetadata()
     840  {
     841    return query.getParameterMetadata();
     842  }
     843
     844  @Override
     845  public QueryProducer getProducer()
     846  {
     847    return query.getProducer();
     848  }
     849
     850  @Override
     851  public RowSelection getQueryOptions()
     852  {
     853    return query.getQueryOptions();
     854  }
     855
     856  @Override
     857  public Query<R> setFlushMode(FlushModeType flushMode)
    347858  {
    348859    query.setFlushMode(flushMode);
     
    351862
    352863  @Override
    353   public Query setInteger(int position, int val)
    354   {
    355     query.setInteger(position, val);
    356     return this;
    357   }
    358 
    359   @Override
    360   public Query setInteger(String name, int val)
    361   {
    362     query.setInteger(name, val);
    363     return this;
    364   }
    365 
    366   @Override
    367   public Query setLocale(int position, Locale locale)
    368   {
    369     query.setLocale(position, locale);
    370     return this;
    371   }
    372 
    373   @Override
    374   public Query setLocale(String name, Locale locale)
    375   {
    376     query.setLocale(name, locale);
    377     return this;
    378   }
    379 
    380   @Override
    381   public Query setLockMode(String alias, LockMode lockMode)
    382   {
    383     query.setLockMode(alias, lockMode);
    384     return this;
    385   }
    386  
    387   @Override
    388   public Query setLockOptions(LockOptions lockOptions)
    389   {
    390     query.setLockOptions(lockOptions);
    391     return this;
    392   }
    393 
    394   @Override
    395   public Query setLong(int position, long val)
    396   {
    397     query.setLong(position, val);
    398     return this;
    399   }
    400 
    401   @Override
    402   public Query setLong(String name, long val)
    403   {
    404     query.setLong(name, val);
    405     return this;
    406   }
    407 
    408   @Override
    409   public Query setMaxResults(int maxResults)
    410   {
    411     query.setMaxResults(maxResults);
    412     return this;
    413   }
    414 
    415   @Override
    416   public Query setParameter(int position, Object val)
    417     throws HibernateException
    418   {
    419     query.setParameter(position, val);
    420     return this;
    421   }
    422 
    423   @Override
    424   public Query setParameter(String name, Object val)
    425     throws HibernateException
    426   {
    427     query.setParameter(name, val);
    428     return this;
    429   }
    430 
    431   @Override
    432   public Query setParameter(int position, Object val, Type type)
    433   {
    434     query.setParameter(position, val, type);
    435     return this;
    436   }
    437 
    438   @Override
    439   public Query setParameter(String name, Object val, Type type)
    440   {
    441     query.setParameter(name, val, type);
    442     return this;
    443   }
    444 
    445   @SuppressWarnings("rawtypes")
    446   @Override
    447   public Query setParameterList(String name, Collection vals)
    448     throws HibernateException
    449   {
    450     query.setParameterList(name, vals);
    451     return this;
    452   }
    453 
    454   @Override
    455   public Query setParameterList(String name, Object[] vals)
    456     throws HibernateException
    457   {
    458     query.setParameterList(name, vals);
    459     return this;
    460   }
    461 
    462   @SuppressWarnings("rawtypes")
    463   @Override
    464   public Query setParameterList(String name, Collection vals, Type type)
    465     throws HibernateException
    466   {
    467     query.setParameterList(name, vals, type);
    468     return this;
    469   }
    470 
    471   @Override
    472   public Query setParameterList(String name, Object[] vals, Type type)
    473     throws HibernateException
    474   {
    475     query.setParameterList(name, vals, type);
    476     return this;
    477   }
    478 
    479   @Override
    480   public Query setParameters(Object[] values, Type[] types)
    481     throws HibernateException
    482   {
    483     query.setParameters(values, types);
    484     return this;
    485   }
    486 
    487   @Override
    488   public Query setProperties(Object bean)
    489     throws HibernateException
    490   {
    491     query.setProperties(bean);
    492     return this;
    493   }
    494 
    495   @SuppressWarnings("rawtypes")
    496   @Override
    497   public Query setProperties(Map bean)
    498     throws HibernateException
    499   {
    500     query.setProperties(bean);
    501     return this;
    502   }
    503 
    504   @Override
    505   public Query setReadOnly(boolean readOnly)
    506   {
    507     query.setReadOnly(readOnly);
    508     return this;
    509   }
    510 
    511   @Override
    512   public Query setResultTransformer(ResultTransformer transformer)
    513   {
    514     query.setResultTransformer(transformer);
    515     return this;
    516   }
    517 
    518   @Override
    519   public Query setSerializable(int position, Serializable val)
    520   {
    521     query.setSerializable(position, val);
    522     return this;
    523   }
    524 
    525   @Override
    526   public Query setSerializable(String name, Serializable val)
    527   {
    528     query.setSerializable(name, val);
    529     return this;
    530   }
    531 
    532   @Override
    533   public Query setShort(int position, short val)
    534   {
    535     query.setShort(position, val);
    536     return this;
    537   }
    538 
    539   @Override
    540   public Query setShort(String name, short val)
    541   {
    542     query.setShort(name, val);
    543     return this;
    544   }
    545 
    546   @Override
    547   public Query setString(int position, String val)
    548   {
    549     query.setString(position, val);
    550     return this;
    551   }
    552 
    553   @Override
    554   public Query setString(String name, String val)
    555   {
    556     query.setString(name, val);
    557     return this;
    558   }
    559 
    560   @Override
    561   public Query setText(int position, String val)
    562   {
    563     query.setText(position, val);
    564     return this;
    565   }
    566 
    567   @Override
    568   public Query setText(String name, String val)
    569   {
    570     query.setText(name, val);
    571     return this;
    572   }
    573 
    574   @Override
    575   public Query setTime(int position, Date date)
    576   {
    577     query.setTime(position, date);
    578     return this;
    579   }
    580 
    581   @Override
    582   public Query setTime(String name, Date date)
    583   {
    584     query.setTime(name, date);
    585     return this;
    586   }
    587 
    588   @Override
    589   public Query setTimeout(int timeout)
    590   {
    591     query.setTimeout(timeout);
    592     return this;
    593   }
    594 
    595   @Override
    596   public Query setTimestamp(int position, Date date)
    597   {
    598     query.setTimestamp(position, date);
    599     return this;
    600   }
    601 
    602   @Override
    603   public Query setTimestamp(String name, Date date)
    604   {
    605     query.setTimestamp(name, date);
    606     return this;
    607   }
    608 
    609   @Override
    610   public Object uniqueResult()
    611     throws HibernateException
    612   {
    613     return query.uniqueResult();
    614   }
    615 
    616   @Override
    617   public FlushMode getFlushMode()
    618   {
    619     return query.getFlushMode();
    620   }
    621 
    622   @Override
    623   public CacheMode getCacheMode()
    624   {
    625     return query.getCacheMode();
    626   }
    627 
    628   @Override
    629   public boolean isCacheable()
    630   {
    631     return query.isCacheable();
    632   }
    633 
    634   @Override
    635   public String getCacheRegion()
    636   {
    637     return query.getCacheRegion();
    638   }
    639 
    640   @Override
    641   public Integer getTimeout()
    642   {
    643     return query.getTimeout();
    644   }
    645 
    646   @Override
    647   public Integer getFetchSize()
    648   {
    649     return query.getFetchSize();
    650   }
    651 
    652   @Override
    653   public Integer getMaxResults()
    654   {
    655     return query.getMaxResults();
    656   }
    657 
    658   @Override
    659   public Integer getFirstResult()
    660   {
    661     return query.getFirstResult();
    662   }
    663 
    664   @Override
    665   public LockOptions getLockOptions()
    666   {
    667     return query.getLockOptions();
    668   }
    669 
    670   @Override
    671   public String getComment()
    672   {
    673     return query.getComment();
    674   }
    675 
    676   @Override
    677   public Query addQueryHint(String hint)
    678   {
    679     query.addQueryHint(hint);
    680     return this;
     864  public Query<R> setHibernateFlushMode(FlushMode flushMode)
     865  {
     866    query.setHibernateFlushMode(flushMode);
     867    return this;
     868  }
     869
     870  @Override
     871  public Query<R> setHint(String name, Object value)
     872  {
     873    query.setHint(name, value);
     874    return this;
     875  }
     876
     877  @Override
     878  public Query<R> setLockMode(LockModeType lockMode)
     879  {
     880    query.setLockMode(lockMode);
     881    return this;
     882  }
     883
     884  @Override
     885  public Query<R> setParameter(int position, Calendar value, TemporalType type)
     886  {
     887    query.setParameter(position, value, type);
     888    return this;
     889  }
     890
     891  @Override
     892  public Query<R> setParameter(int position, Date value, TemporalType type)
     893  {
     894    query.setParameter(position, value, type);
     895    return this;
     896  }
     897
     898  @Override
     899  public Query<R> setParameter(int position, Instant value, TemporalType type)
     900  {
     901    query.setParameter(position, value, type);
     902    return this;
     903  }
     904
     905  @Override
     906  public Query<R> setParameter(int position, LocalDateTime value, TemporalType type)
     907  {
     908    query.setParameter(position, value, type);
     909    return this;
     910  }
     911
     912  @Override
     913  public Query<R> setParameter(int position, OffsetDateTime value, TemporalType type)
     914  {
     915    query.setParameter(position, value, type);
     916    return this;
     917  }
     918
     919  @Override
     920  public <P> Query<R> setParameter(int position, P value, TemporalType type)
     921  {
     922    query.setParameter(position, value, type);
     923    return this;
     924  }
     925
     926  @Override
     927  public Query<R> setParameter(int position, ZonedDateTime value, TemporalType type)
     928  {
     929    query.setParameter(position, value, type);
     930    return this;
     931  }
     932
     933  @Override
     934  public Query<R> setParameter(Parameter<Calendar> param, Calendar value, TemporalType type)
     935  {
     936    query.setParameter(param, value, type);
     937    return this;
     938  }
     939
     940  @Override
     941  public Query<R> setParameter(Parameter<Date> param, Date value, TemporalType type)
     942  {
     943    query.setParameter(param, value, type);
     944    return this;
     945  }
     946
     947  @Override
     948  public Query<R> setParameter(Parameter<Instant> param, Instant value, TemporalType type)
     949  {
     950    query.setParameter(param, value, type);
     951    return this;
     952  }
     953
     954  @Override
     955  public Query<R> setParameter(Parameter<LocalDateTime> param, LocalDateTime value, TemporalType type)
     956  {
     957    query.setParameter(param, value, type);
     958    return this;
     959  }
     960
     961  @Override
     962  public Query<R> setParameter(Parameter<OffsetDateTime> param, OffsetDateTime value, TemporalType type)
     963  {
     964    query.setParameter(param, value, type);
     965    return this;
     966  }
     967
     968  @Override
     969  public <T> Query<R> setParameter(Parameter<T> param, T value)
     970  {
     971    query.setParameter(param, value);
     972    return this;
     973  }
     974
     975  @Override
     976  public Query<R> setParameter(Parameter<ZonedDateTime> param, ZonedDateTime value, TemporalType type)
     977  {
     978    query.setParameter(param, value, type);
     979    return this;
     980  }
     981
     982  @Override
     983  public <P> Query<R> setParameter(QueryParameter<P> param, P value, TemporalType type)
     984  {
     985    query.setParameter(param, value, type);
     986    return this;
     987  }
     988
     989  @Override
     990  public <P> Query<R> setParameter(QueryParameter<P> param, P value, Type type)
     991  {
     992    query.setParameter(param, value, type);
     993    return this;
     994  }
     995
     996  @Override
     997  public <T> Query<R> setParameter(QueryParameter<T> param, T value)
     998  {
     999    query.setParameter(param, value);
     1000    return this;
     1001  }
     1002
     1003  @Override
     1004  public Query<R> setParameter(String name, Calendar value, TemporalType type)
     1005  {
     1006    query.setParameter(name, value, type);
     1007    return this;
     1008  }
     1009
     1010  @Override
     1011  public Query<R> setParameter(String name, Date value, TemporalType type)
     1012  {
     1013    query.setParameter(name, value, type);
     1014    return this;
     1015  }
     1016
     1017  @Override
     1018  public Query<R> setParameter(String name, Instant value, TemporalType type)
     1019  {
     1020    query.setParameter(name, value, type);
     1021    return this;
     1022  }
     1023
     1024  @Override
     1025  public Query<R> setParameter(String name, LocalDateTime value, TemporalType type)
     1026  {
     1027    query.setParameter(name, value, type);
     1028    return this;
     1029  }
     1030
     1031  @Override
     1032  public Query<R> setParameter(String name, OffsetDateTime value, TemporalType type)
     1033  {
     1034    query.setParameter(name, value, type);
     1035    return this;
     1036  }
     1037
     1038  @Override
     1039  public <P> Query<R> setParameter(String name, P value, TemporalType type)
     1040  {
     1041    query.setParameter(name, value, type);
     1042    return this;
     1043  }
     1044
     1045  @Override
     1046  public Query<R> setParameter(String name, ZonedDateTime value, TemporalType type)
     1047  {
     1048    query.setParameter(name, value, type);
     1049    return this;
     1050  }
     1051
     1052  @Override
     1053  public <P> Query<R> setParameterList(QueryParameter<P> param, Collection<P> values)
     1054  {
     1055    query.setParameterList(param, values);
     1056    return this;
     1057  }
     1058
     1059  @Override
     1060  public Stream<R> stream()
     1061  {
     1062    return query.stream();
     1063  }
     1064
     1065  @Override
     1066  public Optional<R> uniqueResultOptional()
     1067  {
     1068    return query.uniqueResultOptional();
    6811069  }
    6821070
Note: See TracChangeset for help on using the changeset viewer.