Function

Description

Sample

Date Time:

{AddDays(,)}

Adds the specified number of days to a given date.
In arguments specify:
Date (the DateTime type);
Number of days to add (double; can be positive or negative).
Returns a DateTime value.

{AddDays(DateSerial(2022,1,1), 10)} - the result is: 11.01.2022 00:00:00, i.e., that means 10 days are added.

{AddHours(,)}

Adds the specified number of hours to a given date.
In arguments specify:
Date (the DateTime type);
Number of hours to add (double; can be positive or negative).
Returns a DateTime value.

{AddHours(DateSerial(2022,1,1), 5)} - the result is: 01.01.2022 05:00:00, that means 5 hours are added.

{AddMilliseconds(,)}

Adds the specified number of milliseconds to a given date.
In arguments specify:
Date (the DateTime type);
Number of milliseconds to add (double; can be positive or negative).
Returns a DateTime value.

{AddMilliseconds(DateSerial(2022,1,1), 500)} - the result is: 01.01.2022 12:00:00, that means 500 milliseconds are added.

{AddMinutes(,)}

Adds the specified number of minutes to a given date.
In arguments specify:
Date (the DateTime type);
Number of minutes to add (double; can be positive or negative).
Returns a DateTime value.

{AddMinutes(DateSerial(2022,1,1), 30)} - the result is: 01.01.2022 00:30:00, that means 30 minutes are added.

{AddMonths(,)}

Adds the specified number of months to a given date.
In arguments specify:
Date (the DateTime type);
Number of months to add (int; can be positive or negative).
Returns a DateTime value.

{AddMonths(DateSerial(2022,1,1), 2)} - the result is: 01.03.2022 00:00:00, that means 2 months are added.

{AddSeconds(,)}

Adds the specified number of seconds to a given date.
In arguments specify:
Date (the DateTime type);
Number of seconds to add (double; can be positive or negative).
Returns a DateTime value.

{AddSeconds(DateSerial(2022,1,1), 30)} - the result is: 01.01.2022 00:00:45, that means 30  seconds are added.

{AddYears(,)}

Adds the specified number of years to a given date.
In arguments specify:
Date (the DateTime type);
Number of years to add (int; can be positive or negative).
Returns a DateTime value.

{AddYears(DateSerial(2022,1,1), 1)} - the result is: 01.01.2023 00:00:00, that means 1 year is added.

{DateDiff(,)}

Calculates the distance between the specified dates.
Arguments should be of the DateTime type;
Returns the TimeSpan value.

{DateDiff(DateSerial(2022,1,30),DateSerial(2022,1,1))} - the result is 29.00:00:00, that means 29 days.

 
{DateDiff(DataSource.Column1,DataSource.Column2)} - the result will be calculated for each value in Column1

{DateSerial(,,)}

Specifies date.
Arguments should be year, month, day;
Returns the DateTime value.

{DateSerial(2022,1,30)} - the result is 1/30/2022 12:00:00 AM

 
The function returns the DateTime value, but if you want to display only the date, you should apply text formatting to the text component.

{Day()}

Shows a day from the specified date.
Arguments should be of the DateTime type;
Returns the long value.

{Day(DateSerial(2022,1,30))} - the result is 30, since in arguments the January 30 2016 is specified.

 
{Day(DataSource.Column)} - the result will be calculated for each Column value.

{DayOfWeek()}

Display a day of the week from a specified date in text form.
In arguments specify:

Date (the DateTime type);
Culture (the string type);
The value true or false (the bool type), to display the result with a capital letter or with a lowercase;
The value true or false (the bool type), depending on which the system culture or designer localization will be used.
Returns the string type.

{DayOfWeek(DateSerial(2022,1,30))} - the result is Sunday.
{DayOfWeek(DataSource.Column)} - for each value a day of the week will be calculated.

 
{DayOfWeek(DateSerial(2022,1,30),"de")} - the result will be Samstag, because the de culture is set.
{DayOfWeek(DataSource.Column,"de")} - all results will correspond to the de culture.
 
{DayOfWeek(DateSerial(2022,1,30),"en", false)} - the day of the week will start from the lower-case letter, i.e. sunday.
{DayOfWeek(DataSource.Column,"de", true)} - the days of the week will start with the capital letter, for example Samstag.
 
{DayOfWeek(DateSerial(2022,1,30), false)} - the day of the week will be displayed on the culture that is used by the system.
{DayOfWeek(DataSource.Column, true)} - the day of the week will be displayed in the culture that is used in the report designer.

{DayOfYear()}

Displays a day of the year .
Specifies the date in the argument (the DateTime type);
Returns the long value.

{DayOfYear(DateSerial(2022,2,14))} - the result is 45, since February 14 is the 45th day of a year.
{DayOfYear(DataSource.Column)} - for each value of the Column the data of a year will be calculated.

{DaysInMonth()}

Displays the number of days in the month.
In arguments specify:
Date (the DateTime type);
Year and month (the long type).
Returns the long value.

{DaysInMonth(DateSerial(2024,2,1))} - the result will be 29, because 2024 is a leap year and there are 29 days in February.
{DaysInMonth(DataSource.Column)} - for each value the number of days in a month will be calculated.
{DaysInMonth(2022,3)} - the result will be 31, since there are 31 days in March.

{DaysInYear()}

Displays the number of days in a year.
Specifies the date in arguments (the DateTime type) or a year (the long type);
Returns the long value.

{DaysInYear(2024)} - the result will be 366 days, since 2024 is a leap year.
{DaysInYear(DataSource.Column)} - for each value of the Column the number of days in a year will be calculated.
 

{FromOADate()}

Converts an OLE Automation Date value to DateTime.

