DAR-C: write your own measures

What DAR-C is

Every fact already gives you simple measures: the sum of Revenue, the count of orders. DAR-C is for everything else. Margin percent, a product's share of its category, this month against the same month last year.

A DAR-C calculation reads like the question you would ask. It runs wherever a visual shows a value: on every bar, in every matrix cell, in every total. You write it once and it gives the right answer in each of those places.

You do not need SQL or a formula language to use it. If you can describe the number in a sentence, you can write it.

Before you start

You need three things in your project:

• A fact with measures, for example a Sales fact with Revenue, Cost and Units.
• Dimensions on that fact, for example Site, Product and Customer.
• A Date Dimension, if you want to compare periods. In this guide it is called Order Date.

The examples in this guide all use the same small model:

Swap in your own names as you go. The rest stays the same.

Your first calculation: margin percent

This takes about five minutes.

1. Open Facts, then your Sales fact.
2. Find the DAR-C Calculations group and add a calculation.
3. Set Alias to Margin %. The alias is the name your visuals will see.
4. Set Format to Percent with 1 decimal place, and tick ×100. A Percent format adds the % sign; ×100 turns 0.42 into 42%.
5. Paste this into the first row:

Context.Value().AggregateFact(Sum, Revenue).SetQueryVariable(SalesTotal);
Context.Value().AggregateFact(Sum, Cost).SetQueryVariable(CostTotal);
Compute(([Query].[SalesTotal] - [Query].[CostTotal]) / [Query].[SalesTotal]).Return();

6. Save the fact. If anything is wrong, the editor shows the problem under the row, and the calculation is not offered to visuals until it is fixed.
7. Add a Card on the Sales fact and pick Margin % as its measure.
8. Now add a Bar Chart by Site Name with the same measure. Each bar shows that site's own margin. You did not change anything: the calculation works out each bar on its own.

Read back, the calculation says: "For this value, add up Revenue and call it SalesTotal. Add up Cost and call it CostTotal. Return SalesTotal minus CostTotal, divided by SalesTotal."

Tip: Paste a whole calculation into one row. The editor splits it into one row per step for you.

How a calculation is built

A calculation is a list of steps. Each step ends with a semicolon ;. Inside a step, commands are chained with dots ..

There are three kinds of step:

Each fetch or compute step ends in one of two ways:

• SetQueryVariable(Name) keeps the result under a name, so a later step can use it.
• Return() hands the result to the visual. A calculation has exactly one Return(), and it ends the last step.

Inside a Compute, you read a kept result as [Query].[Name]. A name starts with a letter, then letters and digits, and each name can be set only once.

A few rules that make typing easier:

• Spaces and line breaks do not matter, so you can lay a step out over several lines. The exception is the text inside Compute(...) and FilterContext(...), which is kept exactly as you wrote it.
• Capitals do not matter. context.value() is the same as Context.Value().
• Every command has a short form: the first three letters of each capitalized word. Context is Con, AggregateFact is AggFac, SetQueryVariable is SetQueVar. You can mix full and short forms freely. Short forms are for commands only, never for aggregations, columns or names.

Con.Val().AggFac(Sum, Revenue).SetQueVar(SalesTotal);
Con.Val().AggFac(Sum, Units).SetQueVar(UnitsSold);
Com([Query].[SalesTotal] / [Query].[UnitsSold]).Ret();

That is the same as writing every command in full, and it returns the average selling price per unit.

Which rows count: contexts

Every value on a visual has filters on it. A bar for the North region only counts North's rows. A card filtered to 2025 only counts 2025. A click on another visual in the report narrows it further.

A context decides which of those filters a fetch keeps. You choose it at the start of every fetch: Context.Value(), Context.Visual() and so on.

An example. A Bar Chart shows Revenue by Region, filtered to 2025: North 300, South 700.

Put the first two together and you have each region's share of the chart:

Context.Value().AggregateFact(Sum, Revenue).SetQueryVariable(Part);
Context.Visual().AggregateFact(Sum, Revenue).SetQueryVariable(Whole);
Compute([Query].[Part] / [Query].[Whole]).Return();

With a Percent format and ×100 ticked, North shows 30% and South 70%.

What each context keeps

Three layers of filters can narrow a value. Its own slot: the bar's category, or the cell's row and column. The visual's own filters: its Filters tab and its drill path. The report: the Interactive Report's filters, and selections made on other visuals.

A chart's categories count as its rows and its legend as its columns. A visual with no columns reads Column() as Visual(), and one with no rows reads Row() the same way. Outside a report, Report() is the same as Model().

Totals are worked out, not added up

In a matrix, the row totals, column totals and grand total each run the whole calculation again in their own context. So the total of a margin percent is the margin of the total, not the sum of the margins. That is the right answer, and it is why ratios and averages stay correct in totals.

Changing what a fetch counts

