public IDataStructure GetOutputStructure(IExpression expression) { IDataStructure structure = this._dsResolver(); if (expression.OperandsCollection.Count != 2) { throw new VtlOperatorError(expression, this.Name, "Expected two components."); } IExpression identiefierExpr = expression.OperandsCollection.First(); IExpression measureExpr = expression.OperandsCollection.Last(); if (!identiefierExpr.IsScalar || !measureExpr.IsScalar) { throw new VtlOperatorError(expression, this.Name, "Expected scalar expression."); } if (identiefierExpr.Structure.Identifiers.Count != 1) { throw new VtlOperatorError(expression, this.Name, "Expected identifier."); } if (measureExpr.Structure.Measures.Count != 1) { throw new VtlOperatorError(expression, this.Name, "Expected measure."); } structure.AddStructure(measureExpr.Structure.GetCopy()); structure.Measures.First().ComponentName = $"pivot_{identiefierExpr.Structure.Identifiers.First().ComponentName}"; structure.DatasetType = DatasetType.Pivoted; return(structure); }
public IDataStructure GetOutputStructure(IExpression expression) { IExpression expr1 = expression.OperandsCollection.ToArray()[0]; IExpression expr2 = expression.OperandsCollection.ToArray()[1]; IDataStructure structure = expr1.Structure.GetCopy(); if (expr2.ResultName.In("Calc", "Aggregation")) { structure.AddStructure(expr2.Structure); } else if (expr2.ResultName.In("Keep", "Drop")) { this.ProcessKeepDropClause(structure, expr2); } else if (expr2.ResultName == "Rename") { this.ProcessRenameClause(structure, expr2); } else if (expr2.ResultName == "Pivot") { this.ProcessPivotClause(structure, expr2); } else if (expr2.ResultName == "Unpivot") { this.ProcessUnpivotClause(structure, expr2); } else if (expr2.ResultName == "Subspace") { this.ProcessSubspaceClause(structure, expr2); } return(structure); }
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)); } } }
/// <summary> /// Precesses unpivoting operations at a given data structure. /// </summary> /// <param name="structure">The data structure.</param> /// <param name="unpivotExpr">The unpivot expression.</param> private void ProcessUnpivotClause(IDataStructure structure, IExpression unpivotExpr) { (structure.Measures as List <StructureComponent>).Clear(); (structure.NonViralAttributes as List <StructureComponent>).Clear(); (structure.ViralAttributes as List <StructureComponent>).Clear(); structure.AddStructure(unpivotExpr.Structure); }
public void GetOutputStructure_NScalarsExpr_DataStructure(string opSymbol) { 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 = TestExprFactory.GetExpression(combination); compCreateExpr.OperatorDefinition = this._exprFac.OperatorResolver(opSymbol); joinExpr.AddOperand("ds_1", compCreateExpr); IDataStructure expectedStructure = compCreateExpr.Operands["ds_1"].Structure.GetCopy(); for (int k = 2; k <= i; k++) { expectedStructure.AddStructure(compCreateExpr.Operands[$"ds_{k}"].Structure); } IDataStructure dataStructure = compCreateExpr.OperatorDefinition.GetOutputStructure(compCreateExpr); Assert.True(expectedStructure.EqualsObj(dataStructure)); } } }
public IDataStructure GetOutputStructure(IExpression expression) { IDataStructure structure = this._dsResolver(); foreach (IExpression expr in expression.OperandsCollection) { if (!expr.IsScalar) { throw new VtlOperatorError(expression, this.Name, "Expected scalar expression."); } if (expr.OperatorSymbol == "#") { string compName = $"{expr.OperandsCollection.ToArray()[0].ExpressionText}#{expr.Operands["ds_2"].ExpressionText}"; expr.Structure.Components[0].BaseComponentName = compName; expr.Structure.Components[0].ComponentName = compName; } structure.AddStructure(expr.Structure); } if (structure.Identifiers.Count != 0) { throw new VtlOperatorError(expression, this.Name, $"Identifiers cannot be included to {this.Symbol.ToLower()} branch of the \"join\" operator expression."); } return(structure); }
/// <summary> /// Precesses pivoting operations at a given data structure. /// </summary> /// <param name="structure">The data structure.</param> /// <param name="pivotExpr">The pivot expression.</param> private void ProcessPivotClause(IDataStructure structure, IExpression pivotExpr) { IExpression compToRemove = pivotExpr.OperandsCollection.First(); (structure.Identifiers as List <StructureComponent>).RemoveAll(r => r.ComponentName == compToRemove.Structure.Components.First().ComponentName); (structure.Measures as List <StructureComponent>).Clear(); (structure.NonViralAttributes as List <StructureComponent>).Clear(); (structure.ViralAttributes as List <StructureComponent>).Clear(); structure.AddStructure(pivotExpr.Structure); structure.DatasetType = DatasetType.Pivoted; }
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 IDataStructure GetOutputStructure(IExpression expression) { IDataStructure structure = this._dsResolver(); if (expression.OperandsCollection.Count != 2) { throw new VtlOperatorError(expression, this.Name, "Expected two components."); } IExpression identiefierExpr = expression.OperandsCollection.First(); IExpression measureExpr = expression.OperandsCollection.Last(); if (!identiefierExpr.IsScalar || !measureExpr.IsScalar) { throw new VtlOperatorError(expression, this.Name, "Expected scalar expression."); } if (identiefierExpr.Structure.Identifiers.Count != 1) { throw new VtlOperatorError(expression, this.Name, "Expected identifier."); } if (measureExpr.Structure.Measures.Count != 1) { throw new VtlOperatorError(expression, this.Name, "Expected measure."); } if (expression.ParentExpression?.Operands["ds_1"]?.Structure.Measures.GroupBy(g => g.ValueDomain.DataType).Count() != 1) { throw new VtlOperatorError(expression, this.Name, "All types of Measure must be that same"); } structure.AddStructure(identiefierExpr.Structure.GetCopy()); structure.AddStructure(measureExpr.Structure.GetCopy()); return(structure); }
/// <summary> /// Gets the structure of the resulting operator parameter for specified operands. /// </summary> /// <param name="expression">The expression.</param> /// <returns>A dynamically defined structure of the output parameter for the given input parameters.</returns> public IDataStructure GetOutputStructure(IExpression expression) { IDataStructure dataStructure = this._dsResolver(); foreach (IExpression expr in expression.OperandsCollection) { if (!expr.IsScalar) { throw new VtlOperatorError(expression, this._name, "Expected scalar expression."); } dataStructure.AddStructure(expr.Structure); } return(dataStructure); }
/// <summary> /// Precesses a "join" expression's datasets structures merging into a given data structure. /// </summary> /// <param name="expression">The "join" expression.</param> /// <param name="mergedStructure">The data structure.</param> private IDataStructure ProcessDsBranch(IJoinExpression expression, IDataStructure mergedStructure) { IExpression[] aliases = expression.Operands["ds"].OperandsCollection.ToArray(); for (int i = 0; i < aliases.Length; i++) { if (i + 1 != aliases.Length && aliases[i].Structure.IsSupersetOf(aliases[i + 1].Structure) && !aliases[i + 1].Structure.IsSupersetOf(aliases[i].Structure)) { throw new VtlOperatorError(expression, this.Symbol, "Datasets doesn't fit"); } mergedStructure.AddStructure(aliases[i].Structure.GetCopy()); } return(mergedStructure); }
/// <summary> /// Precesses a "join" expression's component calculating operations at a given data structure. /// </summary> /// <param name="expression">The "join" expression.</param> /// <param name="mergedStructure">The data structure.</param> private IDataStructure ProcessCalcBranch(IJoinExpression expression, IDataStructure mergedStructure) { IExpression calcBranch = expression.Operands["calc"]; if (calcBranch.OperatorDefinition.Keyword == "Aggr") { foreach (StructureComponent component in calcBranch.Structure.Components.Where(comp => comp.ComponentType != ComponentType.Identifier)) { List <StructureComponent> comps = mergedStructure.Components as List <StructureComponent>; comps.RemoveAll(comp => comp.ComponentName != component.BaseComponentName && comp.ComponentType == component.ComponentType); mergedStructure.Measures = comps.Where(comp => comp.ComponentType == ComponentType.Measure).ToList(); mergedStructure.NonViralAttributes = comps.Where(comp => comp.ComponentType == ComponentType.NonViralAttribute).ToList(); mergedStructure.ViralAttributes = comps.Where(comp => comp.ComponentType == ComponentType.ViralAttribute).ToList(); } } mergedStructure.AddStructure(calcBranch.Structure.GetCopy()); return(mergedStructure); }
public IDataStructure GetMeasuresStructure(IExpression expression) { IDataStructure measuresStructure = this._dsResolver(); List <List <IExpression> > operands = new List <List <IExpression> >(); foreach (IExpression expr in expression.OperandsCollection) { operands.Add(new List <IExpression>()); if (expr.IsApplyComponent) { IDataStructure structure = expr.Structure; if (structure == null && expr.OperatorSymbol != null) { structure = expr.Operands["ds_1"].Structure; } if (structure != null) { for (int i = 0; i < structure.Measures.Count; i++) { StructureComponent measure = structure.Measures[i]; IExpression operand = this._exprFac.GetExpression("Alias", ExpressionFactoryNameTarget.ResultName); operand.Structure = this._dsResolver(measure.ComponentName, measure.ComponentType, measure.ValueDomain.DataType); operands.Last().Add(operand); } } } else { operands.Last().Add(expr); } } List <IExpression> measuresExprList = operands.Last(op => op.FirstOrDefault(o => o.ResultName == "Alias") != null); // Last because first in if-then-else is condition for (int i = 0; i < measuresExprList.Count; i++) { IExpression operatorExpr = this._exprFac.GetExpression(expression.OperatorSymbol, ExpressionFactoryNameTarget.OperatorSymbol); for (int j = 0; j < operands.Count; j++) { IExpression operand = operands[j][0]; if (operands[j].Count > 1 && (j != 0 || j == 0 && expression.OperatorSymbol != "if")) { if (!this.AreExprListsEqual(operands[j], measuresExprList)) { throw new VtlOperatorError(expression, expression.OperatorSymbol, "Aliased measures collections don't match each other."); } operand = operands[j][i]; } operatorExpr.AddOperand($"ds_{j + 1}", operand); } if (operatorExpr.OperatorSymbol == "if") { IExpression[] ifThenElseExprs = operatorExpr.OperandsCollection.ToArray(); operatorExpr.Operands.Clear(); operatorExpr.AddOperand("if", ifThenElseExprs[0]); operatorExpr.AddOperand("then", ifThenElseExprs[1]); operatorExpr.AddOperand("else", ifThenElseExprs[2]); if (operatorExpr.Operands["if"].ResultName != "If") { operatorExpr.Operands["if"].AddOperand("ds_1", ifThenElseExprs[0]); } if (operatorExpr.Operands["then"].ResultName != "Then") { operatorExpr.Operands["then"].AddOperand("ds_1", ifThenElseExprs[1]); } if (operatorExpr.Operands["else"].ResultName != "Else") { operatorExpr.Operands["else"].AddOperand("ds_1", ifThenElseExprs[2]); } } IDataStructure operatorStructure = operatorExpr.OperatorDefinition.GetOutputStructure(operatorExpr); operatorStructure.Measures[0].BaseComponentName = measuresExprList[i].Structure.Measures[0].BaseComponentName; operatorStructure.Measures[0].ComponentName = measuresExprList[i].Structure.Measures[0].ComponentName; measuresStructure.AddStructure(operatorStructure); } return(measuresStructure); }