private CompilableProvider InsertCalculateFilter(CompilableProvider source,
CalculateProvider calculateProvider)
{
var result = source;
if (State.CalculateFilters.ContainsKey(calculateProvider))
{
Expression <Func <Tuple, bool> > concatenatedPredicate = null;
foreach (var filterPair in State.CalculateFilters[calculateProvider])
{
var currentPredicate = (Expression <Func <Tuple, bool> >)calculateExpressionRewriter
.Rewrite(filterPair.First, filterPair.First.Parameters[0],
filterPair.Second, result.Header.Columns);
if (concatenatedPredicate == null)
{
concatenatedPredicate = currentPredicate;
}
else
{
concatenatedPredicate = collectorHelper
.CreatePredicatesConjunction(currentPredicate, concatenatedPredicate);
}
}
result = new FilterProvider(result, concatenatedPredicate);
State.CalculateFilters.Remove(calculateProvider);
}
return(result);
}
/// <inheritdoc/>
protected override SqlProvider VisitCalculate(CalculateProvider provider)
{
var source = Compile(provider.Source);
SqlSelect sqlSelect;
if (provider.Source.Header.Length == 0)
{
SqlSelect sourceSelect = source.Request.Statement;
sqlSelect = sourceSelect.ShallowClone();
sqlSelect.Columns.Clear();
}
else
{
sqlSelect = ExtractSqlSelect(provider, source);
}
var sourceColumns = ExtractColumnExpressions(sqlSelect);
var allBindings = EnumerableUtils <QueryParameterBinding> .Empty;
foreach (var column in provider.CalculatedColumns)
{
var result = ProcessExpression(column.Expression, sourceColumns);
var predicate = result.First;
var bindings = result.Second;
if (column.Type.StripNullable() == typeof(bool))
{
predicate = GetBooleanColumnExpression(predicate);
}
AddInlinableColumn(provider, column, sqlSelect, predicate);
allBindings = allBindings.Concat(bindings);
}
return(CreateProvider(sqlSelect, allBindings, provider, source));
}
private List <ApplyParameter> FindApplyParameters(CalculateProvider newProvider)
{
return((from column in newProvider.CalculatedColumns
let parameter = parameterSearcher.Find(column.Expression)
where parameter != null
select parameter).Distinct().ToList());
}
public bool TryAdd(CalculateProvider provider)
{
var applyParameters = FindApplyParameters(provider);
if (applyParameters.Count == 0)
{
return(false);
}
if (applyParameters.Count > 1)
{
ApplyProviderCorrectorRewriter.ThrowInvalidOperationException();
}
var applyParameter = applyParameters[0];
if (owner.State.SelfConvertibleApplyProviders[applyParameter])
{
return(false);
}
var newPair = new Pair <CalculateProvider, ColumnCollection>(provider, provider.Header.Columns);
if (owner.State.CalculateProviders.ContainsKey(applyParameter))
{
owner.State.CalculateProviders[applyParameter].Add(newPair);
}
else
{
owner.State.CalculateProviders.Add(applyParameter,
new List <Pair <CalculateProvider, ColumnCollection> > {
newPair
});
}
return(true);
}
private static CalculateProvider RecreateCalculate(CalculateProvider provider,
CompilableProvider source)
{
var ccd = provider.CalculatedColumns.Select(
column => new CalculatedColumnDescriptor(column.Name, column.Type, column.Expression));
return(new CalculateProvider(source, ccd.ToArray()));
}
public static Matrix operator *(Matrix matrix, double number)
{
if (matrix == null)
{
throw new ArgumentNullException(nameof(matrix));
}
return(CalculateProvider.Multiply(matrix, number));
}
protected override Provider VisitCalculate(CalculateProvider provider)
{
var source = VisitCompilable(provider.Source);
var newProvider = provider;
if (source != provider.Source)
{
newProvider = RecreateCalculate(provider, source);
}
return(calculateProviderCollector.TryAdd(newProvider) ? source : newProvider);
}
public bool Equals(Matrix matrix)
{
if (ReferenceEquals(matrix, null))
{
return(false);
}
if (ReferenceEquals(this, matrix))
{
return(true);
}
return(CalculateProvider.IsEqual(this, matrix));
}
private void AddCalculateFilter(CalculateProvider calculateProvider, FilterProvider filterProvider)
{
var newPair =
new Pair <Expression <Func <Tuple, bool> >, ColumnCollection>(filterProvider.Predicate,
filterProvider.Header.Columns);
if (owner.State.CalculateFilters.ContainsKey(calculateProvider))
{
owner.State.CalculateFilters[calculateProvider].Add(newPair);
}
else
{
owner.State.CalculateFilters.Add(calculateProvider,
new List <Pair <Expression <Func <Tuple, bool> >, ColumnCollection> > {
newPair
});
}
}
protected override Provider VisitCalculate(CalculateProvider provider)
{
int sourceLength = provider.Source.Header.Length;
var usedColumns = mappings[provider];
var sourceMapping = Merge(
mappings[provider].Where(i => i < sourceLength),
provider.CalculatedColumns.SelectMany(c => mappingsGatherer.Gather(c.Expression))
);
mappings[provider.Source] = sourceMapping;
var newSourceProvider = VisitCompilable(provider.Source);
mappings[provider] = mappings[provider.Source];
bool translated = false;
var descriptors = new List <CalculatedColumnDescriptor>(provider.CalculatedColumns.Length);
var currentMapping = mappings[provider];
for (int calculatedColumnIndex = 0; calculatedColumnIndex < provider.CalculatedColumns.Length; calculatedColumnIndex++)
{
if (usedColumns.Contains(provider.CalculatedColumns[calculatedColumnIndex].Index))
{
currentMapping.Add(provider.Source.Header.Length + calculatedColumnIndex);
var column = provider.CalculatedColumns[calculatedColumnIndex];
var expression = TranslateLambda(provider, column.Expression);
if (expression != column.Expression)
{
translated = true;
}
var ccd = new CalculatedColumnDescriptor(column.Name, column.Type, (Expression <Func <Tuple, object> >)expression);
descriptors.Add(ccd);
}
}
mappings[provider] = currentMapping;
if (descriptors.Count == 0)
{
return(newSourceProvider);
}
if (!translated && newSourceProvider == provider.Source && descriptors.Count == provider.CalculatedColumns.Length)
{
return(provider);
}
return(new CalculateProvider(newSourceProvider, descriptors.ToArray()));
}
public static Matrix operator *(Matrix leftSide, Matrix rightSide)
{
if (leftSide == null)
{
throw new ArgumentNullException(nameof(leftSide));
}
if (rightSide == null)
{
throw new ArgumentNullException(nameof(rightSide));
}
if (leftSide.ColumnsCount != rightSide.RowsCount)
{
throw new DimensionsDontMatchException("Multiplication is impossible");
}
return(CalculateProvider.Multiply(leftSide, rightSide));
}
/// <summary> /// Compiles <see cref="CalculateProvider"/>. /// </summary> /// <param name="provider">Calculate provider.</param> protected abstract TResult VisitCalculate(CalculateProvider provider);
private static bool ContainsAccessToTupleField(IEnumerable <int> tupleAccesses,
CalculateProvider calculateProvider, FilterProvider provider)
{
return(tupleAccesses.Any(i => calculateProvider.Header.Columns.Contains(provider.Header.Columns[i])));
}
