Casts the expression to a BooleanExpression.

Assigns an alias to this expression.

Aliases are useful for renaming fields in the output of a stage or for giving meaningful names to calculated values.

// Calculate total price and alias it "totalPrice"
Field("price").multiply(Field("quantity")).as("totalPrice")

Creates an expression that returns the value of self rounded to the nearest integer.

// Get the value of the "amount" field rounded to the nearest integer.
Field("amount").round()

Creates an expression that returns the square root of self.

// Get the square root of the "area" field.
Field("area").sqrt()

Creates an expression that returns the value of self raised to the power of self.

Returns zero on underflow.

// Get the value of the "amount" field raised to the power of 2.
Field("amount").pow(2)

Creates an expression that returns the value of self raised to the power of self.

Returns zero on underflow.

// Get the value of the "amount" field raised to the power of the "exponent" field.
Field("amount").pow(Field("exponent"))

Creates an expression that returns the natural logarithm of self.

// Get the natural logarithm of the "amount" field.
Field("amount").ln()

Creates an expression that returns the largest numeric value that isn't greater than self.

// Get the floor of the "amount" field.
Field("amount").floor()

Creates an expression that returns e to the power of self.

Returns zero on underflow and nil on overflow.

// Get the exp of the "amount" field.
Field("amount").exp()

Creates an expression that returns the smallest numeric value that isn't less than the number.

// Get the ceiling of the "amount" field.
Field("amount").ceil()

Creates an expression that returns the absolute value of the number.

// Get the absolute value of the "amount" field.
Field("amount").abs()

Creates an expression that returns the value of self truncated to an integer.

// Get the value of the "rating" field truncated to an integer.
Field("rating").trunc()

Creates an expression that truncates self to a specified number of decimal places.

If decimalPlace is positive, truncates number to the right of the decimal point. If decimalPlace is negative, truncates number to the left of the decimal point.

// Truncate the value of the "rating" field to 2 decimal places.
Field("rating").truncToPrecision(2)

Creates an expression that truncates self to a specified number of decimal places.

If decimalPlace is positive, truncates number to the right of the decimal point. If decimalPlace is negative, truncates number to the left of the decimal point.

// Truncate the value of the "rating" field to the number of decimal places specified in the
// "precision" field.
Field("rating").truncToPrecision(Field("precision"))

Creates an expression that adds another expression to this expression. To add multiple expressions, chain calls to this method. Assumes self and the parameter evaluate to compatible types for addition (e.g., numbers, or string/array concatenation if supported by the specific "add" implementation).

// Add the value of the "quantity" field and the "reserve" field.
Field("quantity").add(Field("reserve"))

// Add multiple numeric fields
Field("subtotal").add(Field("tax")).add(Field("shipping"))

Creates an expression that adds a literal value to this expression. To add multiple literals, chain calls to this method. Assumes self and the parameter evaluate to compatible types for addition.

// Add 5 to the "count" field
Field("count").add(5)

// Add multiple literal numbers
Field("score").add(10).add(20).add(-5)

Creates an expression that subtracts another expression from this expression. Assumes self and other evaluate to numeric types.

// Subtract the "discount" field from the "price" field
Field("price").subtract(Field("discount"))

Creates an expression that subtracts a literal value from this expression. Assumes self evaluates to a numeric type.

// Subtract 20 from the value of the "total" field
Field("total").subtract(20)

Creates an expression that multiplies this expression by another expression. To multiply multiple expressions, chain calls to this method. Assumes self and the parameter evaluate to numeric types.

// Multiply the "quantity" field by the "price" field
Field("quantity").multiply(Field("price"))

// Multiply "rate" by "time" and "conversionFactor" fields
Field("rate").multiply(Field("time")).multiply(Field("conversionFactor"))

Creates an expression that multiplies this expression by a literal value. To multiply multiple literals, chain calls to this method. Assumes self evaluates to a numeric type.

// Multiply the "score" by 1.1
Field("score").multiply(1.1)

// Multiply "base" by 2 and then by 3.0
Field("base").multiply(2).multiply(3.0)

