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); }); }