In the arguments, the value (double) is specified;
Returns a DateTime value.

{FromOADate(45200)} - the result in this case will be 10.01.2023 12:00:00, that means the numeric value will be converted into a date.

{Hour()}

Displays an hour.
Specifies time in arguments (the DateTime type);
Returns the long value.

{Hour(DataSource.Column)} - an hour will be displayed from each value. For example, if time is 16:22:36, then the result is 16.

{LocalTimeToUtc()}

Provides the ability to convert local time to UTC:
A local time value is specified in the arguments;
Returns a DateTime value in UTC format.

{LocalTimeToUtc(ParseDateTime("2025-05-20 15:00:00"))} - in this case, the local time will be converted to UTC.

{LocalTimeToUtc(DataSource.Column1)} - in this case, the value of Column1 will be converted from local time to UTC.

{Minute()}

Displays minutes.
Specifies time in arguments (the DateTime type);
Returns the long value.

{Minute(DataSource.Column)} - minutes will be displayed from each value. For example, if time is 16:22:36, then the result is 22.

{Month()}

Displays months.
Specifies time in arguments (the DateTime type);
Returns the long value.

{Month(DateSerial(2022,12,1))} - the result will be 12, as the date is set on December 1, 2022.
{Month(DataSource.Column)} - for each value of the Column a month will be displayed.
 

{MonthIdent()}

Allows you to get the name or identifier of a month based on a date.

The argument is the date;

Returns the month corresponding to the given date.

{MonthIdent(DataSource.DocumentDate)} - returns the month corresponding to the document date.

{MonthName()}

Displays the month name of the specified date.
Specifies in arguments:
Date (the DateTime type) and culture (the string type);
Culture (the string type);

The true or false value (the bool type), to display the result with a capital letter or with a small letter;
The true or false value (the bool type), depending on which the system culture or designer localization will be used.
Returns the string value.

{MonthName(DateSerial(2022,1,1))} - the result is January, because the 1 of January 2022 is set.
{MonthName(DataSource.Column)} - the result is the name of the month for each Column value.
 
 
{MonthName(DateSerial(2022,2,1),"de")} - the result will correspond to the de culture, i.e. Februar.
{MonthName(DataSource.Column,"en")} - all the names of months will correspond to the en culture.
 
{MonthName(DateSerial(2022,1,1), false)} - the name of the month will be in lower case.
{MonthName(DataSource.Column, true)} - the name of the months will start with a capital letter.
 
{MonthName(DateSerial(2022,1,1), false)} - the name of the month will correspond to the culture used by the system.
{MonthName(DataSource.Column, true)} - the names of months will correspond to the culture that corresponds to the culture of the report designer.

{Second()}

Displays seconds.
Specifies time in arguments (the DateTime type);
Returns the long value.

{Second(DataSource.Column)} - seconds will be displayed from each value. For example, if time is 16:22:36, then the result is 36.

{TimeSerial(,,)}

Displays time.

Specifies hours, minutes, seconds in arguments (the long type);
Returns the TimeSpan value.

{TimeSerial(1,14,20)} - the result is 01:14: 20, 1 hour, 14 minutes, 20 seconds.

{ToJapaneseDateString()}

Returns a date converted to a string in the Japanese calendar.
In the arguments, the date (DateTime) and the Japanese calendar date format (string) are specified;
Returns a date value.

{ToJapaneseDateString(DataSource.Date)} - returns the date in Japanese format.

{ToOADate()}

Converts DateTime to OLE Automation Date format.
In the arguments, the value (double) is specified;
Returns a double value.

{ToOADate(DataSource.Date)} - returns a number corresponding to the date.

{UtcToLocalTime()}

Provides the ability to convert UTC time to local time:
A UTC time value is specified in the arguments;
Returns a local DateTime value.

{UtcToLocalTime(ParseDateTime("2025-05-20 12:00:00"))} - in this case, the UTC time will be converted to local time.

{UtcToLocalTime(DataSource.Column1)} - in this case, the value of Column1 will be converted from UTC to local time.

{WeekOfMonth()}

Returns the week number of the month for the specified date.
In the arguments, the following are specified:
Date (type DateTime);
Enumeration value.
Returns a long value.

{WeekOfMonth(DataSource.SaleDate)} - returns the week number in the month.

{WeekOfYear()}

Returns the week number of the year for the specified date.
In the arguments, the following are specified:
Date (type DateTime);
Enumeration value.
Returns a long value.

{WeekOfYear(DataSource.SaleDate)} - returns the week number in the year.

{Year()}

Displays year.

Specifies date in arguments (the DateTime type);
Returns the long value.

{Year(DateSerial(2022,1,2))} - the result will be 2022, since the date is January 2, 2022.
{Year(DataSource.Column)} - the years from each Column value will be displayed.

Math:

{Abs()}

Displays the absolute number.
Specifies the number is arguments (the double,decimal,long type);
Returns respectively double, decimal, long.

{Abs(-42)} - the result is 42
{Abs(DataSource.Column1)} - the result will be absolute numbers from the values of Column1, i.e. without considering the number.

{Acos()}

Displays the angle value in radians.
The cos values in arguments (the double type);
Returns the angle value in radians of the double type.

{Acos(-1)} - the angle in radians will be calculated for the value cos = -1, i.e. the angle will be ~ 3.14.
{Acos(DataSource.Column1)} - for all cos values, the angle in radians will be calculated.

{Asin()}

Displays the angle value in radians.
The sin value in arguments (the double type);
Returns the value of the angle in radians of the double type.

{Asin(0)} - the angle in radians will be calculated for the value sin = 0, i.e. the angle is 0
{Asin(DataSource.Column1)} - for all sin values, the angle will calculated in radians.

{Atan()}

