Changeset 5345


Ignore:
Timestamp:
May 17, 2010, 12:44:31 PM (13 years ago)
Author:
Nicklas Nordborg
Message:

Fixes #1488: Update to Hibernate 3.5.2

Location:
trunk
Files:
20 edited

Legend:

Unmodified
Added
Removed

  • trunk/doc/3rd-party-components.txt

    r5319 r5345  
    4040
    4141More info : http://www.hibernate.org/
    42 Version   : 3.5.0
     42Version   : 3.5.2
    4343License   : LGPL (hibernate.license.txt)
    4444Jar files : hibernate3.jar, antlr-2.7.6.jar, c3p0-0.9.1.jar,

  • trunk/doc/src/docbook/appendix/incompatible.xml

    r5325 r5345  
    6868    </para>
    6969   
    70     <bridgehead>
    71       ReporterFlatFileImporter store file parser settings as job parameters
    72     </bridgehead>
    73     <para>
    74       This change was introduced since it should be possible to run the plug-in
    75       without a configuration. Existing code that uses this plug-in outside the
    76       web client, may fail due to not setting required parameter values as job
    77       parameters.
     70    <bridgehead>Type.getHibernateType() and VirtualColumn.getType()</bridgehead>
     71    <para>
     72      Due to internal changes in Hibernate 3.5.2 the two methods have been
     73      deprecated. We expect more changes in the future (Hibernate 3.6) that
     74      may force us to remove the two methods from the BASE API. Existing code
     75      should be updated to use <code>Type.getTypeWrapper()</code> and
     76      <code>VirtualColumn.getTypeWrapper()</code>
     77      instead. Since the new methods may not provide the same information as the old
     78      methods developers are encouraged to discuss any problems and workarounds
     79      with the BASE team on the developer mailing list. Under all circumstances
     80      it is important to stop using the deprecated methods.
    7881    </para>
    7982  </sect1>

  • trunk/src/core/net/sf/basedb/core/AbstractHqlQuery.java

    r5319 r5345  
    328328        else
    329329        {
    330           query.setParameterList(name, c.size() == 0 ? ZERO_SET : c, valueType.getHibernateType());
     330          query.setParameterList(name, c.size() == 0 ? ZERO_SET : c,
     331            valueType.getTypeWrapper().getHibernateType());
    331332        }
    332333      }
    … …  
    343344        else
    344345        {
    345           query.setParameter(name, value, valueType.getHibernateType());
     346          query.setParameter(name, value, valueType.getTypeWrapper().getHibernateType());
    346347        }
    347348      }

  • trunk/src/core/net/sf/basedb/core/AnnotationRestriction.java

    r5320 r5345  
    2424package net.sf.basedb.core;
    2525
     26import net.sf.basedb.core.hibernate.TypeWrapper;
    2627import net.sf.basedb.core.query.Query;
    2728import net.sf.basedb.core.query.QueryElement;
    … …  
    194195    org.hibernate.Session session = dc.getHibernateSession();
    195196    SQLQuery sqlQuery = HibernateUtil.createSqlQuery(session, sql);
    196     sqlQuery.addScalar("annotationset_id", org.hibernate.Hibernate.INTEGER);
     197    sqlQuery.addScalar("annotationset_id", TypeWrapper.INTEGER.getHibernateType());
    197198    if (includeInheriting)
    198199    {
    199       sqlQuery.addScalar("id", org.hibernate.Hibernate.INTEGER);
     200      sqlQuery.addScalar("id", TypeWrapper.INTEGER.getHibernateType());
    200201    }
    201202    sqlQuery.setInteger("annotationType", annotationTypeId);
    … …  
    228229       
    229230        sqlQuery = HibernateUtil.createSqlQuery(session, sql);
    230         sqlQuery.addScalar("sid", org.hibernate.Hibernate.INTEGER);
     231        sqlQuery.addScalar("sid", TypeWrapper.INTEGER.getHibernateType());
    231232        if (debugSqlEnabled) logSql.debug("Executing annotation query: " + sql);
    232233        List<Integer> ids = HibernateUtil.loadList(Integer.class, sqlQuery, sc);

  • trunk/src/core/net/sf/basedb/core/AnyToAny.java

    r5021 r5345  
    2525import java.util.List;
    2626
    27 import org.hibernate.Hibernate;
    2827import org.hibernate.mapping.PersistentClass;
    2928import org.hibernate.mapping.Table;
    … …  
    3130import net.sf.basedb.core.Transactional.Action;
    3231import net.sf.basedb.core.data.AnyToAnyData;
     32import net.sf.basedb.core.hibernate.TypeWrapper;
    3333import net.sf.basedb.core.query.Expressions;
    3434import net.sf.basedb.core.query.Hql;
    … …  
    415415        if (stray.size() > 0)
    416416        {
    417           deleteQuery.setParameterList("ids", stray, Hibernate.INTEGER);
     417          deleteQuery.setParameterList("ids", stray, TypeWrapper.INTEGER.getHibernateType());
    418418          numDeleted += HibernateUtil.executeUpdate(deleteQuery);
    419419        }

  • trunk/src/core/net/sf/basedb/core/ChangeHistory.java

    r5048 r5345  
    2525import java.util.List;
    2626
    27 import org.hibernate.Hibernate;
    2827import org.hibernate.mapping.PersistentClass;
    2928import org.hibernate.mapping.Table;
    3029
    3130import net.sf.basedb.core.data.ChangeHistoryDetailData;
     31import net.sf.basedb.core.hibernate.TypeWrapper;
    3232import net.sf.basedb.core.log.ChangeType;
    3333import net.sf.basedb.core.query.Expressions;
    … …  
    221221        if (stray.size() > 0)
    222222        {
    223           deleteQuery.setParameterList("ids", stray, Hibernate.INTEGER);
     223          deleteQuery.setParameterList("ids", stray, TypeWrapper.INTEGER.getHibernateType());
    224224          numDeleted += HibernateUtil.executeUpdate(deleteQuery);
    225225        }

  • trunk/src/core/net/sf/basedb/core/Experiment.java

    r4889 r5345  
    2525
    2626import net.sf.basedb.core.data.ExperimentData;
     27import net.sf.basedb.core.hibernate.TypeWrapper;
    2728import net.sf.basedb.core.query.Restrictions;
    2829import net.sf.basedb.core.query.Hql;
    … …  
    795796        WHERE job.id IN (:list)
    796797      */
    797       query.setParameterList("list", jobs, Type.INT.getHibernateType());
     798      query.setParameterList("list", jobs, TypeWrapper.INTEGER.getHibernateType());
    798799      HibernateUtil.executeUpdate(query);
    799800    }

  • trunk/src/core/net/sf/basedb/core/Group.java

    r5077 r5345  
    2525
    2626import net.sf.basedb.core.data.GroupData;
     27import net.sf.basedb.core.hibernate.TypeWrapper;
    2728import net.sf.basedb.core.query.EntityQuery;
    2829import net.sf.basedb.core.query.Restriction;
    … …  
    147148      do
    148149      {
    149         query.setParameterList("groups", allGroups, org.hibernate.Hibernate.INTEGER);
     150        query.setParameterList("groups", allGroups, TypeWrapper.INTEGER.getHibernateType());
    150151      } while (allGroups.addAll(HibernateUtil.loadList(Integer.class, query, null)));
    151152    }

  • trunk/src/core/net/sf/basedb/core/HibernateUtil.java

    r5319 r5345  
    4141import net.sf.basedb.core.hibernate.EntityQueryWrapper;
    4242import net.sf.basedb.core.hibernate.ExecuteUpdateWork;
     43import net.sf.basedb.core.hibernate.TypeWrapper;
    4344import net.sf.basedb.core.hibernate.JdbcWork;
    4445import net.sf.basedb.core.hibernate.MultiUpdateWork;
    … …  
    367368    SimpleValue v = new SimpleValue(t);
    368369    v.addColumn(c);
    369     v.setTypeName(ep.getType().getHibernateType().getName());
     370    v.setTypeName(ep.getType().getTypeWrapper().getHibernateType().getName());
    370371
    371372    Property p = new Property();
    … …  
    485486  {
    486487    cfg.addSqlFunction("rlike",
    487       new SQLFunctionTemplate(Hibernate.BOOLEAN, "(" + dbEngine.rlike("?1", "?2") + ")"));
     488      new SQLFunctionTemplate(TypeWrapper.BOOLEAN.getHibernateType(), "(" + dbEngine.rlike("?1", "?2") + ")"));
    488489  }
    489490 
    … …  
    831832    // Create Hibernate Column mapping
    832833    Column hibernateColumn = new Column("`"+column.getColumn()+"`");
    833     hibernateColumn.setSqlTypeCode(column.getType().sqlType());
     834    hibernateColumn.setSqlTypeCode(column.getTypeWrapper().getSQLType());
    834835    hibernateColumn.setNullable(column.isNullable());
    835836    hibernateColumn.setLength(column.getSize());
    … …  
    837838    // Create Hibernate SimpleValue mapping
    838839    SimpleValue hibernateValue = new SimpleValue();
    839     hibernateValue.setTypeName(column.getType().getName());
     840    hibernateValue.setTypeName(column.getTypeWrapper().getHibernateType().getName());
    840841    hibernateValue.addColumn(hibernateColumn);
    841842   

  • trunk/src/core/net/sf/basedb/core/ItemKey.java

    r5023 r5345  
    2727import net.sf.basedb.core.data.GroupData;
    2828import net.sf.basedb.core.data.ShareableData;
     29import net.sf.basedb.core.hibernate.TypeWrapper;
    2930
    3031import java.util.Map;
    … …  
    188189        WHERE ik.id NOT IN (:used)
    189190      */
    190       query.setParameterList("used", used, org.hibernate.Hibernate.INTEGER);
     191      query.setParameterList("used", used, TypeWrapper.INTEGER.getHibernateType());
    191192      List<ItemKeyData> unused = HibernateUtil.loadList(ItemKeyData.class, query, null);
    192193      for (ItemKeyData ik : unused)
    … …  
    413414          "HAVING COUNT(uk.userId) = :numPermissions"
    414415        );
    415         query.setParameterList("candidates", candidates, org.hibernate.Hibernate.INTEGER);
     416        query.setParameterList("candidates", candidates, TypeWrapper.INTEGER.getHibernateType());
    416417        query.setInteger("numPermissions", numPermissions);
    417418        candidates = HibernateUtil.loadList(Integer.class, query, null);
    … …  
    432433        */
    433434        query.setInteger("numPermissions", numPermissions);
    434         query.setParameterList("candidates", candidates, org.hibernate.Hibernate.INTEGER);
     435        query.setParameterList("candidates", candidates, TypeWrapper.INTEGER.getHibernateType());
    435436        candidates = HibernateUtil.loadList(Integer.class, query, null);       
    436437      }
    … …  
    456457          "HAVING COUNT(gk.groupId) = :numPermissions"
    457458        );
    458         query.setParameterList("candidates", candidates, org.hibernate.Hibernate.INTEGER);
     459        query.setParameterList("candidates", candidates, TypeWrapper.INTEGER.getHibernateType());
    459460        query.setInteger("numPermissions", numPermissions);
    460461        candidates = HibernateUtil.loadList(Integer.class, query, null);

  • trunk/src/core/net/sf/basedb/core/Keyring.java

    r5091 r5345  
    3030import net.sf.basedb.core.data.ItemKeyData;
    3131import net.sf.basedb.core.data.ProjectKeyData;
     32import net.sf.basedb.core.hibernate.TypeWrapper;
    3233
    3334import org.hibernate.HibernateException;
    … …  
    379380        do
    380381        {
    381           query.setParameterList("groups", temp, org.hibernate.Hibernate.INTEGER);
     382          query.setParameterList("groups", temp, TypeWrapper.INTEGER.getHibernateType());
    382383        } while (temp.addAll(HibernateUtil.loadList(Integer.class, query, null)));
    383384        // repeat until no more new groups are found
    … …  
    395396        AND grp.id IN (:groups)
    396397      */
    397       query.setParameterList("groups", groups, org.hibernate.Hibernate.INTEGER);
     398      query.setParameterList("groups", groups, TypeWrapper.INTEGER.getHibernateType());
    398399      temp = new HashSet<Integer>(HibernateUtil.loadList(Integer.class, query, null));
    399400      groupsWithNonHiddenMembers = Collections.unmodifiableSet(temp);
    … …  
    451452          WHERE gp.groupId IN (:groups)
    452453        */
    453         query.setParameterList("groups", groups, org.hibernate.Hibernate.INTEGER);
     454        query.setParameterList("groups", groups, TypeWrapper.INTEGER.getHibernateType());
    454455        for (GroupProjects gp : HibernateUtil.loadList(GroupProjects.class, query, null))
    455456        {
    … …  
    521522            AND grp.id IN (:groups)
    522523          */
    523           query.setParameterList("groups", projectGroups, org.hibernate.Hibernate.INTEGER);
     524          query.setParameterList("groups", projectGroups, TypeWrapper.INTEGER.getHibernateType());
    524525          projectGroups.retainAll(HibernateUtil.loadList(Integer.class, query, null));
    525526        }
    … …  
    565566          WHERE gk.groupId IN (:groups)
    566567        */
    567         query.setParameterList("groups", groups, org.hibernate.Hibernate.INTEGER);
     568        query.setParameterList("groups", groups, TypeWrapper.INTEGER.getHibernateType());
    568569        keys.addAll(HibernateUtil.loadList(KeyPermission.class, query, null));
    569570      }

  • trunk/src/core/net/sf/basedb/core/Metadata.java

    r5319 r5345  
    4848import org.hibernate.type.ComponentType;
    4949import org.hibernate.type.EntityType;
    50 import org.hibernate.type.ImmutableType;
     50import org.hibernate.type.ManyToOneType;
    5151import org.hibernate.type.MapType;
    5252import org.hibernate.EntityMode;
    53 import org.hibernate.Hibernate;
    5453
    5554/**
    … …  
    310309    @since 2.15
    311310  */
    312   @SuppressWarnings("unchecked")
     311  @SuppressWarnings({ "unchecked", "deprecation" })
    313312  public <V> PropertyPath<C, V> getPropertyPath(String path, boolean ignoreCase)
    314313  {
    … …  
    319318    String[] pathElements = path.split("\\.|\\#");
    320319    ClassMetadata metadata = classMetadata;
    321     org.hibernate.type.Type nextType = Hibernate.entity(entityName);
     320    org.hibernate.type.Type nextType = new ManyToOneType(entityName);
    322321    List<PropertyPath> propertyPath = new ArrayList<PropertyPath>();
    323322   
    … …  
    412411      propertyPath.add(new BasicData2ItemPropertyPath(Item.fromDataClass(returnClass), nextType));
    413412    }
    414     else if (nextType instanceof ImmutableType)
     413    else if (nextType instanceof org.hibernate.type.ImmutableType)
    415414    {
    416415      // Safe to return the value unprocessed

  • trunk/src/core/net/sf/basedb/core/PluginDefinition.java

    r5319 r5345  
    3838import net.sf.basedb.core.data.PluginTypeData;
    3939import net.sf.basedb.core.data.GuiContextData;
     40import net.sf.basedb.core.hibernate.TypeWrapper;
    4041import net.sf.basedb.util.ClassUtil;
    4142import net.sf.basedb.util.JarClassLoader;
    … …  
    369370    Set<Integer> itemKeys = sc.getItemKeys(Permission.USE);
    370371    if (itemKeys == null || itemKeys.size() == 0) itemKeys = ZERO_SET;
    371     query.setParameterList("itemKeys", itemKeys, org.hibernate.Hibernate.INTEGER);
     372    query.setParameterList("itemKeys", itemKeys, TypeWrapper.INTEGER.getHibernateType());
    372373
    373374    // Project keys for the active project
    … …  
    375376    if (sc.getActiveProjectId() != 0) projectKeys = sc.getProjectKeys(Permission.USE);
    376377    if (projectKeys == null || projectKeys.size() == 0) projectKeys = ZERO_SET;
    377     query.setParameterList("projectKeys", projectKeys, org.hibernate.Hibernate.INTEGER);
     378    query.setParameterList("projectKeys", projectKeys, TypeWrapper.INTEGER.getHibernateType());
    378379 
    379380    List<Object> pluginCount = HibernateUtil.loadList(Object.class, query, dc.getSessionControl());

  • trunk/src/core/net/sf/basedb/core/ProjectKey.java

    r5023 r5345  
    2626import net.sf.basedb.core.data.ProjectData;
    2727import net.sf.basedb.core.data.ShareableData;
     28import net.sf.basedb.core.hibernate.TypeWrapper;
    2829
    2930import java.util.Map;
    … …  
    159160        WHERE pk.id NOT IN (:used)
    160161      */
    161       query.setParameterList("used", used, org.hibernate.Hibernate.INTEGER);
     162      query.setParameterList("used", used, TypeWrapper.INTEGER.getHibernateType());
    162163      List<ProjectKeyData> unused = HibernateUtil.loadList(ProjectKeyData.class, query, null);
    163164      for (ProjectKeyData pk : unused)
    … …  
    344345          "HAVING COUNT(pk.projectId) = :numPermissions"
    345346        );
    346         query.setParameterList("candidates", candidates, org.hibernate.Hibernate.INTEGER);
     347        query.setParameterList("candidates", candidates, TypeWrapper.INTEGER.getHibernateType());
    347348        query.setInteger("numPermissions", numPermissions);
    348349        candidates = HibernateUtil.loadList(Integer.class, query, null);

  • trunk/src/core/net/sf/basedb/core/Type.java

    r5319 r5345  
    3333import net.sf.basedb.core.data.StringParameterValueData;
    3434import net.sf.basedb.core.data.BooleanParameterValueData;
    35 
    36 import org.hibernate.Hibernate;
    37 import org.hibernate.type.NullableType;
     35import net.sf.basedb.core.hibernate.TypeWrapper;
    3836
    3937import java.text.NumberFormat;
    … …  
    5654    Integer type.
    5755  */
    58   INT(Hibernate.INTEGER, 1, Integer.class, "int", "Integer", "IntegerValues", true, true)
     56  INT(TypeWrapper.INTEGER, 1, Integer.class, "int", "Integer", "IntegerValues", true, true)
    5957  {
    6058    ParameterValueData<Integer> newParameterValueData()
    … …  
    8179    Long integer type.
    8280  */
    83   LONG(Hibernate.LONG, 2, Long.class, "long", "Long", "LongValues", true, true)
     81  LONG(TypeWrapper.LONG, 2, Long.class, "long", "Long", "LongValues", true, true)
    8482  {
    8583    ParameterValueData<Long> newParameterValueData()
    … …  
    106104    Float type.
    107105  */
    108   FLOAT(Hibernate.FLOAT, 3, Float.class, "float", "Float", "FloatValues", true, true)
     106  FLOAT(TypeWrapper.FLOAT, 3, Float.class, "float", "Float", "FloatValues", true, true)
    109107  {
    110108    ParameterValueData<Float> newParameterValueData()
    … …  
    133131    Double type.
    134132  */
    135   DOUBLE(Hibernate.DOUBLE, 4, Double.class, "double", "Double", "DoubleValues", true, true)
     133  DOUBLE(TypeWrapper.DOUBLE, 4, Double.class, "double", "Double", "DoubleValues", true, true)
    136134  {
    137135    ParameterValueData<Double> newParameterValueData()
    … …  
    161159    @see #TEXT
    162160  */
    163   STRING(Hibernate.STRING, 5, String.class, "string", "String", "StringValues", true, false)
     161  STRING(TypeWrapper.STRING, 5, String.class, "string", "String", "StringValues", true, false)
    164162  {
    165163    ParameterValueData<String> newParameterValueData()
    … …  
    170168    {
    171169      return value == null ? 0 : value.toString().length();
     170    }
     171    @Override
     172    public Object parseString(String value)
     173      throws InvalidDataException
     174    {
     175      return value;
    172176    }
    173177  },
    … …  
    177181    @see #STRING
    178182  */
    179   TEXT(Hibernate.TEXT, 6, String.class, "text", "Text", "TextValues", false, false)
     183  TEXT(TypeWrapper.TEXT, 6, String.class, "text", "Text", "TextValues", false, false)
    180184  {
    181185    ParameterValueData<String> newParameterValueData()
    … …  
    187191      return value == null ? 0 : value.toString().length();
    188192    }
     193    @Override
     194    public Object parseString(String value)
     195      throws InvalidDataException
     196    {
     197      return value;
     198    }
    189199  },
    190200
    … …  
    192202    Boolean type.
    193203  */
    194   BOOLEAN(Hibernate.BOOLEAN, 7, Boolean.class, "boolean", "Boolean", "BooleanValues", false, false)
     204  BOOLEAN(TypeWrapper.BOOLEAN, 7, Boolean.class, "boolean", "Boolean", "BooleanValues", false, false)
    195205  {
    196206    ParameterValueData<Boolean> newParameterValueData()
    … …  
    221231    The parameter is a date value.
    222232  */
    223   DATE(Hibernate.DATE, 8, Date.class, "date", "Date", "DateValues", true, false)
     233  DATE(TypeWrapper.DATE, 8, Date.class, "date", "Date", "DateValues", true, false)
    224234  {
    225235    ParameterValueData<Date> newParameterValueData()
    … …  
    253263
    254264
    255   private final NullableType hibernateType;
     265  private final TypeWrapper typeWrapper;
    256266  private final int value;
    257267  private final Class<?> valueClass;
    … …  
    262272  private final boolean isNumerical;
    263273
    264   private Type(NullableType hibernateType, int value, Class<?> valueClass,
     274  private Type(TypeWrapper typeWrapper, int value, Class<?> valueClass,
    265275    String stringValue, String displayValue, String tableName, boolean canEnumerate, boolean isNumerical)
    266276  {
    267     this.hibernateType = hibernateType;
     277    this.typeWrapper = typeWrapper;
    268278    this.value = value;
    269279    this.valueClass = valueClass;
    … …  
    283293    Get the hibernate type of this parameter
    284294    @return The hibernate type of the parameter
    285   */
    286   public NullableType getHibernateType()
    287   {
    288     return hibernateType;
    289   }
    290 
     295    @deprecated In 2.16. The NullableType class was deprecated in Hibernate 3.5.2.
     296      It will be removed in Hibernate 3.6. Since BASE probably will switch to newer
     297      Hibernate versions in the future this method will also be removed. The
     298      {@link #getTypeWrapper()} is intended to replace this method, but it may
     299      not provide the same information that a NullableType can. Problems are solved
     300      on a case-by-case basis. Please ask on the BASE developers mailing list if
     301      you have any issues related to this.
     302  */
     303  @Deprecated
     304  public org.hibernate.type.NullableType getHibernateType()
     305  {
     306    return (org.hibernate.type.NullableType)typeWrapper.getHibernateType();
     307  }
     308
     309  /**
     310    Get a wrapper for accessing underlying type information from Hibernate.
     311    @since 2.16
     312  */
     313  public TypeWrapper getTypeWrapper()
     314  {
     315    return typeWrapper;
     316  }
     317 
    291318  /**
    292319    Get the integer value that is used when storing a type in the database.
    … …  
    324351  public int getSQLType()
    325352  {
    326     return hibernateType.sqlType();
     353    return typeWrapper.getSQLType();
    327354  }
    328355
    … …  
    438465    @throws InvalidDataException If the argument is corrupt.
    439466  */
    440   public Object parseString(String value)
    441     throws InvalidDataException
    442   {
    443     if (value == null)
    444     {
    445       return null;
    446     }
    447     else
    448     {
    449       return getHibernateType().fromStringValue(value);
    450     }
    451   }
     467  public abstract Object parseString(String value)
     468    throws InvalidDataException;
    452469 
    453470  /**
    … …  
    576593    for (Type t : Type.values())
    577594    {
    578       if (t.getHibernateType().equals(hibernateType)) return t;
     595      if (t.getTypeWrapper().getHibernateType().equals(hibernateType)) return t;
    579596    }
    580597    // TODO -- The Hibernate type model is more fine-grained

  • trunk/src/core/net/sf/basedb/core/Update.java

    r5338 r5345  
    6666import net.sf.basedb.core.dbengine.TableInfo;
    6767import net.sf.basedb.core.hibernate.ExecuteUpdateWork;
     68import net.sf.basedb.core.hibernate.TypeWrapper;
    6869import net.sf.basedb.core.hibernate.TableInfoWork;
    6970
    … …  
    16601661      if (ids.size() > 0)
    16611662      {
    1662         duQuery.setParameter("itemType", Item.FILE.getValue(), org.hibernate.Hibernate.INTEGER);
    1663         duQuery.setParameterList("itemList", ids, org.hibernate.Hibernate.INTEGER);
     1663        duQuery.setParameter("itemType", Item.FILE.getValue(), TypeWrapper.INTEGER.getHibernateType());
     1664        duQuery.setParameterList("itemList", ids, TypeWrapper.INTEGER.getHibernateType());
    16641665        HibernateUtil.executeUpdate(duQuery);
    16651666      }
    … …  
    16751676      if (ids.size() > 0)
    16761677      {
    1677         duQuery.setParameter("itemType", Item.EXPERIMENT.getValue(), org.hibernate.Hibernate.INTEGER);
    1678         duQuery.setParameterList("itemList", ids, org.hibernate.Hibernate.INTEGER);
     1678        duQuery.setParameter("itemType", Item.EXPERIMENT.getValue(), TypeWrapper.INTEGER.getHibernateType());
     1679        duQuery.setParameterList("itemList", ids, TypeWrapper.INTEGER.getHibernateType());
    16791680        HibernateUtil.executeUpdate(duQuery);
    16801681      }
    … …  
    16901691      if (ids.size() > 0)
    16911692      {
    1692         duQuery.setParameter("itemType", Item.RAWBIOASSAY.getValue(), org.hibernate.Hibernate.INTEGER);
    1693         duQuery.setParameterList("itemList", ids, org.hibernate.Hibernate.INTEGER);
     1693        duQuery.setParameter("itemType", Item.RAWBIOASSAY.getValue(), TypeWrapper.INTEGER.getHibernateType());
     1694        duQuery.setParameterList("itemList", ids, TypeWrapper.INTEGER.getHibernateType());
    16941695        HibernateUtil.executeUpdate(duQuery);
    16951696      }

  • trunk/src/core/net/sf/basedb/core/User.java

    r5167 r5345  
    3232import net.sf.basedb.core.data.QuotaData;
    3333import net.sf.basedb.core.data.DirectoryData;
     34import net.sf.basedb.core.hibernate.TypeWrapper;
    3435import net.sf.basedb.util.MD5;
    3536import net.sf.basedb.core.query.Restriction;
    … …  
    147148        WHERE ug.groupId IN (:groups)
    148149      */
    149       query.setParameterList("groups", groupIds, org.hibernate.Hibernate.INTEGER);
     150      query.setParameterList("groups", groupIds, TypeWrapper.INTEGER.getHibernateType());
    150151      userIds.addAll(HibernateUtil.loadList(Integer.class, query, null));
    151152     
    … …  
    157158        WHERE usr.quotaGroup.id IN (:groups)
    158159      */
    159       query.setParameterList("groups", groupIds, org.hibernate.Hibernate.INTEGER);
     160      query.setParameterList("groups", groupIds, TypeWrapper.INTEGER.getHibernateType());
    160161      userIds.addAll(HibernateUtil.loadList(Integer.class, query, null));
    161162    }

  • trunk/src/core/net/sf/basedb/core/VirtualColumn.java

    r5320 r5345  
    2424package net.sf.basedb.core;
    2525
    26 import org.hibernate.Hibernate;
    27 import org.hibernate.type.NullableType;
     26import net.sf.basedb.core.hibernate.TypeWrapper;
    2827
    2928import java.util.Map;
    … …  
    6665  */
    6766  public static final VirtualColumn CUBE =
    68     new VirtualColumn("cube", "cube", Hibernate.SHORT, 0,
     67    new VirtualColumn("cube", "cube", TypeWrapper.SHORT, 0,
    6968      !INDEXED, !NULLABLE, PRIMARY_KEY, false);
    7069   
    … …  
    7473  */
    7574  public static final VirtualColumn LAYER =
    76     new VirtualColumn("layer", "layer", Hibernate.SHORT, 0,
     75    new VirtualColumn("layer", "layer", TypeWrapper.SHORT, 0,
    7776      !INDEXED, !NULLABLE, PRIMARY_KEY, false);
    7877
    … …  
    8281  */
    8382  public static final VirtualColumn COLUMN =
    84     new VirtualColumn("column", "column", Hibernate.SHORT, 0,
     83    new VirtualColumn("column", "column", TypeWrapper.SHORT, 0,
    8584      !INDEXED, !NULLABLE, PRIMARY_KEY, false);
    8685 
    … …  
    8988  */
    9089  public static final VirtualColumn POSITION =
    91     new VirtualColumn("position", "position", Hibernate.INTEGER, 0,
     90    new VirtualColumn("position", "position", TypeWrapper.INTEGER, 0,
    9291      !INDEXED, !NULLABLE, PRIMARY_KEY, false);
    9392
    … …  
    9796  */
    9897  public static final VirtualColumn FILTER =
    99     new VirtualColumn("filter", "filter", Hibernate.SHORT, 0,
     98    new VirtualColumn("filter", "filter", TypeWrapper.SHORT, 0,
    10099      !INDEXED, !NULLABLE, PRIMARY_KEY, false);
    101100
    … …  
    105104  */
    106105  public static final VirtualColumn EXTRA =
    107     new VirtualColumn("extra", "extra", Hibernate.SHORT, 0,
     106    new VirtualColumn("extra", "extra", TypeWrapper.SHORT, 0,
    108107      !INDEXED, !NULLABLE, PRIMARY_KEY, false);
    109108
    … …  
    114113  */
    115114  public static final VirtualColumn REPORTER_ID =
    116     new VirtualColumn("reporterId", "reporter_id", Hibernate.INTEGER, 0,
     115    new VirtualColumn("reporterId", "reporter_id", TypeWrapper.INTEGER, 0,
    117116      !INDEXED, NULLABLE, !PRIMARY_KEY, false);
    118117
    … …  
    123122  */
    124123  public static final VirtualColumn RAWDATA_ID =
    125     new VirtualColumn("rawDataId", "rawdata_id", Hibernate.INTEGER, 0,
     124    new VirtualColumn("rawDataId", "rawdata_id", TypeWrapper.INTEGER, 0,
    126125      !INDEXED, !NULLABLE, PRIMARY_KEY, false);
    127126 
    … …  
    132131  */
    133132  public static final VirtualColumn RAWBIOASSAY_ID =
    134     new VirtualColumn("rawBioAssayId", "rawbioassay_id", Hibernate.INTEGER, 0,
     133    new VirtualColumn("rawBioAssayId", "rawbioassay_id", TypeWrapper.INTEGER, 0,
    135134      !INDEXED, !NULLABLE, PRIMARY_KEY, false);
    136135
    … …  
    139138  */
    140139  public static final VirtualColumn EXTRA_INT =
    141     new VirtualColumn("extraInt", "value", Hibernate.INTEGER, 0,
     140    new VirtualColumn("extraInt", "value", TypeWrapper.INTEGER, 0,
    142141      !INDEXED, NULLABLE, !PRIMARY_KEY, false);
    143142
    … …  
    146145  */
    147146  public static final VirtualColumn EXTRA_FLOAT =
    148     new VirtualColumn("extraFloat", "value", Hibernate.FLOAT, 0,
     147    new VirtualColumn("extraFloat", "value", TypeWrapper.FLOAT, 0,
    149148      !INDEXED, NULLABLE, !PRIMARY_KEY, false);
    150149
    … …  
    153152  */
    154153  public static final VirtualColumn EXTRA_STRING =
    155     new VirtualColumn("extraString", "value", Hibernate.STRING, 255,
     154    new VirtualColumn("extraString", "value", TypeWrapper.STRING, 255,
    156155      !INDEXED, NULLABLE, !PRIMARY_KEY, false);
    157156
    … …  
    195194  public static VirtualColumn channelRaw(int channel)
    196195  {
    197     return new VirtualColumn("rch"+channel, "ch"+channel, Hibernate.FLOAT, 0,
     196    return new VirtualColumn("rch"+channel, "ch"+channel, TypeWrapper.FLOAT, 0,
    198197          !INDEXED, NULLABLE, !PRIMARY_KEY, false);
    199198  }
    … …  
    211210  public static VirtualColumn channelIntensity(int channel)
    212211  {
    213     return new VirtualColumn("ch"+channel, "ch"+channel, Hibernate.FLOAT, 0,
     212    return new VirtualColumn("ch"+channel, "ch"+channel, TypeWrapper.FLOAT, 0,
    214213          !INDEXED, NULLABLE, !PRIMARY_KEY, true);
    215214  }
    … …  
    241240    The data type of the column.
    242241  */
    243   private final NullableType type;
     242  private final TypeWrapper typeWrapper;
    244243 
    245244  /**
    … …  
    268267    Create a new virtual column.
    269268  */
    270   private VirtualColumn(String name, String column, NullableType type, int size,
     269  private VirtualColumn(String name, String column, TypeWrapper type, int size,
    271270    boolean indexed, boolean nullable, boolean primaryKey, boolean untransformIntensities)
    272271  {
    273272    this.name = name;
    274273    this.column = column;
    275     this.type = type;
     274    this.typeWrapper = type;
    276275    this.size = size;
    277276    this.indexed = indexed;
    … …  
    321320    Get the data type of the column.
    322321    @return a {@link org.hibernate.type.NullableType} object.
    323   */
    324   public NullableType getType()
    325   {
    326     return type;
     322    @deprecated In 2.16. The NullableType class was deprecated in Hibernate 3.5.2.
     323      It will be removed in Hibernate 3.6. Since BASE probably will switch to newer
     324      Hibernate versions in the future this method will also be removed. The
     325      {@link #getTypeWrapper()} is intended to replace this method, but it may
     326      not provide the same information that a NullableType can. Problems are solved
     327      on a case-by-case basis. Please ask on the BASE developers mailing list if
     328      you have any issues related to this.
     329  */
     330  public org.hibernate.type.NullableType getType()
     331  {
     332    return (org.hibernate.type.NullableType)typeWrapper.getHibernateType();
     333  }
     334 
     335  /**
     336    Get a wrapper for accessing underlying type information from Hibernate.
     337    @since 2.16
     338  */
     339  public TypeWrapper getTypeWrapper()
     340  {
     341    return typeWrapper;
    327342  }
    328343

  • trunk/src/core/net/sf/basedb/core/VirtualTable.java

    r4915 r5345  
    2323package net.sf.basedb.core;
    2424
    25 import org.hibernate.Hibernate;
     25import net.sf.basedb.core.hibernate.TypeWrapper;
     26
    2627import org.hibernate.dialect.Dialect;
    2728
    … …  
    327328    for (VirtualColumn vc : getColumns(rdt))
    328329    {
    329       org.hibernate.type.NullableType type = vc.getType();
    330       if (type == Hibernate.SHORT)
     330      TypeWrapper type = vc.getTypeWrapper();
     331      if (type == TypeWrapper.SHORT)
    331332      {
    332333        bytesPerRow += 2;
    333334      }
    334       else if (type == Hibernate.INTEGER)
     335      else if (type == TypeWrapper.INTEGER)
    335336      {
    336337        bytesPerRow += 4;
    337338      }
    338       else if (type == Hibernate.FLOAT)
     339      else if (type == TypeWrapper.FLOAT)
    339340      {
    340341        bytesPerRow += 4;
    341342      }
    342       else if (type == Hibernate.STRING)
     343      else if (type == TypeWrapper.STRING)
    343344      {
    344345        bytesPerRow += 0; // Actual string length is added by the batcher
Note: See TracChangeset for help on using the changeset viewer.