Sometimes you want a fetch to ignore one filter, or keep only one, or count only some rows. Three commands do that. Write them after the context and before AggregateFact, as many as you need.

Naming a column

These commands name dimension columns as [Dimension].[Column], for example [Product].[Category].

• You can use the name the fact gives the dimension or the dimension's own name.
• [ANY] stands for every column of a dimension: [Product].[ANY].
• The fact's own columns go under the fact's name: [Sales].[Channel].

RemoveDimensionFilter: ignore a filter

Lets go of every filter on the columns you name, wherever it came from: the bar's own category, the Filters tab, a drill, a condition.

A product's share of its category, on a chart drilled from Category into Product Name:

Context.Value().AggregateFact(Sum, Revenue).SetQueryVariable(ThisProduct);
Context.Value().RemoveDimensionFilter([Product].[Product Name]).AggregateFact(Sum, Revenue).SetQueryVariable(WholeCategory);
Compute([Query].[ThisProduct] / [Query].[WholeCategory]).Return();

The second fetch drops the Product Name filter but keeps the drill into the category, so it counts the whole category.

KeepDimensionFilter: keep only some filters

The mirror image: every filter goes except the ones on the columns you name. It also lets go of number filters.

However a visual is sliced, this compares each value with its whole year:

Context.Value().AggregateFact(Sum, Revenue).SetQueryVariable(Here);
Context.Value().KeepDimensionFilter([Order Date].[Year]).AggregateFact(Sum, Revenue).SetQueryVariable(YearTotal);
Compute([Query].[Here] / [Query].[YearTotal]).Return();

FilterContext: count only some rows

Adds a condition the rows must also meet. The condition is written in HU++, the same language as a visual's Filters tab condition.

The online share of revenue:

Context.Value().FilterContext([Channel] = "Online").AggregateFact(Sum, Revenue).SetQueryVariable(Online);
Context.Value().AggregateFact(Sum, Revenue).SetQueryVariable(AllChannels);
Compute([Query].[Online] / [Query].[AllChannels]).Return();

A few things to know about conditions:

• Text goes in quotes. Compare with = != < <= > >=, match patterns with LIKE, and join conditions with AND, OR and NOT.
• A column on its own, like [Channel], works when only one element has a column by that name. Otherwise write [Element].[Column].
• Inside a condition, name a dimension by its own name, the name it has in the Dimensions list. The name a fact gives it only works in the other commands.
• A condition always holds. RemoveDimensionFilter never removes it, and it applies even in Context.Model().

Doing the math: Compute

Compute(...) takes a value written in HU++ and works it out for every bar, cell and total. Inside it you use the names you kept above as [Query].[Name].

A Compute can be kept with SetQueryVariable and used by a later Compute, just like a fetch.

Blanks and zeros

• A blank anywhere in the math gives a blank. Blank plus 1 is blank.
• Dividing by zero, or by a blank, gives a blank, never an error.
• To treat a blank as zero, wrap it: COALESCE([Query].[LastYear], 0).
• A condition used as the value gives 1 when it is true and 0 when it is not.

Comparing over time

DAR-C can move a fetch in time: the month before, the same month last year, the year so far, a rolling three months.

Step 1: tell DAR-C which date to use

Start the calculation with this setting step:

Query.SetDate([Order Date]);

It names a Date Dimension, or a Role Playing Dimension over one, that the fact uses. Every time command after it works on that dimension.

Step 2: add a time command to a fetch

Write it after the context, before AggregateFact:

Query.SetDate([Order Date]);
Context.Value().SamePeriodPreviousYears().AggregateFact(Sum, Revenue).Return();

On a bar for March 2026 that returns the revenue of March 2025.

How DAR-C finds the period

DAR-C reads the period from the date filters on each value: a Year bar gives that year, a Year and Month Name gives the month. It also reads ticked dates, a date drill, a relative window like "last 3 months", or a selection on another visual in the report.

If a value has no date filter at all, there is no period to move, and a time command gives a blank. A card over the whole fact is the usual case: give it a date filter first.

The time commands

Good to know:

• Commands chain. SamePeriodPreviousYears().CalendarYearToDate() is last year to date: January to March 2025.
• Other filters still apply. On a chart with a Region legend, each region gets its own previous month.
• The fiscal year starts in the month set on your Date Dimension. With a January start, the fiscal commands match the calendar ones.
• Rolling is one count over the whole window, so a rolling average or a distinct count is right, not an average of averages.

Calculations on one visual

You do not have to put every calculation on the fact. Every visual that shows a measure has a Calculations tab, its last tab, where you can write calculations for that visual alone. It is on the Bar, Pie, Card, Scatter, Table, Matrix, Multi Axis Line Graph, Stacked Area and Dynamic Visual.

• They use the same language and appear in that visual's measure lists.
• The tab also shows what narrows this visual now: its rows and columns, its drill, its Filters tab and, when you open it from a report, the report's filters. Check it before you choose a context.
• To build on a fact's calculation instead of copying it, start with FactCalculation([Alias]):