Displays the angle value in radians.
The tan value in arguments (the double type);
Returns the value of the angle in radians of the double type.

{Atan(-1)} - the angle in radians will be calculated for the value tan = -1, i.e. the angle will be ~ -0.79
{Atan(DataSource.Column1)} - for all tan values the angle in radians will be calculated

{Ceiling()}

Displays the maximum integer value for a specified number.

The value is specified in arguments (the double, decimal type);
Returns the value of the angle in radians of the double and decimal type.

{Ceiling(25.124)} - It is worth noting that when this function is used, the number is not rounded.
{Ceiling(25.9)} - the result is 26
{Ceiling(DataSource.Column)} -  for all Column values, the nearest maximal integers will be found and displayed.

{Clamp(,,)}

Provides the ability to limit a value to the specified range.
The arguments specify:
The value to check;
The minimum range value;
The maximum range value.
Returns a value within the specified range.

{Clamp(15, 0, 10)} - in this case, the result will be 10 because the value exceeds the maximum limit.

{Clamp(-5, 0, 100)} - in this case, the result will be 0 because the value is less than the minimum limit.

{Cos()}

Calculates and displays the cos value:

The value of the angle in radians is specified in arguments (the double type);
Returns double, decimal values.

{Cos(0)} - the result is 1.
{Cos(DataSource.Column1)} - for all values, the cos of the angle will be calculated.

{Div()}

Displays the result of the division of one argument to another.
In arguments, the following is specified:
The dividend and divisor (the double, decimal, long type);

The dividend and divisor and value that is the result, if the divisor is equal to 0.

Returns the value of the double, decimal, and long types.

{Div(2,1)} - the result is 2, because 2 / 1 = 2
{Div(2,0,4)} - the result is 4, because the divisor is 0 and the third argument will be displayed
 
{Div(DataSource.Column1,DataSource.Column2,DataSource.Column3)} - the results of dividing the Column1 values by the values of Column2 will be displayed. In this case, if Column2 contains zero values, then, instead of the result of the division, in this line, the values from Column3 will be displayed.
 

{Exp()}

Displays the result of rising to the specified degree the number:

The arguments indicate the degree to which the number e must rise (the long type);
Returns the value of the double type.

{Exp(4)} - the number e will be raised to the 4th degree.
{Exp(DataSource.Column1)} - each value from Column1 will be the degree to which the number e will be raised.

{Floor()}

Displays the minimum integer value to the specified number.

The value is specified in arguments (the double, decimal type);
Returns the value of the double, decimal types.

{Floor(123.59)} - the result will be 123 because this is the nearest minimum integer. It should be noted that this function does not round numbers.
Floor(101.99)} -  the result is 101
{Floor(DataSource.Column1)} - for all Column1 values, the nearest minimum integers will be found and displayed.

{Frac()}

Provides the ability to get the fractional part of a number.
The arguments specify a numeric value;
Returns the fractional part of the number.

{Frac(10.75)} - in this case, the result will be 0.75.

{Frac(3.1415)} - in this case, the result will be 0.1415.

{Log()}

Calculates the natural logarithm.

The value is specified in arguments (the double type);
Returns the value of the double type.

{Log(x)}, where x is a number or an expression, the result is a calculation of the natural logarithm.

{Maximum(,)}

Compares the two values and displays the maximum.

Two values are specified in arguments (the long, decimal, double type);
Returns the value of the long, decimal, double types.

{Maximum(5,9)} - the result is 9.
{Maximum(DataSource.Column1,DataSource.Column2)} - all the Column1 values are equal to the Column2 values. The report will display the maximum numbers.

{Minimum(,)}

Compares the two values and displays the minimum.

Two values are specified in arguments (the long, decimal, double type);
Returns the value of the long, decimal, double types.

{Minimum(5,9)} - the result is 5.
{Minimum(DataSource.Column1,DataSource.Column2)} - all the Column1 values are equal to the Column2 values. The report will display the minimum numbers.
 

{Round()}

Rounds up the value to an integer or up to the certain number of decimal.

In arguments, the following is specified:
The value (the decimal, double types);

Number of characters to which the fractional part should be rounded (the int type).
Returns the value of the decimal, double types.

{Round(7.56)} - the result is 8
{Round(DataSource.Column1)} - all Column1 values will be rounded according to the mathematical rounding rules.
 
{Round(5.7896541897,3)} - the result is 5.789
{Round(DataSource.Column1,2)} - all values from the data column will be rounded up to two decimal places in the fractional part, according to the mathematical rounding rules.

{Sign()}

Displays an indicator. For positive numbers 1, 0 - for all zero values, -1 - for negative values.

The value is specified in arguments (the long, decimal, double types);
Returns the value of the long type.

{Sign(256)} - the result is 1.
{Sign(0)} - the result is 0.
{Sign(-157)} - the result is -1.
{Sign(DataSource.Column1)} - to each value from Column1, depending on the sign of the number, an indicator will be assigned.

{Sin(0)}

Calculates sin of an angle.

The value of an angle in radians is specified in arguments (the double type);
Returns the value of the long type.

{Sin(0)} - the result is 0.
{Sin(DataSource.Column1)} - for all values, the sin angle is calculated.

{Sqrt()}

Calculates the square root of the number.
The number is specified in arguments (the double type);
Returns the value of the double type.

{Sqrt(4)} - the result will be 2 because the square root of 4 is 2.
{Sqrt(DataSource.Column1)} - for all Column1 values, the square root will be calculated.

{Tan()}

Calculates tg of an angle.

The value of an angle in radians is specified in arguments (the double type);
Returns the value of the long type.

{Tan(90)} - the result is ~ -1.995
{Tan(DataSource.Column1)} - for all values, the tan of the angle will be calculated.

