The eq operator returns true if the left operand is equal to the right operand, otherwise it returns false.

When applied to operands of entity types, the eq operator returns true if both operands represent the same entity, or both operands represent null.

When applied to operands of complex types, the eq operator returns true if both operands have the same structure and same values, or both operands represent null.

When applied to ordered collections, the eq operator returns true if both operands have the same cardinality and each member of the left operand is equal to the member of the right operand at the same index.

For services that support comparing unordered collections, the eq operator returns true if both operands are equal after applying the same ordering on both collections.

Each of the special values null, -INF, and INF is equal to itself, and only to itself.

The special value NaN is not equal to anything, even to itself.

The ne operator returns true if the left operand is not equal to the right operand, otherwise it returns false.

When applied to operands of entity types, the ne operator returns true if the two operands do not represent the same entity.

When applied to operands of complex types, the ne operator returns true if the operands do not have the same structure and same values.

When applied to ordered collections, the ne operator returns true if both operands do not have the same cardinality or any member of the left operand is not equal to the corresponding member of the right operand.

For services that support comparing unordered collections, the ne operator returns true if both operands do not have the same cardinality or do not contain the same members, in any order.

Each of the special values null, -INF, and INF is not equal to any value but itself.

The special value NaN is not equal to anything, even to itself.

The null value is not equal to any value but itself.

The gt operator returns true if the left operand is greater than the right operand, otherwise it returns false.

The special value INF is greater than any number, and any number is greater than -INF.

The Boolean value true is greater than false.

Services SHOULD order language-dependent strings according to the Content-Language of the response, and SHOULD annotate string properties with language-dependent order with the term Core.IsLanguageDependent, see OData-VocCore.

If any operand is null, the operator returns false.

The ge operator returns true if the left operand is greater than or equal to the right operand, otherwise it returns false.

See rules for gt and eq for details.

The lt operator returns true if the left operand is less than the right operand, otherwise it returns false.

The special value -INF is less than any number, and any number is less than INF.

The Boolean value false is less than true.

Services SHOULD order language-dependent strings according to the Content-Language of the response, and SHOULD annotate string properties with language-dependent order with the term Core.IsLanguageDependent, see OData-VocCore.

If any operand is null, the operator returns false.

The le operator returns true if the left operand is less than or equal to the right operand, otherwise it returns false.

See rules for lt and eq for details.

The and operator returns true if both the left and right operands evaluate to true, otherwise it returns false.

The null value is treated as unknown, so if one operand evaluates to null and the other operand to false, the and operator returns false. All other combinations with null return null.

The or operator returns false if both the left and right operands both evaluate to false, otherwise it returns true.

The null value is treated as unknown, so if one operand evaluates to null and the other operand to true, the or operator returns true. All other combinations with null return null.

The not operator returns true if the operand returns false, otherwise it returns false.

The null value is treated as unknown, so not null returns null.

The has operator returns true if the right operand is an enumeration value whose flag(s) are set on the left operand.

The null value is treated as unknown, so if one operand evaluates to null, the has operator returns null.

The in operator returns true if the equality comparison of the left operand with at least one member of the right operand returns true. The right operand MUST be either a comma-separated list of zero or more primitive values, enclosed in parentheses, or a single expression that resolves to a collection. If the right operand is an empty collection or list of values, the in operator returns false.

The following examples illustrate the use and semantics of each of the logical operators.

http://host/service/Products?$filter=Name eq 'Milk'

http://host/service/Products?$filter=Name ne 'Milk'

http://host/service/Products?$filter=Name gt 'Milk'

http://host/service/Products?$filter=Name ge 'Milk'

http://host/service/Products?$filter=Name lt 'Milk'

http://host/service/Products?$filter=Name le 'Milk'

http://host/service/Products?$filter=Name eq 'Milk' and Price lt 2.55

http://host/service/Products?$filter=Name eq 'Milk' or Price lt 2.55

http://host/service/Products?$filter=not endswith(Name,'ilk')

http://host/service/Products?$filter=style has Sales.Pattern'Yellow'

http://host/service/Products?$filter=Name in ('Milk', 'Cheese')