Creates an expression that divides this expression by another expression. Assumes self and other evaluate to numeric types.

// Divide the "total" field by the "count" field
Field("total").divide(Field("count"))

Creates an expression that divides this expression by a literal value. Assumes self evaluates to a numeric type.

// Divide the "value" field by 10
Field("value").divide(10)

Creates an expression that calculates the modulo (remainder) of dividing this expression by another expression. Assumes self and other evaluate to numeric types.

// Calculate the remainder of dividing the "value" field by the "divisor" field
Field("value").mod(Field("divisor"))

Creates an expression that calculates the modulo (remainder) of dividing this expression by a literal value. Assumes self evaluates to a numeric type.

// Calculate the remainder of dividing the "value" field by 10
Field("value").mod(10)

Creates an expression that returns the input with elements in reverse order.

// Reverse the "tags" array.
Field("tags").arrayReverse()

Creates an expression that concatenates an array expression (from self) with one or more other array expressions. Assumes self and all parameters evaluate to arrays.

// Combine the "items" array with "otherItems" and "archiveItems" array fields.
Field("items").arrayConcat(Field("otherItems"), Field("archiveItems"))

Creates an expression that concatenates an array expression (from self) with one or more array literals. Assumes self evaluates to an array.

// Combine "tags" (an array field) with ["new", "featured"] and ["urgent"]
Field("tags").arrayConcat(["new", "featured"], ["urgent"])

Creates an expression that checks if an array (from self) contains a specific element expression. Assumes self evaluates to an array.

// Check if "sizes" contains the value from "selectedSize" field
Field("sizes").arrayContains(Field("selectedSize"))

Creates an expression that checks if an array (from self) contains a specific literal element. Assumes self evaluates to an array.

// Check if "colors" array contains "red"
Field("colors").arrayContains("red")

Creates an expression that checks if an array (from self) contains all the specified element expressions. Assumes self evaluates to an array.

// Check if "candidateSkills" contains all skills from "requiredSkill1" and "requiredSkill2"
fields
Field("candidateSkills").arrayContainsAll([Field("requiredSkill1"), Field("requiredSkill2")])

Creates an expression that checks if an array (from self) contains all the specified literal elements. Assumes self evaluates to an array.

// Check if "tags" contains both "urgent" and "review"
Field("tags").arrayContainsAll(["urgent", "review"])

Creates an expression that checks if an array (from self) contains all the specified element expressions. Assumes self evaluates to an array.

// Check if the "tags" array contains "foo", "bar", and "baz"
Field("tags").arrayContainsAll(Constant(["foo", "bar", "baz"]))

Creates an expression that checks if an array (from self) contains any of the specified element expressions. Assumes self evaluates to an array.

// Check if "userGroups" contains any group from "allowedGroup1" or "allowedGroup2" fields
Field("userGroups").arrayContainsAny([Field("allowedGroup1"), Field("allowedGroup2")])

Creates an expression that checks if an array (from self) contains any of the specified literal elements. Assumes self evaluates to an array.

// Check if "categories" contains either "electronics" or "books"
Field("categories").arrayContainsAny(["electronics", "books"])

Creates an expression that checks if an array (from self) contains any of the specified element expressions. Assumes self evaluates to an array.

// Check if "groups" array contains any of the values from the "userGroup" field
Field("groups").arrayContainsAny(Field("userGroup"))

Creates an expression that calculates the length of an array. Assumes self evaluates to an array.

// Get the number of items in the "cart" array
Field("cart").arrayLength()

Filters an array to a subset of elements that match the provided condition. Assumes self evaluates to an array.

// Filter the "items" array to include elements where "price" > 10
Field("items").arrayFilter(alias: "item", filter: Variable("item.price").greaterThan(10))

Creates an expression that applies a provided transformation to each element in an array. Assumes self evaluates to an array.

// Transform the "scores" array by multiplying the "score" by 2
Field("scores").arrayTransform(
  elementAlias: "score",
  transform: Variable("score").multiply(2)
)