{Truncate()}

Displays only the integer part without rounding.
The value is specified in arguments (the double, decimal types);
Returns the value of the double, decimal types.

{Truncate(Sqrt(5))} - the result will be number 2 because the square root of 5 is ~ 2.236. The whole part in this number is 2.

{Truncate(DataSource.Column1)} - only the integer part of all Column1 values will be displayed.

Data:

{Coalesce()}

Provides the ability to return the first value that is not null from a list of values.
If all values are null, the result will be null.
The arguments specify a list of values to check.
Returns the first non-null value.

{Coalesce(null, 10, 20)} - in this case, the result will be 10 because the first value is null.

{Coalesce(DataSource.Column1, 0)} - in this case, if the value of Column1 is null, 0 will be returned.

{CoalesceStr()}

Provides the ability to return the first non-empty string from a list of values.
If all values are null or empty strings, the result will be null.
The arguments specify a list of string values;
Returns the first non-empty string.

{CoalesceStr("", "Text", "Value")} - in this case, the result will be "Text" because the first value is empty.

{CoalesceStr(DataSource.Column1, "No Data")} - in this case, if the value of Column1 is empty or null, "No Data" will be displayed.

{GetCrossTabColumnValue()}

Provides the ability to retrieve the value of the Cross-Tab column associated with the current summary cell.
The arguments specify the current Cross-Tab summary cell object;
Returns the column value of the string type.

{GetCrossTabColumnValue(0)} - in this case, the value of the first Cross-Tab column will be retrieved.

{GetCrossTabColumnValue("Year")} - in this case, the value of the Cross-Tab column named "Year" will be retrieved.

{GetCrossTabRowValue()}

Provides the ability to retrieve the value of the Cross-Tab row associated with the current summary cell.
The arguments specify the current Cross-Tab summary cell object;
Returns the row value of the string type.

{GetCrossTabRowValue(0)} - in this case, the value of the first Cross-Tab row will be retrieved.

{GetCrossTabRowValue("Category")} - in this case, the value of the Cross-Tab row named "Category" will be retrieved.

{GetRealPageNumber()}

Provides the ability to retrieve the actual page number for a component on a segmented page.
The arguments specify a component instance;
Returns the page number of the int type.

{GetRealPageNumber()} - in this case, the actual number of the current report page will be displayed.

{IsAllDataRowNullOrEmpty(,)}

Provides the ability to check whether all values in the specified columns are null or empty strings.
The arguments specify:
A data source (object type);
A data column name (string type).
Returns a value of the bool type.

{IsAllDataRowNullOrEmpty(DataSource.Column1, DataSource.Column2)} - in this case, the result will be true if the values of Column1 and Column2 are empty or null.

{IsAllDataRowNullOrEmpty("", null)} - in this case, the result will be true.

{IsDataEmpty()}

Provides the ability to determine whether a data source contains rows.
The arguments specify a data source (object type);
Returns a value of the bool type.

{IsDataEmpty()} - in this case, the result will be true if the data source contains no records.

{IsNull(,)}

Identifies null values in the specified data column. If there is a null value, the result is true, otherwise - false.

In arguments, the following is specified:
The data source (the object type);
The column name (the string type).
Returns the value of the bool type.

{IsNull(DataSource.Column)} - in the rendered report, instead of null values, the true values will be output, and instead of other values, false values will be shown.
 

{IsNullOrEmpty(,)}

Provides the ability to check whether a string value is null or empty.
The arguments specify:
A data source (object type);
A data column name (string type);
Returns a value of the bool type.

{IsNullOrEmpty("")} - in this case, the result will be true because the string is empty.

{IsNullOrEmpty(DataSource.Column1)} - in this case, the value of Column1 will be checked for null or an empty string.

{IsNullOrWhiteSpace(,)}

Provides the ability to check whether a value is null, an empty string, or contains only whitespace characters.
The arguments specify:
A data source (object type);
A data column name (string type).
Returns a value of the bool type.

{IsNullOrWhiteSpace(" ")} - in this case, the result will be true because the string contains only whitespace characters.

{IsNullOrWhiteSpace(DataSource.Column1)} - in this case, the value of Column1 will be checked for null, an empty string, or whitespace characters.

{IsNumeric()}

Provides the ability to determine whether a value is numeric.
The arguments specify the value to check;
Returns a value of the bool type.

{IsNumeric("123")} - in this case, the result will be true because the value is numeric.

{IsNumeric(DataSource.Column1)} - in this case, the value of Column1 will be checked for a numeric type.

{JoinColumnContent(,,)}

Provides the ability to combine all values of a data source column into a single string using a separator.
The arguments specify:
A data source (object type);
A data column name (string type);
A separator (string type).
Returns a string value.

{JoinColumnContent(DataSource, "Column1", ", ")} - in this case, the values of the Column1 column will be combined using ", ".

{JoinColumnContent(DataSource, "Name", " | ")} - in this case, the values of the Name column will be combined using " | ".

{Next(,)}

Displays the value from the next line. If the value of the next line is null, the result is 0.

The data source is specified in arguments (the object type) and a column name (the string type);
Returns the value of the object type.

For example, the Column column contains values 2, 5, 9. Then, using the function {Next(DataSource, "Column")}, the first value will be 5, the second 9, and the third will be null.

{NextIsNull(,)}

Compares the value of the string with the value of the next line. If the value of the next line is 0 or null, the result is true, otherwise - false.

In arguments, the following is specified:

The data source (the object type);
The column name (the string type).
Returns the value of the bool type.

For example, the Column data column contains the values 2, 0, 9. Then, using the function {NextIsNull(DataSource, "Column")}, the first value is true; the second is false; the third is true.

