public Pager findPager(Pager pager, Criteria criteria) { Assert.notNull(pager, "pager is required"); Assert.notNull(criteria, "criteria is required"); Integer pageNumber = pager.getPageNumber(); Integer pageSize = pager.getPageSize(); String searchBy = pager.getSearchBy(); String keyword = pager.getKeyword(); String orderBy = pager.getOrderBy(); Pager.Order order = pager.getOrder(); if (StringUtils.isNotEmpty(searchBy) && StringUtils.isNotEmpty(keyword)) { if (searchBy.contains(".")) { String alias = StringUtils.substringBefore(searchBy, "."); criteria.createAlias(alias, alias); } criteria.add(Restrictions.like(searchBy, "%" + keyword + "%")); } pager.setTotalCount(criteriaResultTotalCount(criteria)); if (StringUtils.isNotEmpty(orderBy) && order != null) { if (order == Pager.Order.asc) { criteria.addOrder(Order.asc(orderBy)); } else { criteria.addOrder(Order.desc(orderBy)); } } ClassMetadata classMetadata = sessionFactory.getClassMetadata(entityClass); if (!StringUtils.equals(orderBy, ORDER_LIST_PROPERTY_NAME) && ArrayUtils.contains(classMetadata.getPropertyNames(), ORDER_LIST_PROPERTY_NAME)) { criteria.addOrder(Order.asc(ORDER_LIST_PROPERTY_NAME)); criteria.addOrder(Order.desc(CREATE_DATE_PROPERTY_NAME)); if (StringUtils.isEmpty(orderBy) || order == null) { pager.setOrderBy(ORDER_LIST_PROPERTY_NAME); pager.setOrder(Pager.Order.asc); } } else if (!StringUtils.equals(orderBy, CREATE_DATE_PROPERTY_NAME) && ArrayUtils.contains(classMetadata.getPropertyNames(), CREATE_DATE_PROPERTY_NAME)) { criteria.addOrder(Order.desc(CREATE_DATE_PROPERTY_NAME)); if (StringUtils.isEmpty(orderBy) || order == null) { pager.setOrderBy(CREATE_DATE_PROPERTY_NAME); pager.setOrder(Pager.Order.desc); } } criteria.setFirstResult((pageNumber - 1) * pageSize); criteria.setMaxResults(pageSize); pager.setResult(criteria.list()); return pager; }
@SuppressWarnings("unchecked") public List<T> getAllList() { ClassMetadata classMetadata = sessionFactory.getClassMetadata(entityClass); String hql; if (ArrayUtils.contains(classMetadata.getPropertyNames(), ORDER_LIST_PROPERTY_NAME)) { hql = "from " + entityClass.getName() + " as entity order by entity." + ORDER_LIST_PROPERTY_NAME + " desc"; } else { hql = "from " + entityClass.getName(); } return getSession().createQuery(hql).list(); }
/** * examines all {@link Type types} for this class and stores pointers to those fields which * represent {@link IObject} instances. These fields may need to be locked when an object of * this type is created or updated. */ Locks(ClassMetadata classMetadata) { this.cm = classMetadata; String[] name = cm.getPropertyNames(); Type[] type = cm.getPropertyTypes(); List<String[]> checks = new ArrayList<String[]>(); List<String[]> groupChecks = new ArrayList<String[]>(); this.size = type.length; this.include = new boolean[size]; this.subnames = new String[size][]; this.subtypes = new Type[size][]; for (int i = 0; i < type.length; i++) { if (type[i].isComponentType() && ((ComponentType) type[i]).isEmbedded()) { EmbeddedComponentType embedded = (EmbeddedComponentType) type[i]; String[] sub_name = embedded.getPropertyNames(); Type[] sub_type = embedded.getSubtypes(); List<String> name_list = new ArrayList<String>(); List<Type> type_list = new ArrayList<Type>(); for (int j = 0; j < sub_type.length; j++) { if (IObject.class.isAssignableFrom(sub_type[j].getReturnedClass())) { String path = name[i] + "." + sub_name[j]; name_list.add(path); type_list.add(sub_type[j]); addCheck(checks, groupChecks, sub_type[j].getReturnedClass(), path); } } add( i, name_list.toArray(new String[name_list.size()]), type_list.toArray(new Type[type_list.size()])); } else if (IObject.class.isAssignableFrom(type[i].getReturnedClass())) { add(i); addCheck(checks, groupChecks, type[i].getReturnedClass(), name[i]); // Create checks for } } this.checks = checks.toArray(new String[checks.size()][]); this.groupChecks = groupChecks.toArray(new String[groupChecks.size()][]); }
private void addChildExampleCriteria(Object exampleInstance, Criteria criteria, Session sesion) { ClassMetadata metadata = sesion.getSessionFactory().getClassMetadata(exampleInstance.getClass()); String[] propertyNames = metadata.getPropertyNames(); Type[] propertyTypes = metadata.getPropertyTypes(); // see if this example instance has any properties that are entities for (int i = 0; i < propertyNames.length; i++) { String propertyName = propertyNames[i]; Type propertyType = propertyTypes[i]; if (propertyType instanceof EntityType) { // this property is an association - Hibernate's Example ignores // these Object value = metadata.getPropertyValue(exampleInstance, propertyName, EntityMode.POJO); if (value != null) { ClassMetadata childMetadata = sesion.getSessionFactory().getClassMetadata(value.getClass()); Criteria childCriteria = criteria.createCriteria(propertyName); if (childMetadata.hasIdentifierProperty()) { Object id = childMetadata.getIdentifier(value, EntityMode.POJO); if (id != null) { // add the identifier to the child criteria childCriteria.add(Restrictions.eq(childMetadata.getIdentifierPropertyName(), id)); } } // add the entity's fields as Example fields childCriteria.add(Example.create(value)); // add this entity's associations addChildExampleCriteria(value, childCriteria, sesion); } } } // ~for }
/** * For each of the fields contained in this {@link Locks} object, parse out the type and the * field name and store those as the key and value in the "value" argument. */ public void fillRelationships(SessionFactoryImplementor sfi, Map<String, Relationship> value) { final Type[] types = cm.getPropertyTypes(); for (int t = 0; t < types.length; t++) { final Type type = types[t]; final String name = type.getName(); String to = null; Relationship field = null; if (type instanceof EntityType) { final EntityType entType = (EntityType) type; to = entType.getAssociatedEntityName(); field = new Relationship(cm.getPropertyNames()[t], false); } else if (types[t] instanceof CollectionType) { final CollectionType colType = (CollectionType) types[t]; final Type elemType = colType.getElementType(sfi); if (!elemType.isEntityType()) { continue; // The case for count maps and other primitives. } to = elemType.getName(); int open = name.indexOf("("); int close = name.lastIndexOf(")"); String role = name.substring(open + 1, close); int dot = role.lastIndexOf("."); field = new Relationship(role.substring(dot + 1), true); } if (to != null && field != null) { Map<String, ClassMetadata> m = sfi.getAllClassMetadata(); for (Class<?> c : Impl.hierarchy(m, to)) { value.put(c.getName(), field); } } } }
/** * examines all model objects to see which fields contain a {@link Type} which points to this * class. Uses {@link #locksFields(Type[])} since this is the inverse process. */ private String[][] lockedByFields(String klass, Map<String, ClassMetadata> m) { if (m == null) { throw new InternalException("ClassMetadata map cannot be null."); } List<String[]> fields = new ArrayList<String[]>(); for (String k : m.keySet()) { ClassMetadata cm = m.get(k); Type[] type = cm.getPropertyTypes(); String[] names = cm.getPropertyNames(); Locks inverse = locksHolder.get(k); for (int i = 0; i < inverse.size(); i++) { if (!inverse.include(i)) { continue; } // this is an embedded component and must be treated // specially. specifically, that we cannot compare against // the top-level returnedClass name but rather against // each of the individual subtype returnedClass names. if (inverse.hasSubtypes(i)) { for (int j = 0; j < inverse.numberOfSubtypes(i); j++) { if (inverse.subtypeEquals(i, j, klass)) { fields.add(new String[] {k, inverse.subtypeName(i, j)}); } } } // no subtypes so can compare directly else if (klass.equals(type[i].getReturnedClass().getName())) { fields.add(new String[] {k, names[i]}); } } } return fields.toArray(new String[fields.size()][2]); }
public void /*test*/ AddNewProperty() { System.out.println("******************* testAddNewProperty ********************"); PersistentClass userMapping = HibernateUtil.getClassMapping(User.class); Column column = new Column(); column.setName("MOTTO"); column.setNullable(false); column.setUnique(true); column.setSqlType("VARCHAR"); userMapping.getTable().addColumn(column); SimpleValue value = new SimpleValue(); value.setTable(userMapping.getTable()); value.addColumn(column); value.setTypeName("string"); Property prop = new Property(); prop.setValue(value); prop.setName("motto"); prop.setPropertyAccessorName("field"); prop.setNodeName(prop.getName()); userMapping.addProperty(prop); HibernateUtil.rebuildSessionFactory(); ClassMetadata metadata = HibernateUtil.getClassMetadata(User.class); String[] propNames = metadata.getPropertyNames(); boolean mottoFound = false; for (int i = 0; i < propNames.length; i++) { String propName = propNames[i]; if (propName.equalsIgnoreCase("motto")) { mottoFound = true; break; } } assertTrue(mottoFound); }