org.hibernate.criterion.Restrictions#not ( )源码实例Demo

public Criterion toHibernateCriterion() {
	Criterion restriction = null;
	switch (getMatch()) {
	case LIKE:
		restriction = Restrictions.like(getName(), (String) getValue(), MatchMode.ANYWHERE);
		break;
	case ILIKE:
		restriction = Restrictions.like(getName(), (String) getValue(), MatchMode.ANYWHERE).ignoreCase();
		break;
	case NOT_EQ:
		restriction = Restrictions.ne(getName(), getValue());
		break;
	case IN:
		restriction = Restrictions.in(getName(), (Object[]) getValue());
		break;
	case NOT_IN:
		restriction = Restrictions.not(Restrictions.in(getName(), (Object[]) getValue()));
		break;
	default:
		restriction = Restrictions.eq(getName(), getValue());
		break;
	}
	return restriction;
}
 

public static Criterion getCategoryCriterionRestriction(CategoryCriterion categoryCriterion) {
	Criterion restriction = null;
	if (categoryCriterion.prefix != null && categoryCriterion.prefix.length() > 0) {
		if (categoryCriterion.caseSensitive) {
			restriction = Restrictions.like(categoryCriterion.field, categoryCriterion.prefix, categoryCriterion.matchMode);
		} else {
			restriction = Restrictions.ilike(categoryCriterion.field, categoryCriterion.prefix, categoryCriterion.matchMode);
		}
	} else if (EmptyPrefixModes.NON_EMPTY_ROWS.equals(categoryCriterion.emptyPrefixMode)) {
		restriction = Restrictions.not(Restrictions.or(Restrictions.eq(categoryCriterion.field, ""), Restrictions.isNull(categoryCriterion.field)));
	} else if (EmptyPrefixModes.EMPTY_ROWS.equals(categoryCriterion.emptyPrefixMode)) {
		restriction = Restrictions.or(Restrictions.eq(categoryCriterion.field, ""), Restrictions.isNull(categoryCriterion.field));
	}
	return restriction;
}
 

public Criterion toCriterion() {
    if (name.equals(NOT)) {
        switch (args.size()) {
            case 0:
                throwRuntimeException(new IllegalArgumentException("Logical expression [not] must contain at least 1 expression"));
                return null;

            case 1:
                return Restrictions.not(args.get(0));

            default:
                // treat multiple sub-criteria as an implicit "OR"
                return Restrictions.not(buildJunction(Restrictions.disjunction(), args));
        }
    }

    if (name.equals(AND)) {
        return buildJunction(Restrictions.conjunction(), args);
    }

    if (name.equals(OR)) {
        return buildJunction(Restrictions.disjunction(), args);
    }

    throwRuntimeException(new IllegalStateException("Logical expression [" + name + "] not handled!"));
    return null;
}
 

@Override
public Object visitUnary(UnaryExpression unary_expression,
      UnaryOperator operator, Object operand)
{
   switch (operator)
   {
      case MINUS:
      {
         if (operand instanceof Long)
         {
            return -((Long) operand);
         }
         else if (operand instanceof Double)
         {
            return -((Double) operand);
         }
         else
         {
            throw new UnsupportedOperationException("Invalid expression: " +
                  unary_expression.getUriLiteral());
         }
      }
      case NOT:
      {
         return Restrictions.not((Criterion) operand);
      }
      default:
         break;
   }
   throw new UnsupportedOperationException("Unsupported operator: " +
         operator.toUriLiteral());
}
 

@SuppressWarnings("unchecked")
public static List<BasicRule> getAllOtherBasicRules(String userID) {
    Session session = getSessionFactory().getCurrentSession();
    session.beginTransaction();
    Criteria crit = session.createCriteria(BasicRule.class);
    Criterion restriction = Restrictions.not(Restrictions.eq(OWNER_ID, Integer.valueOf(userID)));
    List<BasicRule> rules = crit.add(restriction).list();
    session.getTransaction().commit();
    return rules;
}
 

@SuppressWarnings("unchecked")
public static List<BasicRule> getAllOtherPublishedBasicRules(String userID) {
    Session session = getSessionFactory().getCurrentSession();
    session.beginTransaction();
    Criteria crit = session.createCriteria(BasicRule.class);
    Criterion isOwner = Restrictions.not(Restrictions.eq(OWNER_ID, valueOf(userID)));
    SimpleExpression isPublished = Restrictions.eq(PUBLISHED, true);
    List<BasicRule> rules = crit.add(Restrictions.and(isOwner, isPublished)).list();
    session.getTransaction().commit();
    return rules;
}
 

@Deprecated
@SuppressWarnings("unchecked")
public static List<ComplexRule> getAllOtherPublishedComplexRules(String userID) {
    Session session = getSessionFactory().getCurrentSession();
    session.beginTransaction();
    Criteria crit = session.createCriteria(ComplexRule.class);
    Criterion isOwner = Restrictions.not(Restrictions.eq(OWNER_ID, valueOf(userID)));
    SimpleExpression isPublished = Restrictions.eq(PUBLISHED, true);
    List<ComplexRule> rules = crit.add(Restrictions.and(isOwner, isPublished)).list();
    session.getTransaction().commit();
    return rules;
}
 

@Override
public Criterion getHibernateCriterion( QueryPath queryPath )
{
    return Restrictions.not( super.getHibernateCriterion( queryPath ) );
}
 

@Override
public Criterion getHibernateCriterion( QueryPath queryPath )
{
    return Restrictions.not( super.getHibernateCriterion( queryPath ) );
}
 

@Override
public Criterion getHibernateCriterion( QueryPath queryPath )
{
    return Restrictions.not( super.getHibernateCriterion( queryPath ) );
}
 

/** {@inheritDoc} */
@Override
public Object visit(Not filter, Object userData) {
	Criterion c = (Criterion) filter.getFilter().accept(this, userData);
	return Restrictions.not(c);
}
 

/** {@inheritDoc} */
@Override
public Object visit(ExcludeFilter filter, Object userData) {
	return Restrictions.not(Restrictions.conjunction());
}
 

public Criterion buildRestriction(String propertyName, Object[] values) {
	
	return Restrictions.not(Restrictions.in(propertyName, values));
}