Expression Editor functions

NAVIGATION   Modules > Advanced Reporting > Categories icon > click a row > Edit > click an element >  Properties > Data Binding > Expressions > Functions

SECURITY  Advanced Reporting > View Reporting and run reports

You can use a function in an expression to perform actions on data in data regions, groups, and datasets. You can access these functions in the Functions section of the Expression Editor. In any property that accepts expressions, you can drop down the property and select <Expression> to open the dialog.

Refer to the following tables that contain details about each of the functions included in Advanced Reporting for use in property expressions.

To learn more about how to apply functions, refer to Advanced Reporting: Expression Editor.

NOTE  The Date & Time functions used to define the date and time values display the date in MM/DD/YYYY and the time in HH:mm:ss format.

Function Description Syntax (S) and Example (E)
DateAdd Returns a date and time value that is the result of adding the interval to the date and time field of the specified unit. S:DateAdd(DateInterval,Number,DateTime)

E:{DateAdd("d", 5, SaleDate)}; {DateAdd(DateInterval.Day, 5, SaleDate)}

DateDiff Returns the difference between the start date and time and end date and time of the specified unit. S:DateDiff(<DateInterval>, <DateTime1>, <DateTime2>[, <DayOfWeek>[, <WeekOfYear>]])

E:{DateDiff("yyyy", SaleDate, "1/1/2015")}; {DateDiff(DateInterval.Year, SaleDate, "1/1/2015")}

DatePart Returns the Integer value that represents the specified part of the given date. S:DatePart(<DateInterval>, <DateTime>[, <FirstDayOfWeek>[, <FirstWeekOfYear>]])

E:{DatePart("m", SaleDate)}

DateSerial Returns a Date value that represents a specified year, month, and day, with the time information set to midnight (00:00:00). S:DateSerial(<Year Number>, <Month Number>, <Day Number>)

E:{DateSerial(DatePart("yyyy", SaleDate) - 10, DatePart("m", SaleDate) + 5, DatePart("d", SaleDate) - 1)}

DateString Returns the String value that represents the current date in your system. S:DateString()

E:{DateString()}; {DatePart("m", DateString())}

DateValue Returns a Date value that contains the information on date represented by a string, with the time set to midnight (00:00:00). S:DateValue(<StringDate>)

E:{DateString()}; {DatePart("m", DateString())}

Day Returns an Integer value from 1 through 31 that represents the day of the month. S:Day(<DateTime>)

E:{Day(SaleDate)}

Hour Returns an Integer value from 0 through 23 that represents the hour of the day. S:Hour(<DateTime>)

E:{Hour(SaleDate)}

Minute Returns an Integer value from 0 through 59 that represents the minute of the hour. S:Minute(<DateTime>)

E:{Minute(SaleDate)}

Month Returns an Integer value from 1 through 12 that represents the month of the year. S:Month(<DateTime>)

E:{Month(SaleDate)}

MonthName Returns the name of the month specified in the date as a String. S:MonthName(<Month Number>[, <Abbreviate>])

E:{MonthName(MonthNumber)}

Now Returns the current date and time in your system. S:Now()

E:{Now()}

Second Returns an Integer value from 0 through 59 that represents the second of the minute. S:Second(<DateTime>)

E:{Second(SaleDate)}

TimeOfDay Returns a Date value containing the current time of day in your system. S:TimeOfDay()

E:{TimeOfDay()}

Timer Returns a Double value that represents the number of seconds elapsed since midnight. S:Timer()

E:{Timer()}

TimeSerial Returns a Date value that represents a specified hour, minute, and second, with the date information set relative to January 1 of the year 0001. S:TimeSerial(<Hour Number>, <Minute Number>, <Second Number>)

E:{TimeSerial(DatePart("h", SaleDate), DatePart("n", SaleDate), DatePart("s", SaleDate))}

TimeString Returns the String value that represents the current time of day in your system. S:TimeString()