Creates an expression that applies a provided transformation to each element in an array, providing the element's index to the transformation expression. Assumes self evaluates to an array.

// Transform the "scores" array by adding the element index and "name"
Field("scores").arrayTransformWithIndex(
  elementAlias: "score",
  indexAlias: "index",
  transform: Variable("score").add(Variable("index"))
)

Returns a subset of the array starting at the given offset. Assumes self evaluates to an array.

// Get all elements from the "tags" array starting at index 1
Field("tags").arraySlice(offset: 1)

Returns a subset of the array starting at the given offset. Assumes self evaluates to an array.

// Get all elements from "tags" starting at an offset defined by a field
Field("tags").arraySlice(offset: Field("startIdx"))

Returns a subset of the array starting at the given offset, up to the given length. Assumes self evaluates to an array.

// Get 2 elements from the "tags" array starting at index 1
Field("tags").arraySlice(offset: 1, length: 2)

Returns a subset of the array starting at the given offset, up to the given length. Assumes self evaluates to an array.

// Get elements using expressions for offset and length
Field("tags").arraySlice(offset: Field("startIdx"), length: Field("count"))

Returns a subset of the array starting at the given offset, up to the given length. Assumes self evaluates to an array.

// Get n elements from the "tags" array starting at index 1
Field("tags").arraySlice(offset: 1, length: Field("count"))

Returns a subset of the array starting at the given offset, up to the given length. Assumes self evaluates to an array.

// Get 2 elements from the "tags" array starting at an offset defined by a field
Field("tags").arraySlice(offset: Field("startIdx"), length: 2)

Creates an expression that returns the first element of an array. Assumes self evaluates to an array.

// Get the first item in the "tags" array.
Field("tags").arrayFirst()

Creates an expression that returns the first n elements of an array. Assumes self evaluates to an array.

// Get the first 3 items in the "tags" array.
Field("tags").arrayFirstN(3)

Creates an expression that returns the first n elements of an array. Assumes self evaluates to an array.

// Get the first n items in the "tags" array where n is specified by field "count".
Field("tags").arrayFirstN(Field("count"))

Creates an expression that returns the last element of an array. Assumes self evaluates to an array.

// Get the last item in the "tags" array.
Field("tags").arrayLast()

Creates an expression that returns the last n elements of an array. Assumes self evaluates to an array.

// Get the last 3 items in the "tags" array.
Field("tags").arrayLastN(3)

Creates an expression that returns the last n elements of an array. Assumes self evaluates to an array.

// Get the last n items in the "tags" array where n is specified by field "count".
Field("tags").arrayLastN(Field("count"))

Creates an expression that accesses an element in an array (from self) at the specified integer offset. A negative offset starts from the end. If the offset is out of bounds, an error may be returned during evaluation. Assumes self evaluates to an array.

// Return the value in the "tags" field array at index 1.
Field("tags").arrayGet(1)
// Return the last element in the "tags" field array.
Field("tags").arrayGet(-1)

Creates an expression that accesses an element in an array (from self) at the offset specified by an expression. A negative offset starts from the end. If the offset is out of bounds, an error may be returned during evaluation. Assumes self evaluates to an array and offsetExpr evaluates to an integer.

// Return the value in the tags field array at index specified by field "favoriteTagIndex".
Field("tags").arrayGet(Field("favoriteTagIndex"))

Creates an expression that returns the index of the first occurrence of a value in an array. Returns nil if the value is not found. Assumes self evaluates to an array.

// Get the index of "urgent" in the "tags" array.
Field("tags").arrayIndexOf("urgent")

Creates an expression that returns the index of the first occurrence of a value in an array. Returns nil if the value is not found. Assumes self evaluates to an array.

// Get the index of the value of field "searchTag" in the "tags" array.
Field("tags").arrayIndexOf(Field("searchTag"))

Creates an expression that returns the index of the last occurrence of a value in an array. Returns nil if the value is not found. Assumes self evaluates to an array.

// Get the last index of "urgent" in the "tags" array.
Field("tags").arrayLastIndexOf("urgent")