{Previous(,)}

Displays the value from the previous line. If the value of the next line is null, the result is 0.

In arguments, the following is specified:

The data source (the object type);
The column name (the string type).

 
Returns the value of the object type.

For example, the Column column contains values 2, 5, 9. Then, using the function {Previous(DataSource, "Column")}, the first value will be null, the second value will be 2, the third value will be 5.

{PreviousIsNull(,)}

Compares the value of the string with the value of the previous row. If the value of the previous line is 0 or null, the result is true, otherwise - false.

In arguments, the following is specified:
The data source (the object type);
The column name (the string type).
Returns the value of the bool type.

For example, the Column data column contains the values 2, 9, 0. Then, using the function {PreviousIsNull (DataSource, "Column")}, the first value is true; the second is false; the third is false.

{ToQueryString(,,)}

Provides the ability to convert a list of values into a query string.
The arguments specify:
A list of values;
A quotation mark character;
A date format.
Returns a string value.

{ToQueryString("id", 15, "name", "John")} - in this case, the result will be "id=15&name=John".

{ToQueryString("page", 1, "sort", "asc")} - in this case, the result will be "page=1&sort=asc".

{VLookup(,,,)}

Provides the ability to find a value in one column and return a related value from another column in the same row.
In the arguments specify:
A lookup value;
A data source (object type);
A lookup column (string type);
A return column (string type).
Returns the found value.

{VLookup(DataSource, 1001, "Id", "Name")} - in this case, the value in the Name column will be found for the row where Id = 1001.

{VLookup(DataSource, "A01", "Code", "Price")} - in this case, the value of the Price column will be returned for the row with the code "A01".

{VLookupStr(,,,,)}

Provides the ability to search for a string value in a column and return a related value from another column.
In the arguments specify:
A lookup value;
A data source (object type);
A lookup column (string type);
A return column (string type);
An exact match flag (bool type).
Returns the found value.

{VLookupStr(DataSource, 1001, "Id", "Name", "Unknown")} - in this case, the value in the Name column will be found for the row where Id = 1001. If the value is not found, "Unknown" will be returned.

{VLookupStr(DataSource, "A01", "Code", "Category", "Not Found")} - in this case, the value of the Category column will be returned for the row with the code "A01". If no match is found, "Not Found" will be returned.

Drawing:

{ARGB(,,,)}

Provides the ability to create a color based on ARGB components (alpha, red, green, blue).
In the arguments specify:
Alpha transparency value from 0 to 255;
Red color value from 0 to 255;
Green color value from 0 to 255;
Blue color value from 0 to 255.
Returns a value of the Color type.

{ARGB(255, 255, 0, 0)} - in this case, an opaque red color will be created.

{ARGB(128, 0, 0, 255)} - in this case, a semi-transparent blue color will be created.

{ColorFade(,)}

Provides the ability to make a color darker or lighter by the specified value.
In the arguments specify:
A color;
A brightness adjustment value from -1 to 1.
Returns a value of the Color type.

