arb quick start guide - bromcom quick... · once you have a data source, use the infographics...

ARB Quick Start Guide

Contents Before you start ................................................................................................................................................... 3

Creating a report .................................................................................................................................................. 3

Accessing Fields and creating Databands ........................................................................................................... 4

Calculated Fields ................................................................................................................................................. 5

Summarising Tables ............................................................................................................................................ 6

Joining tables ....................................................................................................................................................... 6

Variables ............................................................................................................................................................. 7

Variables as Parameters ...................................................................................................................................... 7

Dependent Variables ........................................................................................................................................... 8

Styles and Formatting .......................................................................................................................................... 9

Charts .................................................................................................................................................................. 9

Interaction .......................................................................................................................................................... 11

Trouble Shooting ............................................................................................................................................... 12

Appendix 1: Functions ....................................................................................................................................... 13

Appendix 2: Aggregate Functions ...................................................................................................................... 27

Appendix 3: Fields ............................................................................................................................................. 29

Before you start In order to access Assessment Results with ARB you must have migrated to the simplified Assessment Structure. If you have not already done this, contact [email protected] for guidance.

Creating a report From the Main Menu select Reporting, then click the ‘Advanced’ option.

ARB link from Reporting Home Screen

Select ‘New’ give your report a title and choose which domains you wish to bring through (and for what intervals). In the report builder all the data areas will be visible but you will only be able to see results if you have chosen to call the data at this stage. You can choose as many data areas as you like but having only what you need improves performance.

Set Name, Permissions and data for the report

Click ‘Design’ to open the report designer (note that you will need popup blocker disabled). Use the Preview tab to view output. Save via the top left Icon

The Report Designer

mailto:[email protected]

Accessing Fields and creating Databands In the bottom left of the Design screen, select ‘Dictionary’ then expand Data Sources and Advanced Reporting Domains to see a list of the available tables.

The Data Sources in the Dictionary

Each table can be further expanded to show the fields it contains. A list of data is called a Databand and can be created by dragging the relevant table onto the page space. In the pop up you can then choose the fields for the Databand and whether you want to add a header and/or footer.

Once you have created a Databand, right click and select ‘Design’ (top left) to adjust the sorting and filtering of the band.

Use the ‘Field is’ selector to choose Value to filter for a specific value or Expression to use a formula/parameter. For example:

In the first example the Databand will always be filtered to Year 9. In the second it will be filtered to the Variable ‘YearVar’ which can be chosen as a Parameter (see below). Note that Field/Datasource names are case sensitive and that expressions involving data type ‘string’ double = is used. You can adjust the properties of the Databand by selecting it and switching to ‘Properties’ in the bottom left. For example you might want the band to be invisible if it is only required as the basis for further calculations. In this case, set the height to 0 and check the ‘Calc Invisible’ property in the Behaviour section

Calculated Fields You can perform calculations on the data in tables. Right click on a table and select ‘New Calculated Column’. A list of functions is provided in Appendix A. Note that if you performing an expression on a certain datatype, but want to return a different one, you may need to ‘cast’ your expression. To do this put the desired datatype in brackets at the start of the expression. E.g.

An IIF Expression, cast as int

The type of the column is int (integer) and it is cast as int. Students.PupilPremium is type string so == is used. Note that the table and field are listed with the syntax table.field 1 and 0 are useful for recording True and False as then the summary function Avg can be used to calculate the percentage. When creating expressions it’s easy to make syntax errors. Check your report frequently using Preview, or ‘Check for Issues’ in the bottom left hand corner.

Summarising Tables In some circumstances you want to work from a summary of a table, not the whole thing. For example, if you wanted a list of unique classes from the Timetables table with a count of their student numbers. To do this right click the dictionary and select ‘New Data Source’. Then choose ‘Data from other Datasource’.

Create New Data Source

In the Data Sources tab click Timetables. In the Groups tab click add group and select ‘GroupName’. In the Results tab click add result, select studentID and change the aggregate function to ‘Count’.

Joining tables To create a join between two Data Sources, right click the dictionary and click ‘New Relation’. This adds the fields from the ‘parent’ Data Source to the ‘child’ Data Source. Give your relation a name, then choose parent and child Data Sources and the field/fields used to join them.

Create New Relation