Creates an expression that returns the index of the last occurrence of a value in an array. Returns nil if the value is not found. Assumes self evaluates to an array.

// Get the last index of the value of field "searchTag" in the "tags" array.
Field("tags").arrayLastIndexOf(Field("searchTag"))

Creates an expression that returns all indices of a value in an array. Returns an empty array if the value is not found. Assumes self evaluates to an array.

// Get all indices of "urgent" in the "tags" array.
Field("tags").arrayIndexOfAll("urgent")

Creates an expression that returns all indices of a value in an array. Returns an empty array if the value is not found. Assumes self evaluates to an array.

// Get all indices of the value of field "searchTag" in the "tags" array.
Field("tags").arrayIndexOfAll(Field("searchTag"))

Creates an expression that returns the maximum element of an array.

Assumes self evaluates to an array.

// Get the maximum value in the "scores" array.
Field("scores").arrayMaximum()

Creates an expression that returns the minimum element of an array.

Assumes self evaluates to an array.

// Get the minimum value in the "scores" array.
Field("scores").arrayMinimum()

Creates an expression that returns the n smallest elements of an array. Assumes self evaluates to an array.

// Get the 3 lowest scores in the "scores" array.
Field("scores").arrayMinimumN(3)

Creates an expression that returns the n smallest elements of an array. Assumes self evaluates to an array.

// Get the n lowest scores in the "scores" array where n is specified by field "count".
Field("scores").arrayMinimumN(Field("count"))

Creates an expression that returns the n largest elements of an array. Assumes self evaluates to an array.

// Get the 3 highest scores in the "scores" array.
Field("scores").arrayMaximumN(3)

Creates an expression that returns the n largest elements of an array. Assumes self evaluates to an array.

// Get the n highest scores in the "scores" array where n is specified by field "count".
Field("scores").arrayMaximumN(Field("count"))

Creates a BooleanExpression that returns true if this expression is greater than the given expression.

Creates a BooleanExpression that returns true if this expression is greater than the given value.

Creates a BooleanExpression that returns true if this expression is greater than or equal to the given expression.

Creates a BooleanExpression that returns true if this expression is greater than or equal to the given value.

Creates a BooleanExpression that returns true if this expression is less than the given expression.

Creates a BooleanExpression that returns true if this expression is less than the given value.

Creates a BooleanExpression that returns true if this expression is less than or equal to the given expression.

Creates a BooleanExpression that returns true if this expression is less than or equal to the given value.

Creates a BooleanExpression that returns true if this expression is equal to the given expression.

Creates a BooleanExpression that returns true if this expression is equal to the given value.

Creates a BooleanExpression that returns true if this expression is not equal to the given expression.

Creates a BooleanExpression that returns true if this expression is not equal to the given value.

Creates an expression that checks if this expression is equal to any of the provided expression values.

// Check if "categoryID" field is equal to "featuredCategory" or "popularCategory" fields
Field("categoryID").equalAny([Field("featuredCategory"), Field("popularCategory")])

Creates an expression that checks if this expression is equal to any of the provided literal values.

// Check if "category" is "Electronics", "Books", or "Home Goods"
Field("category").equalAny(["Electronics", "Books", "Home Goods"])

Creates an expression that checks if this expression is equal to any of the provided expression values.

// Check if "categoryID" field is equal to any of "categoryIDs" fields
Field("categoryID").equalAny(Field("categoryIDs"))

Creates an expression that checks if this expression is not equal to any of the provided expression values.

// Check if "statusValue" is not equal to "archivedStatus" or "deletedStatus" fields
Field("statusValue").notEqualAny([Field("archivedStatus"), Field("deletedStatus")])

Creates an expression that checks if this expression is not equal to any of the provided literal values.

// Check if "status" is neither "pending" nor "archived"
Field("status").notEqualAny(["pending", "archived"])

Creates an expression that checks if this expression is equal to any of the provided expression values.

// Check if "categoryID" field is not equal to any of "categoryIDs" fields
Field("categoryID").equalAny(Field("categoryIDs"))