FactCalculation([Margin %]).SetQueryVariable(Margin);
Compute(ROUND([Query].[Margin] * 100, 1)).Return();

When a visual-only calculation turns out to be useful elsewhere, move it to the fact so every visual can use it.

Using the editor

The DAR-C editor has two views over the same text:

• Designer shows one row per step. A Compute or FilterContext opens a small HU++ window between its parentheses, marked HU++ value or HU++ condition.
• Text shows the whole calculation in one box, handy for pasting or a bigger edit.

While you type:

• Press Ctrl+Space for suggestions. Each command shows its full name with its short form beside it. Left and Right pick the form, and Tab writes it.
• After a finished command, suggestions wait until you type the . that starts the next one.
• Undo and Redo are the editor's own, on the toolbar and in the Edit menu.
• A mistake shows under its row or in its HU++ window. A calculation with any mistake is not offered to visuals.

Aggregations

AggregateFact takes one of fourteen methods, then a column. The column must be one of the fact's measures, such as Revenue. A dimension column like Region cannot be aggregated.

Blanks are skipped and not counted by every method except CountRows and CountBlank. A group with only blanks is blank, not zero.

Recipes

Copy, paste, then rename the columns to yours. Set the Format noted under each one.

Average selling price

Context.Value().AggregateFact(Sum, Revenue).SetQueryVariable(SalesTotal);
Context.Value().AggregateFact(Sum, Units).SetQueryVariable(UnitsSold);
Compute([Query].[SalesTotal] / [Query].[UnitsSold]).Return();

Format: Currency, 2 decimals.

Share of a matrix row

Context.Value().AggregateFact(Sum, Revenue).SetQueryVariable(Cell);
Context.Row().AggregateFact(Sum, Revenue).SetQueryVariable(RowTotal);
Compute([Query].[Cell] / [Query].[RowTotal]).Return();

Format: Percent, ×100. Each row adds up to 100%. Use Context.Column() for the share of a column.

Year over year, percent

Query.SetDate([Order Date]);
Context.Value().AggregateFact(Sum, Revenue).SetQueryVariable(ThisYear);
Context.Value().SamePeriodPreviousYears().AggregateFact(Sum, Revenue).SetQueryVariable(LastYear);
Compute(([Query].[ThisYear] - [Query].[LastYear]) / [Query].[LastYear]).Return();

Format: Percent, ×100, 1 decimal. A fall shows as a negative number.

Change from the previous month

Query.SetDate([Order Date]);
Context.Value().AggregateFact(Sum, Revenue).SetQueryVariable(Now);
Context.Value().PreviousPeriods().AggregateFact(Sum, Revenue).SetQueryVariable(Before);
Compute([Query].[Now] - COALESCE([Query].[Before], 0)).Return();

Format: Currency. COALESCE counts a missing previous month as zero.

Running total

Query.SetDate([Order Date]);
Context.Value().Rolling([INFINITY]).AggregateFact(Sum, Revenue).Return();

Format: Currency. Use it on a chart by month or by year.

Rolling three-month average

Query.SetDate([Order Date]);
Context.Value().Rolling(3).AggregateFact(Sum, Revenue).SetQueryVariable(ThreeMonths);
Compute([Query].[ThreeMonths] / 3).Return();

Format: Currency. In the first two months of your data the window is shorter, so the average reads low there.

Year to date against last year to date

Query.SetDate([Order Date]);
Context.Value().CalendarYearToDate().AggregateFact(Sum, Revenue).SetQueryVariable(Ytd);
Context.Value().SamePeriodPreviousYears().CalendarYearToDate().AggregateFact(Sum, Revenue).SetQueryVariable(LastYtd);
Compute([Query].[Ytd] - [Query].[LastYtd]).Return();

Format: Currency.

Against a fixed year

Each year compared with 2019, whatever year the value is in:

Context.Value().AggregateFact(Sum, Revenue).SetQueryVariable(Now);
Context.Value().RemoveDimensionFilter([Order Date].[Year]).FilterContext([Order Date].[Year] = "2019").AggregateFact(Sum, Revenue).SetQueryVariable(Base);
Compute([Query].[Now] / [Query].[Base]).Return();

Format: Percent, ×100. The first fetch keeps the value's own year; the second lets it go and counts 2019 instead.

Number of order lines

Context.Value().AggregateFact(CountRows).Return();

Format: Number.

When something goes wrong

Calculations written before ConradBI 1.2.49

Version 1.2.49 replaced a few words. Rewrite older calculations like this:

Then open each visual that uses the calculation, pick it again and save, so the visual takes the new version.

Command reference

PreviousPeriods, SamePeriodPreviousYears and Rolling also take [INFINITY]: everything back to your first date. Rolling always needs a count.