{{ColorFade("Red", "Blue")} - in this case, a transition from red to blue will be created.

{ColorFade(RGB(0,255,0), RGB(0,0,0))} - in this case, a transition from green to black will be created.

{ColorValue()}

Provides the ability to convert a string representation of a color into a Color object.
In the arguments specify a string color value;
Returns a value of the Color type.

{ColorValue("Red")} - in this case, the red color will be retrieved.

{ColorValue("#00FF00")} - in this case, the green color will be retrieved.

{FontValue(,)}

Provides the ability to create a font with the specified name, size, and style.
In the arguments specify:
A font name;
A font size;
A font style.
Returns a value of the Font type.

{FontValue("Arial", 12)} - in this case, an Arial font with size 12 will be created.

{FontValue("Times New Roman", 14)} - in this case, a Times New Roman font with size 14 will be created.

{GlareBrushValue(,,,,)}

Provides the ability to create a brush with a glare effect.
In the arguments specify:
A starting gradient color;
An ending gradient color;
A gradient angle;
A gradient center;
A color transition speed.
Returns a value of the GlareBrush type.

{GlareBrushValue("Red", 45, 0.5, 1, "Horizontal")} - in this case, a red glare effect brush will be created.

{GlareBrushValue("Blue", 90, 0.3, 2, "Vertical")} - in this case, a blue glare effect brush will be created.

{GlassBrushValue(,,)}

Provides the ability to create a brush with a glass effect.
In the arguments specify:
A brush color;
A hatch visibility flag;
A blending factor.
Returns a value of the GlassBrush type.

{GlassBrushValue("White", 0.7, 0.5)} - in this case, a white glass effect brush will be created.

{GlassBrushValue("Blue", 1, 0.3)} - in this case, a blue glass effect brush will be created.

{GradientBrushValue(,,)}

Provides the ability to create a gradient brush.
In the arguments specify:
A starting gradient color;
An ending gradient color;
A gradient angle.
Returns a value of the GradientBrush type.

{GradientBrushValue("Red", "Yellow", 45)} - in this case, a gradient brush from red to yellow at a 45 degree angle will be created.

{GradientBrushValue(RGB(0,0,255), RGB(255,255,255), 90)} - in this case, a gradient brush from blue to white will be created.

{HatchBrushValue(,,)}

Provides the ability to create a hatch brush.
In the arguments specify:
A hatch style;
A hatch color;
A background color.
Returns a value of the HatchBrush type.

{HatchBrushValue("DiagonalCross", "Black", "White")} - in this case, a hatch brush with a diagonal cross pattern will be created.

{HatchBrushValue("Horizontal", "Blue", "LightBlue")} - in this case, a horizontal hatch brush will be created.

{RGB(,,)}

Provides the ability to create a color based on RGB components.
In the arguments specify:
Red color value from 0 to 255;
Green color value from 0 to 255;
Blue color value from 0 to 255.
Returns a value of the Color type.

{RGB(255, 0, 0)} - in this case, a red color will be created.

{RGB(0, 255, 0)} - in this case, a green color will be created.

{SolidBrushValue()}

Provides the ability to create a solid brush of the specified color. In the arguments specify:
A brush color;
Returns a value of the SolidBrush type.

{SolidBrushValue("Red")} - in this case, a solid red brush will be created.

{SolidBrushValue(RGB(0,0,255))} - in this case, a solid blue brush will be created.

Programming:

{Choose()}

Displays the value by index.

The arguments specify the index and values;
Returns values by index.

All product groups are grouped by category: expensive goods, medium price goods, cheap goods. An index is assigned to each group: expensive - index 1, average - index 2, cheap - index 3. The report should be displayed instead of their index - category. In this case, you can use the Choose function.

{Choose(DataSource.Column1, "expensive", "average", "cheap")} - instead of index 1, the value expensive will be displayed, instead of index 2 - average, instead of index 3 - cheap.

{Eval()}

Allows you to evaluate an expression provided as a string.

In the arguments, a string with the expression is specified;

Returns the result of the expression evaluation.

In a report, it may be necessary to dynamically calculate a value based on a string, for example, a formula obtained from data. In this case, the Eval function can be used.

{Eval("10 + 5 * 2")} - the result will be 20.

{IIF(,,)}

Used to display a particular value, depending on the condition.

In arguments, the condition is specified, the value if the condition is true (true) and the value if the condition is false (false);
Returns the value of the object type.

In the inventory report, you need to track the number of items. The logistician's task is that, when the quantity of goods is coming to 0 (less than 6), it is necessary to order these goods. To highlight critical positions in the report visually, you can use the function {IIF (,,)}

{IIF(DataSource.Column1 > 6,"Minimum","Normal")},
where DataSource.Column1 - the column with the values of the quantity of goods, 6 - the extreme quantity of goods, Minimum - the value that will be displayed if the stock of goods is less than 6, Normal - the value to be displayed if the stock of goods is 6 or more.

{Rand()}

Returns a random number.

Does not require arguments;

Returns a random value (usually from 0 to 1).

In a report, it may be necessary to generate a random value, for example for test data or random sampling. In this case, the Rand function can be used.

{Rand()} - returns a random number, for example 0.7345.

{Runtime()}

Returns the current report execution time.

Does not require arguments;

Returns the date and time value at the moment of execution.

In a report, it may be necessary to display the report generation time. In this case, the Runtime function can be used.

{Runtime()} — displays the current date and time of report execution.

{RuntimeIdentifier()}

Returns a unique runtime environment identifier.

Does not require arguments;

Returns a string value identifying the runtime.

In a report, it may be necessary to determine the environment in which the system is running (for example, for diagnostics or logging).

{RuntimeIdentifier()} — returns a string with the runtime identifier, for example:

NET472

NET8

NET10

NODE18

CHROME145

UNKNOWN

{RuntimeName()}

Returns the name of the runtime environment.

Does not require arguments;

Returns a string with the runtime name.

In a report, it may be necessary to display information about the platform on which the report is running.

{RuntimeName()} — returns the runtime name, for example:

.NET Framework

.NET

Chrome / Firefox / Opera / Edge

Node.js

Java

Unknown

{RuntimeOS()}

Returns information about the operating system.

Does not require arguments;

Returns a string with the OS name.

In a report, it may be necessary to display the operating system of the server or client.

{RuntimeOS()} — returns the operating system name, for example:

Windows

Linux

MacOS

iOS

Android

Unknown

{RuntimeType()}

Returns the type of the runtime environment.

Does not require arguments;

ВозвращаетReturns a string with the runtime type.

In a report, it may be necessary to determine the environment type (for example, server-side, client-side, or other).

{RuntimeType()} — returns the runtime type, for example:

DotNet

Node

Browser

Java

Unknown

{RuntimeVersion()}

Returns the version of the runtime environment.

Does not require arguments;

Returns a string with the runtime version.

In a report, it may be necessary to display the version of the platform used for diagnostics or auditing.

{RuntimeVersion()} — returns the runtime version, for example:

4.7.2

8.0.101

145

Unknown

{Switch()}

Assigns the specified value when the specified condition is complete.
In arguments, specify the condition and the value that will be assigned, if the condition is complete. Such condition-value pairs can be specified;
Returns the value of the object type.

For example, a list of employees is displayed in the report, and you need to display their position: Nancy is the lead project manager, Andrew is the chief developer, the remaining employees (6 people) are Juniors. In this case, the Switch function will have three pairs of "condition-value" arguments:

{Switch(Employees.FirstName == "Nancy", "Manager", Employees.FirstName == "Andrew", "Developer", Employees.FirstName! = "", "Junior" )}

Strings:

{Arabic()}

Converts these numbers to Arabic numerals.
The value is specified in arguments ( the string or int types);
Returns the value of the string type.

{Arabic(2)} - the number 2 will have an Arabic spelling.

 
{Arabic(DataSource.Column1)} - all the numbers from Column1 will have an Arabic spelling.

{Compare(,)}

Provides the ability to compare two strings and determine their position in sort order.
The arguments specify:
The first string;
The second string.

Returns a value of the int type:
Less than 0 if the first string is less than the second string;
0 if the strings are equal;
Greater than 0 if the first string is greater than the second string.

{Compare(10, 20)} - in this case, the result will be -1 because 10 is less than 20.

{Compare("ABC", "ABC")} - in this case, the result will be 0 because the values are equal.

{ConvertToBase64String()}

Provides the ability to convert a string or a byte array into Base64 format:
A string value or a byte array is specified in the arguments;
Returns a value of the string type.

{ConvertToBase64String("Hello")} - in this case, the result will be "SGVsbG8=".

{ConvertToBase64String(DataSource.Column1)} - in this case, the value of Column1 will be converted to a Base64 string.

{DateToStr()}

Converts date to text value.
In arguments, the following is specified:
Date (the DateTime type);
Boolean values (true or false) for displaying the header that starts with a capital letter or with a lowercase letter.
Returns the value of the string type.

{DateToStr(DataSource.Column1)} - all dates from Column1 will be displayed in text form.

 
{DateToStrPl(DataSource.Column1,true)} - dates will be displayed in text form, in Polish and the first character is a capital letter.

 
{DateToStrPl(DataSource.Column1,false)} - dates will be displayed in text form, in Polish and the first character is a lowercase letter.

 
{DateToStrPtBr(DataSource.Column1)} - the dates will be displayed in text form in the Brazilian language.
 

{Insert(,,)}

Inserts a value after a certain character into another value.

In arguments, the following is specified:
The value in which to insert text (the string type);

The number of a character, after which the value is inserted (the int type);

The value for insertion (the string type).
Returns the value of the string type.

{Insert("25",2," dollars")} - in the value 25, after the second symbol, the value dollars will be inserted, i.e. the result will be 25 dollars.
 
{Insert(DataSource.Column1,2,DataSource.Column2)} - in the Column1 value, after the second character, Column2 values will be inserted. For example, Column1 - contains the value of Category, Column2 - Products, then the result will be CaProductstegory.
 
 

{Left()}

Displays the specified number of characters from the left side of the value.
The value is specified in arguments of the string type string and the number of characters to be displayed (the int type);
Returns the value of the string type.

{Left("Beverages", 4)} - only four characters from the Beverages value will be displayed, the result will be Beve.
 
{Left(DataSource.Column1, 2)} - only the first two characters for each Column1 value will be displayed.

{Length()}

Displays the number of characters for the specified value.

The value is specified in arguments (the string type);
Returns the value of the int type.

{Length("Beverages")} - the result will be number 9 because the value Beverages consists of nine characters.

 
{Length(DataSource.Column1)} - for each Column1 value, the number of characters will be calculated, and this result will be displayed.

{Mid()}

Displays characters from a value. In this case, you can set the reference position.
In arguments, the following is specified:
The value (the string type);

Index of the reference position (the int type);

Number of characters to display (the int type).
Returns the value of the int type.

{Mid("Beverages",2,3)} - three symbols will be displayed after the first two, the result will be ver.
 
Mid(DataSource.Column1,3,2)} - 2 characters will be displayed after the first three for all values.

