Sets the type of the WHERE clause as "less than or equal to.

    Args:
      value: The value to be used in the WHERE condition.

    Returns:
      The query builder that this WHERE builder links to.
426692
def LessThanOrEqualTo(self, value):
    
    self._awql = self._CreateSingleValueCondition(value, '<=')
    return self._query_builder
59240
public Filter<T> lessThan(T value) {
		return new ComparableFilter<T>(this, value, Operator.LESS_THAN);
	}
969071
def where(self, fieldname, value, negate=False):
        
        if negate:
            return self.mask([elem != value
                              for elem in self[fieldname]])
        else:
            return self.mask([elem == value
                              for elem in self[fieldname]])
41487
public function gt($value, bool $is_column = false): WhereStatement
    {
        return $this->greaterThan($value, $is_column);
    }
1130129
def locationType(self, value):
        
        if value.lower() in self._allowed_locationType and \
           self._locationType.lower() != value.lower():
            self._locationType = value.lower()
1230424
def GreaterThan(self, value):
    
    self._awql = self._CreateSingleValueCondition(value, '>')
    return self._query_builder
1221779
def where(self, field, value = None, operator = None):
        
        if field is None:
            return self
        conjunction = None
        if value is None and isinstance(field, dict):
            for f,v in field.items():
                if self.where_criteria.size() > 0:
                    conjunction = 'AND'
                self.where_criteria.append(expressions.ConditionExpression(f, v, operator=operator, conjunction=conjunction))
                
        else:
            if self.where_criteria.size() > 0:
                    conjunction = 'AND'
            self.where_criteria.append(expressions.ConditionExpression(field, value, operator=operator, conjunction=conjunction))
        return self
1053365
public Where<T, ID> like(String columnName, Object value) throws SQLException {
		addClause(new SimpleComparison(columnName, findColumnFieldType(columnName), value,
				SimpleComparison.LIKE_OPERATION));
		return this;
	}
118015
def validate_LESSTHAN(in_value, restriction):
    
    #Sometimes restriction values can accidentally be put in the template <item>100</items>,
    #Making them a list, not a number. Rather than blowing up, just get value 1 from the list.
    if type(restriction) is list:
        restriction = restriction[0]

    value = _get_val(in_value)
    if type(value) is list:
        for subval in value:
            if type(subval) is tuple:
                subval = subval[1]
            validate_LESSTHAN(subval, restriction)
    else:
        try:
            if value >= restriction:
                raise ValidationError("LESSTHAN: %s"%(restriction))
        except TypeError:
            # Incompatible types for comparison.
            raise ValidationError("LESSTHAN: Incompatible types %s"%(restriction))
221384
function parse_where_type_condition(query, type) {
	if(type === undefined) {
		return;
	}

	if(is.array(type)) {
		return parse_where_type_condition_array(query, type);
	}

	if(is.string(type)) {
		// NOTE: We need to use `get_type_id()` until we fix the possibility that some
		// older rows do not have correct `type` field -- these are rows that were created
		// before their current validation schema and do not pass it.
		//query.where( new Predicate("types_id = get_type_id($)", type) );

		// schema v18 should have fixed type's for all documents
		query.where( new Predicate("type = $", type) );

		return;
	}

	if(type instanceof NoPg.Type) {
		query.where( new Predicate("types_id = $", type.$id) );
		return;
	}

	throw new TypeError("Unknown type: " + util.inspect(type));
}
912172
def Eq(value, message="Not equal to {!s}"):
    
    @wraps(Eq)
    def built(_value):
        if _value != value:
            raise Error(message.format(value))
        return _value
    return built
890890
public DiscriminatorJdbcSubBuilder when(String value, Class<? extends T> type) {
        return when(value, (Type)type);
    }
1110004
public static Query lessThanEquals(String field, Object value) {
        return new Query().lessThanEquals(field, value);
    }
372277
def _comparison(self, op, value):
    
    # NOTE: This is also used by query.gql().
    if not self._indexed:
      raise datastore_errors.BadFilterError(
          'Cannot query for unindexed property %s' % self._name)
    from .query import FilterNode  # Import late to avoid circular imports.
    if value is not None:
      value = self._do_validate(value)
      value = self._call_to_base_type(value)
      value = self._datastore_type(value)
    return FilterNode(self._name, op, value)
590822
def _condition_as_sql(self, qn, connection):
        '''
        
        '''
        def escape(value):
            if isinstance(value, bool):
                value = str(int(value))
            if isinstance(value, six.string_types):
                # Escape params used with LIKE
                if '%' in value:
                    value = value.replace('%', '%%')
                # Escape single quotes
                if "'" in value:
                    value = value.replace("'", "''")
                # Add single quote to text values
                value = "'" + value + "'"
            return value

        sql, param = self.condition.query.where.as_sql(qn, connection)
        param = map(escape, param)

        return sql % tuple(param)
1182002
def type(self, value):
        
        if value not in list(defines.Types.values()):
            raise AttributeError
        self._type = value
215512
def convert(self, value, _type):
        
        return self.type_convertors.get(_type, lambda x: x)(value)