private void FlattenSubQuery(SubQueryExpression subQueryExpression, FromClauseBase fromClause,
QueryModel queryModel)
{
// Move the result operator up
if (queryModel.ResultOperators.Count != 0)
{
throw new NotImplementedException();
}
var groupBy = (GroupResultOperator) subQueryExpression.QueryModel.ResultOperators[0];
// Replace the outer select clause...
queryModel.SelectClause.TransformExpressions(s => GroupBySelectClauseRewriter.ReWrite(s, groupBy, subQueryExpression.QueryModel));
queryModel.SelectClause.TransformExpressions(
s =>
new SwapQuerySourceVisitor(queryModel.MainFromClause, subQueryExpression.QueryModel.MainFromClause).Swap
(s));
MainFromClause innerMainFromClause = subQueryExpression.QueryModel.MainFromClause;
CopyFromClauseData(innerMainFromClause, fromClause);
foreach (var bodyClause in subQueryExpression.QueryModel.BodyClauses)
{
queryModel.BodyClauses.Add(bodyClause);
}
queryModel.ResultOperators.Add(groupBy);
}
protected void CopyFromClauseData(FromClauseBase source, FromClauseBase destination)
{
ArgumentUtility.CheckNotNull("source", source);
ArgumentUtility.CheckNotNull("destination", destination);
destination.FromExpression = source.FromExpression;
destination.ItemName = source.ItemName;
destination.ItemType = source.ItemType;
}
protected override void FlattenSubQuery(
[NotNull] SubQueryExpression subQueryExpression,
[NotNull] FromClauseBase fromClause,
[NotNull] QueryModel queryModel,
int destinationIndex)
{
Check.NotNull(subQueryExpression, nameof(subQueryExpression));
Check.NotNull(fromClause, nameof(fromClause));
Check.NotNull(queryModel, nameof(queryModel));
var subQueryModel = subQueryExpression.QueryModel;
VisitQueryModel(subQueryModel);
if (subQueryModel.ResultOperators
.Any(ro => !(ro is OfTypeResultOperator)) ||
subQueryModel.BodyClauses.Any(bc => bc is OrderByClause))
{
return;
}
var innerMainFromClause
= subQueryExpression.QueryModel.MainFromClause;
CopyFromClauseData(innerMainFromClause, fromClause);
var innerSelectorMapping = new QuerySourceMapping();
innerSelectorMapping.AddMapping(fromClause, subQueryExpression.QueryModel.SelectClause.Selector);
queryModel.TransformExpressions(
ex => ReferenceReplacingExpressionTreeVisitor
.ReplaceClauseReferences(ex, innerSelectorMapping, false));
InsertBodyClauses(subQueryExpression.QueryModel.BodyClauses, queryModel, destinationIndex);
var innerBodyClauseMapping = new QuerySourceMapping();
innerBodyClauseMapping
.AddMapping(innerMainFromClause, new QuerySourceReferenceExpression(fromClause));
queryModel.TransformExpressions(ex =>
ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences(ex, innerBodyClauseMapping, false));
foreach (var resultOperator in subQueryModel.ResultOperators.Reverse())
{
queryModel.ResultOperators.Insert(0, resultOperator);
}
foreach (var queryAnnotation
in _queryAnnotations
.Where(qa => qa.QuerySource == subQueryExpression.QueryModel.MainFromClause))
{
queryAnnotation.QuerySource = fromClause;
}
}
public static Result CreateProjector(
string name,
FromClauseBase fromClause,
SubQueryExpression sqe,
QueryParts parts)
{
var result = new Result {
QuerySource = fromClause, Name = name, Type = fromClause.ItemType
};
var method = ProjectionMethod.Method.GetGenericMethodDefinition().MakeGenericMethod(fromClause.ItemType);
var instancer = (Func <string, object>)method.Invoke(null, new object[] { sqe, parts });
result.Instancer = value => instancer(value.ToString());
return(result);
}
private void FlattenSubQuery(SubQueryExpression subQueryExpression, FromClauseBase fromClause,
QueryModel queryModel)
{
// Replace the outer select clause...
queryModel.SelectClause.TransformExpressions(GroupBySelectClauseVisitor.Visit);
MainFromClause innerMainFromClause = subQueryExpression.QueryModel.MainFromClause;
CopyFromClauseData(innerMainFromClause, fromClause);
// Move the result operator up
if (queryModel.ResultOperators.Count != 0)
{
throw new NotImplementedException();
}
queryModel.ResultOperators.Add(subQueryExpression.QueryModel.ResultOperators[0]);
}
internal FromClauseBase TryToSimplifyAdditionalFrom(AdditionalFromClause additionalFrom)
{
FromClauseBase from = additionalFrom;
var sqe = from.FromExpression as SubQueryExpression;
if (sqe != null)
{
var subquery = SubqueryGeneratorQueryModelVisitor.ParseSubquery(sqe.QueryModel, this, ContextName, Context.Select());
if (subquery.Joins.Count > 0 ||
subquery.ResultOperators.Any(it => it is CastResultOperator == false && it is DefaultIfEmptyResultOperator == false) ||
subquery.AdditionalJoins.Count > 0)
{
return(from);
}
return(TryToSimplifyMainFrom(sqe.QueryModel.MainFromClause));
}
return(from);
}
/// <summary>Visits a from clause.</summary>
/// <param name="fromClause">From clause to be visited.</param>
/// <param name="queryModel">Query model containing given from clause.</param>
/// <param name="index">Index of the where clause in the query model. In case of the main from clause this value is -1.</param>
protected virtual void VisitQuerableFromClause(FromClauseBase fromClause, Remotion.Linq.QueryModel queryModel, int index)
{
if (typeof(IQueryable).IsAssignableFrom(fromClause.FromExpression.Type))
{
if ((fromClause.FromExpression.Type.GetGenericArguments().Length > 0) && (fromClause.FromExpression.Type.GetGenericArguments()[0] != typeof(IEntity)))
{
StrongEntityAccessor entityAccessor = this.GetEntityAccessor(fromClause);
if (_mainFromComponent == null)
{
_query.Elements.Add(_mainFromComponent = entityAccessor);
}
}
}
else
{
_visitor.Visit(fromClause.FromExpression);
}
}
protected virtual void FlattenSubQuery(
SubQueryExpression subQueryExpression, FromClauseBase fromClause, QueryModel queryModel, int destinationIndex)
{
CheckFlattenable(subQueryExpression.QueryModel);
var innerMainFromClause = subQueryExpression.QueryModel.MainFromClause;
CopyFromClauseData(innerMainFromClause, fromClause);
var innerSelectorMapping = new QuerySourceMapping();
innerSelectorMapping.AddMapping(fromClause, subQueryExpression.QueryModel.SelectClause.Selector);
queryModel.TransformExpressions(ex => ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences(ex, innerSelectorMapping, false));
InsertBodyClauses(subQueryExpression.QueryModel.BodyClauses, queryModel, destinationIndex);
var innerBodyClauseMapping = new QuerySourceMapping();
innerBodyClauseMapping.AddMapping(innerMainFromClause, new QuerySourceReferenceExpression(fromClause));
queryModel.TransformExpressions(ex => ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences(ex, innerBodyClauseMapping, false));
}
public static Result CreateProjector(
string name,
FromClauseBase fromClause,
SubQueryExpression sqe,
QueryParts parts)
{
var result = new Result {
QuerySource = fromClause, Name = name, Type = fromClause.ItemType
};
var method = ProjectionMethod.Method.GetGenericMethodDefinition().MakeGenericMethod(fromClause.ItemType);
var tempInst = method.Invoke(null, new object[] { sqe, parts });
var instancer = tempInst as Func <string, BufferedTextReader, object>;
if (instancer == null)
{
var invMethod = tempInst.GetType().GetMethod("Invoke");
instancer = (value, reader) => invMethod.Invoke(tempInst, new object[] { value, reader });
}
result.Instancer = (value, reader) => instancer(value.ToString(), reader);
return(result);
}
private static void FlattenSubQuery(SubQueryExpression subQueryExpression, FromClauseBase fromClause, QueryModel queryModel, int destinationIndex)
{
//if ( !CheckFlattenable( subQueryExpression.QueryModel ) )
// return;
var mainFromClause = subQueryExpression.QueryModel.MainFromClause;
CopyFromClauseData(mainFromClause, fromClause);
var innerSelectorMapping = new QuerySourceMapping();
innerSelectorMapping.AddMapping(fromClause, subQueryExpression.QueryModel.SelectClause.Selector);
//queryModel.TransformExpressions( ex => ReferenceReplacingExpressionVisitor.ReplaceClauseReferences( ex, innerSelectorMapping, false ) );
InsertBodyClauses(subQueryExpression.QueryModel.BodyClauses, queryModel, destinationIndex);
InsertResultOperators(subQueryExpression.QueryModel.ResultOperators, queryModel);
var innerBodyClauseMapping = new QuerySourceMapping();
innerBodyClauseMapping.AddMapping(mainFromClause, new QuerySourceReferenceExpression(fromClause));
//queryModel.TransformExpressions( ex => ReferenceReplacingExpressionVisitor.ReplaceClauseReferences( ex, innerBodyClauseMapping, false ) );
}
protected override void FlattenSubQuery(
SubQueryExpression subQueryExpression,
FromClauseBase fromClause,
QueryModel queryModel,
int destinationIndex)
{
var subQueryModel = subQueryExpression.QueryModel;
if (!(subQueryModel.ResultOperators.Count <= 0 &&
!subQueryModel.BodyClauses.Any(bc => bc is OrderByClause)))
{
return;
}
var innerMainFromClause
= subQueryExpression.QueryModel.MainFromClause;
CopyFromClauseData(innerMainFromClause, fromClause);
var innerSelectorMapping = new QuerySourceMapping();
innerSelectorMapping.AddMapping(fromClause, subQueryExpression.QueryModel.SelectClause.Selector);
queryModel.TransformExpressions(
ex => ReferenceReplacingExpressionTreeVisitor
.ReplaceClauseReferences(ex, innerSelectorMapping, false));
InsertBodyClauses(subQueryExpression.QueryModel.BodyClauses, queryModel, destinationIndex);
var innerBodyClauseMapping = new QuerySourceMapping();
innerBodyClauseMapping.AddMapping(innerMainFromClause, new QuerySourceReferenceExpression(fromClause));
queryModel.TransformExpressions(
ex => ReferenceReplacingExpressionTreeVisitor
.ReplaceClauseReferences(ex, innerBodyClauseMapping, false));
}
public PagingRewriterSelectClauseVisitor(FromClauseBase querySource)
{
this.querySource = querySource;
}
protected override void FlattenSubQuery(
[NotNull] SubQueryExpression subQueryExpression,
[NotNull] FromClauseBase fromClause,
[NotNull] QueryModel queryModel,
int destinationIndex)
{
Check.NotNull(subQueryExpression, nameof(subQueryExpression));
Check.NotNull(fromClause, nameof(fromClause));
Check.NotNull(queryModel, nameof(queryModel));
var subQueryModel = subQueryExpression.QueryModel;
VisitQueryModel(subQueryModel);
if ((subQueryModel.ResultOperators
.All(ro => (ro is OfTypeResultOperator || ro is CastResultOperator)) &&
!subQueryModel.BodyClauses.Any(bc => bc is OrderByClause)) ||
(queryModel.IsIdentityQuery() &&
!queryModel.ResultOperators.Any()))
{
var innerMainFromClause = subQueryExpression.QueryModel.MainFromClause;
var isGeneratedNameOuter = fromClause.HasGeneratedItemName();
var outerItemName = fromClause.ItemName;
CopyFromClauseData(innerMainFromClause, fromClause);
if (innerMainFromClause.HasGeneratedItemName() &&
!isGeneratedNameOuter)
{
fromClause.ItemName = outerItemName;
}
var innerSelectorMapping = new QuerySourceMapping();
innerSelectorMapping.AddMapping(fromClause, subQueryExpression.QueryModel.SelectClause.Selector);
queryModel.TransformExpressions(
ex => ReferenceReplacingExpressionVisitor
.ReplaceClauseReferences(ex, innerSelectorMapping, false));
InsertBodyClauses(subQueryExpression.QueryModel.BodyClauses, queryModel, destinationIndex);
foreach (var resultOperator in subQueryModel.ResultOperators.Reverse())
{
queryModel.ResultOperators.Insert(0, resultOperator);
}
var innerBodyClauseMapping = new QuerySourceMapping();
innerBodyClauseMapping
.AddMapping(innerMainFromClause, new QuerySourceReferenceExpression(fromClause));
queryModel.TransformExpressions(ex =>
ReferenceReplacingExpressionVisitor.ReplaceClauseReferences(ex, innerBodyClauseMapping, false));
foreach (var queryAnnotation
in _queryAnnotations
.Where(qa => qa.QuerySource == subQueryExpression.QueryModel.MainFromClause))
{
queryAnnotation.QuerySource = fromClause;
queryAnnotation.QueryModel = queryModel;
}
}
}
private static Result CreateResult(FromClauseBase fromClause, QueryParts parts)
{
var ce = fromClause.FromExpression as ConstantExpression;
if (ce != null)
{
var type = ce.Value.GetType();
if (type.IsQueryable())
{
return(CreateResult(fromClause.ItemName, type.GetGenericArguments()[0], fromClause, parts, true));
}
return(CreateResult(fromClause.ItemName, fromClause.ItemType, fromClause, parts, true));
}
var qsre = fromClause.FromExpression as QuerySourceReferenceExpression;
if (qsre != null)
{
if (fromClause.ItemType.IsInterface && qsre.ReferencedQuerySource.ItemType.IsGrouping())
{
var mfc = qsre.ReferencedQuerySource as MainFromClause;
if (mfc != null)
{
var sq = mfc.FromExpression as SubQueryExpression;
if (sq != null)
{
var smf = sq.QueryModel.MainFromClause.ItemType;
if (fromClause.ItemType.IsAssignableFrom(smf))
{
return(CreateResult(fromClause.ItemName, smf, fromClause, parts, false));
}
}
}
}
return(CreateResult(fromClause.ItemName, fromClause.ItemType, fromClause, parts, true));
}
var sqe = fromClause.FromExpression as SubQueryExpression;
if (sqe != null)
{
var source = GetOriginalSource(sqe.QueryModel.MainFromClause);
//TODO: ugly hack to decide if VALUE(X) should be used or not
var simplified = fromClause is MainFromClause
? parts.TryToSimplifyMainFrom(fromClause as MainFromClause)
: fromClause is AdditionalFromClause
? parts.TryToSimplifyAdditionalFrom(fromClause as AdditionalFromClause)
: null;
if (fromClause.ItemType == source.ItemType ||
fromClause.ItemType.IsAssignableFrom(source.ItemType) ||
fromClause.ItemType.IsGrouping())
{
return(CreateResult(fromClause.ItemName, source.ItemType, fromClause, parts, source == simplified));
}
return(CreateProjector(fromClause.ItemName, fromClause, sqe, parts));
}
var nae = fromClause.FromExpression as NewArrayExpression;
if (nae != null)
{
return(CreateResult(fromClause.ItemName, fromClause.ItemType, fromClause, parts, true));
}
var me = fromClause.FromExpression as MemberExpression;
if (me != null)
{
return(CreateResult(fromClause.ItemName, fromClause.ItemType, fromClause, parts, true));
}
throw new NotImplementedException("Unknown from clause. Please provide feedback about missing feature.");
}
protected void CopyFromClauseData(FromClauseBase source, FromClauseBase destination)
{
destination.FromExpression = source.FromExpression;
destination.ItemName = source.ItemName;
destination.ItemType = source.ItemType;
}
protected void CopyFromClauseData(FromClauseBase source, FromClauseBase destination)
{
destination.FromExpression = source.FromExpression;
destination.ItemName = source.ItemName;
destination.ItemType = source.ItemType;
}
public IEnumerable <T> ExecuteCollection <T>(QueryModel queryModel)
{
var file = new SpirvFile();
file.AddHeaderStatement(Op.OpCapability, Capability.Shader);
file.AddHeaderStatement(file.GetNextResultId(), Op.OpExtInstImport, "GLSL.std.450");
file.AddHeaderStatement(Op.OpMemoryModel, AddressingModel.Logical, MemoryModel.GLSL450);
var expressionVisitor = new ShanqExpressionVisitor(file);
ResultId voidId = expressionVisitor.Visit(Expression.Constant(typeof(void)));
ResultId actionId = expressionVisitor.Visit(Expression.Constant(typeof(Action)));
ResultId entryPointerFunctionId = file.GetNextResultId();
ResultId entryPointerLabelId = file.GetNextResultId();
file.AddFunctionStatement(entryPointerFunctionId, Op.OpFunction, voidId, FunctionControl.None, actionId);
file.AddFunctionStatement(entryPointerLabelId, Op.OpLabel);
var fieldMapping = new Dictionary <FieldInfo, ResultId>();
var bindingMapping = new Dictionary <FieldInfo, Tuple <ResultId, int> >();
var builtinList = new Dictionary <FieldInfo, Tuple <ResultId, ResultId, int> >();
bool hasBuiltInOutput = false;
var resultType = typeof(T);
foreach (var field in resultType.GetFields())
{
if (field.GetCustomAttribute <LocationAttribute>() != null)
{
var pointerType = typeof(OutputPointer <>).MakeGenericType(field.FieldType);
ResultId outputPointerId = expressionVisitor.Visit(Expression.Constant(pointerType));
ResultId outputVariableId = file.GetNextResultId();
file.AddGlobalStatement(outputVariableId, Op.OpVariable, outputPointerId, StorageClass.Output);
fieldMapping.Add(field, outputVariableId);
}
hasBuiltInOutput |= field.GetCustomAttribute <BuiltInAttribute>() != null;
}
var fromClauses = new FromClauseBase[] { queryModel.MainFromClause }
.Concat(queryModel.BodyClauses.OfType <AdditionalFromClause>());
var inputTypes = new List <Type>();
var bindingTypes = new List <Type>();
foreach (var clause in fromClauses)
{
var queryable = (IShanqQueryable)((ConstantExpression)clause.FromExpression).Value;
switch (queryable.Origin)
{
case QueryableOrigin.Input:
inputTypes.Add(clause.ItemType);
break;
case QueryableOrigin.Binding:
bindingTypes.Add(clause.ItemType);
break;
}
}
foreach (var field in inputTypes.SelectMany(type => type.GetFields()))
{
if (field.GetCustomAttribute <LocationAttribute>() != null)
{
var pointerType = typeof(InputPointer <>).MakeGenericType(field.FieldType);
ResultId inputPointerId = expressionVisitor.Visit(Expression.Constant(pointerType));
ResultId inputVariableId = file.GetNextResultId();
file.AddGlobalStatement(inputVariableId, Op.OpVariable, inputPointerId, StorageClass.Input);
fieldMapping.Add(field, inputVariableId);
expressionVisitor.AddInputMapping(field, inputVariableId);
}
}
foreach (var type in bindingTypes)
{
ResultId structureTypeId = expressionVisitor.Visit(Expression.Constant(type));
var pointerType = typeof(InputPointer <>).MakeGenericType(type);
ResultId uniformPointerId = expressionVisitor.Visit(Expression.Constant(pointerType));
ResultId uniformVariableId = file.GetNextResultId();
file.AddGlobalStatement(uniformVariableId, Op.OpVariable, uniformPointerId, StorageClass.Uniform);
file.AddAnnotationStatement(Op.OpDecorate, structureTypeId, Decoration.Block);
file.AddAnnotationStatement(Op.OpDecorate, uniformVariableId, Decoration.DescriptorSet, 0);
file.AddAnnotationStatement(Op.OpDecorate, uniformVariableId, Decoration.Binding, 0);
int fieldIndex = 0;
foreach (var field in type.GetFields())
{
expressionVisitor.AddBinding(field, Tuple.Create(uniformVariableId, fieldIndex));
if (ShanqExpressionVisitor.IsMatrixType(field.FieldType))
{
//HACK Should adapt to different matrix formats
file.AddAnnotationStatement(Op.OpMemberDecorate, structureTypeId, fieldIndex, Decoration.ColMajor);
file.AddAnnotationStatement(Op.OpMemberDecorate, structureTypeId, fieldIndex, Decoration.Offset, Marshal.OffsetOf(type, field.Name).ToInt32());
file.AddAnnotationStatement(Op.OpMemberDecorate, structureTypeId, fieldIndex, Decoration.MatrixStride, 16);
}
fieldIndex++;
}
}
var entryPointParameters = fieldMapping.Select(x => x.Value).Distinct().ToList();
if (hasBuiltInOutput)
{
var builtInFields = resultType.GetFields().Select(x => new { Field = x, BuiltIn = x.GetCustomAttribute <BuiltInAttribute>()?.BuiltIn })
.Where(x => x.BuiltIn != null);
var structureType = GetTupleType(builtInFields.Count()).MakeGenericType(builtInFields.Select(x => x.Field.FieldType).ToArray());
ResultId structureTypeId = expressionVisitor.Visit(Expression.Constant(structureType));;
var structurePointerType = typeof(OutputPointer <>).MakeGenericType(structureType);
ResultId structurePointerId = expressionVisitor.Visit(Expression.Constant(structurePointerType));
ResultId outputVariableId = file.GetNextResultId();
file.AddGlobalStatement(outputVariableId, Op.OpVariable, structurePointerId, StorageClass.Output);
file.AddAnnotationStatement(Op.OpDecorate, structureTypeId, Decoration.Block);
foreach (var field in builtInFields.Select((x, y) => new { Index = y, Field = x.Field, Value = x.BuiltIn.Value }))
{
file.AddAnnotationStatement(Op.OpMemberDecorate, structureTypeId, field.Index, Decoration.BuiltIn, field.Value);
builtinList.Add(field.Field, Tuple.Create(structurePointerId, outputVariableId, field.Index));
}
entryPointParameters.Add(outputVariableId);
}
file.AddHeaderStatement(Op.OpEntryPoint, new object[] { this.model, entryPointerFunctionId, "main" }.Concat(entryPointParameters.Cast <object>()).ToArray());
if (this.model == ExecutionModel.Fragment)
{
file.AddHeaderStatement(Op.OpExecutionMode, entryPointerFunctionId, ExecutionMode.OriginUpperLeft);
}
foreach (var mapping in fieldMapping)
{
if (mapping.Key.GetCustomAttribute <LocationAttribute>() != null)
{
var attribute = mapping.Key.GetCustomAttribute <LocationAttribute>();
file.AddAnnotationStatement(Op.OpDecorate, mapping.Value, Decoration.Location, attribute.LocationIndex);
}
}
var selector = queryModel.SelectClause.Selector;
switch (selector.NodeType)
{
case ExpressionType.Constant:
foreach (var field in resultType.GetFields())
{
var fieldValue = field.GetValue(((ConstantExpression)queryModel.SelectClause.Selector).Value);
ResultId valueId = expressionVisitor.Visit(Expression.Constant(fieldValue, field.FieldType));
file.AddFunctionStatement(Op.OpStore, fieldMapping[field], valueId);
}
break;
case ExpressionType.MemberInit:
var initExpression = (MemberInitExpression)selector;
foreach (var binding in initExpression.Bindings)
{
var fieldValue = ((MemberAssignment)binding).Expression;
ResultId valueId = expressionVisitor.Visit(fieldValue);
var field = (FieldInfo)binding.Member;
if (fieldMapping.ContainsKey(field))
{
file.AddFunctionStatement(Op.OpStore, fieldMapping[field], valueId);
}
else if (builtinList.ContainsKey(field))
{
ResultId constantIndex = expressionVisitor.Visit(Expression.Constant(builtinList[field].Item3));
ResultId fieldId = file.GetNextResultId();
var fieldPointerType = typeof(OutputPointer <>).MakeGenericType(field.FieldType);
ResultId fieldPointerTypeId = expressionVisitor.Visit(Expression.Constant(fieldPointerType));
file.AddFunctionStatement(fieldId, Op.OpAccessChain, fieldPointerTypeId, builtinList[field].Item2, constantIndex);
file.AddFunctionStatement(Op.OpStore, fieldId, valueId);
}
}
break;
default:
throw new NotImplementedException();
}
file.AddFunctionStatement(Op.OpReturn);
file.AddFunctionStatement(Op.OpFunctionEnd);
int bound = file.Entries.Select(x => x.ResultId)
.Where(x => x.HasValue)
.Max(x => x.Value.Id) + 1;
var sink = new BinarySink(this.outputStream, bound);
foreach (var entry in file.Entries)
{
sink.AddStatement(entry.ResultId, entry.Statement);
}
return(Enumerable.Empty <T>());
}
protected override void FlattenSubQuery(SubQueryExpression subQueryExpression, FromClauseBase fromClause, QueryModel queryModel,
int destinationIndex)
{
var subQueryModel = subQueryExpression.QueryModel;
MoveResultOperatorsToParent(queryModel, subQueryModel);
base.FlattenSubQuery(subQueryExpression, fromClause, queryModel, destinationIndex);
}
