public void ParseMultipleDaxQueries()
{
var text = @"EVALUATE t1 EVALUATE t2";
Babel.Parser.Parser parser = ParseText(text);
// Expect NOT to fail on parsing
}
public void ParseQueryWithOrderBy()
{
Babel.Parser.Parser parser = ParseText(@"DEFINE
MEASURE Table1[PercentProfit]=SUMX(Table1,[SalesAmount] - [TotalProductCost])
MEASURE DimProductSubCategory[CountProducts]=COUNTROWS(DimProduct)
EVALUATE
ADDCOLUMNS(
FILTER(
CROSSJOIN(
VALUES(DimDate[CalendarYear]),
VALUES(DimProductSubCategory[EnglishProductSubCategoryName])
),
NOT(ISBLANK(DimDate[CalendarYear])) &&
NOT(ISBLANK(DimProductSubCategory[EnglishProductSubCategoryName])) &&
(
NOT(ISBLANK(CALCULATE(SUM(Table1[SalesAmount])))) ||
NOT(ISBLANK(Table1[PercentProfit])) ||
NOT(ISBLANK(DimProductSubCategory[CountProducts]))
)
),
""Amount"", CALCULATE(SUM(Table1[SalesAmount])),
""PercentProfit"", Table1[PercentProfit],
""CountProducts"", DimProductSubCategory[CountProducts]
)
ORDER BY
DimDate[CalendarYear] DESC,
DimProductSubCategory[EnglishProductSubCategoryName] ASC
");
Assert.IsNotNull(parser);
}
public BlenXAuthoringScope(Babel.Parser.Parser parser, Babel.Source source)
{
this.parser = parser;
this.source = source;
// how should this be set?
this.resolver = new Babel.Resolver();
}
public void CalculateShortcut()
{
var text = @" CREATE MEASURE 't3'[shortcut]=[M1](All(T)) + 't'[m 2](All(T2))";
Babel.Parser.Parser parser = ParseText(text);
Assert.AreEqual(1, parser.Measures.Count);
var measure1 = parser.Measures.First();
Assert.AreEqual("t3", measure1.TableName);
Assert.AreEqual("shortcut", measure1.Name);
}
public void YearDayMonth()
{
var text = @" CREATE MEASURE 'TRANSACTIONS'[ThisYear]=Date(Year(Now()), Month(Now()), Day(Now()))";
Babel.Parser.Parser parser = ParseText(text);
Assert.AreEqual(1, parser.Measures.Count);
var measure1 = parser.Measures.First();
Assert.AreEqual("TRANSACTIONS", measure1.TableName);
Assert.AreEqual("ThisYear", measure1.Name);
}
public void ParseTableNameTime()
{
Babel.Parser.Parser parser = ParseText("CREATE MEASURE 'Table1'[Hourly Avg CallCount]=AVERAGEX(CROSSJOIN(VALUES('Date'[DateID]), VALUES(Time[Hour])), [Count]);");
Assert.AreEqual(1, parser.Measures.Count);
var measure = parser.Measures.First();
Assert.AreEqual("Table1", measure.TableName);
Assert.AreEqual("Hourly Avg CallCount", measure.Name);
Assert.AreEqual("AVERAGEX(CROSSJOIN(VALUES('Date'[DateID]), VALUES(Time[Hour])), [Count])", measure.Expression);
Assert.AreEqual("CREATE MEASURE 'Table1'[Hourly Avg CallCount]=AVERAGEX(CROSSJOIN(VALUES('Date'[DateID]), VALUES(Time[Hour])), [Count])", measure.FullText);
}
public void ParseSimpleMeasure()
{
Babel.Parser.Parser parser = ParseText("CREATE MEASURE t[B]=Now()");
Assert.AreEqual(1, parser.Measures.Count);
var measure = parser.Measures.First();
Assert.AreEqual("t", measure.TableName);
Assert.AreEqual("B", measure.Name);
Assert.AreEqual("Now()", measure.Expression);
Assert.AreEqual("CREATE MEASURE t[B]=Now()", measure.FullText);
}
public void ParseTrueFalse()
{
Babel.Parser.Parser parser = ParseText("CREATE MEASURE t[B]=TRUE() && TRUE || FALSE || FALSE()");
Assert.AreEqual(1, parser.Measures.Count);
var measure = parser.Measures.First();
Assert.AreEqual("t", measure.TableName);
Assert.AreEqual("B", measure.Name);
Assert.AreEqual("TRUE() && TRUE || FALSE || FALSE()", measure.Expression);
Assert.AreEqual("CREATE MEASURE t[B]=TRUE() && TRUE || FALSE || FALSE()", measure.FullText);
}
public void ParseFunctionWithoutParameterAfterComma()
{
try
{
var text = @"EVALUATE ROW(""a"", Calculate([m], ))";
Babel.Parser.Parser parser = ParseText(text);
Assert.Fail("Exception expected");
}
catch (Exception e)
{
StringAssert.Contains("syntax error", e.Message);
}
}
public void ParseMeasureCalcPropertyWrongFormatType()
{
var text = @"CREATE MEASURE 'Table1'[C]=1 CALCULATION PROPERTY WrongFormatType";
try
{
Babel.Parser.Parser parser = ParseText(text);
Assert.Fail("Exception expected");
}
catch (Exception e)
{
StringAssert.Contains("Wrong calculation property type", e.Message);
}
}
public void ParseQueryWithTrue()
{
Babel.Parser.Parser parser = ParseText(@"
DEFINE MEASURE Table1[M1] = CountRows ( Table1 )
EVALUATE CalculateTable (
ADDCOLUMNS (
FILTER(ALL(Table3),MOD([M1],2) = 1),
""X"",
CALCULATE(CALCULATE([M1],AllSelected(Table3)))
)
, Table5[BOOL] = TRUE
, Table3[IntMeasure] > 0
, Table3[PK] > 4
)
");
Assert.IsNotNull(parser);
}
public void ParseDifficultDataTable()
{
var text = @" =
DATATABLE (
""Quarter"", STRING,
""StartDate"", DATETIME,
""EndDate"", DATETIME,
{
{ ""Q1"", BLANK(), ""2015-03-31"" },
{ ""Q2"", ""2015-04-01"", DATE(2009,4,15)+TIME(2,45,21) },
{ ""Q3"",, ""2015-09-30"" },
{ ""Q4"", ""2015-010-01"", ""2015-12-31"" }
}
)";
Babel.Parser.Parser parser = ParseText(text);
}
public void ParseMeasureWithCalcProperty1()
{
var text = @"CREATE MEASURE 'Table1'[C]=1 CALCULATION PROPERTY NumberDecimal Accuracy=5 ThousandSeparator=True Format='#,0.00000'";
Babel.Parser.Parser parser = ParseText(text);
Assert.AreEqual(1, parser.Measures.Count);
var measure1 = parser.Measures.First();
Assert.AreEqual("Table1", measure1.TableName);
Assert.AreEqual("C", measure1.Name);
Assert.AreEqual("1", measure1.Expression);
Assert.AreEqual("CREATE MEASURE 'Table1'[C]=1", measure1.FullText);
Assert.IsNotNull(measure1.CalcProperty);
Assert.AreEqual(DaxCalcProperty.FormatType.NumberDecimal, measure1.CalcProperty.Format);
Assert.IsTrue(measure1.CalcProperty.Accuracy.HasValue);
Assert.AreEqual(5, measure1.CalcProperty.Accuracy.Value);
}
public void ParseSimpleVarExpression2()
{
var text = @"=
CALCULATETABLE (
ADDCOLUMNS (
VAR
OnePercentOfSales = [SalesAmount] * 0.01
RETURN
FILTER (
VALUES ( Product[Product Name] ),
[SalesAmount] >= OnePercentOfSales
),
""SalesOfProduct"", [SalesAmount]
),
Product[Color] = ""Black""
)";
Babel.Parser.Parser parser = ParseText(text);
}
public void ParseSimpleVarExpression()
{
var text = @"=
VAR
CurrentSales = SUM ( Sales[Quantity] )
VAR
SalesLastYear = CALCULATE (
SUM ( Sales[Quantity] ),
SAMEPERIODLASTYEAR ( 'Date'[Date] )
)
RETURN
IF (
AND ( CurrentSales <> 0, SalesLastYear <> 0 ),
DIVIDE (
CurrentSales - SalesLastYear,
SalesLastYear
)
)";
Babel.Parser.Parser parser = ParseText(text);
}
private static Babel.Parser.Parser ParseText(string text, bool trace = false)
{
Babel.Parser.ErrorHandler handler = new Babel.Parser.ErrorHandler();
Babel.Lexer.Scanner scanner = new Babel.Lexer.Scanner();
Babel.Parser.Parser parser = new Babel.Parser.Parser(); // use noarg constructor
parser.Trace = trace;
parser.scanner = scanner;
scanner.Handler = handler;
parser.SetHandler(handler);
scanner.SetSourceText(text);
var request = new ParseRequest(true);
request.Sink = new AuthoringSink(ParseReason.None, 0, 0, Babel.Parser.Parser.MaxErrors);
parser.MBWInit(request);
var result = parser.Parse();
if (handler.Errors)
{
throw new Exception(handler.ToString());
}
return(parser);
}
public void SeveralMeasures()
{
var text = @"CALCULATE;
CREATE MEMBER CURRENTCUBE.Measures.[__XL_Count of Models] AS 1, VISIBLE = 0;
ALTER CUBE CURRENTCUBE UPDATE DIMENSION Measures, Default_Member = [__XL_Count of Models];
----------------------------------------------------------
-- PowerPivot measures command (do not modify manually) --
----------------------------------------------------------
CREATE MEASURE Table1[Measure 1]=1;
----------------------------------------------------------
-- PowerPivot measures command (do not modify manually) --
----------------------------------------------------------
CREATE MEASURE 'Table1'[MeasureCountRows]=COUNTROWS(Table1);
";
Babel.Parser.Parser parser = ParseText(text);
Assert.AreEqual(2, parser.Measures.Count);
var measure1 = parser.Measures.First();
Assert.AreEqual("Table1", measure1.TableName);
Assert.AreEqual("Measure 1", measure1.Name);
Assert.AreEqual("1", measure1.Expression);
Assert.AreEqual("CREATE MEASURE Table1[Measure 1]=1", measure1.FullText);
var measure2 = parser.Measures.Skip(1).First();
Assert.AreEqual("Table1", measure2.TableName);
Assert.AreEqual("MeasureCountRows", measure2.Name);
Assert.AreEqual("COUNTROWS(Table1)", measure2.Expression);
Assert.AreEqual("CREATE MEASURE 'Table1'[MeasureCountRows]=COUNTROWS(Table1)", measure2.FullText);
}
/// <summary>
/// Main function of the parsing thread.
/// This function waits on the queue of the parsing requests and build the parsing tree for
/// a specific file. The resulting tree is built using LibraryNode objects so that it can
/// be used inside the class view or object browser.
/// </summary>
private void ParseThread()
{
const int waitTimeout = 500;
// Define the array of events this function is interest in.
WaitHandle[] eventsToWait = new WaitHandle[] { requestPresent, shutDownStarted };
// Execute the tasks.
while (true)
{
// Wait for a task or a shutdown request.
int waitResult = WaitHandle.WaitAny(eventsToWait, waitTimeout, false);
if (1 == waitResult)
{
// The shutdown of this component is started, so exit the thread.
return;
}
LibraryTask task = null;
lock (requests)
{
if (0 != requests.Count)
{
task = requests.Dequeue();
}
if (0 == requests.Count)
{
requestPresent.Reset();
}
}
if (task == null)
{
continue;
}
if (task.Text == null)
{
if (System.IO.File.Exists(task.FileName))
{
var parser = new Babel.Parser.Parser();
handler.Clear();
using (var stream = File.OpenRead(task.FileName))
{
Babel.Lexer.Scanner scanner = new Babel.Lexer.Scanner(stream);
handler.SetFileName(task.FileName);
scanner.Handler = handler;
Debug.Assert(symbolTable != null);
parser.SetParsingInfo(task.FileName, symbolTable, handler);
parser.scanner = scanner;
//parser.MBWInit(req);
var retval = parser.Parse();
// the parse result is to fill the symbol table
}
}
}
else
{
var parser = new Babel.Parser.Parser();
handler.Clear();
Babel.Lexer.Scanner scanner = new Babel.Lexer.Scanner(); // string interface
handler.SetFileName(task.FileName);
scanner.Handler = handler;
Debug.Assert(symbolTable != null);
parser.SetParsingInfo(task.Text, symbolTable, handler);
parser.scanner = scanner;
scanner.SetSource(task.Text, 0);
//parser.MBWInit(req);
parser.Parse();
}
//LibraryNode module = new LibraryNode(
// System.IO.Path.GetFileName(task.FileName),
// LibraryNode.LibraryNodeType.PhysicalContainer);
//CreateModuleTree(module, module, scope, "", task.ModuleID);
//if (null != task.ModuleID)
//{
// LibraryNode previousItem = null;
// lock (files)
// {
// if (files.TryGetValue(task.ModuleID, out previousItem))
// {
// files.Remove(task.ModuleID);
// }
// }
// library.RemoveNode(previousItem);
//}
//library.AddNode(module);
//if (null != task.ModuleID)
//{
// lock (files)
// {
// files.Add(task.ModuleID, module);
// }
//}
}
}
/// <summary>
/// Parses measures from the mdx script text. If there is an error during parsing an exception is thrown.
/// </summary>
/// <param name="daxScript">mdx script text</param>
/// <returns>Enumerable dax measures</returns>
public static MeasuresContainer ParseDaxScript(string daxScript)
{
var handler = new Babel.Parser.ErrorHandler();
var scanner = new Babel.Lexer.Scanner();
var parser = new Babel.Parser.Parser(); // use noarg constructor
parser.scanner = scanner;
scanner.Handler = handler;
parser.SetHandler(handler);
scanner.SetSourceText(daxScript);
var request = new ParseRequest(true);
request.Sink = new AuthoringSink(ParseReason.None, 0, 0, Babel.Parser.Parser.MaxErrors);
parser.MBWInit(request);
var parseResult = parser.Parse();
if (handler.Errors)
{
throw DaxParsingException.FromHandler(handler, daxScript);
}
//Add support measures if measure contains KPIs
var measures = parser.AllMeasures;
var supportMeasures = new List <DaxMeasure>();
var containsSupportMeasures = measures.GetSupportingMeasures().Count() != 0;
if (!containsSupportMeasures)
{
foreach (var measure in measures)
{
if (measure.CalcProperty?.KPI == null)
{
continue;
}
if (!string.IsNullOrWhiteSpace(measure.CalcProperty.KPI.TargetExpression))
{
var newMeasure = new DaxMeasure(
"_" + measure.Name + " Goal",
measure.TableName,
measure.CalcProperty.KPI.TargetExpression
);
supportMeasures.Add(newMeasure);
}
if (!string.IsNullOrWhiteSpace(measure.CalcProperty.KPI.StatusExpression))
{
var newMeasure = new DaxMeasure(
"_" + measure.Name + " Status",
measure.TableName,
measure.CalcProperty.KPI.StatusExpression
);
supportMeasures.Add(newMeasure);
}
if (!string.IsNullOrWhiteSpace(measure.CalcProperty.KPI.TrendExpression))
{
var newMeasure = new DaxMeasure(
"_" + measure.Name + " Trend",
measure.TableName,
measure.CalcProperty.KPI.TrendExpression
);
supportMeasures.Add(newMeasure);
}
}
}
return(new MeasuresContainer(measures.Union(supportMeasures).ToList()));
}
public void ParseNumberThatStartsWithDot()
{
var text = @"EVALUATE ROW(""a"", .1)";
Babel.Parser.Parser parser = ParseText(text);
}
