Apply a "less than or equal to" constraint to two properties.

@param propertyName The first property
@param otherPropertyName The other property
@return The constraint
339574
public PropertyConstraint lteProperty(String propertyName, String otherPropertyName) {
        return valueProperties(propertyName, LessThanEqualTo.instance(), otherPropertyName);
    }
772730
public QueryExpression le(String propertyName,String value)
    {
        return new SimpleQueryExpression(propertyName, ComparisonOperator.LESS_THAN_OR_EQUAL,wrap(value));
    }
202600
public void add(String propertyName, Constraint[] valueConstraints) {
		add(new PropertyValueConstraint(propertyName, all(valueConstraints)));
	}
1122614
public PropertyConstraint ltProperty(String propertyName, String otherPropertyName) {
        return valueProperties(propertyName, LessThan.instance(), otherPropertyName);
    }
673325
public String foreignKeyColumnName(String propertyName, String propertyEntityName, String propertyTableName,
      String referencedColumnName) {
    String header = null == propertyName ? propertyTableName : unqualify(propertyName);
    if (header == null) { throw new AssertionFailure("NamingStrategy not properly filled"); }
    if (isManyToOne()) {
      header = addUnderscores(header);
    } else {
      header = addUnderscores(propertyTableName);
    }
    return header + "_" + referencedColumnName;

  }
139042
public QueryExpression gt(String propertyName,String value)
    {
        return new SimpleQueryExpression(propertyName, ComparisonOperator.GREATER_THAN,wrap(value));
    }
181821
public PropertyConstraint inGroup(String propertyName, Object[] group) {
        return value(propertyName, new InGroup(group));
    }
1353824
public static <A extends Comparable<A>> Restriction lessThan(String property, A value) {
        return new LessThan(property, value);

    }
123048
public <Y extends Comparable<? super Y>> RestrictionsContainer addEq(String property, Y value) {
		
		// Ajout de la restriction
		restrictions.add(new Eq<Y>(property, value));
		
		// On retourne le conteneur
		return this;
	}
1147754
private void putPropertyConstraint(PropertyConstraint constraint) {
		And and = new And();
		and.add(constraint);
		if (logger.isDebugEnabled()) {
			logger.debug("Putting constraint for property '" + constraint.getPropertyName() + "', constraint -> ["
					+ constraint + "]");
		}
        PropertyConstraint compoundConstraint = new CompoundPropertyConstraint(and);
		propertiesConstraints.put(constraint.getPropertyName(), compoundConstraint);
        orderedConstraints.add( compoundConstraint );
	}
523834
public PropertyConstraint eq(String propertyName, Object propertyValue) {
        return new ParameterizedPropertyConstraint(propertyName, eq(propertyValue));
    }
176851
public org.grails.datastore.mapping.query.api.Criteria rlike(String propertyName, Object propertyValue) {
        if (!validateSimpleExpression()) {
            throwRuntimeException(new IllegalArgumentException("Call to [rlike] with propertyName [" +
                    propertyName + "] and value [" + propertyValue + "] not allowed here."));
        }

        propertyName = calculatePropertyName(propertyName);
        propertyValue = calculatePropertyValue(propertyValue);
        addToCriteria(new RlikeExpression(propertyName, propertyValue));
        return this;
    }
82490
public PropertyConstraint lte(String propertyName, Comparable propertyValue) {
        return new ParameterizedPropertyConstraint(propertyName, lte(propertyValue));
    }
161422
public IPAddressSeqRange intersect(IPAddressSeqRange other) {
		IPAddress otherLower = other.getLower();
		IPAddress otherUpper = other.getUpper();
		IPAddress lower = this.getLower();
		IPAddress upper = this.getUpper();
		if(compareLowValues(lower, otherLower) <= 0) {
			if(compareLowValues(upper, otherUpper) >= 0) {
				return other;
			} else if(compareLowValues(upper, otherLower) < 0) {
				return null;
			}
			return create(otherLower, upper);
		} else if(compareLowValues(otherUpper, upper) >= 0) {
			return this;
		} else if(compareLowValues(otherUpper, lower) < 0) {
			return null;
		}
		return create(lower, otherUpper);
	}
518322
public org.grails.datastore.mapping.query.api.Criteria between(String propertyName, Object lo, Object hi) {
        if (!validateSimpleExpression()) {
            throwRuntimeException(new IllegalArgumentException("Call to [between] with propertyName [" +
                    propertyName + "]  not allowed here."));
        }

        propertyName = calculatePropertyName(propertyName);
        addToCriteria(Restrictions.between(propertyName, lo, hi));
        return this;
    }
302189
public PropertyConstraint ifTrue(PropertyConstraint ifConstraint, PropertyConstraint[] thenConstraints) {
		return new ConditionalPropertyConstraint(ifConstraint, new CompoundPropertyConstraint(new And(thenConstraints)));
	}
620278
private short getForeignKeyConstraintProperty(
      String property_name, String property)
  {
    short result = 0;
    switch (property_name)
    {
      case "update":
      case "delete":
        switch (property)
        {
          case "NO ACTION":
            result = importedKeyNoAction;
            break;
          case "CASCADE":
            result = importedKeyCascade;
            break;
          case "SET NULL":
            result = importedKeySetNull;
            break;
          case "SET DEFAULT":
            result = importedKeySetDefault;
            break;
          case "RESTRICT":
            result = importedKeyRestrict;
            break;
        }
      case "deferrability":
        switch (property)
        {
          case "INITIALLY DEFERRED":
            result = importedKeyInitiallyDeferred;
            break;
          case "INITIALLY IMMEDIATE":
            result = importedKeyInitiallyImmediate;
            break;
          case "NOT DEFERRABLE":
            result = importedKeyNotDeferrable;
            break;
        }
    }
    return result;
  }