The add operator adds the left and right numeric operands.

For operands of type Edm.Decimal the scale of the result is \({\rm scaleof}(A {\ \tt add\ } B) = \max({\rm scaleof}(A), {\rm scaleof}(B))\), or variable if any operand has variable scale.

The add operator is also valid for the following time-related operands:

• DateTimeOffset add Duration results in a DateTimeOffset
• Duration add Duration results in a Duration
• Date add Duration results in a Date

The rules for time-related operands are defined in XML-Schema-2, section E.3.3. Specifically, for adding a duration to a date:

• Convert date to datetime (in any timezone) with a zero time component
• Add/subtract duration
• Convert to date by removing the time and timezone components

Thus, today plus a positive duration smaller than one day is today; today minus a positive duration smaller than one day is yesterday.

The sub operator subtracts the right numeric operand from the left numeric operand.

For operands of type Edm.Decimal the scale of the result is \({\rm scaleof}(A {\ \tt sub\ } B) = \max({\rm scaleof}(A), {\rm scaleof}(B))\), or variable if any operand has variable scale.

The sub operator is also valid for the following time-related operands:

• DateTimeOffset sub Duration results in a DateTimeOffset
• Duration sub Duration results in a Duration
• DateTimeOffset sub DateTimeOffset results in a Duration
• Date sub Duration results in a Date
• Date sub Date results in a Duration

The rules for time-related operands are defined in XML-Schema-2, section E.3.3. Specifically for subtracting a duration from a date see the preceding section.

The negation operator, represented by a minus (-) sign, changes the sign of its numeric or Duration operand.

The mul operator multiplies the left and right numeric operands. The mul operator is also valid for multiplying a Duration value with a numeric value.

For operands of type Edm.Decimal the scale of the result is \({\rm scaleof}(A {\ \tt mul\ } B) = {\rm scaleof}(A) + {\rm scaleof}(B)\), floating if any operand has floating scale, or else variable if any operand has variable scale.

The div and divby operators divide the left numeric operand by the right numeric operand. They are also valid for dividing a Duration value by a numeric value.

If the left operand is of type Edm.Decimal with floating scale, Edm.Double, or Edm.Single, then positive div zero returns INF, negative div zero returns -INF, and zero div zero returns NaN. For all other types the request fails.

For operands of type Edm.Decimal the result is computed with maximal decimal scale. If any operand has floating scale, the result has floating scale, else if any operand has variable scale, the result has variable scale. Otherwise the resulting scale is service-specific, and clients can use cast to force the result to a specific scale.

The div and divby operators differ in their handling of integers. If both operands to div are of an integer type, the result is an integer representing the whole number of times the right operator fits into the left operator. The divby operator, on the other hand, promotes both operands to decimal before computing the result, may yield a fractional result, and does not fail for divby zero, returning -INF, INF, or NaN depending on the sign of the left operand.

The mod operator returns the remainder when the left numeric operand is divided by the right numeric operand. The sign of the result is the same as the sign of the left operand. If the right operand is zero, the request fails.

For operands of type Edm.Decimal the scale of the result is \({\rm scaleof}(A {\ \tt mod\ } B) = \max({\rm scaleof}(A), {\rm scaleof}(B))\), or variable if any operand has variable scale.

The following examples illustrate the use and semantics of each of the Arithmetic operators.

http://host/service/Products?$filter=Price add 2.45 eq 5.00

http://host/service/Products?$filter=Price sub 0.55 eq 2.00

http://host/service/Products?$filter=Price mul 2.0 eq 5.10

http://host/service/Products?$filter=Price div 2.55 eq 1

http://host/service/Products?$filter=Rating div 2 eq 2

http://host/service/Products?$filter=Rating divby 2 eq 2.5

http://host/service/Products?$filter=Rating mod 5 eq 0

The concat function has three overloads, with the following signatures:

Edm.String concat(Edm.String,Edm.String)
Collection concat(Collection,Collection)
OrderedCollection concat(OrderedCollection,OrderedCollection)

The concat function with string parameter values returns a string that appends the second parameter string value to the first.

The concat function with collection parameter values returns a collection that appends all items of the second collection to the first. If both collections are ordered, the result is also ordered.

