public void Build_AggrAnalyticOperatorExpr_Expr()
{
List <string> opSymbols = new List <string>(AggrFunctionOperator.Symbols);
opSymbols.AddRange(AnalyticFunctionOperator.Symbols);
foreach (string opSymbol in opSymbols)
{
ApplyBranch applyBranch = new ApplyBranch(ModelResolvers.ExprResolver, this._exprTextGenerator);
Mock <IOperatorDefinition> opDefMock = new Mock <IOperatorDefinition>();
opDefMock.SetupGet(opDef => opDef.Symbol).Returns(opSymbol);
opDefMock.Setup(opDef => opDef.GetOutputStructure(It.IsAny <IExpression>()))
.Returns((IExpression expr) => { return(ModelResolvers.DsResolver()); });
IExpression expr = TestExprFactory.GetExpression(opSymbol, ExpressionFactoryNameTarget.OperatorSymbol);
expr.OperatorDefinition = opDefMock.Object;
expr.AddOperand("ds", ModelResolvers.ExprResolver());
expr.AddOperand("group", ModelResolvers.ExprResolver());
expr.AddOperand("having", ModelResolvers.ExprResolver());
expr.AddOperand("over", ModelResolvers.ExprResolver());
IExpression result = applyBranch.Build(expr);
Assert.NotNull(result.Structure);
Assert.Equal("Generated text", result.ExpressionText);
Assert.Equal("Apply", result.ResultName);
Assert.Equal("apply", result.ParamSignature);
Assert.Equal(expr.OperatorSymbol, result.OperatorSymbol);
Assert.Equal(1, result.OperandsCollection.Count);
Assert.True(result.Operands.ContainsKey("ds"));
}
}
public void GetOutputStructure_Group2ScalarsExpr_DataStructure(params TestExprType[] types)
{
IExpression compCreateExpr = this._exprFac.GetExpression("group", ExpressionFactoryNameTarget.OperatorSymbol);
IExpression idExpr1 = ModelResolvers.ExprResolver();
IExpression idExpr2 = ModelResolvers.ExprResolver();
idExpr1.ExpressionText = "Id1";
idExpr2.ExpressionText = "Id2";
idExpr1.Structure = ModelResolvers.DsResolver("Id1", ComponentType.Identifier, (BasicDataType)types[0]);
idExpr2.Structure = ModelResolvers.DsResolver("Id2", ComponentType.Identifier, (BasicDataType)types[1]);
compCreateExpr.AddOperand("ds_1", idExpr1);
compCreateExpr.AddOperand("ds_2", idExpr2);
IJoinExpression joinExpr = ModelResolvers.JoinExprResolver(this._exprFac.GetExpression("join", ExpressionFactoryNameTarget.OperatorSymbol));
joinExpr.AddOperand("ds_1", compCreateExpr);
IDataStructure expectedStructure = compCreateExpr.Operands["ds_1"].Structure.GetCopy();
expectedStructure.Identifiers.Add(compCreateExpr.Operands["ds_2"].Structure.GetCopy().Identifiers[0]);
IDataStructure dataStructure = compCreateExpr.OperatorDefinition.GetOutputStructure(compCreateExpr);
Assert.True(expectedStructure.EqualsObj(dataStructure));
}
public void GetOutputStructure_CorrectDatasetCollectionExpr_BoolScalarStructure()
{
foreach (string opSymbol in this._operators)
{
IExpression collectionExpr = ModelResolvers.ExprResolver();
collectionExpr.Structure = ModelResolvers.DsResolver();
collectionExpr.OperatorDefinition = ModelResolvers.OperatorResolver("collection");
collectionExpr.Structure.Measures.Add(new StructureComponent(BasicDataType.Integer));
collectionExpr.Structure.Measures.Add(new StructureComponent(BasicDataType.Number));
collectionExpr.Structure.Measures.Add(new StructureComponent(BasicDataType.None));
IExpression inExpr = ModelResolvers.ExprResolver();
inExpr.AddOperand("ds_1", TestExprFactory.GetExpression(TestExprType.NumbersDataset));
inExpr.AddOperand("ds_2", collectionExpr);
inExpr.Operands["ds_1"].Structure.Measures.RemoveAt(1);
inExpr.OperatorDefinition = ModelResolvers.OperatorResolver(opSymbol);
IExpression expected = TestExprFactory.GetExpression(TestExprType.BoolsDataset);
expected.Structure.Measures.RemoveAt(1);
IDataStructure dataStructure = inExpr.OperatorDefinition.GetOutputStructure(inExpr);
Assert.True(expected.Structure.EqualsObj(dataStructure));
}
}
public IExpression Build(IExpression datasetExpr)
{
/*
* This method is using mainly for dataset "comparison" operators. Example: DS_r := X = Y;
* The method can be used to generate a "rename" operator expression renaming a given dataset expression's single measure name to "bool_var".
*/
IExpression renameBranch = this._exprFactory.GetExpression("rename", ExpressionFactoryNameTarget.OperatorSymbol);
IExpression renameExpr = this._exprFactory.GetExpression("renameExpr", ExpressionFactoryNameTarget.OperatorSymbol);
IExpression compExpr1 = this._exprFactory.GetExpression("comp", ExpressionFactoryNameTarget.OperatorSymbol);
IExpression compExpr2 = this._exprFactory.GetExpression("comp", ExpressionFactoryNameTarget.OperatorSymbol);
renameBranch.OperatorDefinition.Keyword = "Variable";
renameBranch.LineNumber = datasetExpr.LineNumber;
renameExpr.LineNumber = datasetExpr.LineNumber;
compExpr1.LineNumber = datasetExpr.LineNumber;
compExpr2.LineNumber = datasetExpr.LineNumber;
compExpr1.ExpressionText = datasetExpr.Structure.Measures[0].BaseComponentName;
compExpr2.ExpressionText = datasetExpr.Structure.Measures[0].ComponentName;
renameExpr.AddOperand("ds_1", compExpr1);
renameExpr.AddOperand("ds_2", compExpr2);
renameBranch.AddOperand("ds_1", renameExpr);
this._exprTextGen.Generate(renameExpr);
this._exprTextGen.Generate(renameBranch);
return(renameBranch);
}
public void GetOutputStructure_WrongComponentTwoDatasetsJoinExpr_DurationScalarStructure(bool isMemership, TestExprType type)
{
foreach (string name in DatasetClauseOperator.ClauseNames.Where(name => !name.In("Pivot", "Unpivot", "Subspace")))
{
IExpression joinExpr = ModelResolvers.JoinExprResolver(TestExprFactory.GetExpression("join", ExpressionFactoryNameTarget.OperatorSymbol));
IExpression ds1Expr = TestExprFactory.GetExpression("get", ExpressionFactoryNameTarget.OperatorSymbol);
IExpression ds2Expr = TestExprFactory.GetExpression("get", ExpressionFactoryNameTarget.OperatorSymbol);
IExpression clauseExpr = TestExprFactory.GetExpression(name, ExpressionFactoryNameTarget.ResultName);
IExpression periodIndicatorExpr = TestExprFactory.GetExpression("period_indicator", ExpressionFactoryNameTarget.OperatorSymbol);
IExpression paramExpr = TestExprFactory.GetExpression(type);
if (isMemership)
{
paramExpr.OperatorDefinition = ModelResolvers.OperatorResolver("#");
}
joinExpr.AddOperand("ds", ModelResolvers.ExprResolver());
joinExpr.Operands["ds"].AddOperand("ds_1", ds1Expr);
joinExpr.Operands["ds"].AddOperand("ds_2", ds2Expr);
joinExpr.AddOperand(name, clauseExpr);
clauseExpr.AddOperand("ds_1", periodIndicatorExpr);
periodIndicatorExpr.AddOperand("ds_1", paramExpr);
ds1Expr.Structure = ModelResolvers.DsResolver();
ds1Expr.Structure.Identifiers.Add(new StructureComponent(BasicDataType.Integer, "Id1"));
ds1Expr.Structure.Identifiers.Add(new StructureComponent((BasicDataType)type, "Id2"));
ds1Expr.Structure.Measures.Add(new StructureComponent(BasicDataType.String, "Me1"));
ds2Expr.Structure = ds1Expr.Structure.GetCopy();
Assert.ThrowsAny <VtlOperatorError>(() => { periodIndicatorExpr.OperatorDefinition.GetOutputStructure(periodIndicatorExpr); });
}
}
public void Build_NotAggrAnalyticOperatorExpr_Expr(string opSymbol)
{
ApplyBranch applyBranch = new ApplyBranch(ModelResolvers.ExprResolver, this._exprTextGenerator);
Mock <IOperatorDefinition> opDefMock = new Mock <IOperatorDefinition>();
opDefMock.SetupGet(opDef => opDef.Symbol).Returns(opSymbol);
opDefMock.Setup(opDef => opDef.GetOutputStructure(It.IsAny <IExpression>()))
.Returns((IExpression expr) => { return(ModelResolvers.DsResolver()); });
IExpression expr = TestExprFactory.GetExpression(opSymbol, ExpressionFactoryNameTarget.OperatorSymbol);
expr.OperatorDefinition = opDefMock.Object;
expr.AddOperand("ds", ModelResolvers.ExprResolver());
expr.AddOperand("group", ModelResolvers.ExprResolver());
expr.AddOperand("having", ModelResolvers.ExprResolver());
expr.AddOperand("over", ModelResolvers.ExprResolver());
IExpression result = applyBranch.Build(expr);
Assert.NotNull(result.Structure);
Assert.Equal("Generated text", result.ExpressionText);
Assert.Equal("Apply", result.ResultName);
Assert.Equal("apply", result.ParamSignature);
Assert.Equal(expr.OperatorSymbol, result.OperatorSymbol);
Assert.Equal(expr.OperandsCollection.Count, result.OperandsCollection.Count);
for (int i = 0; i < expr.OperandsCollection.Count; i++)
{
Assert.Equal(expr.OperandsCollection.ToArray()[i].ParamSignature, result.OperandsCollection.ToArray()[i].ParamSignature);
}
}
public void GetOutputStructure_CorrectNoParamOneDatasetJoinExpr_DurationScalarStructure()
{
foreach (string name in DatasetClauseOperator.ClauseNames.Where(name => !name.In("Pivot", "Unpivot", "Subspace")))
{
IExpression joinExpr = ModelResolvers.JoinExprResolver(TestExprFactory.GetExpression("join", ExpressionFactoryNameTarget.OperatorSymbol));
IExpression datasetExpr = TestExprFactory.GetExpression("get", ExpressionFactoryNameTarget.OperatorSymbol);
IExpression clauseExpr = TestExprFactory.GetExpression(name, ExpressionFactoryNameTarget.ResultName);
IExpression periodIndicatorExpr = TestExprFactory.GetExpression("period_indicator", ExpressionFactoryNameTarget.OperatorSymbol);
joinExpr.AddOperand("ds", ModelResolvers.ExprResolver());
joinExpr.Operands["ds"].AddOperand("ds_1", datasetExpr);
joinExpr.AddOperand(name, clauseExpr);
clauseExpr.AddOperand("ds_1", periodIndicatorExpr);
datasetExpr.Structure = ModelResolvers.DsResolver();
datasetExpr.Structure.Identifiers.Add(new StructureComponent(BasicDataType.Integer, "Id1"));
datasetExpr.Structure.Identifiers.Add(new StructureComponent(BasicDataType.TimePeriod, "Id2"));
datasetExpr.Structure.Measures.Add(new StructureComponent(BasicDataType.String, "Me1"));
IDataStructure expectedStructure = ModelResolvers.DsResolver("duration_var", ComponentType.Measure, BasicDataType.Duration);
IDataStructure dataStructure = periodIndicatorExpr.OperatorDefinition.GetOutputStructure(periodIndicatorExpr);
Assert.True(expectedStructure.EqualsObj(dataStructure));
}
}
public void GetOutputStructure_Wrong()
{
IExpression expr = ModelResolvers.ExprResolver();
expr.OperatorDefinition = ModelResolvers.OperatorResolver("subExpr");
IExpression compExpr = TestExprFactory.GetDatasetExpr(new KeyValuePair <ComponentType, BasicDataType>(ComponentType.Identifier, BasicDataType.String));
IExpression constExpr = TestExprFactory.GetDatasetExpr(new KeyValuePair <ComponentType, BasicDataType>(ComponentType.Measure, BasicDataType.Integer));
expr.AddOperand("ds_1", compExpr);
expr.AddOperand("ds_2", constExpr);
Assert.ThrowsAny <Exception>(() => { expr.OperatorDefinition.GetOutputStructure(expr); });
}
public IExpression Build(IExpression datasetExpr)
{
/*
* This method is using mainly for aggregate invocation function "count". Example: DS_r := count(X group by Id1);
* The method can be used to transform "aggr" expressions to "calc" expressions instead of single "apply" expression.
*/
IExpression calcBranch = this._exprFactory.GetExpression("calc", ExpressionFactoryNameTarget.OperatorSymbol);
calcBranch.OperatorDefinition.Keyword = "Aggr Built";
for (int i = 0; i < datasetExpr.Operands["ds_1"].Structure.Measures.Count; i++)
{
StructureComponent measure = datasetExpr.Operands["ds_1"].Structure.Measures[i];
IExpression calcExpr = this._exprFactory.GetExpression("calcExpr", ExpressionFactoryNameTarget.OperatorSymbol);
IExpression aggrFunctionExpr = this._exprFactory.GetExpression(datasetExpr.OperatorSymbol, ExpressionFactoryNameTarget.OperatorSymbol);
IExpression compExpr1 = this._exprFactory.GetExpression("comp", ExpressionFactoryNameTarget.OperatorSymbol);
IExpression compExpr2 = this._exprFactory.GetExpression("comp", ExpressionFactoryNameTarget.OperatorSymbol);
calcBranch.LineNumber = datasetExpr.LineNumber;
calcExpr.LineNumber = datasetExpr.LineNumber;
aggrFunctionExpr.LineNumber = datasetExpr.LineNumber;
compExpr1.LineNumber = datasetExpr.LineNumber;
compExpr2.LineNumber = datasetExpr.LineNumber;
compExpr1.ExpressionText = measure.BaseComponentName;
compExpr2.ExpressionText = measure.BaseComponentName;
aggrFunctionExpr.AddOperand("ds_1", compExpr1);
calcExpr.AddOperand("ds_1", compExpr2);
calcExpr.AddOperand("ds_2", aggrFunctionExpr);
calcExpr.OperatorDefinition.Keyword = "measure";
calcBranch.AddOperand($"ds_{i + 1}", calcExpr);
if (datasetExpr.OperatorSymbol == "count")
{
compExpr2.ExpressionText = "int_var";
aggrFunctionExpr.ExpressionText = "count()";
aggrFunctionExpr.Operands.Clear();
this._exprTextGen.Generate(calcExpr);
break;
}
}
this._exprTextGen.GenerateRecursively(calcBranch);
return(calcBranch);
}
public void Build_Expr_Expr()
{
UsingBranch usingBranch = new UsingBranch(this._exprFac);
IExpression expr = TestExprFactory.GetExpression("join", ExpressionFactoryNameTarget.OperatorSymbol);
IJoinExpression joinExpr = ModelResolvers.JoinExprResolver(expr);
IExpression ds1Expr = TestExprFactory.GetExpression("get", ExpressionFactoryNameTarget.OperatorSymbol);
ds1Expr.Structure = ModelResolvers.DsResolver();
ds1Expr.Structure.Identifiers.Add(new StructureComponent(BasicDataType.Integer, "Id1"));
ds1Expr.Structure.Identifiers.Add(new StructureComponent(BasicDataType.Boolean, "Id2"));
IExpression ds2Expr = TestExprFactory.GetExpression("get", ExpressionFactoryNameTarget.OperatorSymbol);
ds2Expr.Structure = ModelResolvers.DsResolver();
ds2Expr.Structure.Identifiers.Add(new StructureComponent(BasicDataType.Integer, "Id1"));
ds2Expr.Structure.Identifiers.Add(new StructureComponent(BasicDataType.Boolean, "Id2"));
ds2Expr.Structure.Identifiers.Add(new StructureComponent(BasicDataType.String, "Id3"));
IExpression dsBranch = ModelResolvers.ExprResolver();
dsBranch.AddOperand("ds_1", ds1Expr);
dsBranch.AddOperand("ds_2", ds2Expr);
joinExpr.AddOperand("ds", dsBranch);
IExpression expected = TestExprFactory.GetExpression("Using", ExpressionFactoryNameTarget.ResultName);
expected.ParamSignature = "using";
expected.ExpressionText = "using Id1, Id2";
IExpression expected_1 = ModelResolvers.ExprResolver();
IExpression expected_2 = ModelResolvers.ExprResolver();
expected_1.ExpressionText = "Id1";
expected_2.ExpressionText = "Id2";
expected.AddOperand("Id1", expected_1);
expected.AddOperand("Id2", expected_2);
IExpression result = usingBranch.Build(joinExpr);
Assert.Equal(expected.OperandsCollection.Count, result.OperandsCollection.Count);
Assert.Equal(expected.Operands["Id1"].ExpressionText, result.Operands["Id1"].ExpressionText);
Assert.Equal(expected.Operands["Id2"].ExpressionText, result.Operands["Id2"].ExpressionText);
Assert.Equal(expected.ExpressionText, result.ExpressionText);
}
public void Build_Expr_Expr(params string[] opSymbols)
{
DsBranch dsBranch = new DsBranch(this._exprFac, this._exprTextGenerator);
IExpression expr = ModelResolvers.ExprResolver();
IExpression expected = ModelResolvers.ExprResolver();
for (int i = 0; i < opSymbols.Length; i++)
{
IExpression subExpr = this._exprFac.GetExpression(opSymbols[i], ExpressionFactoryNameTarget.OperatorSymbol); // local expFactory expected
subExpr.Structure = ModelResolvers.DsResolver();
subExpr.ExpressionText = opSymbols[i];
expr.AddOperand($"ds_{i}", subExpr);
if (opSymbols[i].In("get", "ref", "#", "join"))
{
expected.AddOperand($"ds_{i}", subExpr);
}
}
IExpression result = dsBranch.Build(expr);
Assert.Equal(expected.OperandsCollection.Count, result.OperandsCollection.Count);
foreach (string opSymbol in opSymbols.Where(opS => opS.In("get", "ref", "#", "join")))
{
Assert.True(result.OperandsCollection.Where(op => op.OperatorSymbol == opSymbol).Count() == 1);
}
}
public void GetOutputStructure_CalcComponentExpr_DataStructure(string keyword)
{
IExpression calcExpr = ModelResolvers.ExprResolver();
IExpression compExpr = ModelResolvers.ExprResolver();
compExpr.ExpressionText = "component";
compExpr.OperatorDefinition = ModelResolvers.OperatorResolver("comp");
calcExpr.OperatorDefinition = ModelResolvers.OperatorResolver("calcExpr");
calcExpr.OperatorDefinition.Keyword = keyword;
calcExpr.AddOperand("ds_1", compExpr);
ComponentType compType;
switch (keyword)
{
case "identifier": compType = ComponentType.Identifier; break;
case "measure": compType = ComponentType.Measure; break;
case "attribute": compType = ComponentType.NonViralAttribute; break;
case "viral attribute": compType = ComponentType.ViralAttribute; break;
default: throw new ArgumentOutOfRangeException("keyword");
}
IDataStructure dataStructure = compExpr.OperatorDefinition.GetOutputStructure(compExpr);
Assert.True(dataStructure.IsSingleComponent);
Assert.Equal(compType, dataStructure.Components[0].ComponentType);
}
public void Constructor_JoinExpr_JoinExpr()
{
IExpression expr = TestExprFactory.GetExpression("join", ExpressionFactoryNameTarget.OperatorSymbol);
IExpression refExpr = ModelResolvers.ExprResolver();
ITransformationSchema schema = ModelResolvers.SchemaResolver();
refExpr.AddOperand("ds", expr);
expr.ContainingSchema = schema;
expr.ReferenceExpression = refExpr;
IJoinExpression joinExpr2 = ModelResolvers.JoinExprResolver(expr);
joinExpr2.BasicStructure = ModelResolvers.DsResolver();
JoinExpression joinExpr = new JoinExpression(joinExpr2);
Assert.Equal(expr.ParentExpression, joinExpr.ParentExpression);
Assert.Equal(expr.ContainingSchema, joinExpr.ContainingSchema);
Assert.Equal(expr.ExpressionText, joinExpr.ExpressionText);
Assert.Equal(expr.LineNumber, joinExpr.LineNumber);
Assert.Equal(expr.OperandsCollection, joinExpr.OperandsCollection);
Assert.Equal(expr.OperatorDefinition, joinExpr.OperatorDefinition);
Assert.Equal(expr.ParamSignature, joinExpr.ParamSignature);
Assert.Equal(expr.ReferenceExpression, joinExpr.ReferenceExpression);
Assert.Equal(expr.ResultName, joinExpr.ResultName);
Assert.Equal(expr.Structure, joinExpr.Structure);
Assert.Equal(joinExpr2.BasicStructure, joinExpr.BasicStructure);
}
public void IsPartOfBranch_Exprs_CorrectResult()
{
IExpression branchExpr1 = ModelResolvers.ExprResolver();
IExpression branchExpr2 = ModelResolvers.ExprResolver();
IExpression expr1 = ModelResolvers.ExprResolver();
IExpression expr2 = ModelResolvers.ExprResolver();
IExpression expr3 = ModelResolvers.ExprResolver();
JoinExpression joinExpr = new JoinExpression(TestExprFactory.GetExpression("join", ExpressionFactoryNameTarget.OperatorSymbol));
joinExpr.AddOperand("branch_1", branchExpr1);
joinExpr.AddOperand("branch_2", branchExpr2);
branchExpr1.AddOperand("ds_1", expr1);
branchExpr2.AddOperand("ds_1", expr2);
Assert.True(joinExpr.IsPartOfBranch("branch_1", branchExpr1));
Assert.True(joinExpr.IsPartOfBranch("branch_1", expr1));
Assert.True(joinExpr.IsPartOfBranch("branch_2", branchExpr2));
Assert.True(joinExpr.IsPartOfBranch("branch_2", expr2));
Assert.False(joinExpr.IsPartOfBranch("branch_2", branchExpr1));
Assert.False(joinExpr.IsPartOfBranch("branch_2", expr1));
Assert.False(joinExpr.IsPartOfBranch("branch_1", branchExpr2));
Assert.False(joinExpr.IsPartOfBranch("branch_1", expr2));
Assert.False(joinExpr.IsPartOfBranch("branch_1", expr3));
Assert.False(joinExpr.IsPartOfBranch("branch_2", expr3));
}
public void GetOutputStructure_GroupNScalarsExpr_DataStructure()
{
IJoinExpression joinExpr = ModelResolvers.JoinExprResolver(this._exprFac.GetExpression("join", ExpressionFactoryNameTarget.OperatorSymbol));
for (int i = 3; i <= 5; i++) // very expensive
{
TestExprType[][] combinations = Enum.GetValues(typeof(TestExprType)).Cast <TestExprType>().Where(type => (int)type <= 8).GetCombinations(i);
foreach (TestExprType[] combination in combinations)
{
IExpression compCreateExpr = this._exprFac.GetExpression("group", ExpressionFactoryNameTarget.OperatorSymbol);
joinExpr.AddOperand("ds_1", compCreateExpr);
IDataStructure expectedStructure = ModelResolvers.DsResolver();
for (int k = 2; k <= i; k++)
{
IExpression idExpr = ModelResolvers.ExprResolver();
idExpr.ExpressionText = $"Id{k}";
idExpr.Structure = ModelResolvers.DsResolver($"Id{k}", ComponentType.Identifier, (BasicDataType)combination[k - 1]);
compCreateExpr.AddOperand($"ds_{k}", idExpr);
expectedStructure.AddStructure(compCreateExpr.Operands[$"ds_{k}"].Structure);
}
IDataStructure dataStructure = compCreateExpr.OperatorDefinition.GetOutputStructure(compCreateExpr);
Assert.True(expectedStructure.EqualsObj(dataStructure));
}
}
}
public void Build_Expr_Expr()
{
RenameBranch renameBranch = new RenameBranch(this._exprFac, this._exprTextGenerator);
IExpression expr = TestExprFactory.GetExpression("=", ExpressionFactoryNameTarget.OperatorSymbol);
expr.LineNumber = 10;
expr.Structure = ModelResolvers.DsResolver("Me1", ComponentType.Measure, BasicDataType.Boolean);
expr.Structure.Measures[0].BaseComponentName = "Me1_v2";
IExpression expected = TestExprFactory.GetExpression("rename", ExpressionFactoryNameTarget.OperatorSymbol);
IExpression expected_1 = TestExprFactory.GetExpression("renameExpr", ExpressionFactoryNameTarget.OperatorSymbol);
IExpression expected_1_1 = TestExprFactory.GetExpression("comp", ExpressionFactoryNameTarget.OperatorSymbol);
IExpression expected_1_2 = TestExprFactory.GetExpression("comp", ExpressionFactoryNameTarget.OperatorSymbol);
expected_1_1.ExpressionText = "Me1_v2";
expected_1_2.ExpressionText = "Me1";
expected.LineNumber = expr.LineNumber;
expected_1.LineNumber = expr.LineNumber;
expected_1_1.LineNumber = expr.LineNumber;
expected_1_2.LineNumber = expr.LineNumber;
expected.AddOperand("ds_1", expected_1);
expected_1.AddOperand("ds_1", expected_1_1);
expected_1.AddOperand("ds_2", expected_1_2);
IExpression result = renameBranch.Build(expr);
Assert.Equal(expected.OperandsCollection.Count, result.OperandsCollection.Count);
Assert.Equal(expected.Operands["ds_1"].OperandsCollection.Count, result.Operands["ds_1"].OperandsCollection.Count);
Assert.Equal(expected.OperatorSymbol, result.OperatorSymbol);
Assert.Equal(expected.Operands["ds_1"].OperatorSymbol, result.Operands["ds_1"].OperatorSymbol);
Assert.Equal(expected.Operands["ds_1"].Operands["ds_1"].OperatorSymbol, result.Operands["ds_1"].Operands["ds_1"].OperatorSymbol);
Assert.Equal(expected.Operands["ds_1"].Operands["ds_2"].OperatorSymbol, result.Operands["ds_1"].Operands["ds_2"].OperatorSymbol);
Assert.Equal(expected.Operands["ds_1"].Operands["ds_1"].ExpressionText, result.Operands["ds_1"].Operands["ds_1"].ExpressionText);
Assert.Equal(expected.Operands["ds_1"].Operands["ds_2"].ExpressionText, result.Operands["ds_1"].Operands["ds_2"].ExpressionText);
Assert.Equal(expected.LineNumber, result.LineNumber);
Assert.Equal(expected.Operands["ds_1"].LineNumber, result.Operands["ds_1"].LineNumber);
Assert.Equal(expected.Operands["ds_1"].Operands["ds_1"].LineNumber, result.Operands["ds_1"].Operands["ds_1"].LineNumber);
Assert.Equal(expected.Operands["ds_1"].Operands["ds_2"].LineNumber, result.Operands["ds_1"].Operands["ds_2"].LineNumber);
}
/// <summary>
/// Processes a no parameter version of an operator and returns the resulting structure.
/// </summary>
/// <param name="expression">The expression.</param>
/// <returns>A dynamically defined structure.</returns>
private IDataStructure ProcessNoParameterFunction(IExpression expression)
{
IExpression componentExpr = this._exprFac.GetExpression("comp", ExpressionFactoryNameTarget.OperatorSymbol);
IExpression ancesorExpr = null;
foreach (string name in DatasetClauseOperator.ClauseNames)
{
ancesorExpr = expression.GetFirstAncestorExpr(name);
if (ancesorExpr != null)
{
break;
}
}
if (ancesorExpr == null)
{
throw new VtlOperatorError(expression, this.Name, "Expected function parameter.");
}
if (expression.CurrentJoinExpr == null)
{
IExpression datasetExpr = ancesorExpr.ParentExpression.OperandsCollection.ToArray()[0];
StructureComponent component = datasetExpr.Structure.Identifiers.FirstOrDefault(comp => comp.ValueDomain.DataType == BasicDataType.TimePeriod);
if (component == null)
{
throw new VtlOperatorError(expression, this.Name, "Could not find time period data type identifier.");
}
if (datasetExpr.Structure.Identifiers.Where(comp => comp.ValueDomain.DataType == BasicDataType.TimePeriod).ToArray().Length > 1)
{
throw new VtlOperatorError(expression, this.Name, "Found more than 1 identifier of time period data type.");
}
componentExpr.ExpressionText = component.ComponentName.GetNameWithoutAlias();
}
else
{
string[] aliases = this.GetCompatibleAliases(expression.CurrentJoinExpr.Operands["ds"]);
if (aliases.Length == 0)
{
throw new VtlOperatorError(expression, this.Name, "Could not find time period data type identifier.");
}
if (aliases.Length > 1)
{
throw new VtlOperatorError(expression, this.Name, "Identifier of time period data type has been found in more than 1 join structure.");
}
componentExpr.ExpressionText = expression.CurrentJoinExpr.GetAliasExpression(aliases[0]).Structure.Identifiers
.First(id => id.ValueDomain.DataType == BasicDataType.TimePeriod).ComponentName.GetNameWithoutAlias();
}
expression.AddOperand("ds_1", componentExpr);
componentExpr.LineNumber = expression.LineNumber;
componentExpr.Structure = componentExpr.OperatorDefinition.GetOutputStructure(componentExpr);
IDataStructure structure = this._dsResolver("duration_var", ComponentType.Measure, BasicDataType.Duration);
structure.Components[0].BaseComponentName = componentExpr.Structure.Components[0].BaseComponentName;
return(structure);
}
public void GetOutputStructure_RenameComponentExpr_DataStructure(ComponentType compType)
{
IExpression renameExpr = ModelResolvers.ExprResolver();
IExpression compExpr = ModelResolvers.ExprResolver();
IExpression oldCompExpr = ModelResolvers.ExprResolver();
compExpr.ExpressionText = "component";
compExpr.OperatorDefinition = ModelResolvers.OperatorResolver("comp");
oldCompExpr.Structure = ModelResolvers.DsResolver("oldComponent", compType, BasicDataType.Integer);
renameExpr.OperatorDefinition = ModelResolvers.OperatorResolver("renameExpr");
renameExpr.AddOperand("ds_1", oldCompExpr);
renameExpr.AddOperand("ds_2", compExpr);
IDataStructure dataStructure = compExpr.OperatorDefinition.GetOutputStructure(compExpr);
Assert.True(dataStructure.IsSingleComponent);
Assert.True(oldCompExpr.Structure.Components[0].EqualsObj(dataStructure.Components[0]));
}
public void GetOutputStructure_Correct()
{
IExpression expr = ModelResolvers.ExprResolver();
expr.OperatorDefinition = ModelResolvers.OperatorResolver("subExpr");
IExpression compExpr = TestExprFactory.GetDatasetExpr(new KeyValuePair <ComponentType, BasicDataType>(ComponentType.Identifier, BasicDataType.String));
IExpression constExpr = TestExprFactory.GetDatasetExpr(new KeyValuePair <ComponentType, BasicDataType>(ComponentType.Measure, BasicDataType.String));
expr.AddOperand("ds_1", compExpr);
expr.AddOperand("ds_2", constExpr);
IDataStructure dataStructure = expr.OperatorDefinition.GetOutputStructure(expr);
Assert.True(dataStructure.Identifiers.Count == 1);
Assert.True(dataStructure.Components.Count == 1);
Assert.True(dataStructure.Identifiers.First().ComponentName == compExpr.Structure.Identifiers.First().ComponentName);
Assert.True(dataStructure.Identifiers.First().ValueDomain.DataType == constExpr.Structure.Measures.First().ValueDomain.DataType);
}
public void GetOutputStructure_ScalarDatasetExpr_ThrowsException()
{
TestExprType[][] combinations = Enum.GetValues(typeof(TestExprType)).Cast <TestExprType>().GetCombinations(2);
TestExprType[][] mixedCombs = combinations.Where(comb => (int)comb[0] < 9 && (int)comb[1] >= 9).ToArray();
foreach (TestExprType[] mixedComb in mixedCombs)
{
foreach (string opSymbol in this._operators)
{
IExpression setExpr = ModelResolvers.ExprResolver();
setExpr.OperatorDefinition = ModelResolvers.OperatorResolver(opSymbol);
setExpr.AddOperand("ds_1", TestExprFactory.GetExpression(mixedComb[0]));
setExpr.AddOperand("ds_2", TestExprFactory.GetExpression(mixedComb[1]));
Assert.ThrowsAny <VtlOperatorError>(() => { setExpr.OperatorDefinition.GetOutputStructure(setExpr); });
}
}
}
private IExpression GetExpr(string opSymbol)
{
Mock <IExpression> exprMock = new Mock <IExpression>();
exprMock.SetupAllProperties();
exprMock.SetupGet(o => o.Operands).Returns(new Dictionary <string, IExpression>());
exprMock.SetupGet(o => o.OperatorSymbol).Returns(opSymbol);
exprMock.SetupGet(o => o.OperandsCollection).Returns(exprMock.Object.Operands.Values);
exprMock.Setup(o => o.AddOperand(It.IsAny <string>(), It.IsAny <IExpression>()))
.Callback((string signature, IExpression expression) =>
{
exprMock.Object.Operands.Add(signature, expression);
});
exprMock.Setup(o => o.GetDescendantExprs(It.IsAny <string>()))
.Returns((string resultName) =>
{
List <IExpression> descendantExprs = new List <IExpression>();
foreach (IExpression expr in exprMock.Object.OperandsCollection)
{
if (expr.ResultName == resultName)
{
descendantExprs.Add(expr);
}
descendantExprs.AddRange(expr.GetDescendantExprs(resultName));
}
return(descendantExprs);
});
IExpression expr = exprMock.Object;
expr.AddOperand("ds_1", ModelResolvers.ExprResolver());
expr.AddOperand("ds_2", ModelResolvers.ExprResolver());
expr.AddOperand("ds_3", ModelResolvers.ExprResolver());
expr.Operands["ds_1"].ExpressionText = "expr1";
expr.Operands["ds_2"].ExpressionText = "expr2";
expr.Operands["ds_3"].ExpressionText = "expr3";
return(expr);
}
public void Generate_IfThenElseExpr_CorrectText(string resultName)
{
IExpression expr = TestExprFactory.GetExpression(resultName, ExpressionFactoryNameTarget.ResultName);
expr.AddOperand("ds_1", ModelResolvers.ExprResolver());
string exprText = expr.Operands["ds_1"].ExpressionText = "expr1";
this._exprTextGenerator.Generate(expr);
Assert.Equal($"{resultName.ToLower()} {exprText}", expr.ExpressionText);
}
public void GetOutputStructure_WrongScalarExpr_ThrowsException(TestExprType type)
{
IExpression periodIndicatorExpr = TestExprFactory.GetExpression("period_indicator", ExpressionFactoryNameTarget.OperatorSymbol);
IExpression scalarExpr = TestExprFactory.GetExpression(type);
scalarExpr.OperatorDefinition = ModelResolvers.OperatorResolver("const");
periodIndicatorExpr.AddOperand("ds_1", scalarExpr);
Assert.ThrowsAny <VtlOperatorError>(() => { periodIndicatorExpr.OperatorDefinition.GetOutputStructure(periodIndicatorExpr); });
}
/// <summary>
/// Folds expression from given expressions.
/// </summary>
/// <param name="expressions">The expressions.</param>
/// <returns>The expression.</returns>
public static IExpression FoldExpression(ICollection <IExpression> expressions)
{
IExpression expr = ModelResolvers.ExprResolver();
for (int i = 0; i < expressions.ToArray().Length; i++)
{
expr.AddOperand($"ds_{i + 1}", expressions.ToArray()[i]);
}
return(expr);
}
public void GetDescendantExprs_Name_DescendantExprsWithGivenName()
{
Expression expr = new Expression();
IExpression childExpr1 = ModelResolvers.ExprResolver();
IExpression childExpr2 = ModelResolvers.ExprResolver();
IExpression grandChildExpr1_1 = ModelResolvers.ExprResolver();
IExpression grandChildExpr1_2 = ModelResolvers.ExprResolver();
IExpression grandChildExpr2_1 = ModelResolvers.ExprResolver();
IExpression grandChildExpr2_2 = ModelResolvers.ExprResolver();
childExpr1.ResultName = "childExpr1";
childExpr2.ResultName = "childExpr2";
grandChildExpr1_1.ResultName = "childExpr1";
grandChildExpr1_2.ResultName = "childExpr2";
grandChildExpr2_1.ResultName = "childExpr1";
grandChildExpr2_2.ResultName = "childExpr2";
expr.AddOperand("ds_1", childExpr1);
expr.AddOperand("ds_2", childExpr2);
childExpr1.AddOperand("ds_1", grandChildExpr1_1);
childExpr1.AddOperand("ds_2", grandChildExpr1_2);
childExpr2.AddOperand("ds_1", grandChildExpr2_1);
childExpr2.AddOperand("ds_2", grandChildExpr2_2);
List <IExpression> descendantExprs = new List <IExpression>()
{
childExpr1,
grandChildExpr1_1,
grandChildExpr2_1
};
ICollection <IExpression> result = expr.GetDescendantExprs("childExpr1");
Assert.NotNull(result);
Assert.Equal(descendantExprs.Count, result.Count);
foreach (IExpression childExpr in result)
{
Assert.Contains(childExpr, descendantExprs);
}
}
public void GetOutputStructure_Correct2Operands()
{
IExpression expr = ModelResolvers.ExprResolver();
expr.OperatorDefinition = ModelResolvers.OperatorResolver("sub");
IExpression operand1 = TestExprFactory.GetDatasetExpr(new KeyValuePair <ComponentType, BasicDataType>(ComponentType.Identifier, BasicDataType.Integer));
IExpression operand2 = TestExprFactory.GetDatasetExpr(new KeyValuePair <ComponentType, BasicDataType>(ComponentType.Identifier, BasicDataType.String));
expr.AddOperand("ds_1", operand1);
expr.AddOperand("ds_2", operand2);
IDataStructure operandCollection = ModelResolvers.DsResolver();
operandCollection.AddStructure(operand1.Structure);
operandCollection.AddStructure(operand2.Structure);
IDataStructure dataStructure = expr.OperatorDefinition.GetOutputStructure(expr);
Assert.True(operandCollection.EqualsObj(dataStructure));
}
public void GetOutputStructure_CorrectDatasetsExpr_DataStructure()
{
TestExprType[][] combinations = Enum.GetValues(typeof(TestExprType)).Cast <TestExprType>().GetCombinations(2);
TestExprType[][] datasetCombs = combinations.Where(comb => (int)comb[0] >= 9 && (int)comb[1] >= 9).ToArray();
foreach (TestExprType[] datasetComb in datasetCombs.Where(comb => comb[0] == comb[1]))
{
foreach (string opSymbol in this._operators)
{
IExpression setExpr = ModelResolvers.ExprResolver();
setExpr.OperatorDefinition = ModelResolvers.OperatorResolver(opSymbol);
setExpr.AddOperand("ds_1", TestExprFactory.GetExpression(datasetComb[0]));
setExpr.AddOperand("ds_2", TestExprFactory.GetExpression(datasetComb[1]));
IDataStructure dataStructure = setExpr.OperatorDefinition.GetOutputStructure(setExpr);
Assert.True(setExpr.Operands["ds_1"].Structure.EqualsObj(dataStructure));
}
}
}
/// <summary>
/// Creates and returns a component expression.
/// </summary>
/// <param name="expressionText">The expression text.</param>
/// <param name="lineNumber">The line number.</param>
/// <param name="parentExpr">The parent expression.</param>
/// <returns>A component expression.</returns>
private IExpression CreateComponentExpression(string expressionText, int lineNumber, IExpression parentExpr)
{
IExpression componentExpr = this._exprFac.GetExpression("comp", ExpressionFactoryNameTarget.OperatorSymbol);
componentExpr.ExpressionText = expressionText;
componentExpr.LineNumber = lineNumber;
parentExpr.AddOperand($"ds_{parentExpr.OperandsCollection.Count + 1}", componentExpr);
componentExpr.Structure = componentExpr.OperatorDefinition.GetOutputStructure(componentExpr);
return(componentExpr);
}
public void GetOutputStructure_WrongNoParamDatasetClauseExpr_ThrowsException(BasicDataType type)
{
foreach (string name in DatasetClauseOperator.ClauseNames)
{
IExpression datasetClauseExpr = ModelResolvers.ExprResolver();
IExpression datasetExpr = ModelResolvers.ExprResolver();
IExpression clauseExpr = TestExprFactory.GetExpression(name, ExpressionFactoryNameTarget.ResultName);
IExpression periodIndicatorExpr = TestExprFactory.GetExpression("period_indicator", ExpressionFactoryNameTarget.OperatorSymbol);
datasetClauseExpr.AddOperand("ds_1", datasetExpr);
datasetClauseExpr.AddOperand("ds_2", clauseExpr);
clauseExpr.AddOperand("ds_1", periodIndicatorExpr);
datasetExpr.Structure = ModelResolvers.DsResolver();
datasetExpr.Structure.Identifiers.Add(new StructureComponent(BasicDataType.Integer, "Id1"));
datasetExpr.Structure.Identifiers.Add(new StructureComponent(type, "Id2"));
datasetExpr.Structure.Measures.Add(new StructureComponent(BasicDataType.String, "Me1"));
Assert.ThrowsAny <VtlOperatorError>(() => { periodIndicatorExpr.OperatorDefinition.GetOutputStructure(periodIndicatorExpr); });
}
}
public void GetOutputStructure_WrongComponentType(ComponentType wrongType)
{
IExpression expr = ModelResolvers.ExprResolver();
expr.OperatorDefinition = ModelResolvers.OperatorResolver("sub");
IExpression operand = TestExprFactory.GetDatasetExpr(new KeyValuePair <ComponentType, BasicDataType>(wrongType, BasicDataType.Integer));
expr.AddOperand("ds_1", operand);
Assert.ThrowsAny <Exception>(() => { expr.OperatorDefinition.GetOutputStructure(expr); });
}