private void RegisterOuterMapping(ApplyParameter parameter, int value)
{
if (outerColumnUsages.TryGetValue(parameter, out var map) && !map.Contains(value))
{
map.Add(value);
}
}
public static Expression Rewrite(Expression expression,
ApplyParameter oldParameter, ApplyParameter newParameter)
{
var expressionRewriter = new ApplyParameterRewriter(oldParameter, newParameter);
return(expressionRewriter.Visit(expression));
}
public static CompilableProvider Rewrite(CompilableProvider provider, ApplyParameter oldParameter, ApplyParameter newParameter)
{
var expressionRewriter = new ApplyParameterRewriter(oldParameter, newParameter);
var providerRewriter = new CompilableProviderVisitor(expressionRewriter.RewriteExpression);
return(providerRewriter.VisitCompilable(provider));
}
public ItemProjectorExpression RewriteApplyParameter(ApplyParameter oldParameter, ApplyParameter newParameter)
{
var newDataSource = ApplyParameterRewriter.Rewrite(DataSource, oldParameter, newParameter);
var newItemProjectorBody = ApplyParameterRewriter.Rewrite(Item, oldParameter, newParameter);
return(new ItemProjectorExpression(newItemProjectorBody, newDataSource, Context));
}
public void CrossApplyExistenseTest()
{
Require.AllFeaturesSupported(ProviderFeatures.ScalarSubqueries);
using (var session = Domain.OpenSession()) {
using (session.OpenTransaction()) {
LoadData(session);
long total = 0;
foreach (var customer in allCustomers)
{
if (allInvoices.Any(o => o.Customer == customer))
{
total++;
}
}
var parameter = new ApplyParameter();
var subquery = orderPrimary
.Filter(t => t.GetValue(invoiceCustomerIndex) == parameter.Value.GetValue(customerIdIndex))
.Existence("LALALA");
var result = customerPrimary
.Apply(parameter, subquery, false, ApplySequenceType.Single, JoinType.Inner)
.GetRecordSetReader(Session.Current, new ParameterContext())
.ToEnumerable()
.Count(t => (bool)t.GetValue(t.Count - 1));
Assert.AreEqual(total, result);
}
}
}
public ApplyParameter Find(LambdaExpression predicate)
{
ArgumentValidator.EnsureArgumentNotNull(predicate, "predicate");
result = null;
Visit(predicate);
return(result);
}
public static Expression Rewrite(Expression expression,
Parameter <Tuple> parameterOfTuple, ApplyParameter applyParameter)
{
var expressionRewriter = new ApplyParameterToTupleParameterRewriter(parameterOfTuple, applyParameter);
return(expressionRewriter.Visit(expression));
}
private IncludeFilterMappingGatherer(Expression filterDataTuple, ApplyParameter filteredTuple, MappingEntry[] resultMapping)
{
calculatedColumnParameter = Expression.Parameter(typeof(Tuple), "filteredRow");
this.filterDataTuple = filterDataTuple;
this.filteredTuple = filteredTuple;
this.resultMapping = resultMapping;
}
/// <summary>
/// Initializes a new instance of this class.
/// </summary>
public ApplyProvider(ApplyParameter applyParameter, CompilableProvider left, CompilableProvider right, bool isInlined, ApplySequenceType applySequenceType, JoinType applyType)
: base(ProviderType.Apply, left, right)
{
ApplyParameter = applyParameter;
IsInlined = isInlined;
SequenceType = applySequenceType;
ApplyType = applyType;
Initialize();
}
protected override Provider VisitApply(ApplyProvider provider)
{
// split
List <int> leftMapping;
List <int> rightMapping;
SplitMappings(provider, out leftMapping, out rightMapping);
ApplyParameter applyParameter = provider.ApplyParameter;
var currentOuterUsages = new List <int>();
outerColumnUsages.Add(applyParameter, currentOuterUsages);
outerColumnUsageVisitor.VisitCompilable(provider.Right);
outerColumnUsages.Remove(applyParameter);
leftMapping = Merge(leftMapping, currentOuterUsages);
if (leftMapping.Count == 0)
{
leftMapping.Add(0);
}
// visit
var oldMappings = ReplaceMappings(provider.Left, leftMapping);
CompilableProvider newLeftProvider = VisitCompilable(provider.Left);
leftMapping = mappings[provider.Left];
ReplaceMappings(provider.Right, rightMapping);
outerColumnUsages.Add(applyParameter, leftMapping);
CompilableProvider newRightProvider = VisitCompilable(provider.Right);
outerColumnUsages.Remove(applyParameter);
var pair = OverrideRightApplySource(provider, newRightProvider, rightMapping);
if (pair.First == null)
{
rightMapping = mappings[provider.Right];
}
else
{
newRightProvider = pair.First;
rightMapping = pair.Second;
}
RestoreMappings(oldMappings);
mappings[provider] = Merge(leftMapping, rightMapping.Select(map => map + provider.Left.Header.Length));
if (newLeftProvider == provider.Left && newRightProvider == provider.Right)
{
return(provider);
}
return(new ApplyProvider(applyParameter, newLeftProvider, newRightProvider, provider.IsInlined, provider.SequenceType, provider.ApplyType));
}
public SqlExpression GetOuterExpression(ApplyParameter parameter, int columnIndex)
{
var reference = OuterReferences[parameter];
var sqlProvider = reference.First;
var useQueryReference = reference.Second;
return(useQueryReference
? sqlProvider.PermanentReference[columnIndex]
: ExtractColumnExpression(sqlProvider.Request.Statement.Columns[columnIndex]));
}
private int ResolveOuterMapping(ApplyParameter parameter, int value)
{
int result = outerColumnUsages[parameter].IndexOf(value);
if (result < 0)
{
return(value);
}
return(result);
}
public SubQueryExpression(
Type type,
ParameterExpression parameterExpression,
bool defaultIfEmpty,
ProjectionExpression projectionExpression,
ApplyParameter applyParameter)
: base(ExtendedExpressionType.SubQuery, type, parameterExpression, defaultIfEmpty)
{
ProjectionExpression = projectionExpression;
ApplyParameter = applyParameter;
}
public GroupingExpression(
Type type,
ParameterExpression parameterExpression,
bool defaultIfEmpty,
ProjectionExpression projectionExpression,
ApplyParameter applyParameter,
Expression keyExpression,
SelectManyGroupingInfo selectManyInfo)
: base(type, parameterExpression, defaultIfEmpty, projectionExpression, applyParameter, ExtendedExpressionType.Grouping)
{
SelectManyInfo = selectManyInfo;
KeyExpression = keyExpression;
}
public ApplyParameter GetApplyParameter(CompilableProvider provider)
{
ApplyParameter parameter;
if (!applyParameters.TryGetValue(provider, out parameter))
{
parameter = new ApplyParameter(provider.GetType().GetShortName());
// parameter = new ApplyParameter(provider.ToString());
// ENABLE ONLY FOR DEBUGGING!
// May lead TO entity.ToString() calls, while ToString can be overriden.
applyParameters.Add(provider, parameter);
}
return(parameter);
}
// Constructors
public virtual Expression ReplaceApplyParameter(ApplyParameter newApplyParameter)
{
if (newApplyParameter == ApplyParameter)
{
return(new SubQueryExpression(Type, OuterParameter, DefaultIfEmpty, ProjectionExpression, ApplyParameter));
}
var newItemProjector = ProjectionExpression.ItemProjector.RewriteApplyParameter(ApplyParameter, newApplyParameter);
var newProjectionExpression = new ProjectionExpression(
ProjectionExpression.Type,
newItemProjector,
ProjectionExpression.TupleParameterBindings,
ProjectionExpression.ResultType);
return(new SubQueryExpression(Type, OuterParameter, DefaultIfEmpty, newProjectionExpression, newApplyParameter));
}
public override Expression ReplaceApplyParameter(ApplyParameter newApplyParameter)
{
if (newApplyParameter == ApplyParameter)
{
return(new GroupingExpression(Type, OuterParameter, DefaultIfEmpty, ProjectionExpression, ApplyParameter, KeyExpression, SelectManyInfo));
}
var newItemProjector = ProjectionExpression.ItemProjector.RewriteApplyParameter(ApplyParameter, newApplyParameter);
var newProjectionExpression = new ProjectionExpression(
ProjectionExpression.Type,
newItemProjector,
ProjectionExpression.TupleParameterBindings,
ProjectionExpression.ResultType);
return(new GroupingExpression(Type, OuterParameter, DefaultIfEmpty, newProjectionExpression, newApplyParameter, KeyExpression, SelectManyInfo));
}
protected override Expression VisitMethodCall(MethodCallExpression mc)
{
if (mc.AsTupleAccess() != null)
{
var applyParameter = mc.GetApplyParameter();
if (result == null)
{
result = applyParameter;
}
else if (applyParameter != null && result != applyParameter)
{
throw new InvalidOperationException(Strings.ExPredicateContainsAccessesToDifferentApplyParameters);
}
return(mc);
}
return(base.VisitMethodCall(mc));
}
private void SaveApplyPredicate(FilterProvider filter, ApplyParameter applyParameter)
{
if (owner.State.Predicates.ContainsKey(applyParameter))
{
owner.State.Predicates[applyParameter]
.Add(new Pair <Expression <Func <Tuple, bool> >, ColumnCollection>(filter.Predicate,
filter.Header.Columns));
}
else
{
var newPair = new Pair <Expression <Func <Tuple, bool> >, ColumnCollection>(filter.Predicate,
filter.Header.Columns);
owner.State.Predicates.Add(applyParameter,
new List <Pair <Expression <Func <Tuple, bool> >, ColumnCollection> > {
newPair
});
}
}
public void OuterApplyTest()
{
using (var session = Domain.OpenSession()) {
using (session.OpenTransaction()) {
LoadData(session);
long total = 0;
foreach (var customer in allCustomers)
{
total += Math.Max(1, allInvoices.Count(o => o.Customer == customer));
}
var parameter = new ApplyParameter();
var subquery = orderPrimary
.Filter(t => t.GetValue(invoiceCustomerIndex) == parameter.Value.GetValue(customerIdIndex))
.Alias("XYZ");
var result = customerPrimary
.Apply(parameter, subquery, false, ApplySequenceType.All, JoinType.LeftOuter)
.Count(Session.Current);
Assert.AreEqual(total, result);
}
}
}
private int ResolveOuterMapping(ApplyParameter parameter, int value)
{
var result = outerColumnUsages[parameter].IndexOf(value);
return(result < 0 ? value : result);
}
// Constructors
private ApplyParameterToTupleParameterRewriter(Parameter <Tuple> parameterOfTuple, ApplyParameter applyParameter)
{
this.parameterOfTuple = parameterOfTuple;
parameterOfTupleExpression = Expression.Property(Expression.Constant(parameterOfTuple), WellKnownMembers.ParameterOfTupleValue);
this.applyParameter = applyParameter;
}
public static CompilableProvider Rewrite(CompilableProvider provider, Parameter <Tuple> parameterOfTuple, ApplyParameter applyParameter)
{
var expressionRewriter = new ApplyParameterToTupleParameterRewriter(parameterOfTuple, applyParameter);
var providerRewriter = new CompilableProviderVisitor(expressionRewriter.RewriteExpression);
return(providerRewriter.VisitCompilable(provider));
}
// Constructors
private ApplyParameterRewriter(ApplyParameter oldParameter, ApplyParameter newParameter)
{
newApplyParameterValueExpression = Expression.Property(Expression.Constant(newParameter), WellKnownMembers.ApplyParameterValue);
oldApplyParameter = oldParameter;
newApplyParameter = newParameter;
}
private static int DefaultResolveOuterColumn(ApplyParameter parameter, int columnIndex)
{
throw new NotSupportedException();
}
public static MappingEntry[] Gather(Expression filterExpression, Expression filterDataTuple, ApplyParameter filteredTuple, int columnCount)
{
var mapping = Enumerable.Repeat((MappingEntry)null, columnCount).ToArray();
var visitor = new IncludeFilterMappingGatherer(filterDataTuple, filteredTuple, mapping);
visitor.Visit(filterExpression);
if (mapping.Contains(null))
{
throw Exceptions.InternalError("Failed to gather mappings for IncludeProvider", OrmLog.Instance);
}
return(mapping);
}
// Constructors
/// <summary>
/// Initializes a new instance of this class.
/// </summary>
public ApplyParameterAccessVisitor(ApplyParameter applyParameter, Func <MethodCallExpression, int, Expression> processor)
{
this.processor = processor;
this.applyParameter = applyParameter;
}
// Constructors
/// <summary>
/// Initializes a new instance of this class.
/// </summary>
public ApplyProvider(ApplyParameter applyParameter, CompilableProvider left, CompilableProvider right)
: this(applyParameter, left, right, false, ApplySequenceType.All, JoinType.Inner)
{
}
private static void DefaultRegisterOuterColumn(ApplyParameter parameter, int columnIndex)
{
}
// Constructors
public SubqueryFilterChecker(ApplyParameter filterParameter)
{
this.filterParameter = filterParameter;
meaningfulLefts = new Stack <Expression>();
meaningfulRights = new Stack <Expression>();
}