Variables Variables allow you to input information or calculate it outside of a Databand and are especially useful for summarising data. To create a new Variable, right click the Dictionary and select ‘New Variable’ Give your variable a name (Use the suffix –Var to make it clear it’s a variable), choose a datatype, whether it’s a single value or a list, and (init by) whether it’s a static value or initiated by an expression. If you choose Expression tick to make it Read Only.

Create a new Variable

The following summary formulas can be used in Variables:

Formula Syntax E.g.

Count Count(Databand) Count(Databand1)

CountIf CountIf(Databand,Condition) CountIf(Databand1,Students.FSM ==”Y”)

Avg Avg(Databand,Field) Avg(Databand1,Students.IsFSM)

AvgIf AvgIf(Databand,Field,Condition) AvgIf(Databand1,Students.IsFSM,Students.Gender ==”F”)

Sum Sum(Databand,Field) Sum(Databand1,Attendances.IsPresent)

SumIf SumIf(Databand,Field,Condition) SumIf(Databand1,Attendances.IsPresent,Attendances.Period ==1)

To perform summary calculations on Data Sources instead of Databands, use the prefix Totals. E.g. Totals.Avg(Assessment.IsFive) to return the mean of the column IsFive in the Data Source Assessment. There are syntax changes when DateTimes are involved. For more details and explanations of the Min, Max, Median, Mode and Rank functions see Appendix 2.

Variables as Parameters Selecting the ‘Request from user’ check box makes a Variable into a parameter supplied by the Report user at run time. The Data Source by default is ‘Items’ which can be added manually in the Items box, or it can be a Data Column. Often you will want to create specific Data Sources (see above) to supply the data columns for your variables. Changing the Variable type to ‘List’ means a Variable can be a tick list of values. As with single value variables the list can be supplied as static items, or a column in a datasource. To use the list in an expression, use the ‘Contains’ expression, with the following syntax: ListVariable.Contains(field) e.g. IIF(SubsVar.Contains(Assessment.Subject),”Y”,”N”) will return Y if the Subject field in the Assessment table is contained in the list variable SubsVar.

Dependent Variables Variables can depend on others so that, for example, after choosing Year Group 9, you can then choose from subjects offered in that year. By making BVar dependent on AVar you filter the Data Source that provides values for BVar using AVar as the criteria to filter a specified ‘Dependent Column’ in BVar’s Data Source.

New Variable request from user. Note that only Variables with type ‘Value’ can be dependent

Say you want users to choose a year and subject then a class of that year and subject. This is a little tricky as each variable can only depend on one higher variable so we need to make a data source that combines year and subject info. First make a variable called YearVar with the year values in it. Next make a Data Source based on the Groups Data Source called 'Subjects'. Add Groups.SubjectDescription and Groups.Students.YearGroup as *Groups* of that Data Source. Add a calculated column 'SubYear' to Subjects with the expression: 'Insert(Subjects.Students_YearGroup,0,Subjects.SubjectDescription)' (note that in the expression the full stop in the datafield Students.YearGroup is replaced with an underscore) Now make a Variable called SubVar. Request From User. Data Source: Data Columns Set the keys to Subjects.SubYear and values to Subjects.SubjectDescription. Click to make it a dependent variable. Variable YearVar, dependent column Subjects.Students_YearGroup Now make another Data Source based on Groups called ClassList. Add GroupName as a Group and subject and year as results. Use the same formula as above to create a 'SubYear' column. Now add a variable ClassVar. Request from user, Data Source Data Columns. Set Keys to ClassList.GroupName Make it dependent on SubVar with dependent column ClassList.SubYear.

Styles and Formatting To create styles click the ‘Style Designer’, select Add Style, then choose ‘Component’. Use the properties window on the left to define the style then save. This style can now be selected for a table component in the ‘Component Style’ dropdown, in the ‘Appearance’ section of the properties window. To quickly transfer your chosen style to all components, add it to one via Properties, then use the ‘Copy Style’ button to paste it onto the others.

Create a new style via ‘Add Style’, modify it using the Properties on the left. Copy and paste it using ‘Copy Style’

above

Charts In order to create useful charts you will probably need Data Sources based on Data Sources to provide your data. For example, let’s say we want to show the percentage of children who have 5 and above in Maths. First add a calculated column to the Assessment table to show if a result is greater or equal to five:

