protected override void SpecificBuild()
{
var ctrXml = ConstraintXml as LookupExistsXml;
ctrXml.ResultSet.Settings = ctrXml.Settings;
var factory = new ColumnIdentifierFactory();
var mappings = new ColumnMappingCollection(
ctrXml.Join?.Mappings
.Select(mapping => new ColumnMapping(
factory.Instantiate(mapping.Candidate)
, factory.Instantiate(mapping.Reference)
, mapping.Type))
.Union(
ctrXml.Join?.Usings.Select(@using => new ColumnMapping(
factory.Instantiate(@using.Column)
, @using.Type)
)));
var builder = new ResultSetServiceBuilder();
builder.Setup(Helper.InstantiateResolver(ctrXml.ResultSet));
builder.Setup(Helper.InstantiateAlterations(ctrXml.ResultSet));
var service = builder.GetService();
var ctr = ctrXml.IsReversed ? new LookupReverseExistsConstraint(service) : new LookupExistsConstraint(service);
Constraint = ctr.Using(mappings);
}
protected object EvaluateExpression(IColumnExpression expression, DataRow row)
{
if (expression.Language == LanguageType.NCalc)
{
var exp = new NCalc.Expression(expression.Value);
var factory = new ColumnIdentifierFactory();
exp.EvaluateParameter += delegate(string name, NCalc.ParameterArgs args)
{
args.Result = GetValueFromRow(row, factory.Instantiate(name));
};
return(exp.Evaluate());
}
else if (expression.Language == LanguageType.Native)
{
var parse = expression.Value.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
var variable = new ColumnIdentifierFactory().Instantiate(parse.ElementAt(0));
var value = GetValueFromRow(row, variable);
foreach (var nativeFunction in parse.Skip(1))
{
var factory = new NativeTransformationFactory();
var transformer = factory.Instantiate(nativeFunction);
value = transformer.Evaluate(value);
}
return(value);
}
else
{
throw new ArgumentOutOfRangeException($"The language {expression.Language} is not supported during the evaluation of an expression.");
}
}
private IDictionary <IColumnIdentifier, Tolerance> BuildTolerances(InclusionXml inclusionXml)
{
var columnIdentifierFactory = new ColumnIdentifierFactory();
var toleranceFactory = new ToleranceFactory();
var tuples = inclusionXml?.Mappings.Where(mapping => !string.IsNullOrEmpty(mapping.Tolerance))
.Select(mapping => new
{
Identifier = columnIdentifierFactory.Instantiate(mapping.Candidate),
Tolerance = toleranceFactory.Instantiate(mapping.Type, mapping.Tolerance)
}
)
.Union(
inclusionXml?.Usings.Where(@using => !string.IsNullOrEmpty(@using.Tolerance))
.Select(@using => new
{
Identifier = columnIdentifierFactory.Instantiate(@using.Column),
Tolerance = toleranceFactory.Instantiate(@using.Type, @using.Tolerance)
}
));
var dico = new Dictionary <IColumnIdentifier, Tolerance>();
foreach (var tuple in tuples)
{
dico.Add(tuple.Identifier, tuple.Tolerance);
}
return(dico);
}
public void Instantiate_SsasNameWithDoubleBrackets_NameIdentifier()
{
var factory = new ColumnIdentifierFactory();
var id = factory.Instantiate("[[dimension].[hierarchy].[level]]");
Assert.That(id, Is.TypeOf <ColumnNameIdentifier>());
Assert.That((id as ColumnNameIdentifier).Name, Is.EqualTo("[dimension].[hierarchy].[level]"));
}
public void Instantiate_SsasName_NameIdentifier(string identifier)
{
var factory = new ColumnIdentifierFactory();
var id = factory.Instantiate(identifier);
Assert.That(id, Is.TypeOf <ColumnNameIdentifier>());
Assert.That((id as ColumnNameIdentifier).Name, Is.EqualTo(identifier));
}
public void Instantiate_Ordinal_PositionIdentifier(int identifier)
{
var factory = new ColumnIdentifierFactory();
var id = factory.Instantiate("#" + identifier.ToString());
Assert.That(id, Is.TypeOf <ColumnOrdinalIdentifier>());
Assert.That((id as ColumnOrdinalIdentifier).Ordinal, Is.EqualTo(identifier));
}
protected object EvaluateExpression(IColumnExpression expression, DataRow row)
{
var exp = new NCalc.Expression(expression.Value);
var factory = new ColumnIdentifierFactory();
exp.EvaluateParameter += delegate(string name, NCalc.ParameterArgs args)
{
args.Result = GetValueFromRow(row, factory.Instantiate(name));
};
return(exp.Evaluate());
}
private IEnumerable <ColumnMapping> BuildMappings(JoinXml joinXml)
{
var factory = new ColumnIdentifierFactory();
return(joinXml?.Mappings.Select(mapping => new ColumnMapping(
factory.Instantiate(mapping.Candidate)
, factory.Instantiate(mapping.Reference)
, mapping.Type))
.Union(
joinXml?.Usings.Select(@using => new ColumnMapping(
factory.Instantiate(@using.Column)
, @using.Type)
)));
}
public void Execute_DuplicatedIdentifiers_ColumnFilterped(string id1, string id2)
{
var rs = new NBi.Core.ResultSet.ResultSet();
rs.Load("a;1;120");
rs.Columns[0].ColumnName = "Foo";
rs.Columns[1].ColumnName = "Col1";
rs.Columns[2].ColumnName = "Col2";
var factory = new ColumnIdentifierFactory();
var filter = new ProjectEngine(new ProjectArgs(new[] { factory.Instantiate(id1), factory.Instantiate(id2) }));
filter.Execute(rs);
Assert.That(rs.Columns.Count, Is.EqualTo(1));
}
public void Execute_NonExistingIdentifiers_ColumnSkipped(string id)
{
var rs = new NBi.Core.ResultSet.ResultSet();
rs.Load("a;1;120");
rs.Columns[0].ColumnName = "Foo";
rs.Columns[1].ColumnName = "Col1";
rs.Columns[2].ColumnName = "Col2";
var factory = new ColumnIdentifierFactory();
var skip = new ProjectAwayEngine(new ProjectAwayArgs(new[] { factory.Instantiate(id) }));
skip.Execute(rs);
Assert.That(rs.Columns.Count, Is.EqualTo(3));
}
public void Execute_MultipleIdentifiersNotSameOrder_ColumnFilteredOrderChanged(string id1, string id2)
{
var rs = new NBi.Core.ResultSet.ResultSet();
rs.Load("a;1;120");
rs.Columns[0].ColumnName = "Foo";
rs.Columns[1].ColumnName = "Col1";
rs.Columns[2].ColumnName = "Bar";
var factory = new ColumnIdentifierFactory();
var project = new ProjectEngine(new ProjectArgs(new[] { factory.Instantiate(id1), factory.Instantiate(id2) }));
project.Execute(rs);
Assert.That(rs.Columns.Count, Is.EqualTo(2));
Assert.That(rs.Columns[0].ColumnName, Is.EqualTo("Bar"));
Assert.That(rs.Columns[1].ColumnName, Is.EqualTo("Foo"));
}
public void Instantiate_Ordinal_Failure(string identifier)
{
var factory = new ColumnIdentifierFactory();
Assert.Throws <ArgumentException>(() => factory.Instantiate(identifier));
}
public IEnumerable <Alter> InstantiateAlterations(ResultSetSystemXml resultSetXml)
{
if (resultSetXml.Alteration == null)
{
yield break;
}
if (resultSetXml.Alteration.Filters != null)
{
var factory = new ResultSetFilterFactory(variables);
foreach (var filterXml in resultSetXml.Alteration.Filters)
{
if (filterXml.Ranking == null)
{
var expressions = new List <IColumnExpression>();
if (filterXml.Expression != null)
{
expressions.Add(filterXml.Expression);
}
if (filterXml.Predication != null)
{
yield return(factory.Instantiate
(
filterXml.Aliases
, expressions
, filterXml.Predication
).Apply);
}
if (filterXml.Combination != null)
{
yield return(factory.Instantiate
(
filterXml.Aliases
, expressions
, filterXml.Combination.Operator
, filterXml.Combination.Predicates
).Apply);
}
}
else
{
yield return(factory.Instantiate(
filterXml.Ranking,
filterXml.Ranking?.GroupBy?.Columns
).Apply);
}
}
}
if (resultSetXml.Alteration.Conversions != null)
{
foreach (var conversionXml in resultSetXml.Alteration.Conversions)
{
var factory = new ConverterFactory();
var converter = factory.Instantiate(conversionXml.Converter.From, conversionXml.Converter.To, conversionXml.Converter.DefaultValue, conversionXml.Converter.Culture);
var engine = new ConverterEngine(conversionXml.Column, converter);
yield return(engine.Execute);
}
}
if (resultSetXml.Alteration.Transformations != null)
{
var identifierFactory = new ColumnIdentifierFactory();
var provider = new TransformationProvider();
foreach (var transformationXml in resultSetXml.Alteration.Transformations)
{
provider.Add(transformationXml.Identifier, transformationXml);
}
yield return(provider.Transform);
}
}
