Create a greater than or equals expression
@param propertyName The propery name
@param value The value
@return The query expression
500717
public QueryExpression ge(String propertyName,String value)
    {
        return new SimpleQueryExpression(propertyName, ComparisonOperator.GREATER_THAN_OR_EQUAL,wrap(value));
    }
998539
public void addProperty(final String propertyName, final String value) {
        Preconditions.checkNotNull(propertyName);
        Preconditions.checkNotNull(value);
        List<String> values = properties.get(propertyName);
        if (values == null) {
            values = new ArrayList<>();
            values.add(value);
            properties.put(propertyName, values);
        } else {
            values.add(value);
        }
    }
444951
public static ExpressionComparator compareTo(List<String> properties) {
		ExpressionComparator comparator = ExpressionComparator.create();
		for (String property : properties) {
			comparator.with(thisProperty(property), thatProperty(property), true);
		}
		return comparator;
	}
1331836
def NotEqualTo(self, value):
    
    self._awql = self._CreateSingleValueCondition(value, '!=')
    return self._query_builder
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;
    }
494495
public StatementBuilder withQualifierValue(PropertyIdValue propertyIdValue,
			Value value) {
		withQualifier(factory.getValueSnak(propertyIdValue, value));
		return getThis();
	}
78867
@SuppressWarnings("rawtypes")
    public org.grails.datastore.mapping.query.api.Criteria in(String propertyName, Collection values) {
        if (!validateSimpleExpression()) {
            throwRuntimeException(new IllegalArgumentException("Call to [in] with propertyName [" +
                    propertyName + "] and values [" + values + "] not allowed here."));
        }

        propertyName = calculatePropertyName(propertyName);

        if(values instanceof List) {
            values = convertArgumentList((List)values);
        }
        addToCriteria(Restrictions.in(propertyName, values == null ? Collections.EMPTY_LIST : values));
        return this;
    }
621605
public T query(String name, Object value) {
        this.query(name, value, true);
        return returnThis();
    }
494803
public static <A extends Comparable<A>> Restriction greaterThan(String property, A value) {
        return new GreaterThan<>(property, value);
    }
914524
@Override
    public <Y extends Comparable<? super Y>> Predicate greaterThan(Expression<? extends Y> lhs,
            Expression<? extends Y> rhs)
    {

        return new ComparisonPredicate(lhs, rhs, ConditionalOperator.GT);
    }
583309
public ZealotKhala andMoreEqual(String field, Object value) {
        return this.doNormal(ZealotConst.AND_PREFIX, field, value, ZealotConst.GTE_SUFFIX, true);
    }
1272019
public String getValue(String propertyName) {
        Property property = super.get(propertyName);
        if (property == null) {
            return null;
        }
        return property.getValue();
    }
205105
public PropertyConstraint gte(String propertyName, Comparable propertyValue) {
        return new ParameterizedPropertyConstraint(propertyName, gte(propertyValue));
    }
408606
public Criteria addProperty(String name, String value, Operator operator) {
        properties.add(new PropertyCriteria(name, value, operator));
        return this;
    }
1170006
public static RelationalBinding notEqualBinding(
            final String property,
            final Object value
            )
    {
        return (new RelationalBinding( property, Relation.NOT_EQUAL, value ));
    }
569160
public static String resolve(String value, Map<String, String> properties) {
		do {
			int i = value.indexOf("${");
			if (i < 0) return value;
			int j = value.indexOf('}', i + 2);
			if (j < 0) return value;
			String name = value.substring(i + 2, j);
			String val = properties.get(name);
			if (val == null) val = "";
			value = value.substring(0, i) + val + value.substring(j + 1);
		} while (true);		
	}
70603
@SuppressWarnings({ "unchecked", "rawtypes" })
    public org.grails.datastore.mapping.query.api.Criteria eqAll(String propertyName, Closure<?> propertyValue) {
        return eqAll(propertyName, new grails.gorm.DetachedCriteria(targetClass).build(propertyValue));
    }