Creates an expression that checks if a field exists in the document.

// Check if the document has a field named "phoneNumber"
Field("phoneNumber").exists()

Creates an expression that checks if this expression produces an error during evaluation.

// Check if accessing a non-existent array index causes an error
Field("myArray").arrayGet(100).isError()

Creates an expression that returns true if the result of this expression is absent (e.g., a field does not exist in a map). Otherwise, returns false.

// Check if the field `value` is absent.
Field("value").isAbsent()

Creates an expression that joins the elements of an array of strings with a given separator.

Assumes self evaluates to an array of strings.

// Join the "tags" array with a ", " separator.
Field("tags").join(separator: ", ")

Creates an expression that splits a string into an array of substrings based on a delimiter.

Creates an expression that splits a string into an array of substrings based on a delimiter.

Creates an expression that returns the length of a string.

// Get the length of the "name" field.
Field("name").length()

Creates an expression that calculates the character length of a string in UTF-8. Assumes self evaluates to a string.

// Get the character length of the "name" field in its UTF-8 form.
Field("name").charLength()

Creates an expression that performs a case-sensitive string comparison using wildcards against a literal pattern. Assumes self evaluates to a string.

// Check if the "title" field contains the word "guide" (case-sensitive)
Field("title").like("%guide%")

Creates an expression that performs a case-sensitive string comparison using wildcards against an expression pattern. Assumes self evaluates to a string, and pattern evaluates to a string.

// Check if "filename" matches a pattern stored in "patternField"
Field("filename").like(Field("patternField"))

Creates an expression that checks if a string (from self) contains a specified regular expression literal as a substring. Assumes self evaluates to a string.

// Check if "description" contains "example" (case-insensitive)
Field("description").regexContains("(?i)example")

Creates an expression that checks if a string (from self) contains a specified regular expression (from an expression) as a substring. Assumes self evaluates to a string, and pattern evaluates to a string.

// Check if "logEntry" contains a pattern from "errorPattern" field
Field("logEntry").regexContains(Field("errorPattern"))

Creates an expression that returns the first substring of a string expression that matches a specified regular expression. Assumes self evaluates to a string.

// Extract the domain name from an email field
Field("email").regexFind("@[A-Za-z0-9.-]+")

Creates an expression that returns the first substring of a string expression that matches a specified regular expression. Assumes self evaluates to a string, and pattern evaluates to a string.

// Extract a substring based on a dynamic pattern stored in another field
Field("email").regexFind(Field("pattern"))

Creates an expression that evaluates to a list of all substrings in a string expression that match a specified regular expression. Assumes self evaluates to a string.

// Extract all hashtags from a post content field
Field("content").regexFindAll("#[A-Za-z0-9_]+")

Creates an expression that evaluates to a list of all substrings in a string expression that match a specified regular expression. Assumes self evaluates to a string, and pattern evaluates to a string.

// Extract all matches based on a dynamic pattern stored in another field
Field("content").regexFindAll(Field("pattern"))

Creates an expression that checks if a string (from self) matches a specified regular expression literal entirely. Assumes self evaluates to a string.

// Check if the "email" field matches a valid email pattern
Field("email").regexMatch("[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}")

Creates an expression that checks if a string (from self) matches a specified regular expression (from an expression) entirely. Assumes self evaluates to a string, and pattern evaluates to a string.

// Check if "input" matches the regex stored in "validationRegex"
Field("input").regexMatch(Field("validationRegex"))

Creates an expression that checks if a string (from self) contains a specified literal substring (case-sensitive). Assumes self evaluates to a string.

// Check if the "description" field contains "example".
Field("description").stringContains("example")

Creates an expression that checks if a string (from self) contains a specified substring from an expression (case-sensitive). Assumes self evaluates to a string, and expression evaluates to a string.

// Check if the "message" field contains the value of the "keyword" field.
Field("message").stringContains(Field("keyword"))

Creates an expression that checks if a string (from self) starts with a given literal prefix (case-sensitive). Assumes self evaluates to a string.