The concatMethodCallExpr syntax rule defines how the concat function is invoked.

http://host/service/Customers?$filter=concat(concat(City,', '),Country) eq 'Berlin, Germany'

The contains function has two overloads, with the following signatures:

Edm.Boolean contains(Edm.String,Edm.String)
Edm.Boolean contains(OrderedCollection,OrderedCollection)

The contains function with string parameter values returns true if the second string is a substring of the first string, otherwise it returns false. String comparison is case-sensitive, case-insensitive comparison can be achieved in combination with tolower or toupper.

The contains function with ordered collection parameter values returns true if the first collection can be transformed into the second collection by removing zero or more items from the beginning or the end of the first collection.

The containsMethodCallExpr syntax rule defines how the contains function is invoked.

http://host/service/Customers?$filter=contains(CompanyName,'Alfreds')

The endswith function has two overloads, with the following signatures:

Edm.Boolean endswith(Edm.String,Edm.String)
Edm.Boolean endswith(OrderedCollection,OrderedCollection)

The endswith function with string parameter values returns true if the first string ends with the second string, otherwise it returns false. String comparison is case-sensitive, case-insensitive comparison can be achieved in combination with tolower or toupper.

The endswith function with ordered collection parameter values returns true if the first collection can be transformed into the second collection by removing zero or more items from the beginning of the first collection.

The endsWithMethodCallExpr syntax rule defines how the endswith function is invoked.

http://host/service/Customers?$filter=endswith(CompanyName,'Futterkiste')

The indexof function has two overloads, with the following signatures:

Edm.Int32 indexof(Edm.String,Edm.String)
Edm.Int32 indexof(OrderedCollection,OrderedCollection)

The indexof function with string parameter values returns the zero-based character position of the first occurrence of the second string in the first string, or -1 if the first string does not contain the second string. String comparison is case-sensitive, case-insensitive comparison can be achieved in combination with tolower or toupper.

The indexof function with ordered collection parameter values returns the zero-based index of the first occurrence of the second collection in the first collection, or -1 if the first collection does not contain the second collection.

The indexOfMethodCallExpr syntax rule defines how the indexof function is invoked.

http://host/service/Customers?$filter=indexof(CompanyName,'lfreds') eq 1

The length function has two overloads, with the following signatures:

Edm.Int32 length(Edm.String)
Edm.Int32 length(Collection)

The length function with a string parameter value returns the number of characters in the string.

The length function with a collection parameter value returns the number of itens in the collection.

The lengthMethodCallExpr syntax rule defines how the length function is invoked.

http://host/service/Customers?$filter=length(CompanyName) eq 19

The startswith function has two overloads, with the following signatures:

Edm.Boolean startswith(Edm.String,Edm.String)
Edm.Boolean startswith(Collection,Collection)

The startswith function with string parameter values returns true if the first string starts with the second string, otherwise it returns false. String comparison is case-sensitive, case-insensitive comparison can be achieved in combination with tolower or toupper.

The startswith function with ordered collection parameter values returns true if the first collection can be transformed into the second collection by removing zero or more items from the end of the first collection.

The startsWithMethodCallExpr syntax rule defines how the startswith function is invoked.

http://host/service/Customers?$filter=startswith(CompanyName,'Alfr')

The substring function has four overloads, with the following signatures:

Edm.String substring(Edm.String,Edm.Int32)
Edm.String substring(Edm.String,Edm.Int32,Edm.Int32)
OrderedCollection substring(OrderedCollection,Edm.Int32)
OrderedCollection substring(OrderedCollection,Edm.Int32,Edm.Int32)

The two-parameter substring function with string parameter values returns a substring of the first parameter string value, starting at the Nth character and finishing at the last character (where N is the second parameter integer value). The three-parameter substring function with string parameter values returns a substring of the first parameter string value identified by selecting up to M characters starting at the Nth character (where N is the second parameter integer value and M is the third parameter integer value).

The two-parameter substring function with ordered collection parameter values returns an ordered collection consisting of all items of the first collection starting at the Nth item and finishing at the last item. The three-parameter substring function with ordered collection parameter values returns an ordered collection consisting of up to M items of the first collection starting at the Nth item (where N is the second parameter integer value and M is the third parameter integer value).

