# Expressions

Expressions enable the creation of **logical**, **mathematical,** and **relational** **statements**, which are used to apply rules, perform mathematical calculations on retrieved data, compare model objects and check the feasibility of a statement. **Expressions are also used to access data of model objects.**

##### tip

In Altogic, you use expressions to set **default values** of model fields, define custom **validation rules**, **query data** from your app database and set **parameters** of your no-code service nodes.

The basic expression types implemented by the Altogic platform can be summarized as follows:

- Mathematical
- Logical
- Relational
- Informational (data retrieval from model objects)

**Expressions are defined as combinations of operands and operators in a logical sequence.** Such a sequence may represent a mathematical calculation, logical reasoning, relational comparison, or even an informational operation. Below are some expression examples.

`10 - 5`

`(100 - 20) * 8`

`'Altogic' + '-' + 'Backend as a service platform'`

`(shoppingCart.totalPrice / SIZE(shoppingCart.items)) > 25`

The first expression above is a mathematical expression, the second one is again a mathematical expression, but it is nested. The third one is a string manipulation expression, and the last one is a combination of relational, informational, and mathematical expressions, including the use of `SIZE`

function. This last expression checks whether the average price of an item in an imaginary shopping cart object is greater than 25 or not. As seen from the above examples, the expression types and combinations may differ from one expression to another. However, **the main rule is to keep combinations and types similar to each other**. The results of the expression operands evaluation, namely the values, must be of the same type to have a proper operator implementation.

An operand can be a **basic value** or an expression defined using other expressions because expressions can be treated as recursive data structures.

**Values**

Each expression is formed by logically combining values. Values are actually primitive data types, but more complex data types such as lists and geo-points can also be used in expressions. For example, a value can be a:

Value type | Examples |
---|---|

Boolean | `true` `false` |

Number | `134` `56.98` |

Text | `'Hello world!'` |

Datetime | `'2020-04-01T06:40:12.941+00:00'` |

List (array of basic values) | `['pop', '90s', 'urban', 'dance']` |

Geo-point (longitude and latitude) | `[29.032589793205258, 41.2200826257151]` |

Model field value | `profile.email` `address.city` |

**Operators**

Operators carry out all the computations using the expression elements and can be classified into two main categories. They can be either **unary** or **binary**.

**Unary operators** carry the calculations on a **single value**, namely on an operand; however, **binary operators** carry calculations on **two operands**, one on the left of the operator (left operand) and the other on the right (right operand).

**Arithmetic operators**

Arithmetic operators are used for mathematical calculations.

Operator | Syntax | Description |
---|---|---|

+ (unary) | + Expression | Assigns a positive sign to expression |

+ | Expression + expression | Adds the values |

- (unary) | - Expression | Assigns a negative sign to the expression value |

- | Expression – expression | Subtracts the values |

* | Expression * expression | Multiplies the values |

/ | Expression / expression | Divides the values |

Example:`-(10 + ((10 * 5 - 4) / 100 - 20))`

In the above expression, all the arithmetic operators are used. The expression is purely mathematical, and it is nested. Moreover, the evaluation result of the expression value sign is converted to a negative value by the unary minus operator.

**Logical operators**

Logical operators are used to evaluating an expression to **true** (1) or **false** (0).

Operator | Syntax | Description |
---|---|---|

&& | Expression && expression | Logical AND returns true (1) only if both expressions evaluate a nonzero value; otherwise, it returns false (0). |

|| | Expression || expression | Logical OR returns true (1) if either of the expressions evaluates a nonzero value; otherwise, it returns false (0). |

! | !Expression | Logical negation returns false (0) if the expression evaluates a nonzero value; otherwise, it returns true (1). |

Example:`(profile.firstName && profile.lastName) || profile.fullName`

The above example uses a combination of both logical && and || operators. It uses three field values of an imaginary 'profile' object. Initially, the expression in parenthesis will be evaluated, which performs a logical AND conditioning on the first two attributes. The result obtained from this evaluation will next be combined with the evaluation result of the last expression operand (profile.fullName), and the final result will be either evaluated to true or false.

##### info

Instead of the logical operators, you can also use **AND** function for `&&`

, **OR** function for `||`

and **NOT** function for `!`

operator. Using the functions instead of operators, the above example can be written as:

`OR(AND(profile.firstName, profile.lastName), profile.fullName)`

**Relational operators**

Like logical operators, relational operators also evaluate an expression to **true** (1) or **false** (0).

Operator | Syntax | Description |
---|---|---|

== | Expression == expression | Checks equality of expressions; if the expressions are equal, it returns true (1); otherwise, it returns false (0) |

