-- define the calculated member for average monthly customer sales
-- between January and June, 1997

with member [Measures].[Avg Monthly Cust Sales 6mo] as
'Avg({{[Time].[1997].[Q1].[1]:[Time].[1997].[Q2].[6]}*
{[Customers].[Name].Members}}, [Measures].[Unit Sales])'
select
{[Measures].[Avg Monthly Cust Sales 6mo]} on columns
from [Sales]

-- [Measures].[Avg Monthly Cust Sales 6mo] = 15.66 (instant response)

-- now find customers whose June sales exceed this average by 4 times
select
{[Measures].[Unit Sales]} on columns,
Filter([Customers].[Name].Members,
[Measures].[Unit Sales] > 15.66 * 4)
on rows
from [Sales]
where ([Time].[1997].[Q2].[6])

-- 8 customers returned with June, 1997 sales > 400% of 15.66 (instant response)

-- now putting the two together yields:

with member [Measures].[Avg Monthly Cust Sales 6mo] as
'Avg({{[Time].[1997].[Q1].[1]:[Time].[1997].[Q2].[6]}
*{[Customers].[Name].Members}}, [Measures].[Unit Sales])'
select
{[Measures].[Unit Sales]} on columns,
Filter([Customers].[Name].Members,
[Measures].[Unit Sales] > [Measures].[Avg Monthly Cust Sales 6mo] * 4)
on rows
from [Sales]
where ([Time].[1997].[Q2].[6])

-- and the query runs forever. What's going on? How should the query be changed?

The first query actually takes a takes about a second to
run (at least in my workstation).
The calculated member is evaluated in the context of the
filter expression,
using Customers.currentmember as its Customers coordinate.
This means the calculated member is evaluated for each of
the 10281 customers.
At a second per customer, that explains why the query
might take a while to complete.
If you override the Customers coordinate, by specifying
one customer in the filter expression, the value is
calculated just once, cached and reused.
Any customer will do, since the formula doesn't vary by
customer.
So, you could rewrite your filter to:

Filter([Customers].[Name].Members,[Measures].[Unit Sales]
Customers])* 4)

HTH,
Brian
www.geocities.com/brianaltmann/olap.html

Apparently there's something else involved.

Changing the rows expression as suggested to:
....
Filter([Customers].[Name].Members,
[Measures].[Unit Sales] > ([Measures].[Avg Monthly Cust Sales 6mo],
[Customers].[All Customers]) * 4) on rows
....

The query now runs in about 30 seconds, far longer than the 4 secs it
takes to run if the tuple ([Measures].[Avg Monthly Cust Sales 6mo],
[Customers].[All Customers]) is replaced with a literal (15.66 in this
example).

So I'm guessing that we're seeing 26 secs of overhead for 10281 calls
to evaluate the tuple whose value doesn't change although it may be
cached. But it seems like we can't avoid it.

It begs the question, is there an optimization made for literals in an
expression that doesn't apply to cached expressions?

Thanks again for your help.