The start index N is zero-based.

If the start index N is larger than the length of the string/collection, an empty string/collection is returned.

If the length M is larger than the length of the remaining string/collection starting at the Nth character/item, as many characters/items as are available are returned.

A negative length M is a bad request.

A negative start index N, if supported, returns a string/collection starting N characters/items before the end of the string/collection.

The substringMethodCallExpr syntax rule defines how the substring function is invoked.

http://host/service/Customers?$filter=substring(CompanyName,1) eq 'lfreds Futterkiste'

http://host/service/Customers?$filter=substring(CompanyName,1,2) eq 'lf'

The hassubset function has the following signature:

Edm.Boolean hassubset(Collection, Collection)

The hassubset function returns true if the first collection can be transformed into the second collection by reordering and/or removing zero or more items. The hasSubsetMethodCallExpr syntax rule defines how the hassubset function is invoked.

hassubset([4,1,3],[4,1,3])

hassubset([4,1,3],[1,3,4])

hassubset([4,1,3],[3,1])

hassubset([4,1,3],[4,3])

hassubset([4,1,3,1],[1,1])

hassubset([1,2],[1,1,2])

The hassubsequence function has the following signature:

Edm.Boolean hassubsequence(OrderedCollection,OrderedCollection)

The hassubsequence function returns true if the first collection can be transformed into the second collection by removing zero or more items. The hasSubsequenceMethodCallExpr syntax rule defines how the hassubsequence function is invoked.

hassubsequence([4,1,3],[4,1,3])

hassubsequence([4,1,3],[4,1])

hassubsequence([4,1,3],[4,3])

hassubsequence([4,1,3,1],[1,1])

hassubsequence([4,1,3],[1,3,4])

hassubsequence([4,1,3],[3,1])

hassubsequence([1,2],[1,1,2])

The matchespattern function has the following signatures:

Edm.Boolean matchespattern(Edm.String,Edm.String)
Edm.Boolean matchespattern(Edm.String,Edm.String,Edm.String)

The second parameter MUST evaluate to a string containing an ECMAScript (JavaScript) regular expression, otherwise the function returns null. The matchespattern function returns true if the first parameter evaluates to a string matching that regular expression, using syntax and semantics of ECMAScript regular expressions, otherwise it returns false. If the optional third parameter is provided, it MUST evaluate to a string consisting of ECMAScript regular expression flags to modify the match, otherwise the function returns null.

http://host/service/Customers?$filter=matchespattern(CompanyName,'%5EA.*e$')

http://host/service/Customers?$filter=matchespattern(FormattedAddress,'berg$','m')

The tolower function has the following signature:

Edm.String tolower(Edm.String)

The tolower function returns the input parameter string value with all uppercase characters converted to lowercase according to Unicode rules. The toLowerMethodCallExpr syntax rule defines how the tolower function is invoked.

http://host/service/Customers?$filter=tolower(CompanyName) eq 'alfreds futterkiste'

The toupper function has the following signature:

Edm.String toupper(Edm.String)

The toupper function returns the input parameter string value with all lowercase characters converted to uppercase according to Unicode rules. The toUpperMethodCallExpr syntax rule defines how the toupper function is invoked.

http://host/service/Customers?$filter=toupper(CompanyName) eq 'ALFREDS FUTTERKISTE'

The trim function has the following signature:

Edm.String trim(Edm.String)

The trim function returns the input parameter string value with all leading and trailing whitespace characters, according to Unicode rules, removed. The trimMethodCallExpr syntax rule defines how the trim function is invoked.

http://host/service/Customers?$filter=trim(CompanyName) eq CompanyName

The date function has the following signature:

Edm.Date date(Edm.DateTimeOffset)

The date function returns the date part of the DateTimeOffset parameter value, evaluated in the time zone of the DateTimeOffset parameter value.

The day function has the following signatures:

Edm.Int32 day(Edm.Date)
Edm.Int32 day(Edm.DateTimeOffset)