Then create a new Data Source, based on Assessment, filtered to the desired Term, Subject etc, with the result the Avg Aggregate function of Assessment.IsFive. You can then create a calculated column in your new Data Source subtracting that value from 1, to give you the percentage of results lower than five. You might want to tidy up your value using the Round function, which has the syntax Round(field/expression,number of decimal places) e.g. Round(NewDatasource.IsFivePercent*100,1) would take a value for IsFivePercent of .33333333 and convert it to 33.3

Once you have a Data Source, use the Infographics dropdown on the Insert tab to choose your chart type.

Draw your chart on the page, then use the chart wizard/properties window to define its data/style. Use the ‘series’ tab to define the chart data, which can be a data column, or a list of values. If you want to use variables as chart labels or values in a list, enclose them in spiral brackets, e.g. {FivePlusVar}. Rename the Series via the Behaviour section. The name can be dynamic if you set to be a variable like {YearVar}. The Chart tab of the Chart Wizard lets you add a title and you can also include variables in spiral brackets along with text, eg. Year {YearVar} Attainment would render as ‘Year 9 Attainment’ if 9 was selected as the YearVar parameter.

Interaction Make your report features interactive by adding Drilldowns, hyperlinks or tooltips using the ‘Interaction’ in the Chart wizard and in Properties.

Create an Interactive Feature

The Interaction Wizard

Trouble Shooting Why is my calculated variable zero? Variables calculated from expressions must be set to 'read only'. If still showing zero, check the filtering of the datasource/databand on which the expression is performed. Attainment and Progress 8 Table The Attainment & Progress 8 table draws from Headline Figures Analysis, so if data is missing, run the Analysis Data Transfer for Headline Figures and select the assessment types you want to transfer. The field YearName is the exam year of the results which is the year as of the beginning of the academic year. (So Results for the 2016-17 academic year have an exam year of 2016). YearName is type string. To convert it to an integer (for comparison, filtering etc) create a calculated column and use formula int.Parse(AttainmentProgress8.YearName) The current exam year will be the same as the current year in Sept - Dec and CY-1 in Jan-Aug. In order to calculate this create the following variables and expressions (remember to set them as type int and read only)

Variable Expression

MonthVar Month(Today)

YearVar Year(Today)

LastYearVar YearVar - 1

ExamYearVar IIF(MonthVar > 8,YearVar,LastYearVar)

Index is out of range error If a cross tab component is placed to near to the edge of the page, such that it tries to expand beyond the page's edge, you will get an Index is out of range error. Try moving the cross tab, increasing the page size or reducing its margins. Filtering for Today There is a system variable called "Today" which can be used to create filters to show today's events, classes, attendance etc. Note that it is a datetime variable so it is in fact midnight today. Therefore, in filters you should use Datasource.DateColumn > Today (not == Today). You can create variables for Yesterday, last week etc. by using the AddDays expression in the Init by expression field of the variable: Eg. Yesterday: Today.AddDays(-1) 1 week ago: Today.AddDays(-7) Create a date range from a single date Say you want to look at events happening in week beginning x. You need to create two variables StartVar and EndVar and filter your datasource to be greater than/less than respectively. But you can make EndVar calculate automatically as 1 week greater than StartVar. Just set EndVar to be initiated by expression, and use: StartVar.AddDays(7) Can’t filter datasource based on datasource Sometimes when you create a datasource based on another datasource, columns are recast as type 'object'. If that happens text filters won't work. Right click the columns in question and change their type to 'string' and their filters should now work. Pie Chart Legend shows values not categories By default the legend of a pie chart lists the percentages, rather than showing you what the segements of the pie are. To change this, in the chart settings go to labels, then change the 'Legend Value Type' to Argument. If Statement with 2 conditions The IIF function (and AvgIf, SumIf etc) can have one or two conditions. Use && to add a second condition. Eg. Totals.CountIf(Students,Students.Gender == "F" && Students.PupilPremium == "Y") counts female PP students. Casting Columns When creating columns to put students into categories (e.g. high PA and PP) it's best to use 1 and 0 for true and false as then you can simply average the column to get a percentage. However, if you use the expression IIF(Students.PupilPremium == "Y" & Students.KS2FineScore >4.99,1,0) ARB will throw an error, even if your column type is 'int'. To overcome this error you need to 'cast' your column as an integer by adding (int) at the beginning: (int) IIF(Students.PupilPremium == "Y" & Students.PA == "H",1,0)