E:{TimeString()}

TimeValue Returns a Date value that contains the information on time represented by a string, with the date set to January 1 of the year 0001. S:TimeValue(<StringTime>)

E:{TimeValue("15:25:45")}; {TimeValue(SaleDate)}

Today Returns a Date value that contains the current date in your system. S:Today()

E:{Today()}

Weekday Returns an Integer value that contains a number representing the day of the week. S:Weekday(<DateTime>[,<DayOfWeek>])

E:{Weekday(SaleDate, 0)}
WeekdayName Returns a String value that contains the name of the specified weekday. S:WeekdayName(<WeekDay>[, <Abbreviate>[, <FirstDayOfWeek>]])

E:{WeekdayName(3, true, 0)}; {WeekDayName(DatePart("w", SaleDate), true, 0)}

Quarter Returns an Integer value from 1 through 4 that represents the quarter of the year. S:Quarter(<DateTime>)

E:{Quarter(SaleDate)}

QuarterName Returns a String value that represents the quarter of the year. S:QuarterName(<DateTime>)

E:QuarterName(SaleDate)

Year Returns an Integer value from 1 through 9999 representing the year. S:Year(<DateTime>)

E:{Year(SaleDate)}

AddYears Returns a date and time value that is a result of adding the date interval in years. The specified date interval can be negative. S:DateTime>.AddYears(<Number>)

E:{OrderDate.AddYears(3)}

AddMonths Returns a date and time value that is a result of adding the date interval in months. The specified date interval can be negative. S:<DateTime>.AddMonths(<Number>)

E:{OrderDate.AddMonths(2)}

AddDays Returns a date and time value that is a result of adding the date interval in days. The specified date interval can be negative. S:<DateTime>.AddDays(<Number>)

E:{OrderDate.AddDays(5)}

AddHours Returns a date and time value that is a result of adding the time interval in hours. The specified time interval can be negative. S:<DateTime>.AddHours(<Number>)

E:{OrderDate.AddHours(12)}

AddMinutes Returns a date and time value that is a result of adding the time interval in minutes. The specified time interval can be negative. S:<DateTime>.AddMinutes(<Number>)

E:{OrderDate.AddMinutes(30)}

AddSeconds Returns a date and time value that is a result of adding the time interval in seconds. The specified time interval can be negative. S:<DateTime>.AddSeconds(<Number>)

E:{OrderDate.AddSeconds(30)}

AddMilliseconds Returns a date and time value that is a result of adding the time interval in milliseconds. The specified time interval can be negative. S:<DateTime>.AddMilliseconds(<Number>)

E:{OrderDate.AddMilliseconds(500)}

DateTime.Parse Converts the specified string value to a date and time value. S:DateTime.Parse(<String>[, <String>])

E:{DateTime.Parse("01/01/1970")}