The day function returns the day component Date or DateTimeOffset parameter value, evaluated in the time zone of the DateTimeOffset parameter value. The dayMethodCallExpr syntax rule defines how the day function is invoked.

Services that are unable to preserve the offset of Edm.DateTimeOffset values and instead normalize the values to some common time zone (for example UTC) MUST fail evaluation of the day function for literal Edm.DateTimeOffset values that are not stated in the time zone of the normalized values.

http://host/service/Employees?$filter=day(BirthDate) eq 8

The fractionalseconds function has the following signatures:

Edm.Decimal fractionalseconds[(Edm.DateTimeOffset)
Edm.Decimal fractionalseconds(Edm.TimeOfDay)

The fractionalseconds function returns the fractional seconds component of the DateTimeOffset or TimeOfDay parameter value as a non-negative decimal value less than 1. The fractionalsecondsMethodCallExpr syntax rule defines how the fractionalseconds function is invoked.

http://host/service/Employees?$filter=[fractionalseconds(BirthDate) lt 0.1

The hour function has the following signatures:

Edm.Int32 hour(Edm.DateTimeOffset)
Edm.Int32 hour(Edm.TimeOfDay)

The hour function returns the hour component (0 to 23) of the DateTimeOffset or TimeOfDay parameter value, evaluated in the time zone of the DateTimeOffset parameter value. The hourMethodCallExpr syntax rule defines how the hour function is invoked.

Services that are unable to preserve the offset of Edm.DateTimeOffset values and instead normalize the values to some common time zone (for example UTC) MUST fail evaluation of the hour function for literal Edm.DateTimeOffset values that are not stated in the time zone of the normalized values.

http://host/service/Employees?$filter=hour(BirthDate) eq 4

The maxdatetime function has the following signature:

Edm.DateTimeOffset maxdatetime()

The maxdatetime function returns the latest possible point in time as a DateTimeOffset value.

The mindatetime function has the following signature:

Edm.DateTimeOffset mindatetime()

The mindatetime function returns the earliest possible point in time as a DateTimeOffset value.

The minute function has the following signatures:

Edm.Int32 minute(Edm.DateTimeOffset)
Edm.Int32 minute(Edm.TimeOfDay)

The minute function returns the minute component (0 to 59) of the DateTimeOffset or TimeOfDay parameter value, evaluated in the time zone of the DateTimeOffset parameter value. The minuteMethodCallExpr syntax rule defines how the minute function is invoked.

http://host/service/Employees?$filter=minute(BirthDate) eq 40

The month function has the following signatures:

Edm.Int32 month(Edm.Date)
Edm.Int32 month(Edm.DateTimeOffset)

The month function returns the month component of the Date or DateTimeOffset parameter value, evaluated in the time zone of the DateTimeOffset parameter value. The monthMethodCallExpr syntax rule defines how the month function is invoked.

Services that are unable to preserve the offset of Edm.DateTimeOffset values and instead normalize the values to some common time zone (for example UTC) MUST fail evaluation of the month function for literal Edm.DateTimeOffset values that are not stated in the time zone of the normalized values.

http://host/service/Employees?$filter=month(BirthDate) eq 5

The now function has the following signature:

Edm.DateTimeOffset now()

The now function returns the current point in time (date and time with time zone) as a DateTimeOffset value.

Services are free to choose the time zone for the current point, for example UTC. Services that are unable to preserve the offset of Edm.DateTimeOffset values and instead normalize the values to some common time zone SHOULD return a value in the normalized time zone (for example UTC).

The second function has the following signatures:

Edm.Int32 second(Edm.DateTimeOffset)
Edm.Int32 second(Edm.TimeOfDay)

The second function returns the second component (0 to 59 for regular seconds, and 60 for leap seconds, without the fractional part) of the DateTimeOffset or TimeOfDay parameter value. The secondMethodCallExpr syntax rule defines how the second function is invoked.

http://host/service/Employees?$filter=second(BirthDate) eq 40

The time function has the following signature:

Edm.TimeOfDay time(Edm.DateTimeOffset)

The time function returns the time part of the DateTimeOffset parameter value, evaluated in the time zone of the DateTimeOffset parameter value.

Services that are unable to preserve the offset of Edm.DateTimeOffset values and instead normalize the values to some common time zone (for example UTC) MUST fail evaluation of the time function for literal Edm.DateTimeOffset values that are not stated in the time zone of the normalized values.

The totaloffsetminutes function has the following signature:

Edm.Int32 totaloffsetminutes(Edm.DateTimeOffset)

The totaloffsetminutes function returns the signed number of minutes in the time zone offset part of the DateTimeOffset parameter value, evaluated in the time zone of the DateTimeOffset parameter value.

The totalseconds function has the following signature:

Edm.Decimal totalseconds(Edm.Duration)

The totalseconds function returns the duration of the value in total seconds, including fractional seconds.

The year function has the following signatures:

Edm.Int32 year(Edm.Date)
Edm.Int32 year(Edm.DateTimeOffset)

The year function returns the year component of the Date or DateTimeOffset parameter value, evaluated in the time zone of the DateTimeOffset parameter value. The yearMethodCallExpr syntax rule defines how the year function is invoked.

Services that are unable to preserve the offset of Edm.DateTimeOffset values and instead normalize the values to some common time zone (for example UTC) MUST fail evaluation of the year function for literal Edm.DateTimeOffset values that are not stated in the time zone of the normalized values.

http://host/service/Employees?$filter=year(BirthDate) eq 1971

The ceiling function has the following signatures

Edm.Double ceiling(Edm.Double)
Edm.Decimal ceiling(Edm.Decimal)

The ceiling function rounds the input numeric parameter up to the nearest numeric value with no decimal component. The ceilingMethodCallExpr syntax rule defines how the ceiling function is invoked.

http://host/service/Orders?$filter=ceiling(Freight) eq 32

The floor function has the following signatures

Edm.Double floor(Edm.Double)
Edm.Decimal floor(Edm.Decimal)

The floor function rounds the input numeric parameter down to the nearest numeric value with no decimal component. The floorMethodCallExpr syntax rule defines how the floor function is invoked.

http://host/service/Orders?$filter=floor(Freight) eq 32

The round function has the following signatures

Edm.Double round(Edm.Double)
Edm.Decimal round(Edm.Decimal)

The round function rounds the input numeric parameter to the nearest numeric value with no decimal component. The mid-point between two integers is rounded away from zero, i.e. 0.5 is rounded to 1 and -0.5 is rounded to -1. The roundMethodCallExpr syntax rule defines how the round function is invoked.

http://host/service/Orders?$filter=round(Freight) eq 32

The cast function has the following signatures:

type cast(type)
type cast(expression,type)

The single parameter cast function returns the current instance cast to the type specified. The two-parameter cast function returns the object referred to by the expression cast to the type specified.

The cast function follows these assignment rules:

1. The null value can be cast to any type.
2. Primitive types are cast to Edm.String or a type definition based on it by using the literal representation used in payloads, and WKT (well-known text) format for Geo types, see rules fullCollectionLiteral, fullLineStringLiteral, fullMultiPointLiteral, fullMultiLineStringLiteral, fullMultiPolygonLiteral, fullPointLiteral, and fullPolygonLiteral in OData-ABNF. The cast fails if the target type specifies an insufficient MaxLength.
3. Edm.String, or a type definition based on Edm.String, can be cast to a primitive type if the string contains a literal representation for the target type.
4. Numeric primitive types are cast to each other with appropriate rounding. The cast fails if the integer part doesn’t fit into the target type.
5. Edm.DateTimeOffset, Edm.Duration, and Edm.TimeOfDay values can be cast to the same type with a different precision with appropriate rounding.
6. Non-Unicode string values can be cast to a Unicode string type definition. Unicode string values can be cast to a non-Unicode string type definition if the Unicode string only contains ASCII characters.
7. Structured types are assignable to their type or a direct or indirect base type.
8. Collections are cast item by item.
9. Enumeration types are cast to integer types based on the numeric value of the enumeration member. The cast fails if the numeric value is not in the value range of the target type.
10. Integer types are cast to enumeration types based on the numeric value of the enumeration members of the target type. For non-flag enumeration types the cast fails if there is no enumeration member with the same numeric value as the integer value. For flag enumeration types the cast fails if the integer value is not in the value range of the underlying integer type of the enumeration type.
11. String values containing a representation of a date-time value according to XML-Schema-2, section 3.3.7 dateTime, can be cast to Edm.DateTimeOffset. If the string value does not contain a time-zone offset, it is treated as UTC.

If the cast fails, the cast function returns null.

The isof function has the following signatures

Edm.Boolean isof(type)
Edm.Boolean isof(expression,type)

The single parameter isof function returns true if the current instance is assignable to the type specified, according to the assignment rules for the cast function, otherwise it returns false.

The two parameter isof function returns true if the object referred to by the expression is assignable to the type specified, according to the same rules, otherwise it returns false.

The isofExpr syntax rule defines how the isof function is invoked.

http://host/service/Orders?$filter=isof(NorthwindModel.BigOrder)

http://host/service/Orders?$filter=isof($it,NorthwindModel.BigOrder)

http://host/service/Orders?$filter=isof(Customer,NorthwindModel.VIPCustomer)

The geo.distance function has the following signatures:

Edm.Double geo.distance(Edm.GeographyPoint,Edm.GeographyPoint)
Edm.Double geo.distance(Edm.GeometryPoint,Edm.GeometryPoint)

The geo.distance function returns the shortest distance between the two points in the coordinate reference system signified by the two points’ SRIDs.

The geo.intersects function has the following signatures:

Edm.Boolean geo.intersects(Edm.GeographyPoint,Edm.GeographyPolygon)
Edm.Boolean geo.intersects(Edm.GeometryPoint,Edm.GeometryPolygon)

The geo.intersects function returns true if the specified point lies within the interior or on the boundary of the specified polygon, otherwise it returns false.

The geo.length function has the following signatures:

Edm.Double geo.length(Edm.GeographyLineString)
Edm.Double geo.length(Edm.GeometryLineString)

The geo.length function returns the total length of its line string parameter in the coordinate reference system signified by its SRID.

The case function has the following signature:

expression case(Edm.Boolean:expression, …, Edm.Boolean:expression)

Each parameter is a pair of expressions separated by a colon (:), where the first expression — the condition — MUST be a Boolean expression, and the second expression — the result — may evaluate to any type.

The case function evaluates the condition in each pair, starting with the leftmost pair, and stops as soon as a condition evaluates to true. It then returns the value of the result of this pair. It returns null if none of the conditions in any pair evaluates to true. Clients can specify a last pair whose condition is true to get a non-null “default/else/otherwise” result.

Boolean expressions containing DateTimeOffset or TimeOfDay literals without the optional seconds part will introduce ambiguity for parsers. Clients SHOULD use whitespace or parentheses to avoid ambiguity.

Clients SHOULD ensure that the results in all pairs are compatible. If all results are of the same type, the type of the case expression is of that type. If all results are of numeric type, then the type of the case expression is a numeric type capable of representing any of these expressions according to standard type promotion rules.

Services MAY support case expressions containing parameters of incompatible types, in which case the case expression is treated as Edm.Untyped and its value has the type of the parameter expression selected by the case statement.

$compute=case(X gt 0:1,X lt 0:-1,true:0) as SignumX

The any operator applies a Boolean expression to each member of a collection and returns true if and only if the expression is true for any member of the collection, otherwise it returns false. This implies that the any operator always returns false for an empty collection.

The any operator can be used without an argument expression. This short form returns false if and only if the collection is empty.

http://host/service/Orders?$filter=Items/any(d:d/Quantity gt 100)

http://host/service/Customers?$filter=Orders/any(o:o/ShippingAddress ne Address)

http://host/service/Categories?$expand=Products(
  $filter=OrderItems/any(oi:oi/UnitPrice ne UnitPrice))