// Check if the "name" field starts with "Mr."
Field("name").startsWith("Mr.")

Creates an expression that checks if a string (from self) starts with a given prefix from an expression (case-sensitive). Assumes self evaluates to a string, and prefix evaluates to a string.

// Check if "fullName" starts with the value of "firstName"
Field("fullName").startsWith(Field("firstName"))

Creates an expression that checks if a string (from self) ends with a given literal suffix (case-sensitive). Assumes self evaluates to a string.

// Check if the "filename" field ends with ".txt"
Field("filename").endsWith(".txt")

Creates an expression that checks if a string (from self) ends with a given suffix from an expression (case-sensitive). Assumes self evaluates to a string, and suffix evaluates to a string.

// Check if "url" ends with the value of "extension" field
Field("url").endsWith(Field("extension"))

Creates an expression that converts a string (from self) to lowercase. Assumes self evaluates to a string.

// Convert the "name" field to lowercase
Field("name").toLower()

Creates an expression that converts a string (from self) to uppercase. Assumes self evaluates to a string.

// Convert the "title" field to uppercase
Field("title").toUpper()

Creates an expression that removes leading and trailing whitespace from a string.

Assumes self evaluates to a string.

// Trim leading/trailing whitespace from the "comment" field.
Field("comment").trim()

Creates an expression that removes leading and trailing occurrences of specified characters from a string (from self). Assumes self evaluates to a string, and value evaluates to a string.

// Trim leading/trailing "xy" from field
Field("code").trim(characters: "xy")

Creates an expression that removes leading and trailing occurrences of specified string (from an expression) from a string (from self). Assumes self evaluates to a string, and value evaluates to a string.

// Trim characters specified by the "trimChars" field from "data"
Field("data").trim(characters: Field("trimChars"))

Creates an expression that removes leading whitespace from this string expression. Assumes self evaluates to a string.

// Trim leading whitespace from the "text" field.
Field("text").ltrim()

Creates an expression that removes specified leading characters from this string expression. Assumes self evaluates to a string, and value evaluates to a string.

The characters in value are treated as a set of characters to trim, not as a substring.

// Trim all leading '-' or '_' characters from the "text" field.
Field("text").ltrim("-_")

Creates an expression that removes specified leading characters from this string expression. Assumes self evaluates to a string, and value evaluates to a string.

The characters in value are treated as a set of characters to trim, not as a substring.

// Trim leading characters defined by the "chars" field from the "text" field.
Field("text").ltrim(Field("chars"))

Creates an expression that removes trailing whitespace from this string expression. Assumes self evaluates to a string.

// Trim trailing whitespace from the "text" field.
Field("text").rtrim()

Creates an expression that removes specified trailing characters from this string expression. Assumes self evaluates to a string, and value evaluates to a string.

The characters in value are treated as a set of characters to trim, not as a substring.

// Trim trailing '-' or '_' characters from the "text" field.
Field("text").rtrim("-_")

Creates an expression that removes specified trailing characters from this string expression. Assumes self evaluates to a string, and value evaluates to a string.

The characters in value are treated as a set of characters to trim, not as a substring.

// Trim trailing characters defined by the "chars" field from the "text" field.
Field("text").rtrim(Field("chars"))

Creates an expression that repeats this string expression a given number of times. Assumes self evaluates to a string.

// Repeat the "name" field 3 times.
Field("name").stringRepeat(3)

Creates an expression that repeats this string expression a given number of times. Assumes self evaluates to a string.

// Repeat the "name" field the number of times specified in the "count" field.
Field("name").stringRepeat(Field("count"))

Creates an expression that replaces all occurrences of a literal substring with another literal string. Assumes self evaluates to a string.

// Replace all occurrences of "cat" with "dog" in the "text" field.
Field("text").stringReplaceAll("cat", with: "dog")

Creates an expression that replaces all occurrences of a substring (from an expression) with another string. Assumes self evaluates to a string.

// Replace all occurrences of the "old" field with the "new" field in "text".
Field("text").stringReplaceAll(Field("old"), with: Field("new"))