Function Description Syntax (S) and Example (E)
Abs Returns the absolute or positive value of a single-precision floating-point number. S:Abs(<Number>

E:{Abs(-5.5)}; {Abs(YearlyIncome - 80000)}

Acos Returns the angle whose cosine is the specified number. S:Acos(<Number>)

E:{Acos(0.5)}; {Acos(Angle)}

Asin Returns the angle whose sine is the specified number. S:Asin(<Number>)

E:{Asin(0.5)}; {Asin(Angle)}

Atan Returns the angle whose tangent is the specified number. S:Atan(<Number>)

E:{Atan(0.5)}; {Atan(Angle)}

Atan 2 Returns the angle whose tangent is the quotient of two specified numbers. S:Atan2(<Number1>, <Number2>)

E:{Atan2(3, 7)}; {Atan2(CoordinateY, CoordinateX)}

BigMul Returns the multiplication of two 32-bit numbers. S:BigMul(<Number1>, <Number2>)

E:{BigMul(4294967295, -2147483647)}; {BigMul(Int32Value, Int32Value)}

Ceiling Returns the smallest integer greater than or equal to the specified double-precision floating-point number. S:Ceiling(<Number>)

E:{Ceiling(98.4331)}; {Ceiling(AnnualSales / 6)}

Cos Returns the smallest integer greater than or equal to the specified double-precision floating-point number. S:Cos(<Number>)

E:{Cos(60)}

Cosh Returns the hyperbolic cosine of the specified angle. S:Cosh(<Number>)

E:{Cosh(60)}

E Returns the value of E, which is 2.71828182845905. S:E

E:{E * 2}

Exp Returns e raised to the specified power, where e is Euler's number. It is the inverse of the Log function. S:Exp(<Number>)

E:{Exp(3)}; {Exp(IntegerCounter)}

Fix Returns the integer portion of a number. S:Fix(<Number>)

E:{Fix(-7.15)}; {Fix(AnnualSales / -5)}

Floor Returns the largest integer less than or equal to the specified double-precision floating-point number. S:Floor(<Number>)

E:{Floor(4.67)}; {Floor(AnnualSales / 12)}

IEEERemainder Returns the remainder after division of one number by another according to IEEE standards. S:IEEERemainder(<Number1>, <Number2>)

E:{IEEERemainder(9, 8)}

Log Returns the logarithm of the specified number. S:Log(<Number>)

E:{Log(20.5)}; {Log(NumberValue)}

Log10 Returns the logarithm of the specified number to the base 10. S:Log10(<Number>)

E:{Log10(20.5)}; {Log10(NumberValue)}

Max Returns the maximum non-null value from the specified expression. S:Max(<Values>)

E:{Max(OrderTotal)}

Min Returns the minimum non-null value from the specified expression. S:Min(<Values>)

E:{Min(OrderTotal)}

PI Returns the value of PI, which is 3.14159265358979. S:PI

E:{2 * PI * Radius}

Pow Returns one number raised to the power of another number. S:Pow(<Number1>, <Number2>)

E:{Pow(Quantity, 2)}

Round Returns the round-off of a decimal number to the nearest integer or to the nearest decimal number up to the specified digits. S:Round(<Number>)

E:{Round(12.456)}; {Round(AnnualSales / 12.3)}

Sign Returns a value indicating the sign of an 8-bit signed integer. S:Sign(<Number>)

E:{Sign(AnnualSales - 60000)}

Sin Returns the sine of the specified number. S:Sin(<Number>)

E:{Sin(60)}

Sinh Returns the hyperbolic sine of the specified angle. S:Sinh(<Number>)

E:{Sinh(60)}

Sqrt Returns the square root of the specified number. S:Sqrt(<Number>)

E:{Sqrt(121)}

Tan Returns the tangent of the specified number. S:Tan(<Number>)

E:{Tan(60)}

Tanh Returns the hyperbolic tangent of the specified angle. S:Tanh(<Number>)

E:{Tanh(60)}

Truncate Removes the digits after decimal point without rounding-off, and returns the integer value. S:Truncate(<Number>)

E:{Truncate(UnitPrice)}

Function Description Syntax (S) and Example (E)
Contains Returns True if the string contains the specified substring. S:<String>.Contains(<String>)

E:{ShipAddress.Contains("street")}

EndsWith Returns True if the string ends with the specified substring. S:<String>.EndsWith(<String>)

E:{Description.EndsWith("documents")}

IndexOf Returns the index of the first occurrence of the specified substring within the string. S:<String>.IndexOf(<String>[, <Number>])

E:{Description.IndexOf("documents")}

InStr Returns the start position of the first occurrence of the specified substring within the string. S:InStr(<String>, <String>)

E:{InStr(Description, "documents")}

LastIndexOf Returns the index of the last occurrence of the specified substring within the string. S:<String>.LastIndexOf(<String>[, <Number>])

E:{Description.LastIndexOf("documents")}

Replace Replaces all the occurrences of the first specified substring with the second specified substring within the string. S:<String>.Replace(<String>, <String>)

E:{Description.Replace("documents", "invoices")}

StartsWith Returns True if the string starts with the specified substring. S:<String>.StartsWith(<String>)

E:{Description.StartsWith("Invoice")}

Substring Returns the substring at the specified position (zero-based) of the specified length. S:<String>.Substring(<Number>, <Number>)

E:{Description.Substring(1, 10)}

ToLower Returns the specified string in lower case. S:<String>.ToLower()

E:{ShipCountry.ToLower()}

ToUpper Returns the specified string in upper case. S:<String>.ToUpper()

E:{ShipCountry.ToUpper()}

Trim Returns the string after removing all the white-space characters from both the start and the end of the specified string. S:<String>.Trim()

E:{@Info.Trim()}

TrimEnd Returns the string after removing all the white-space characters from the end of the specified string. S:<String>.TrimEnd()

E:{@Info.TrimEnd()}

TrimStart Returns the string after removing all the white-space characters from the start of the specified string. S:<String>.TrimStart()

E:{@Info.TrimStart()}

Function Description Syntax (S) and Example (E)
IsArray Returns True if the expression can be evaluated as an array. S:IsArray(<Expression>)

E:{IsArray(@Initials)}

IsDate Returns True if the expression represents a valid Date value. S:IsDate(<Expression>)

E:{IsDate(BirthDate)}; {IsDate("31/12/2010")}

IsDBNull Returns True if the expression evaluates to a null. S:IsDBNull(<Expression>)

E:{IsDBNull(MonthlySales)}

IsError Returns True if the expression evaluates to an error. S:IsError(<Expression>)

E:{IsError(AnnualSales = 80000)}

IsNothing Returns True if the expression evaluates to nothing. S:IsNothing(<Expression>)

E:{IsNothing(MiddleInitial)}

IsNumeric Returns True if the expression can be evaluated as a number. S:IsNumeric(<Expression>)

E:{IsNumeric(AnnualSales)}

DBNull.Value Allows checking whether a value is a DBNull value. S:DBNull.Value

E:{IIF(Organization is DBNull.Value, "<NULL>", Organization)}

Function Description Syntax (S) and Example (E)
Choose Returns a value from a list of arguments. S:Choose(<Index>, <Value1>[, <Value2>,...[, <ValueN>]])

E:{Choose(3, "10", "15", "20", "25")}

IIF Returns the first value if the expression evaluates to True, and the second value if the expression evaluates to False. S:IIF(<Condition>, <TruePart>, <FalsePart>)

E:{{IIF(AnnualSales >= 80000, "Above Average", "Below Average")}

Partition Returns a string (in the form x : y) that represents the calculated range based on the specified interval containing the specified number. S:Partition(<Value>, <Start>, <End>, <Interval>)

E:{Partition(1999, 1980, 2000, 10)}

Switch Returns the value of the first expression that evaluates to True among a list of expressions. S:Switch(<Condition1>, <Value1>[, <Condition2>, <Value2>,...[, <ConditionN>, <ValueN>]])

E:{Switch(FirstName = "Abraham", "Adria", FirstName = "Charelotte", "Cherrie")}

Function Description Syntax (S) and Example (E)
AggregateIf Calculates the aggregate of the values from the specified expression if the Boolean expression meets the given condition. S:AggregateIf(<Condition>, <AggregateFunction>, <AggregateArguments>)

E:{AggregateIf(Discontinued = true, "Sum", InStock)}

AggregateIf (with scope) Calculates the aggregate of the values from the specified expression if the Boolean expression meets the given condition, within the specified scope. S:AggregateIf(<Condition>, <AggregateFunction>, <AggregateArguments>, <Scope>)

E:{AggregateIf(Discontinued = true, "Sum", InStock, "Category")}

Avg Calculates the average of all non-null numeric values from the specified expression. S:Avg(<Values>)

E:{Avg(LifeExpentancy)}

Avg (with scope) Calculates the average of all non-null numeric values from the specified expression within the specified scope. S:Avg(<Values>, <Scope>)

E:{Avg(LifeExpentancy, "GroupByCountry")}

Count Calculates the number of non-null values from the specified expression. S:Count(<Values>)

E:{Count(EmployeeID)}

Count (with scope) Calculates the number of non-null values from the specified expression within the specified scope. S:Count(<Values>, <Scope>)

E:{Count(EmployeeID, "Title")}

CountDistinct Calculates the number of non-repeated values from the specified expression. S:CountDistinct(<Values>)

E:{CountDistinct(OrderID)}

CountDistinct (with scope) Calculates the number of non-repeated values from the specified expression within the specified scope. S:CountDistinct(<Values>, <Scope>)

E:{{CountDistinct(OrderID, "GroupByCategory")}

CountRows Calculates the number of rows. S:CountRows()

E:{CountRows()}

CountRows (with Scope) Calculates the number of rows within the specified scope. S:CountRows(<Scope>)

E:{CountRows("Title")}

CrossAggregate Calculates the specified function with specified expression as an argument in the cross of specified row and column. S:CrossAggregate(<Expression>, <FunctionName>, <ColumnGroupName>, <RowGroupName>)

E:{CrossAggregate(Amount, "Sum", "YearGroup", "CategoryGroup")}

CumulativeTotal Calculates the sum of page-level aggregates returned by the expression for current and previous pages. S:CumulativeTotal(<Expression>, <Aggregate>)

E:{CumulativeTotal(OrderID, "Count")}

DistinctSum Calculates the sum of values from the specified expression when the value of the other expression is not repeated. S:DistinctSum(<Values>, <Value>)

E:{DistinctSum(OrderID, OrderFreight)}

DistinctSum (wih scope) Calculates the sum of values of the specified expression when the value of the other expression is not repeated, within the specified scope. S:DistinctSum(<Values>, <Value>, <Scope>)

E:{DistinctSum(OrderID, OrderFreight, "Order")}

First Returns the first value from the specified expression. S:First(<Values>)

E:{First(ProductNumber)}

First (with scope) Returns the first value from the specified expression within the specified scope. S:First(<Values>, <Scope>)

E:{First(ProductNumber, "Category")}

Last Returns the last value from the specified expression. S:Last(<Values>)

E:{Last(ProductNumber)}

Last (with scope) Returns the last value from the specified expression within the specified scope. S:Last(<Values>, <Scope>)

E:{Last(ProductNumber, "Category")}

Max Returns the maximum non-null value from the specified expression. S:Max(<Values>)

E:{Max(OrderTotal)}

Max (with scope) Returns the maximum non-null value from the specified expression within the specified scope. S:Max(<Values>, <Scope>)

E:{Max(OrderTotal, "Year")}

Median Returns the value that is the mid-point of the values in the specified expression. Median is the center value in a sequence of values. S:Median(<Values>)

E:{Median(OrderTotal)}

Median (with scope) Returns the value that is the mid-point of the ordered values in the specified expression, within the specified scope. Median is the center value in a sequence of values. S:Median(<Values>, <Scope>)

E:{Median(OrderTotal, "Year")}

Min Returns the minimum non-null value from the specified expression. S:Min(<Values>)

E:{Min(OrderTotal)}

Min (with scope) Returns the minimum non-null value from the specified expression within the specified scope. S:Min(<Values>, <Scope>)

E:{Min(OrderTotal, "Year")}

Mode Returns the most frequently occurring value from the specified expression. S:Mode(<Values>)

E:{Mode(OrderTotal)}

Mode (with scope) Returns the most frequently occurring value from the specified expression, within the specified scope. S:Mode(<Values>, <Scope>)

E:{{Mode(OrderTotal, "Year")}

RunningValue Calculates a running aggregate of all non-null numeric values from the specified expression, using another aggregate function as a parameter. S:RunningValue(<Values>, <AggregateFunction>)

E:{RunningValue(Price, "Sum")}

RunningValue (with scope) Calculates a running aggregate of all non-null numeric values from the specified expression, using another aggregate function as a parameter, within the specified scope. S:RunningValue(<Values>, <AggregateFunction>, <Scope>)

E:{RunningValue(Price, "Sum", "Nwind")}

StDev Calculates the standard deviation of all non-null values of the specified expression. S:StDev(<Values>)

E:{StDev(LineTotal)}

StDev (with scope) Calculates the standard deviation of all non-null values of the specified expression, within the specified scope. S:StDev(<Values>, <Scope>)

E:{StDev(LineTotal, "Nwind")}

StDevP Calculates the population standard deviation of all non-null values of the specified expression. S:StDevP(<Values>)

E:{StDevP(LineTotal)}

StDevP (with scope) Calculates the population standard deviation of all non-null values of the specified expression within the specified scope. S:StDevP(<Values>, <Scope>)

E:{StDevP(LineTotal, "Order")}

Sum Calculates the sum of the values of the specified expression. S:Sum(<Values>)

E:{Sum(Price)}

Sum (with scope) Calculates the sum of the values of the specified expression within the specified scope. S:Sum(<Values>, <Scope>)

E:{Sum(Price, "Category")}

Var Calculates the variance (standard deviation squared) of all non-null values of the specified expression. S:Var(<Values>)

E:{Var(LineTotal)}

Var (with scope) Calculates the variance (standard deviation squared) of all non-null values of the specified expression. S:Var(<Values>, <Scope>)

E:{Var(LineTotal, "Order")}

VarP Calculates the population variance (population standard variation squared) of all non-null values of the specified expression. S:VarP(<Values>)

E:{VarP(LineTotal)}

VarP (with scope) Calculates the population variance (population standard variation squared) of all non-null values of the specified expression, within the specified scope. S:VarP(<Values>, <Scope>)

E:{VarP(LineTotal, "Order")}

Function Description Syntax (S) and Example (E)
ToBoolean Converts the specified value to Boolean. S:ToBoolean(<Value>)

E:{ToBoolean(HouseOwnerFlag)}

ToByte Converts the specified value to Byte. S:ToByte(<Value>)

E:{ToByte(ProductNumber)}

ToChar Converts the specified value to Char. S:ToChar(<Value>)

E:{ToChar(OrderStatus)}; {ToChar("Hello")}

ToDateTime Converts the specified value to a Date and Time value. S:ToDateTime(<Value>)

E:{ToDateTime(SaleDate)}; {ToDateTime("1 January, 2017")}

ToDecimal Converts the specified value to Decimal. S:ToDecimal(<Value>)

E:{ToDecimal(Sales)}}

ToDouble Converts the specified value to Double . S:ToDouble (<Value>)

E:{ToDouble(AnnualSales)}; {ToDouble(535.85 * 0.2691 * 67483)}

ToInt16 Converts the specified value to a 16-bit signed Integer. S:ToInt16(<Value>)

E:{ToInt16(AnnualSales)}; {ToInt16(535.85)}

ToInt32 Converts the specified value to a 32-bit signed Integer. S:ToInt32(<Value>)

E:{ToInt32(AnnualSales)}

ToInt64 Converts the specified value to a 64-bit signed Integer. S:ToInt64(<Value>)

E:{ToInt64(AnnualSales)}

ToSingle Converts the specified value to a single-precision floating-point number. S:ToSingle(<Value>)

E:{ToSingle(AnnualSales)}; {ToSingle(15.857692134)}

ToString Converts the specified value to String. S:ToString(<Value>)

E:{ToString(YearlyIncome)}; {ToString(13.5)}

.ToString Converts the value to String in the specified format. S:.ToString(<Value>)

E:{OrderDate.ToString("dd MMM yyyy")}

ToUInt16 Converts the specified value to a 16-bit unsigned Integer. S:ToUInt16(<Value>)

E:{ToUInt16(AnnualSales)}

ToUInt32 Converts the specified value to a 32-bit unsigned Integer. S:ToUInt32(<Value>)

E:{ToUInt32(AnnualSales)}

ToUInt64 Converts the specified value to a 64-bit unsigned Integer. S:ToUInt64(<Value>)

E:{ToUInt64(AnnualSales)}

Format Converts the specified value to rmat. S:Format(<Value>)

E:{Format(OrderDate, "dd MMM yyyy")}

NumberToWords Converts the specified value to words. Single argument function uses the current language from the portal. A function with two arguments uses the language passed by the second argument(Supported cultures: "zh-cn", "en-us", "ja-jp"). S:NumberToWords(<Value>)

E:{UserContext.NumberToWords(123.5)}; {UserContext.NumberToWords(981, "zh-CN")}
Function Description Syntax (S) and Example (E)
GetFields Returns an IDictionary<string,Field> object that contains the current contents of the Fields collection. Only valid when used within a data region. This function makes it easier to write code that deals with complex conditionals. To write the equivalent function without GetFields() would require passing each of the queried field values into the method which could be prohibitive when dealing with many fields. S:GetFields()

E:{GetFields()}; {Code.DisplayAccountID(GetFields())}

InScope Evaluates to true or false depending on whether the current value is in the specified scope. S:InScope(<Scope>)

E:{InScope("Order")}

Level Returns a zero-based integer representing the current level of depth in a recursive hierarchy in the current scope. The first level in the hierarchy is 0. S:Level()

E:{{Level()}

Level (with scope) Returns a zero-based integer representing the current level of depth in a recursive hierarchy in the specified scope. The first level in the hierarchy is 0. S:Level(<Scope>)

E:{Level("Order")}

Lookup Returns the first matching value for the specified name from the dataset with name and value pairs. S:Lookup(<Source>, <Destination>, <Result>, <DataSet>)

E:{Lookup(ProductID, ProductID, Quantity, "DataSet2")}

LookupSet Returns the set of matching values for the specified name from the dataset that contains name/value pairs. S:LookupSet(<Source>, <Destination>, <Result>, <DataSet>)

E:{LookupSet(ProductID, ProductID, Quantity, "DataSet2")}

Previous Calculates the value of the expression for the previous row of data. S:Previous(<Expression>)

E:{Previous(OrderID)}

Previous (with scope) Calculates the value of the expression for the previous row of data. S:Previous(<Expression>, <Scope>)

E:{Previous(OrderID, "Order")}

RowNumber Returns the running count of all the rows. S:RowNumber()

E:{RowNumber()}

RowNumber (with scope) Returns the running count of all the rows in the specified scope. S:RowNumber(<Scope>)

E:{RowNumber("OrderID")}

GetLength Returns the number of elements in the specified array. S:<Collection>.GetLength(<Number>)

E:{@MultiValueParameter.GetLength(0)}

Item Returns an item by its name from Fields/Parameters/ReportItems. S:<Object/Record>.Item(<String>)

E:{Fields.Item("Company Name").Name}; {Parameters.Item("Parameter1").Name}; {ReportItems.Item("TextBox1").Value}

Join Returns a string that is a result of joining the elements of an array, using the specified delimiter between elements. S:Join(<Values>, <String>)

E:{Join(@MultiValueParameter, ", ")}

GetUserValue Displays the user context value for specified property, e.g. "name","email". S:UserContext.getValue(<String>)

E:{UserContext.getValue("name")}

UserContext.T Displays the user translation for specified key. S:UserContext.T(<String>)

E:{UserContext.T("translationKey")}

UserContext.GetRenderMode Returns the render mode: "preview", "print" or "export". S:UserContext.GetRenderMode()

E:{UserContext.GetRenderMode()}