The all operator applies a Boolean expression to each member of a collection and returns true if the expression is true for all members of the collection, otherwise it returns false. This implies that the all operator always returns true for an empty collection.

The all operator cannot be used without an argument expression.

http://host/service/Orders?$filter=Items/all(d:d/Quantity gt 100)

Primitive literals can appear in the resource path as key property values, and in the query part, for example, as operands in $filter expressions. They are represented according to the primitiveLiteral rule in OData-ABNF.

NullValue eq null

TrueValue eq true

FalseValue eq false

Custom.Base64UrlDecode(binary'T0RhdGE') eq 'OData'

IntegerValue lt -128

DoubleValue ge 0.31415926535897931e1

SingleValue eq INF

DecimalValue eq 34.95

StringValue eq 'Say Hello,then go'

DateValue eq 2012-12-03

DateTimeOffsetValue eq 2012-12-03T07:16:23Z

DurationValue eq duration'P12DT23H59M59.999999999999S'

DurationValue eq 'P12DT23H59M59.999999999999S'

TimeOfDayValue eq 07:59:59.999

GuidValue eq 01234567-89ab-cdef-0123-456789abcdef

Int64Value eq 0

ColorEnumValue eq Sales.Pattern'Yellow'

ColorEnumValue eq 'Yellow'