{ParseDateTime()}
{ParseDecimal()}
{ParseDouble()}

{ParseLong()}

Provides the ability to convert a string representation of a value into the corresponding numeric or date type.

In arguments specify a string value to convert;

Returns a value of the corresponding type:

ParseDateTime() - a value of the DateTime type;

ParseDecimal() - a value of the Decimal type;

ParseDouble() - a value of the Double type;

ParseLong() - a value of the Long type.

{ParseDateTime("2025-05-20")} - in this case, the string value will be converted to the date 20 May 2025.

{ParseDateTime(DataSource.Column1)} - in this case, the value of Column1 will be converted to the DateTime type.

{ParseDecimal("15.75")} - in this case, the result will be 15.75.

{ParseDecimal(DataSource.Column1)} - in this case, the value of Column1 will be converted to the decimal type.

{ParseDouble("3.1415")} - in this case, the result will be 3.1415.

{ParseDouble(DataSource.Column1)} - in this case, the value of Column1 will be converted to the double type.

{ParseLong("1500")} - in this case, the result will be 1500.

{ParseLong(DataSource.Column1)} - in this case, the value of Column1 will be converted to the long type.

{Persian()}

Converts specified numbers to numbers in Persian.
The value is specified in arguments of the string or int types;
Returns the value of the string type.

{Persian(5)} - number 2 will have Persian spelling.

 
{Persian(DataSource.Column1)} - all the numbers from Column1 will have Persian spelling.

{Remove()}

Deletes the specified number of characters from the index of a specific position.
In arguments, the following is specified:
The value (the string type);

Index of the reference position (the int type);

Number of characters to delete (the int type).
Returns the value of the int type.
 

{Remove("Beverages",2,3)} - after the second character, three characters will be deleted, the result is Beages.
 
{Remove(DataSource.Column1,3,2)}  - for all values from Column1, two characters will be deleted after the first three.

{Replace(,,)}

Replaces certain characters or their combination with other characters.
In arguments, the following is specified:
The value (the string type) in which the replacement will be made;

Characters to be replaced (the string type);

Characters to be inserted (the string type).
Returns the value of the string type.

{Replace("Beverages","ver","NEW")} - in the value Beverages, the ver characters will be replaced by the characters NEW, the result is BeNEWages.
 
{Replace(DataSource.Column1, "rex","sum")} - for Column1 values, in which the combination of rex characters occurs, rex will be replaced by sum. In values where there is no combination of rex, a replacement will not be done.

{Right()}

Displays the specified number of characters from the right side of the value.
The value is specified in arguments of the string type and the number of characters which should be displayed (the int type);
Returns the value of the string type.

{Right("Beverages",3)} - three characters from the right side of the value will be displayed, ges.
 
{Right(DataSource.Column1,4)} - for each Column1 value, four characters will be displayed from the right side.

{Roman()}

Converts Arabic numerals to Roman numerals.
In the arguments, specify the number (the int type);
Returns the value of the string type.