!= | Expression != expression | Checks not equality of expressions; if the expressions are not equal, it returns true (1); otherwise, it returns false (0) |

< | Expression < expression | Checks whether the first expression is less than the second one; if the first expression is less than the second one, it returns true (1); otherwise, it returns false (0) |

> | Expression > expression | Checks whether the first expression is greater than the second one; if the first expression is greater than the second one, it returns true (1); otherwise, it returns false (0) |

<= | Expression <= expression | Checks whether the first expression is less than or equal to the second one; if the first expression is less than or equal to the second one, it returns true (1); otherwise, it returns false (0) |

>= | Expression >= expression | Checks whether the first expression is greater than or equal to the second one; if the first expression is greater than or equal to the second one, it returns true (1); otherwise, it returns false (0) |

Example:`task.completionDate > task.dueDate`

The expression above uses a relational greater than operator. It checks whether the completion time is later than the due date of an imaginary task object.

### Altogic specific operators

Operator | Syntax | Description |
---|---|---|

[ ] | [expression, expression, ...] | This bracket operator specifies that the expressions which are separated by commas between the brackets are members of a list (array) |

" " | "text" | This operator specifies that the expression between the double quotation is a text value. |

' ' | 'text' | This operator specifies that the expression between the quotation is a text value. |

Examples:

`'10' + '20' + '30'`

`'Result : ' + (10 * 5 + 100)`

`SIZE([45,26,94,73]) == 4`

The first expression illustrates a basic string concatenation operation. The characters between the double quotes are treated as a string. The second and the third strings are concatenated to the first one, which results in this final string: `102030`

. The second expression is a special one, and evaluation result of this expression is `Result : 150`

. This is again a string concatenation operation, but the second expression is evaluated as a mathematical one, and the result is converted to a string value. The last expression is a relational equality check whether the left operand value equals the right operand value. `size`

is a built-in function that returns the length (count of items) of an array. In this case, the array length is 4, and this overall expression evaluates to true (1).

**Associativity and Precedence of Operators**

In expressions, operators have different precedence. Evaluation of the expressions is carried on according to the precedence of the operators. From simple algebra, multiplication precedes addition or subtraction; however, division and multiplication have the same precedence.

The precedence relation between the arithmetical, logical, special, and relational operators implemented is as follows.

Operators | Associativity |
---|---|

( ) " ' [ ] | Left to right |

+ - ! | Left to right |

* / | Left to right |

+ - | Left to right |

< <= > >= | Left to right |

== != | Left to right |

&& | Left to right |

|| | Left to right |

Operators in the same category have equal precedence with each other. Where duplicates of operators appear in the table, the first occurrence is unary, the second binary. Each category has an associativity rule: left to right. In the absence of parentheses, this rule resolves the grouping of expressions with operators of equal precedence. The precedence of each operator in table above is indicated by its order in the table. The first category (on the first line) has the highest precedence. Operators on the same line have equal precedence.

## Functions

There are several **logical**, **text**, **array**, **mathematical**, **date & time, validation,** and **geolocation** functions implemented as expressions for performing advanced calculations and data manipulations. You can use these functions in your expressions.

Each function has a name and zero or more input parameters. The number and type of input parameters are all specific to a function.

Examples:

`STARTSWITH(main_text, search_text)`

STARTSWITH("Jonh Adams", "Jon")`PRODUCT(number1, number2, ...)`

PRODUCT(10, 23, 5, -75)

The first example above is the "STARTSWITH" function. This function checks whether a string starts with the characters of a search string, returning true or false as appropriate. It accepts two text parameters, *main text* and *search text*. The second example is the "PRODUCT" function. This function multiplies all the numbers given as arguments and returns the resulting number. There is no fixed number of input parameters for this function. At a minimum, it takes two parameters, and maximum, it can have 100.

Please refer to functions reference for detailed information about built-in functions.

## Data query expressions

Altogic does not use a separate data query syntax (e.g., SQL) for selecting/filtering data from the database. Instead, **you use the same expression syntax described above to query your data.**

Assuming you have an imaginary product model with quantity (integer), weight (decimal), volume (decimal), and type (text) information. Below are some data query examples that you can create to fetch/filter your product's data.

Examples:

`quantity > 100 && quantity < 200 && type == "plastic"`

`(weight / volume > 2 && type == 'metal') || (weight / volume <= 2 && type == 'plastic')`

The first data query above searches for plastic products and has a stock quantity between 100-200 items. The second data query search for metal or plastic products with a weight-to-volume ratio greater than 2 or less than or equal to 2, respectively.

##### info

Functions can also be used in data query expressions. Please note that not all functions can be used in data queries. Please refer to functions reference for detailed information on which functions can be used in data query expressions,