geo.distance(Location,geography'SRID=0;Point(142.1 64.1)')

Duration literals in OData 4.0 required prefixing with “duration”. Enumeration literals in OData 4.0 required prefixing with the qualified type name of the enumeration.

In OData 4.01, services MUST support duration and enumeration literals with or without the type prefix. OData clients that want to operate across OData 4.0 and OData 4.01 services should always include the prefix for duration and enumeration types.

Complex literals and collection literals in URLs are represented as JSON objects and arrays according to the arrayOrObject rule in OData-ABNF. Such literals MUST NOT appear in the path portion of the URL but can be passed to bound functions and function imports in path segments by using parameter aliases.

Object member values and array items can be expressions, including other objects and arrays, arithmetic expressions, property names, and of course primitive values.

Note that the special characters {, }, [, ], and " MUST be percent-encoded in URLs although some browsers will accept and pass them on unencoded.

http://host/service/ProductsByColors(colors=@c)?@c=["red","green"]

$filter=[FirstName,LastName] in [["John","Doe"],["Jane","Smith"]]

Entities are represented as structured literals as described in OData-JSON, section 6. Non-transient entities can alternatively be represented through their resource path.

http://host/service/Price(Product=@p)?@p={"Color":"red"}

The null literal can be used to compare a value to null, or to pass a null value to a function.