Appendix 1: Functions

Function Description Sample

Date:

{DateDiff(,)} Calculates the distance between the specified dates

Arguments should be of the DateTime type

Returns the TimeSpan value

{DateDiff(DateSerial(2016,1,30),DateSerial(2016,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(2016,1,30)} - the result is 1/30/2016 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(2016,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 of which the system culture or designer localization will be used

Returns the string type

{DayOfWeek(DateSerial(2016,1,30))} - the result is Saturday. {DayOfWeek(DataSource.Column)} - for each value a day of the week will be calculated {DayOfWeek(DateSerial(2016,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(2016,1,30),"en", false)} - the day of the week will start from the lower-case letter, i.e. saturday. {DayOfWeek(DataSource.Column,"de", true)} - the days of the week will start with the capital letter, for example Samstag. {DayOfWeek(DateSerial(2016,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)

{DayOfYear(DateSerial(2016,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:


Year and month (the long type)


{DaysInMonth(DateSerial(2016,2,1))} - the result will be 29, because 2016 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(2016,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)


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

{Hour()} Displays an hour: Specifies time in

arguments (the DateTime type)


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

{Minute()} Displays minutes: Specifies time in



{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



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

{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 to display the result with a capital letter or with a small letter.

{MonthName(DateSerial(2016,1,1))} - the result is January, because the 1 of January 2016 is set. {MonthName(DataSource.Column)} - the result is the name of the month for each Column value. {MonthName(DateSerial(2016,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(2016,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(2016,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

The true or false value (the bool type), depending on which the system culture or designer localization will be used

Returns the string value

correspond to the culture that corresponds to the culture of the report designer.

{Second()} Displays seconds: Specifies time in



{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.

{Year()} Displays year: Specifies date in



{Year(DateSerial(2016,1,2))} - the result will be 2016, since the date is January 2, 2016. {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.

{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 division, in this line, the values from Column3 will be displayed.

{Exp()} Displays the result of raising to the specified degree the number e:

The arguments indicate the degree to which the

{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.

number e must be risen (the long type)

Returns the value of the double type

{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.

{Log()} Calculates the natural logarithm:

The value is specified in arguments (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 a certain number of decimal:

In arguments, the following is specified:

The value (the decimal, double

{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.

types), Number of

characters to which the fractional part should be rounded (the int type)

Returns the value of the decimal, double types

{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).


{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).


{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).


{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

{Truncate(Sqrt(5))} - the result will be number 2, because the square root of 5 is ~ 2.236, i.e. The whole part in this number is 2. {Truncate(DataSource.Column1)} - only the integer part of all Column1 values will be displayed.

arguments (the double, decimal types).

Returns the value of the double, decimal types

Print State:

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


The data source (the object type)

The column name (the string type).

Returns the value of the bool type

{Next(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.

{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 empty.

{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.





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.





For example, the Column column contains values 2, 5, 9. Then, using the function {Previous (DataSource, "Column")}, the first value will be empty, 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.


The data source (the object 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.

Programming Shortcut:

{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.

{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)

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. In order 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.


{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


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.

{DateToStr()} Converts date to text value:



Boolean values (true or false) for displaying the header that starts with a capital letter or with a lowercase letter.


{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:


The value in which to insert text (the string type),

The number of a

{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.

character, after which the value is inserted (the int type),

The value for insertion (the string type)


{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)


{Left("Beverages", 4)} - only four characters from the Beverages value will be displayed, i.e. 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 the 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:


The value (the string type)

Index of the reference position (the int type)

Number of characters to display (the int type)


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

{Persian()} Converts specified numbers to numbers in Persian:

The value is specified in arguments of the

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

string or int types Returns the

value of the string type

{Remove()} Deletes the specified number of characters from the index of a specific position:


The value (the string type)

Index of the reference position (the int type)

Number of characters to delete (the int type)


{Remove("Beverages",2,3)} - after the second character, three characters will be deleted, i.e. 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:


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)


{Replace("Beverages","ver","NEW")} - in the value Beverages, the ver characters will be replaced by the characters NEW, i.e. 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)


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

{Roman()} Converts Arabic numerals to Roman

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

numerals: In the arguments,

specify the number (the int type)


have a Roman spelling.

{Substring()} Displays a certain number of characters from the specified position:


The value (the string type) from which the characters will be displayed

The index of position (the int type), i.e. how many characters are skipped

Number of characters to display (the int type)


{Substring("Beverages",6,3)} - the first six characters are skipped and three characters will be displayed, i.e. the result is ges. {Substring("Beverages",0,2)} - two characters will be displayed starting with zero, i.e. 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:


Numeric value (the double, decimal, long types)

You can also specify values (true or false) to display them with a capital letter and display cents (type bool)

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

It is possible to specify the ISO code (the string type)

You can also specify a base unit for the integer part and a fractional In addition, various combinations of arguments are

{ToCurrencyWords(100)} - the used currency is dollars of USA, so the result will be One hundred dollars and zero cents. {ToCurrencyWords(Products.UnitPrice)} - all product prices will be displayed as text. {ToCurrencyWords(100,true,false)} - the result will be displayed with the first capital letter (since it is set to true) and without displaying cents (since it is set to false), i.e. the result will be One hundred dollars. {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.

possible. There are also some types of this function that support different cultures.


{ToLowerCase()} Displays the value in lowercase:



{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)


{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:



{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.

{ToUpperCase()} Displays the value in uppercase:



{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:


A numeric value that will be converted to text (decimal, double, long)

True or false

{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, i.e. Cien {ToProperCase(DataSource.Column1)} - all values will be displayed in text.

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


{Trim()} Trims the spaces at the beginning or end of the line:



{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:


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.

Appendix 2: Aggregate Functions

Function Description Sample

{Avg()} Calculates the arithmetic mean: In arguments, specify an object or two

objects Returns values of different types (double,

decimal, long, DateTime, TimeSpan), depending on the function selected.

{Avg(DataSource.Column1)} - the arithmetic mean of the Column1 column will be calculated. {AvgDate(DataSource.ColumnDate)} - the average of the date on the ColumnDate column will be calculated. {AvgTime(DataSource.ColumnTime)} - the average time by the ColumnTime column will be calculated. All functions can have two arguments. For example, the report uses several Data bands. It is necessary to calculate the arithmetic mean for the first Data band. In this case, the first argument is the band, the second is the object for calculation - {Avg(DataBand1,DataSource.Column2)}. As a result, the arithmetic mean of Column2 will be calculated, but only for the DataBand1 values.

{Count()} Calculates the number of values or the number of unique values:

In arguments, specify a value, object or two objects

Returns the values of various long types

{Count()} - the result is the number of entries in the data source. {Count(DataBand1, DataSource.Column1)} - the result is the number of entries in Column1 column for DataBand1. {CountDistinct(DataSource.Column1)} - the result is the number of unique entries in DataSource.Column1. {CountDistinct(DataBand2, DataSource.Column2)} - the result is the number of unique entries in Column2 column for DataBand2.

{First()} Displays the first value from the specified object:

In arguments, specify an object or two objects

Returns the values of various object types

{First(DataSource1.Column1)} - the result is the first value of Column1 from the DataSource1. {First(DataBand2, DataSource.Column2)} - the result is the first value of Column2 of the DataBand2 band.

{Last()} Displays the last value from the specified object:


Returns the values of various object types

{Last(DataSource1.Column1)} - the result is the last value of Column1 from the DataSource1. {Last(DataBand2, DataSource.Column2)} - the result is the last value of Column2 of the DataBand2.

{Max()} Displays the maximum value from the specified object:


Returns the values of various double, decimal, long, DateTime, TimeSpan, string types depending on the function selected.

{Max(DataSource1.Column1)} - the result is the maximum value from Column1 of DataSource1. {MaxDate(DataSource1.ColumnDate)} - the result is the maximum date from the ColumnDate of the DataSource1. {MaxTime(DataSource1.ColumnTime)} - the result is the maximum time from the ColumnTime of the DataSource1. {MaxStr(DataSource1.Column1)} - all values will be sorted alphabetically. The result is the last value. {Max(DataBand2, DataSource.Column2)} - the result will be the maximum value of Column2 of the DataBand2 band.

{Median()} Displays the mean (non-arithmetic) value Suppose, Column1 contains 5 values: 2, 5, 6,1,7. The

from the list: In arguments, specify an object or two

objects Returns the values of various double,

decimal, long types, depending on the function selected.

{Median(DataSource1.Column1)} function displays the average value from this list, i.e. the result is 6. {Median(DataBand2, DataSource.Column2)} - the result is the average value of Column2 of the DataBand2.

{Min()} Displays the maximum value from the specified object:


Returns the values of various double, decimal, long, DateTime, TimeSpan, string types depending on the function selected.

{Min(DataSource1.Column1)} - the result is the minimum value from Column1 of DataSource1. {MinDate(DataSource1.ColumnDate)} - the result is the minimum date from the ColumnDate of the DataSource1. {MinTime(DataSource1.ColumnTime)} - the result is the minimum time from the ColumnTime of the DataSource1. {MinStr(DataSource1.Column1)} - all values will be sorted alphabetically. The result is the first value. {Min(DataBand2, DataSource.Column2)} - the result is the minimum value of Column2 of the DataBand2 band.

{Mode()} Displays the value that is most common in the list of values:


Returns the values of various double, decimal, long types depending on the function selected.

{Mode(DataSource1.Column1)}. Suppose, Column1 contains a list of values: 2, 2, 6, 7, 7, 8, 7, 6, 5, 9, 4. In this case, the result is 7, because it is most often repeated in the list of values. {Mode(DataBand2, DataSource.Column2)} - the result will be the value from Column2 of the DataBand2, which is the most common.

{Rank(,)} Display the rank of the value. The prefix Totals is mandatory:

Specify in arguments: Objects for processing and assigning

rank (the object type) The value (true or false) for assigning a

tight or not tight rank Sorting direction of values. Returns the values of various long types

{Totals.Rank(DataBand1,DataSource.Column1)}. Suppose, Column1 contains a list of values: 44, 9, 36, 55, 71. In this case, the values will be sorted in ascending order, i.e. 9, 36, 44, 55, 71 and to each of them a rank will be assigned. The number 9 will receive rank 1; 36 - rank 2; 44 - rank 3; 55 - rank 4; 71 - rank 5. By default, calculates a tight rank and sorts the values for assigning rank by ascending order {Totals.Rank(DataBand1,DataSource.Column1, true, StiRankOrder.Dess)} - in this case, there will be a tight rank since it is set to true. When the rank is assigned, the values will be sorted in descending order since StiRankOrder is set to Desc. For sorting in ascending order (used by default), you should set to Asc (StiRankOrder.Asc). An example of a not tight rank is {Totals.Rank(DataBand1, DataSource.Column1, false, StiRankOrder.Asc)}. Assume Column1 contains a list of values: 44, 9, 44, 9, 31, 64,68, 71. The values are assigned in ascending order, i.e. 9, 9, 31, 44, 44, 44, 68, 71. In this case, the ranks will be as follows: 9 - rank 1, 9 - rank 1, 31 - rank 3, 44 - rank 4, 44 - rank 4, 44 - rank 4, 68 - rank 7, 71 - rank 8. In other words, when assigning a rank to a number, the rank of the previous value and the number of values with this rank are taken into account.

{Sum()} Displays the result of the sum of the values: Specify in arguments: Objects for processing and assigning

{Sum(DataSource1.Column1)} - the result is the sum of all Column1 values in the DataSource1.

rank (type object) Condition Summation expression Returns the values of various long,

decimal, double, TimeSpan types

{SumDistinct(DataSource1.Column1)} - the result is the sum of all the unique Column1 values in the DataSource1. SumTime(DataSource1.Column1) - the result is the sum of the time from Column1 in the DataSource1. {Sum(DataBand2,DataSource2.Column2)} - the result is the sum of the values from Column2 of the DataBand2. {SumDistinct(DataBand1,DataSource.Column1, DataSource.Column2)} - the result is the sum of the Column2 values that correspond to the unique values from Column1 of the DataBand2.

Appendix 3: Fields

arb quick start guide - bromcom quick... · once you have a data source, use the infographics...

Documents