{Roman(4)} - the number 4 will have a Roman spelling.

 
{Roman(DataSource.Column1)} - all the numbers from Column1 will have a Roman spelling.

{Substring()}

Displays a certain number of characters from the specified position.
In arguments, the following is specified:
The value (the string type) from which the characters will be displayed;

The index of position (the int type), how many characters are skipped;

Number of characters to display (the int type).
Returns the value of the string type.

{Substring("Beverages",6,3)} - the first six characters are skipped and three characters will be displayed, the result is ges.
 
{Substring("Beverages",0,2)} - two characters will be displayed starting with zero, the result will be Be.
 
{Substring(DataSource.Column1,1,4)} - the first character is skipped, and four are counted starting from the second one. This is the result for each Column1 value, which is displayed in the report.

{ToCurrencyWords()}

Displays the currency value as the text.
You can pass to the function:
Argument as numeric value (double, decimal, long) which will be converted to text;

Argument (true or false) to display text with a capital letter;

Argument (true or false) to display cents;

Single and plural formats for currency and cents (the string type);

You can also specify a base unit for the integer part and a fractional.

In addition, various combinations of arguments are possible. There are also some types of this function that support different cultures. Pay attention to you can specify the currencies ISO code (the string type).

 
Returns the value of the string type.
 

{ToCurrencyWords(100)} - the used currency is dollars of the USA, so that the result will be:  "One hundred dollars and zero cents.
 

{ToCurrencyWords(100, false)} - the result will be displayed without displaying cents (since it is set to true), the result will be: "One hundred dollars".

{ToCurrencyWords(100,false,true)} - the result will be displayed with the first lowercase letter (since it is set to false) and with displaying cents (since it is set to true), the result will be: "one hundred dollars and zero cents".

{ToCurrencyWords(125.9,true,true,"currency","cent name")} - in this case, the result will be displayed with the first uppercase letter (since it is set to true) and with displaying cents (since it is set to true). Also, we defined the basic unit as "currency", and the fractional unit as "cent name". The result will be: "One hundred and twenty-five currency and ninety cent name".

 
{ToCurrencyWordsEnGb(1.25,"EUR",2)} - the ISO code EUR will be applied, and the result will be one euro and twenty-five cents.

{ToCurrencyWordsEnIn("dollars","cents",1.25M,0,true)} - the base unit for the integer part as dollars will be specified, the fractional part - cents, the number for conversion 1.25, then the number of decimal signs to convert and the value true means that the entry will start with the capital letter.

{ToLowerCase()}

Displays the value in lowercase.
The value is specified in arguments (the string type);
Returns the value of the string type,

{ToLowerCase("EURO")} - the result is euro.
{ToLowerCase(DataSource.Column1)} - all values of this column will be displayed in lowercase.

{ToOrdinal()}

Converts numerals to ordinal.
The value is specified in arguments (the long type);
Returns the value of the string type.

{ToOrdinal(25)} - the result is 25th.
{ToOrdinal(DataSource.Column1)} - all the values of this column will be converted to ordinal numerals.

{ToProperCase()}

Converts the text to the format - the first character is capital, the rest characters are in lowercase.
The value is specified in arguments (the string type);
Returns the value of the string type.

{ToProperCase("dOllars")} - the result is Dollars.
{ToProperCase("dollars")} - the result is Dollars.
{ToProperCase("dOLLARS")} - the result is Dollars.
{ToProperCase(DataSource.Column1)} - all values from this column will be with the first capital letter and the rest ones in lowercase.

{ToString()}

Provides the ability to convert a value into a string type:
A value of any type is specified in the arguments;
Returns a value of the string type.

{ToString(12345)} - in this case, the result will be "12345".

{ToString(DataSource.Column1)} - in this case, the value of Column1 will be converted to a string.

{ToUpperCase()}

Displays the value in uppercase.
The value is specified in arguments (the string type);
Returns the value of the string type.

{ToUpperCase("dollars")} - the result is DOLLARS.
{ToUpperCase("dOllars")} - the result is DOLLARS.
{ToUpperCase("dOLLARS")} - the result is DOLLARS.
{ToProperCase(DataSource.Column1)} - all values will be written in uppercase.

{ToWords()}

Displays the numerals as text.
In arguments, the following is specified:

A numeric value that will be converted to text (decimal, double, long);
True or false values whether to display the first character with a capital letter;
True or false values to return null and empty values;
It is also possible to specify true or false values to provide the feminine form for the result.
 
Returns the value of the string type.

{ToWords(100)} - the result is one hundred.
{ToWords(100, true)} - the result is One hundred.
{ToWordsEnIn(0,false)} - the result is Zero.
{ToWordsEnIn(0,true)} - there will be no results.
{ToWordsEs(100,true,true)} - the result starts with a capital letter and in feminine form, Cien
{ToProperCase(DataSource.Column1)} - all values will be displayed in text.

{Trim()}

Trims the spaces at the beginning or end of the line.
The value is specified in arguments (the string type);
Returns the value of the string type.

{Trim("   <1 dollars>   ")} - the result in this case is <1 dollars>".
{Trim(DataSource.Column1)} - the spaces before each value and after each value will be truncated.
 

{TryParseDecimal()}
{TryParseDouble()}
{TryParseLong()}

Checks the value for conversion to decimal, double, long.
The value is specified in arguments (the string type);
Returns a value of the bool type. If true, then the conversion will be successful, otherwise it will be false.

{TryParseLong("100")} - The value can be converted to long.
{TryParseLong(" { 100")} - the result is false. The value cannot be converted to long.
{TryParseLong(DataSource.Column1)} - each value will be checked on possibility to be converted to long.

Totals in-depth