The $it literal can be used in expressions to refer to the current instance of the resource identified by the resource path. For a collection-valued resource the current instance is the instance currently being evaluated by the system query option. For a single-valued resource it is the resource itself.

It allows comparing properties of related entities to properties of the current instance in expressions within lambda operators or in $filter expressions nested within $expand or $select.

It also can be used in $filter and $orderby expressions on collections of primitive types to refer to the current primitive instance, but using the $this literal is preferred as $this can also be used in $filter and $orderby expressions nested within $select.

Note: property names and property paths in $filter expressions nested within $expand are evaluated in the context of the declared type of the expanded navigation property, so property names and property paths for the current instance of the collection identified by the resource path MUST be prefixed with $it/.

The $it literal can also be used as a path prefix to invoke a bound function overload on the current instance within an expression. Function names without a path prefix refer to an unbound function overload.

http://host/service/Customers(1)/EmailAddresses?$filter=endswith($it,'.com')

http://host/service/Customers?$expand=Orders($filter=$it/Address/City eq ShipTo/City)

http://host/service/Products?$filter=$it/Model.PositiveReviews()/$count ge 10

The $root literal can be used in expressions to refer to resources of the same service.

http://host/service/Employees?$filter=LastName eq $root/Employees('A1245')/LastName

http://host/service/ProductsOrderedBy(Customers=@c)
  ?@c=[$root/Customers('ALFKI'),$root/Customers('BLAUS')]

http://host/service/Employees('A1245')/self.AvgRating(RatedBy=@peers)
  ?@peers=$root/Employees/$filter(Department eq 'D1')

The $this literal can be used in $filter and $orderby expressions nested within $expand and $select for collection-valued properties and navigation properties. It refers to the current instance of the collection.

http://host/service/Customers?$select=EmailAddresses($filter=endswith($this,'.com'))