/// <summary>
/// Actually try and process this! The count consisits of a count integer and something to increment it
/// at its current spot.
/// </summary>
/// <param name="resultOperator"></param>
/// <param name="queryModel"></param>
/// <param name="codeEnv"></param>
/// <returns></returns>
public Expression ProcessResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, IGeneratedQueryCode gc, ICodeContext cc, CompositionContainer container)
{
if (gc == null)
throw new ArgumentNullException("CodeEnv must not be null!");
var c = resultOperator as CountResultOperator;
if (c == null)
throw new ArgumentNullException("resultOperator can only be a CountResultOperator and must not be null");
//
// The accumulator where we will store the result.
//
var accumulator = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
accumulator.SetInitialValue("0");
//
// Use the Aggregate infrasturcutre to do the adding. This
// has the advantage that it will correctly combine with
// similar statements during query optimization.
//
var add = Expression.Add(accumulator, Expression.Constant((int)1));
var addResolved = ExpressionToCPP.GetExpression(add, gc, cc, container);
gc.Add(new StatementAggregate(accumulator, addResolved));
return accumulator;
}
/// <summary>
/// Implement the skipping. We have a main limitation: we currently know only how to implement integer skipping.
/// We implement with "if" statements to support composability, even if it means running longer in the end...
/// We actually return nothing when goes - we aren't really a final result the way "Count" is.
/// </summary>
/// <param name="resultOperator"></param>
/// <param name="queryModel"></param>
/// <param name="_codeEnv"></param>
/// <returns></returns>
public void ProcessResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, IGeneratedQueryCode codeEnv, ICodeContext codeContext, CompositionContainer container)
{
///
/// Quick checks to make sure
///
if (codeEnv == null)
throw new ArgumentNullException("codeEnv cannot be null");
var take = resultOperator as TakeResultOperator;
var skip = resultOperator as SkipResultOperator;
if (take == null && skip == null)
{
throw new ArgumentNullException("resultOperator must not be null and must represent either a take or a skip operation!");
}
if (take != null && take.Count.Type != typeof(int))
throw new ArgumentException("Take operator count must be an integer!");
if (skip != null && skip.Count.Type != typeof(int))
throw new ArgumentException("Skip operator count must be an integer!");
// If this is a "global" take, then we need to declare the variable a bit specially.
// Global: we have a limit on the number of objects that goes across events. We test this by seeing if this
// is a sub-query that is registered (or not).
var isGlobalTake = codeContext.IsInTopLevelQueryModel(queryModel);
// Now, we create a count variable and that is how we will tell if we are still skipping or
// taking. It must be declared in the current block, before our current code! :-)
var counter = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int), otherDependencies: codeContext.LoopIndexVariable.Return<IDeclaredParameter>());
if (isGlobalTake)
{
counter.DeclareAsStatic = true;
codeEnv.Add(counter);
} else
{
codeEnv.AddOutsideLoop(counter);
}
var comparison = StatementIfOnCount.ComparisonOperator.LessThanEqual;
IValue limit = null;
if (skip != null)
{
comparison = StatementIfOnCount.ComparisonOperator.GreaterThan;
limit = ExpressionToCPP.GetExpression(skip.Count, codeEnv, codeContext, container);
}
else
{
limit = ExpressionToCPP.GetExpression(take.Count, codeEnv, codeContext, container);
}
codeEnv.Add(new StatementIfOnCount(counter, limit, comparison));
///
/// We are particularly fortunate here. We don't have to update the Loop variable - whatever it is, is
/// still the right one! Normally we'd have to futz with the LoopVariable in code context because we
/// were iterating over something new. :-) Easy!
///
}
#pragma warning restore 649
/// <summary>
/// Process a result operator. If this result is amenable to be made into a function, then
/// do so.
/// </summary>
/// <param name="resultOperator"></param>
/// <param name="queryModel"></param>
/// <param name="index"></param>
public override void VisitResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, int index)
{
// Look for a single-result processor
var processor = _operators.FindScalarROProcessor(resultOperator.GetType());
if (processor != null)
{
var result = processor.ProcessResultOperator(resultOperator, queryModel, _codeEnv, _codeContext, MEFContainer);
if (result != null)
{
_codeEnv.SetResult(result);
_scoping.Add(_codeContext.Add(queryModel, result));
}
return;
}
// Look for a sequence processor
var collectionProcessor = _operators.FindCollectionROProcessor(resultOperator.GetType());
if (collectionProcessor != null)
{
collectionProcessor.ProcessResultOperator(resultOperator, queryModel, _codeEnv, _codeContext, MEFContainer);
_codeEnv.ResetResult();
return;
}
///
/// Uh oh - no idea how to do this!
///
throw new InvalidOperationException("LINQToTTree can't translate the operator '" + resultOperator.ToString() + "'");
}
/// <summary>
/// Visits the result operator.
/// </summary>
/// <param name="resultOperator">The result operator.</param>
/// <param name="queryModel">The query model.</param>
/// <param name="index">The index.</param>
public override void VisitResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, int index)
{
if (resultOperator is CountResultOperator)
{
this.IsCount = true;
}
else
throw new NotSupportedException(string.Format("Operator {0} is not supported.", resultOperator.GetType()));
}
internal void ProcessResultOperator(
[PexAssumeUnderTest]ROUniqueCombinations target,
ResultOperatorBase resultOperator,
QueryModel queryModel,
CodeContext cc,
[PexAssumeNotNull]GeneratedCode codeEnv
)
{
target.ProcessResultOperator(resultOperator, queryModel, codeEnv, cc, null);
}
public void SetUp ()
{
_builder = new QueryModelBuilder();
_mainFromClause = ExpressionHelper.CreateMainFromClause_Int ();
_whereClause1 = ExpressionHelper.CreateWhereClause ();
_whereClause2 = ExpressionHelper.CreateWhereClause ();
_selectClause = ExpressionHelper.CreateSelectClause ();
_resultOperator1 = ExpressionHelper.CreateResultOperator ();
_resultOperator2 = ExpressionHelper.CreateResultOperator ();
}
/// <summary>
/// Try to do a fast count. Basically, what we are dealing with here is the fact that we have
/// a simple array, we need only take its length, and return that.
/// </summary>
/// <param name="resultOperator"></param>
/// <param name="queryModel"></param>
/// <param name="_codeEnv"></param>
/// <param name="_codeContext"></param>
/// <param name="container"></param>
/// <returns></returns>
public Tuple<bool, Expression> ProcessIdentityQuery(ResultOperatorBase resultOperator, QueryModel queryModel, IGeneratedQueryCode _codeEnv, ICodeContext _codeContext, CompositionContainer container)
{
//
// We just need to return a length expression. We are low enough level we need to do some basic resolution.
//
if (!queryModel.MainFromClause.FromExpression.Type.IsArray)
return Tuple.Create(false, null as Expression);
var lengthExpr = Expression.ArrayLength(queryModel.MainFromClause.FromExpression).Resolve(_codeEnv, _codeContext, container);
return Tuple.Create(true, lengthExpr as Expression);
}
public override void VisitResultOperator (ResultOperatorBase resultOperator, QueryModel queryModel, int index)
{
ArgumentUtility.CheckNotNull ("resultOperator", resultOperator);
ArgumentUtility.CheckNotNull ("queryModel", queryModel);
var fetchRequest = resultOperator as FetchRequestBase;
if (fetchRequest != null)
{
queryModel.ResultOperators.RemoveAt (index);
_fetchQueryModelBuilders.Add (new FetchQueryModelBuilder (fetchRequest, queryModel, index));
}
}
public override void VisitResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, int index)
{
if (resultOperator is CountResultOperator)
{
// For count operators, we can remove any order-by result operators
foreach (var orderby in queryModel.BodyClauses.Where(bc => bc is OrderByClause).ToList())
{
queryModel.BodyClauses.Remove(orderby);
}
}
base.VisitResultOperator(resultOperator, queryModel, index);
}
internal Expression ProcessResultOperator(
[PexAssumeUnderTest]ROMinMax target,
ResultOperatorBase resultOperator,
QueryModel queryModel,
IGeneratedQueryCode gc,
ICodeContext cc,
CompositionContainer container
)
{
Expression result
= target.ProcessResultOperator(resultOperator, queryModel, gc, cc, container);
return result;
// TODO: add assertions to method ROMinMaxTest.ProcessResultOperator(ROMinMax, ResultOperatorBase, QueryModel, IGeneratedQueryCode, ICodeContext, CompositionContainer)
}
public override void VisitResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, int index)
{
var handler = resultOperators.GetItem(resultOperator.GetType());
if (handler != null)
{
handler.Accept(resultOperator, model);
}
else
{
model.ApplyUnsupported(resultOperator);
}
base.VisitResultOperator(resultOperator, queryModel, index);
}
public override void VisitResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, int index)
{
if (resultOperator is FirstResultOperator)
{
_queryParts.Take = 1;
return;
}
if (resultOperator is CountResultOperator || resultOperator is LongCountResultOperator)
{
_queryParts.ReturnCount = true;
return;
}
if (resultOperator is TakeResultOperator)
{
var exp = ((TakeResultOperator)resultOperator).Count;
if (exp.NodeType == ExpressionType.Constant)
{
_queryParts.Take = (int)((ConstantExpression)exp).Value;
}
else
{
throw new NotSupportedException("Currently not supporting methods or variables in the Skip or Take clause.");
}
return;
}
if (resultOperator is SkipResultOperator)
{
var exp = ((SkipResultOperator) resultOperator).Count;
if (exp.NodeType == ExpressionType.Constant)
{
_queryParts.Skip = (int)((ConstantExpression)exp).Value;
}
else
{
throw new NotSupportedException("Currently not supporting methods or variables in the Skip or Take clause.");
}
return;
}
base.VisitResultOperator(resultOperator, queryModel, index);
}
/// <summary>
/// Take the incoming stream of items, and send them along! :-)
/// </summary>
/// <param name="resultOperator"></param>
/// <param name="queryModel"></param>
/// <param name="_codeEnv"></param>
/// <param name="_codeContext"></param>
/// <param name="container"></param>
public void ProcessResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, IGeneratedQueryCode gc, ICodeContext cc, CompositionContainer container)
{
//
// Some basic checks on the input.
//
if (cc == null)
throw new ArgumentNullException("cc");
if (gc == null)
throw new ArgumentNullException("gc");
if (cc.LoopVariable == null)
throw new ArgumentNullException("No defined loop variable!");
//
// Get the indexer that is being used to access things. We will just push that onto a temp vector of int's. That will be
// a list of the items that we want to come back and look at. That said, once done we need to pop-up one level in our
// depth.
//
var arrayRecord = DeclarableParameter.CreateDeclarableParameterArrayExpression(typeof(int));
gc.AddOutsideLoop(arrayRecord);
var recordIndexStatement = new Statements.StatementRecordIndicies(ExpressionToCPP.GetExpression(cc.LoopIndexVariable.AsExpression(), gc, cc, container), arrayRecord);
gc.Add(recordIndexStatement);
gc.Pop();
//
// Now, we go down one loop and run over the pairs with a special loop.
//
var index1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var index2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var indexIterator = new Statements.StatementPairLoop(arrayRecord, index1, index2);
gc.Add(indexIterator);
//
// Finally, build the resulting loop variable. For now it is just a tuple, which is basically the formed expression we started with,
// but with the other index properties. Other bits will have to do the translation for us. :-)
//
var item1 = cc.LoopVariable.ReplaceSubExpression(cc.LoopIndexVariable.AsExpression(), index1);
var item2 = cc.LoopVariable.ReplaceSubExpression(cc.LoopIndexVariable.AsExpression(), index2);
var tupleType = typeof(Tuple<,>).MakeGenericType(cc.LoopVariable.Type, cc.LoopVariable.Type);
var newTuple = Expression.New(tupleType.GetConstructor(new Type[] { cc.LoopVariable.Type, cc.LoopVariable.Type }), item1, item2);
cc.SetLoopVariable(newTuple, null);
}
public static List<Expression> HandleContains(ResultOperatorBase resultOperator, IEnumerable values)
{
List<Expression> expressions = new List<Expression>();
if (resultOperator is ContainsResultOperator && values != null)
{
var cro = resultOperator as ContainsResultOperator;
foreach (var v in values)
{
expressions.Add(
Expression.Equal(cro.Item, Expression.Convert(Expression.Constant(v), cro.Item.Type)));
}
}
return expressions;
}
public virtual Expression HandleResultOperator(
EntityQueryModelVisitor entityQueryModelVisitor,
ResultOperatorBase resultOperator,
QueryModel queryModel)
{
Check.NotNull(entityQueryModelVisitor, nameof(entityQueryModelVisitor));
Check.NotNull(resultOperator, nameof(resultOperator));
Check.NotNull(queryModel, nameof(queryModel));
ResultHandler handler;
if (!_handlers.TryGetValue(resultOperator.GetType(), out handler))
{
throw new NotImplementedException(resultOperator.GetType().ToString());
}
return handler(entityQueryModelVisitor, resultOperator, queryModel);
}
public override void VisitResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, int index)
{
if (resultOperator is CountResultOperator || resultOperator is LongCountResultOperator)
{
// For count operators, we can remove any order-by result operators
foreach (IBodyClause orderby in queryModel.BodyClauses.Where(bc => bc is OrderByClause).ToList())
{
queryModel.BodyClauses.Remove(orderby);
}
}
if (resultOperator is CastResultOperator)
{
Array.ForEach(queryModel.ResultOperators.OfType<CastResultOperator>().ToArray(), castOperator=> queryModel.ResultOperators.Remove(castOperator));
}
base.VisitResultOperator(resultOperator, queryModel, index);
}
/// <summary>
/// We want to print the results out to a file.
/// </summary>
/// <param name="resultOperator"></param>
/// <param name="queryModel"></param>
/// <param name="_codeEnv"></param>
/// <param name="_codeContext"></param>
/// <param name="container"></param>
/// <returns></returns>
/// <remarks>
/// We can handle several types of streams here:
/// 1) a stream of double's - this is just one column.
/// 2) A stream of Tuples
/// 3) A stream of custom objects
/// </remarks>
public override Expression ProcessResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, IGeneratedQueryCode gc, ICodeContext cc, CompositionContainer container)
{
// Argument checking
var asTTree = resultOperator as AsTTreeResultOperator;
if (asTTree == null)
throw new ArgumentException("resultOperaton");
// Declare the includes.
gc.AddIncludeFile("<map>");
gc.AddIncludeFile("TSystem.h");
gc.AddIncludeFile("TFile.h");
gc.AddIncludeFile("TTree.h");
// If we were left to our own devices generating an output file, then make one up based on the tree name.
var outputFile = asTTree.OutputFile != null
? asTTree.OutputFile
: new FileInfo($"{asTTree.TreeName}.root");
// Declare the TTree and the file we will be using!
// Initialization is not important as we will over-write this directly.
var stream = DeclarableParameter.CreateDeclarableParameterExpression(typeof(OutputTTreeFileType));
stream.InitialValue = new OutputTTreeFileType(outputFile);
// Generate a real filename. We are going to key the file by the cache key. Unfortunately, at this
// point in the generation the cache key isn't known. So we have to have a 'promise' that can be used
// for later when the code is actually generated.
var outputFilePromise = GenerateUniqueFile(outputFile, cc);
// Open the file and declare the tree
gc.AddInitalizationStatement(new StatementSimpleStatement(() => $"{stream.RawValue}.first = new TFile(\"{outputFilePromise().FullName.AddCPPEscapeCharacters()}\",\"RECREATE\")", dependentVars: new string[0], resultVars: new string[] { stream.RawValue }));
gc.AddInitalizationStatement(new StatementSimpleStatement($"{stream.RawValue}.second = new TTree(\"{asTTree.TreeName}\", \"{asTTree.TreeTitle}\")", dependentVars: new string[0], resultVars: new string[] { stream.RawValue }));
// Get the list of item values we are going to need here.
List<Expression> itemValues = ExtractItemValueExpressions(queryModel);
// We are just going to print out the line with the item in it.
var itemAsValues = itemValues.Select(iv => ExpressionToCPP.GetExpression(iv, gc, cc, container)).ToArray();
var pstatement = new StatementFillTree(stream, itemAsValues.Zip(asTTree.HeaderColumns, (i, h) => Tuple.Create(i, h)).ToArray());
gc.Add(pstatement);
// The return is a file path in the C# world. But here in C++, what should be returned?
// We will use a string.
return stream;
}
public override void VisitResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, int index)
{
//Affects SQL result operators
if (resultOperator is TakeResultOperator)
{
var take = resultOperator as TakeResultOperator;
SqlStatement.Aggregate = string.Format("TOP {0} *", take.Count);
}
else if (resultOperator is AverageResultOperator)
UpdateAggregate(queryModel, "AVG");
else if (resultOperator is CountResultOperator)
SqlStatement.Aggregate = "COUNT(*)";
else if (resultOperator is LongCountResultOperator)
SqlStatement.Aggregate = "COUNT(*)";
else if (resultOperator is FirstResultOperator)
SqlStatement.Aggregate = "TOP 1 *";
else if (resultOperator is MaxResultOperator)
UpdateAggregate(queryModel, "MAX");
else if (resultOperator is MinResultOperator)
UpdateAggregate(queryModel, "MIN");
else if (resultOperator is SumResultOperator)
UpdateAggregate(queryModel, "SUM");
else if (resultOperator is DistinctResultOperator)
ProcessDistinctAggregate(queryModel);
//Not supported result operators
else if (resultOperator is ContainsResultOperator)
throw new NotSupportedException("LinqToExcel does not provide support for the Contains() method");
else if (resultOperator is DefaultIfEmptyResultOperator)
throw new NotSupportedException("LinqToExcel does not provide support for the DefaultIfEmpty() method");
else if (resultOperator is ExceptResultOperator)
throw new NotSupportedException("LinqToExcel does not provide support for the Except() method");
else if (resultOperator is GroupResultOperator)
throw new NotSupportedException("LinqToExcel does not provide support for the Group() method");
else if (resultOperator is IntersectResultOperator)
throw new NotSupportedException("LinqToExcel does not provide support for the Intersect() method");
else if (resultOperator is OfTypeResultOperator)
throw new NotSupportedException("LinqToExcel does not provide support for the OfType() method");
else if (resultOperator is SingleResultOperator)
throw new NotSupportedException("LinqToExcel does not provide support for the Single() method. Use the First() method instead");
else if (resultOperator is UnionResultOperator)
throw new NotSupportedException("LinqToExcel does not provide support for the Union() method");
base.VisitResultOperator(resultOperator, queryModel, index);
}
public void SetUp ()
{
_mockRepository = new MockRepository();
_visitorMock = _mockRepository.StrictMock<TestQueryModelVisitor>();
_bodyClauseMock1 = _mockRepository.StrictMock<IBodyClause>();
_bodyClauseMock2 = _mockRepository.StrictMock<IBodyClause>();
_ordering1 = new Ordering (ExpressionHelper.CreateExpression(), OrderingDirection.Asc);
_ordering2 = new Ordering (ExpressionHelper.CreateExpression(), OrderingDirection.Asc);
_resultOperator1 = new TestResultOperator();
_resultOperator2 = new TestResultOperator();
_queryModel = ExpressionHelper.CreateQueryModel<Cook>();
_orderByClause = ExpressionHelper.CreateOrderByClause();
_groupJoinClause = ExpressionHelper.CreateGroupJoinClause<Cook>();
}
public override void VisitResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, int index)
{
base.VisitResultOperator(resultOperator, queryModel, index);
if (resultOperator is FirstResultOperator) {
_objectExpression.Executor.Take(1);
return;
}
var takeResultOperator = resultOperator as TakeResultOperator;
if (takeResultOperator != null) {
var countConstantExpression = takeResultOperator.Count as ConstantExpression;
if (countConstantExpression != null) {
_objectExpression.Take = (int)countConstantExpression.Value;
}
return;
}
var skipResultOperator = resultOperator as SkipResultOperator;
if (skipResultOperator != null) {
var countConstantExpression = skipResultOperator.Count as ConstantExpression;
if (countConstantExpression != null)
_objectExpression.Skip = (int)countConstantExpression.Value;
return;
}
var contains = resultOperator as ContainsResultOperator;
if (contains != null)
{
var visitor = new EnigmaExpressionTreeVisitor(_objectExpression);
visitor.VisitExpression(contains.Item);
_objectExpression.Contains();
return;
}
var any = resultOperator as AnyResultOperator;
if (any != null)
{
_objectExpression.Any();
return;
}
}
public void SetUp ()
{
_mockRepository = new MockRepository();
_visitorMock = _mockRepository.StrictMock<QueryModelVisitorBase>();
_testVisitor = new TestQueryModelVisitor ();
_bodyClauseMock1 = _mockRepository.StrictMock<WhereClause> (ExpressionHelper.CreateExpression());
_bodyClauseMock2 = _mockRepository.StrictMock<WhereClause> (ExpressionHelper.CreateExpression());
_orderingMock1 = _mockRepository.StrictMock<Ordering> (ExpressionHelper.CreateExpression(), OrderingDirection.Asc);
_orderingMock2 = _mockRepository.StrictMock<Ordering> (ExpressionHelper.CreateExpression(), OrderingDirection.Asc);
_resultOperatorMock1 = _mockRepository.StrictMock<ResultOperatorBase> ();
_resultOperatorMock2 = _mockRepository.StrictMock<ResultOperatorBase> ();
_queryModel = ExpressionHelper.CreateQueryModel<Cook> ();
_orderByClause = ExpressionHelper.CreateOrderByClause ();
_groupJoinClause = ExpressionHelper.CreateGroupJoinClause<Cook> ();
}
/// <summary>
/// We want to print the results out to a file.
/// </summary>
/// <param name="resultOperator"></param>
/// <param name="queryModel"></param>
/// <param name="_codeEnv"></param>
/// <param name="_codeContext"></param>
/// <param name="container"></param>
/// <returns></returns>
/// <remarks>
/// We can handle several types of streams here:
/// 1) a stream of double's - this is just one column.
/// 2) A stream of Tuples
/// 3) A stream of custom objects
/// </remarks>
public override Expression ProcessResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, IGeneratedQueryCode gc, ICodeContext cc, CompositionContainer container)
{
// Argument checking
var asCSV = resultOperator as AsCSVResultOperator;
if (asCSV == null)
throw new ArgumentException("resultOperaton");
// Declare the includes.
gc.AddIncludeFile("<fstream>");
gc.AddIncludeFile("<iostream>");
// The output filename. How we do this is a little funny because we need the hash from the completely
// done query, which isn't ready just yet.
var outputFile = GenerateUniqueFile(asCSV.OutputFile, cc);
var stream = DeclarableParameter.CreateDeclarableParameterExpression(typeof(OutputCSVTextFileType));
stream.InitialValue = new OutputCSVTextFileType(outputFile);
var headerline = new StringBuilder();
bool first = true;
foreach (var h in asCSV.HeaderColumns)
{
if (!first)
{
headerline.Append(", ");
}
headerline.Append(h);
first = false;
}
gc.AddInitalizationStatement(new Statements.StatementSimpleStatement($"{stream.RawValue} << \"{headerline.ToString()}\" << std::endl;", dependentVars: new string[0], resultVars: new string[] { stream.RawValue }));
// Get the list of item values we are going to need here.
List<Expression> itemValues = ExtractItemValueExpressions(queryModel);
// We are just going to print out the line with the item in it.
var itemAsValues = itemValues.Select(iv => ExpressionToCPP.GetExpression(iv, gc, cc, container));
var pstatement = new StatementCSVDump(stream, itemAsValues.ToArray());
gc.Add(pstatement);
// The return is a file path in the C# world. But here in C++, what should be returned?
// We will use a string.
return stream;
}
public override void VisitResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, int index)
{
if (resultOperator is SumResultOperator)
{
queryModel.SelectClause.Selector = new NhSumExpression(queryModel.SelectClause.Selector);
queryModel.ResultOperators.Remove(resultOperator);
}
else if (resultOperator is AverageResultOperator)
{
queryModel.SelectClause.Selector = new NhAverageExpression(queryModel.SelectClause.Selector);
queryModel.ResultOperators.Remove(resultOperator);
}
else if (resultOperator is MinResultOperator)
{
queryModel.SelectClause.Selector = new NhMinExpression(queryModel.SelectClause.Selector);
queryModel.ResultOperators.Remove(resultOperator);
}
else if (resultOperator is MaxResultOperator)
{
queryModel.SelectClause.Selector = new NhMaxExpression(queryModel.SelectClause.Selector);
queryModel.ResultOperators.Remove(resultOperator);
}
else if (resultOperator is DistinctResultOperator)
{
queryModel.SelectClause.Selector = new NhDistinctExpression(queryModel.SelectClause.Selector);
queryModel.ResultOperators.Remove(resultOperator);
}
else if (resultOperator is CountResultOperator)
{
queryModel.SelectClause.Selector = new NhShortCountExpression(new NhStarExpression(queryModel.SelectClause.Selector));
queryModel.ResultOperators.Remove(resultOperator);
}
else if (resultOperator is LongCountResultOperator)
{
queryModel.SelectClause.Selector = new NhLongCountExpression(new NhStarExpression(queryModel.SelectClause.Selector));
queryModel.ResultOperators.Remove(resultOperator);
}
base.VisitResultOperator(resultOperator, queryModel, index);
}
public override void VisitResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, int index)
{
if (resultOperator is CountResultOperator || resultOperator is LongCountResultOperator)
{
// For count operators, we can remove any order-by result operators
var bodyClauses = queryModel.BodyClauses.OfType<OrderByClause>().ToList();
foreach (var orderby in bodyClauses)
{
queryModel.BodyClauses.Remove(orderby);
}
}
if (resultOperator is CastResultOperator)
{
Array.ForEach(queryModel.ResultOperators.OfType<CastResultOperator>().ToArray(), castOperator=> queryModel.ResultOperators.Remove(castOperator));
}
if (resultOperator is AnyResultOperator)
{
Array.ForEach(queryModel.ResultOperators.OfType<FetchOneRequest>().ToArray(), op => queryModel.ResultOperators.Remove(op));
Array.ForEach(queryModel.ResultOperators.OfType<FetchManyRequest>().ToArray(), op => queryModel.ResultOperators.Remove(op));
}
base.VisitResultOperator(resultOperator, queryModel, index);
}
public override Expression HandleResultOperator(EntityQueryModelVisitor entityQueryModelVisitor, ResultOperatorBase resultOperator, QueryModel queryModel)
{
if (_handlers.TryGetValue(resultOperator.GetType(), out var handler))
{
return(handler(entityQueryModelVisitor, resultOperator, queryModel));
}
return(base.HandleResultOperator(entityQueryModelVisitor, resultOperator, queryModel));
}
public override void VisitResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, int index)
{
_memberExpressionJoinDetector.Transform(resultOperator);
}
public override void VisitResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, int index)
{
_expander.Transform(resultOperator);
}
public Tuple <bool, Expression> ProcessIdentityQuery(ResultOperatorBase resultOperator, QueryModel queryModel, IGeneratedQueryCode _codeEnv, ICodeContext _codeContext, CompositionContainer container)
{
return(null);
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public override void VisitResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, int index)
{
if (resultOperator is ValueFromSequenceResultOperatorBase &&
!(resultOperator is FirstResultOperator) &&
!(resultOperator is SingleResultOperator) &&
!(resultOperator is LastResultOperator) &&
!queryModel.ResultOperators
.Any(r => r is TakeResultOperator || r is SkipResultOperator))
{
for (var i = queryModel.BodyClauses.Count - 1; i >= 0; i--)
{
if (queryModel.BodyClauses[i] is OrderByClause)
{
queryModel.BodyClauses.RemoveAt(i);
}
}
}
if (resultOperator is OfTypeResultOperator ofTypeOperator)
{
var searchedItemType = ofTypeOperator.SearchedItemType;
if (searchedItemType == queryModel.MainFromClause.ItemType)
{
queryModel.ResultOperators.RemoveAt(index);
}
else
{
var entityType = _queryCompilationContext.Model.FindEntityType(searchedItemType)
?? _queryCompilationContext.FindEntityType(queryModel.MainFromClause);
if (entityType != null)
{
var oldQuerySource = queryModel.MainFromClause;
if (((oldQuerySource.FromExpression as ConstantExpression)?.Value as IQueryable)?.Provider
is IAsyncQueryProvider entityQueryProvider)
{
queryModel.ResultOperators.RemoveAt(index);
var newMainFromClause
= new MainFromClause(
oldQuerySource.ItemName,
entityType.ClrType,
entityQueryProvider.CreateEntityQueryableExpression(entityType.ClrType));
queryModel.MainFromClause = newMainFromClause;
_queryCompilationContext.AddOrUpdateMapping(newMainFromClause, entityType);
UpdateQuerySourceMapping(
queryModel,
oldQuerySource,
new QuerySourceReferenceExpression(newMainFromClause));
}
}
}
}
ProcessSetResultOperator(resultOperator);
TryOptimizeContains(resultOperator, queryModel);
base.VisitResultOperator(resultOperator, queryModel, index);
}
/// <summary> /// This API supports the Entity Framework Core infrastructure and is not intended to be used /// directly from your code. This API may change or be removed in future releases. /// </summary> public override void VisitResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, int index) => resultOperator.TransformExpressions(TransformingVisitor.Visit);
private void ThrowNotSupported(ResultOperatorBase resultOperator)
{
throw new NotSupportedException("Result operator is not supported by the SuperOffice Linq Provider: " + resultOperator.ToString());
}
/// <inheritdoc />
public override void VisitResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, int index)
{
LogWriter.WriteLine($"VisitResultOperator: {resultOperator}, type {resultOperator.GetType().Name}");
switch (resultOperator)
{
// First()
case FirstResultOperator _:
_collector.Take = 1;
break;
// Count()
case CountResultOperator _:
case LongCountResultOperator _:
_collector.SetResultAggregationType(AggregationTypeStrict.Count);
break;
// Take()
case TakeResultOperator takeOperator:
var takeExpr = takeOperator.Count;
if (takeExpr.NodeType == ExpressionType.Constant)
{
_collector.Take = (int)((ConstantExpression)takeExpr).Value;
}
else
{
throw new NotSupportedException("Currently not supporting methods or variables in the Skip or Take clause.");
}
break;
// Skip()
case SkipResultOperator skipOperator:
var skipExpr = skipOperator.Count;
if (skipExpr.NodeType == ExpressionType.Constant)
{
_collector.Skip = (int)((ConstantExpression)skipExpr).Value;
}
else
{
throw new NotSupportedException("Currently not supporting methods or variables in the Skip or Take clause.");
}
break;
// Min()
case MinResultOperator _:
_state.SetFunction("Min", null);
break;
// Max()
case MaxResultOperator _:
_state.SetFunction("Max", null);
break;
// Average()
case AverageResultOperator _:
_state.SetFunction("Average", null);
break;
// GroupBy()
case GroupResultOperator groupOperator:
using (_state.PushCollectorMode(QueryCollectionState.GroupBy))
{
var key = groupOperator.KeySelector;
var elementSelector = groupOperator.ElementSelector;
UpdateEntitySchemaQueryExpression(key);
UpdateEntitySchemaQueryExpression(elementSelector);
if (key is NewExpression newKeySelector)
{
int position = 0;
foreach (var memberInfo in newKeySelector.Members)
{
_state.SetColumnAlias(position++, memberInfo.Name);
}
}
}
break;
}
}
/// <summary>
/// Code up the min/max result operators. We run the loop out, and then
/// we return the result whatever it is. We only work when the type is
/// something simple we can deal with!
/// </summary>
/// <param name="resultOperator"></param>
/// <param name="queryModel"></param>
/// <param name="_codeEnv"></param>
/// <param name="_codeContext"></param>
/// <param name="container"></param>
/// <returns></returns>
public Expression ProcessResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, IGeneratedQueryCode gc, ICodeContext cc, CompositionContainer container)
{
///
/// Some argument checking
///
if (cc == null)
{
throw new ArgumentNullException("cc");
}
if (gc == null)
{
throw new ArgumentNullException("gc");
}
if (gc.Depth == 1)
{
throw new ArgumentException("The Max/Min operators can't be used as result operators for a query - they can only be used in a sub-query");
}
///
/// Is it min or max?
///
var minOperator = resultOperator as MinResultOperator;
var maxOperator = resultOperator as MaxResultOperator;
if (minOperator == null && maxOperator == null)
{
throw new InvalidOperationException("Should always have min or max operator!");
}
bool doMax = maxOperator != null;
bool returnDefaultValue = false;
if (doMax)
{
returnDefaultValue = maxOperator.ReturnDefaultWhenEmpty;
}
else
{
returnDefaultValue = minOperator.ReturnDefaultWhenEmpty;
}
///
/// Next, look at the type of the current result that is running.
///
var valueExpr = queryModel.SelectClause.Selector;
if (!TimeCanBeCompared(valueExpr.Type))
{
throw new ArgumentException(string.Format("I don't know how to fix the min or max of a sequence of '{0}'s", cc.LoopVariable.Type.Name));
}
///
/// Now, declare two variables, one bool which gets set when we get the first value,
/// and the other to hold the min/max value! Note that we initalize the variable to
/// the proper type. We don't declare minmax holder - as it may end up be used
/// externally.
///
var vIsFilled = DeclarableParameter.CreateDeclarableParameterExpression(typeof(bool));
vIsFilled.InitialValue = new ValSimple("false", typeof(bool), null);
var vMaxMin = DeclarableParameter.CreateDeclarableParameterExpression(valueExpr.Type);
vMaxMin.InitialValue = new ValSimple("0", typeof(int), null);
gc.AddOutsideLoop(vIsFilled);
///
/// The expression we want to mimize or maximize
///
var exprToMinOrMaximize = ExpressionToCPP.GetExpression(valueExpr, gc, cc, container);
///
/// Now, we just have to put the x-checks in there.
///
var ifStatement = new Statements.StatementMinMaxTest(vIsFilled, vMaxMin, exprToMinOrMaximize, doMax);
gc.Add(ifStatement);
return(vMaxMin);
}
public virtual void VisitResultOperator (ResultOperatorBase resultOperator, QueryModel queryModel, int index)
{
ArgumentUtility.CheckNotNull ("resultOperator", resultOperator);
ArgumentUtility.CheckNotNull ("queryModel", queryModel);
// nothing to do here
}
public new void UpdateDataInfo(ResultOperatorBase resultOperator, SqlStatementBuilder sqlStatementBuilder, IStreamedDataInfo dataInfo)
{
base.UpdateDataInfo(resultOperator, sqlStatementBuilder, dataInfo);
}
public override void VisitResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, int index)
{
//Affects SQL result operators
if (resultOperator is TakeResultOperator)
{
var take = resultOperator as TakeResultOperator;
SqlStatement.Aggregate = string.Format("TOP {0} *", take.Count);
}
else if (resultOperator is AverageResultOperator)
{
UpdateAggregate(queryModel, "AVG");
}
else if (resultOperator is CountResultOperator)
{
SqlStatement.Aggregate = "COUNT(*)";
}
else if (resultOperator is LongCountResultOperator)
{
SqlStatement.Aggregate = "COUNT(*)";
}
else if (resultOperator is FirstResultOperator)
{
SqlStatement.Aggregate = "TOP 1 *";
}
else if (resultOperator is MaxResultOperator)
{
UpdateAggregate(queryModel, "MAX");
}
else if (resultOperator is MinResultOperator)
{
UpdateAggregate(queryModel, "MIN");
}
else if (resultOperator is SumResultOperator)
{
UpdateAggregate(queryModel, "SUM");
}
else if (resultOperator is DistinctResultOperator)
{
ProcessDistinctAggregate(queryModel);
}
//Not supported result operators
else if (resultOperator is ContainsResultOperator)
{
throw new NotSupportedException("LinqToExcel does not provide support for the Contains() method");
}
else if (resultOperator is DefaultIfEmptyResultOperator)
{
throw new NotSupportedException("LinqToExcel does not provide support for the DefaultIfEmpty() method");
}
else if (resultOperator is ExceptResultOperator)
{
throw new NotSupportedException("LinqToExcel does not provide support for the Except() method");
}
else if (resultOperator is GroupResultOperator)
{
throw new NotSupportedException("LinqToExcel does not provide support for the Group() method");
}
else if (resultOperator is IntersectResultOperator)
{
throw new NotSupportedException("LinqToExcel does not provide support for the Intersect() method");
}
else if (resultOperator is OfTypeResultOperator)
{
throw new NotSupportedException("LinqToExcel does not provide support for the OfType() method");
}
else if (resultOperator is SingleResultOperator)
{
throw new NotSupportedException("LinqToExcel does not provide support for the Single() method. Use the First() method instead");
}
else if (resultOperator is UnionResultOperator)
{
throw new NotSupportedException("LinqToExcel does not provide support for the Union() method");
}
base.VisitResultOperator(resultOperator, queryModel, index);
}
public async Task <int> StreamJson <TResult>(Stream stream, Expression expression, CancellationToken token, ResultOperatorBase op)
{
var builder = new LinqHandlerBuilder(this, _session, expression, op);
var handler = builder.BuildHandler <TResult>();
var cmd = _session.BuildCommand(handler);
using var reader = await _session.Database.ExecuteReaderAsync(cmd, token);
return(await handler.StreamJson(stream, reader, token));
}
public Task <TResult> ExecuteAsync <TResult>(Expression expression, CancellationToken token, ResultOperatorBase op)
{
var builder = new LinqHandlerBuilder(this, _session, expression, op);
var handler = builder.BuildHandler <TResult>();
return(ExecuteHandlerAsync(handler, token));
}
private Task <TResult> addItem <TDoc, TResult>(IQueryable <TDoc> queryable, ResultOperatorBase op)
{
var handler = queryable.As <MartenLinqQueryable <TDoc> >().BuildHandler <TResult>(op);
return(AddItem(handler));
}
public void Transform(ResultOperatorBase resultOperator)
{
resultOperator.TransformExpressions(VisitExpression);
}
private void AddResultOperator(ResultOperatorBase resultOperator, IFieldMapping fields)
{
switch (resultOperator)
{
case ISelectableOperator selectable:
CurrentStatement = selectable.ModifyStatement(CurrentStatement, _session);
break;
case TakeResultOperator take:
CurrentStatement.Limit = (int)take.Count.Value();
break;
case SkipResultOperator skip:
CurrentStatement.Offset = (int)skip.Count.Value();
break;
case AnyResultOperator _:
CurrentStatement.ToAny();
break;
case CountResultOperator _:
if (CurrentStatement.IsDistinct)
{
CurrentStatement.ConvertToCommonTableExpression(_session);
CurrentStatement = new CountStatement <int>(CurrentStatement);
}
else
{
CurrentStatement.ToCount <int>();
}
break;
case LongCountResultOperator _:
if (CurrentStatement.IsDistinct)
{
CurrentStatement.ConvertToCommonTableExpression(_session);
CurrentStatement = new CountStatement <long>(CurrentStatement);
}
else
{
CurrentStatement.ToCount <long>();
}
break;
case FirstResultOperator first:
CurrentStatement.Limit = 1;
CurrentStatement.SingleValue = true;
CurrentStatement.ReturnDefaultWhenEmpty = first.ReturnDefaultWhenEmpty;
CurrentStatement.CanBeMultiples = true;
break;
case SingleResultOperator single:
CurrentStatement.Limit = 2;
CurrentStatement.SingleValue = true;
CurrentStatement.ReturnDefaultWhenEmpty = single.ReturnDefaultWhenEmpty;
CurrentStatement.CanBeMultiples = false;
break;
case DistinctResultOperator _:
CurrentStatement.IsDistinct = true;
CurrentStatement.ApplySqlOperator("distinct");
break;
case AverageResultOperator _:
CurrentStatement.ApplyAggregateOperator("AVG");
break;
case SumResultOperator _:
CurrentStatement.ApplyAggregateOperator("SUM");
break;
case MinResultOperator _:
CurrentStatement.ApplyAggregateOperator("MIN");
break;
case MaxResultOperator _:
CurrentStatement.ApplyAggregateOperator("MAX");
break;
case ToJsonArrayResultOperator _:
CurrentStatement.ToJsonSelector();
break;
case LastResultOperator _:
throw new InvalidOperationException("Marten does not support Last() or LastOrDefault() queries. Please reverse the ordering and use First()/FirstOrDefault() instead");
case IncludeResultOperator includeOp:
var include = includeOp.BuildInclude(_session, fields);
_provider.AllIncludes.Add(include);
break;
default:
throw new NotSupportedException("Don't yet know how to deal with " + resultOperator);
}
}
public override void VisitResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, int index)
{
// it is not necessary to visit result ops at the moment, since we don't optimize subqueries that contain any result ops
// however, we might support some result ops in the future
resultOperator.TransformExpressions(_innerVisitor.Visit);
}
public void AddResultOperator(ResultOperatorBase resultOperator)
{
ArgumentUtility.CheckNotNull("resultOperator", resultOperator);
_resultOperators.Add(resultOperator);
}
/// <summary>
/// The AsQueriable, for us, is a no-op. We will just pass things along.
/// </summary>
/// <param name="resultOperator"></param>
/// <param name="queryModel"></param>
/// <param name="_codeEnv"></param>
/// <param name="_codeContext"></param>
/// <param name="container"></param>
public void ProcessResultOperator(ResultOperatorBase resultOperator,
QueryModel queryModel,
IGeneratedQueryCode _codeEnv, ICodeContext _codeContext, CompositionContainer container)
{
}
public override void VisitResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, int index)
{
base.VisitResultOperator(resultOperator, queryModel, index);
}
public void Transform(ResultOperatorBase resultOperator)
{
resultOperator.TransformExpressions(Visit);
}
public override void VisitResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, int index)
{
_resultOperatorAndOrderByJoinDetector.Transform(resultOperator);
}
private bool IsFirstSingleLastOrDefault(ResultOperatorBase resultOperator) => (resultOperator is FirstResultOperator first && first.ReturnDefaultWhenEmpty) ||
/// <summary>
/// 解析返回操作表达式
/// </summary>
/// <param name="resultOperator"></param>
/// <param name="queryModel"></param>
/// <param name="index"></param>
public override void VisitResultOperator( ResultOperatorBase resultOperator, QueryModel queryModel, int index )
{
if( resultOperator is SkipResultOperator )
{
SkipResultOperator @operator = resultOperator as SkipResultOperator;
this.queryPartsAggregator.LimitParts.From = @operator.GetConstantCount();
}
else if( resultOperator is TakeResultOperator )
{
TakeResultOperator @operator = resultOperator as TakeResultOperator;
this.queryPartsAggregator.LimitParts.Count = @operator.GetConstantCount();
}
else if( resultOperator is CountResultOperator || resultOperator is LongCountResultOperator )
{
this.queryPartsAggregator.SelectPart = "COUNT(*)";
}
else if( resultOperator is FirstResultOperator || resultOperator is SingleResultOperator )
{
this.queryPartsAggregator.LimitParts.From = 0;
this.queryPartsAggregator.LimitParts.Count = 1;
}
else if( resultOperator is DistinctResultOperator )
{
this.queryPartsAggregator.IsDistinct = true;
}
else
{
if( resultOperator is AverageResultOperator )
{
throw new NotSupportedException();
}
if( resultOperator is MaxResultOperator )
{
throw new NotSupportedException();
}
if( resultOperator is MinResultOperator )
{
throw new NotSupportedException();
}
if( resultOperator is SumResultOperator )
{
throw new NotSupportedException();
}
if( resultOperator is ContainsResultOperator )
{
throw new NotSupportedException();
}
if( resultOperator is DefaultIfEmptyResultOperator )
{
throw new NotSupportedException();
}
if( resultOperator is ExceptResultOperator )
{
throw new NotSupportedException();
}
if( resultOperator is GroupResultOperator )
{
throw new NotSupportedException();
}
if( resultOperator is IntersectResultOperator )
{
throw new NotSupportedException();
}
if( resultOperator is OfTypeResultOperator )
{
throw new NotSupportedException();
}
if( resultOperator is UnionResultOperator )
{
throw new NotSupportedException();
}
}
base.VisitResultOperator( resultOperator, queryModel, index );
}
/// <summary>
/// Visits the result operator.
/// </summary>
/// <param name="resultOperator">Result operator.</param>
/// <param name="queryModel">Query model.</param>
/// <param name="index">Index.</param>
public override void VisitResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, int index)
{
if (resultOperator is SkipResultOperator)
{
SkipResultOperator @operator = resultOperator as SkipResultOperator;
this.commandBuilder.LimitParts.From = @operator.GetConstantCount();
}
else if (resultOperator is TakeResultOperator)
{
TakeResultOperator @operator = resultOperator as TakeResultOperator;
this.commandBuilder.LimitParts.Count = @operator.GetConstantCount();
}
else if (resultOperator is CountResultOperator || resultOperator is LongCountResultOperator)
{
this.commandBuilder.SelectPart = "count(*)";
}
else if (resultOperator is FirstResultOperator || resultOperator is SingleResultOperator)
{
this.commandBuilder.LimitParts.From = 0;
this.commandBuilder.LimitParts.Count = 1;
}
else if (resultOperator is DistinctResultOperator)
{
this.commandBuilder.IsDistinct = true;
}
else
{
if (resultOperator is AverageResultOperator)
{
throw new NotSupportedException();
}
if (resultOperator is MaxResultOperator)
{
throw new NotSupportedException();
}
if (resultOperator is MinResultOperator)
{
throw new NotSupportedException();
}
if (resultOperator is SumResultOperator)
{
throw new NotSupportedException();
}
if (resultOperator is ContainsResultOperator)
{
throw new NotSupportedException();
}
if (resultOperator is DefaultIfEmptyResultOperator)
{
throw new NotSupportedException();
}
if (resultOperator is ExceptResultOperator)
{
throw new NotSupportedException();
}
if (resultOperator is GroupResultOperator)
{
throw new NotSupportedException();
}
if (resultOperator is IntersectResultOperator)
{
throw new NotSupportedException();
}
if (resultOperator is OfTypeResultOperator)
{
throw new NotSupportedException();
}
if (resultOperator is UnionResultOperator)
{
throw new NotSupportedException();
}
}
}
public override void VisitResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, int index)
{
QueryParts.AddResultOperator(resultOperator);
base.VisitResultOperator(resultOperator, queryModel, index);
}
/// <summary>
/// Visits the result operator.
/// </summary>
/// <param name="resultOperator">The result operator.</param>
/// <param name="queryModel">The query model.</param>
/// <param name="index">The index.</param>
/// <remarks></remarks>
public override void VisitResultOperator(ResultOperatorBase resultOperator, Remotion.Linq.QueryModel queryModel, int index)
{
if (typeof(CountResultOperator).IsAssignableFrom(resultOperator.GetType()))
{
//_queryDescription.SetResultFilterClause(queryModel.MainFromClause.ItemType, ResultFilterType.Count, 0);
_queryDescription.AddResultFilter(queryModel.MainFromClause.ItemType, ResultFilterType.Count, 0);
}
if (typeof(SingleResultOperator).IsAssignableFrom(resultOperator.GetType()))
{
var op = resultOperator as SingleResultOperator;
var filter = op.ReturnDefaultWhenEmpty ? ResultFilterType.SingleOrDefault : ResultFilterType.Single;
//_queryDescription.SetResultFilterClause(queryModel.MainFromClause.ItemType, filter, 0);
_queryDescription.AddResultFilter(queryModel.MainFromClause.ItemType, filter, 0);
}
if (typeof(TakeResultOperator).IsAssignableFrom(resultOperator.GetType()))
{
var firstResultOperator = resultOperator as TakeResultOperator;
var countExpression = firstResultOperator.Count as ConstantExpression;
var count = Convert.ToInt32(countExpression.Value);
//_queryDescription.SetTakeResultFilter(queryModel.MainFromClause.ItemType, count);
_queryDescription.AddTakeResultFilter(queryModel.MainFromClause.ItemType, count);
}
var skipResultOp = resultOperator as SkipResultOperator;
if (skipResultOp != null)
{
var countExpression = skipResultOp.Count as ConstantExpression;
var count = Convert.ToInt32(countExpression.Value);
//_queryDescription.SetSkipResultFilter(queryModel.MainFromClause.ItemType, count);
_queryDescription.AddSkipResultFilter(queryModel.MainFromClause.ItemType, count);
}
if (resultOperator is AnyResultOperator)
{
//_queryDescription.SetResultFilterClause(queryModel.MainFromClause.ItemType, ResultFilterType.Any, 0);
_queryDescription.AddResultFilter(queryModel.MainFromClause.ItemType, ResultFilterType.Any, 0);
}
var allResultOp = resultOperator as AllResultOperator;
if (allResultOp != null)
{
var criteriaExpression = this.GetCriteriaExpression(queryModel, allResultOp.Predicate);
_queryDescription.SetCriteria(criteriaExpression);
//_queryDescription.SetResultFilterClause(queryModel.MainFromClause.ItemType, ResultFilterType.All, 0);
_queryDescription.AddResultFilter(queryModel.MainFromClause.ItemType, ResultFilterType.All, 0);
}
var firstResultOp = resultOperator as FirstResultOperator;
if (firstResultOp != null)
{
//this._queryDescription.SetResultFilterClause(
// queryModel.MainFromClause.ItemType,
// firstResultOp.ReturnDefaultWhenEmpty ? ResultFilterType.FirstOrDefault : ResultFilterType.First,
// 0);
this._queryDescription.AddResultFilter(
queryModel.MainFromClause.ItemType,
firstResultOp.ReturnDefaultWhenEmpty ? ResultFilterType.FirstOrDefault : ResultFilterType.First,
0);
}
var lastResultOp = resultOperator as LastResultOperator;
if (lastResultOp != null)
{
this._queryDescription.AddResultFilter(
queryModel.MainFromClause.ItemType,
lastResultOp.ReturnDefaultWhenEmpty ? ResultFilterType.LastOrDefault : ResultFilterType.Last,
0);
}
base.VisitResultOperator(resultOperator, queryModel, index);
}
public override void VisitResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, int index)
{
if ((resultOperator is TakeResultOperator))
{
var takeResultOperator = resultOperator as TakeResultOperator;
_queryPartsAggregator.AddLimitPart(" LIMIT {0}",
Convert.ToInt32(GetN1QlExpression(takeResultOperator.Count)));
}
else if (resultOperator is SkipResultOperator)
{
var skipResultOperator = resultOperator as SkipResultOperator;
_queryPartsAggregator.AddOffsetPart(" OFFSET {0}",
Convert.ToInt32(GetN1QlExpression(skipResultOperator.Count)));
}
else if (resultOperator is DistinctResultOperator)
{
var distinctResultOperator = resultOperator as DistinctResultOperator;
_queryPartsAggregator.AddDistinctPart("DISTINCT ");
}
else if (resultOperator is ExplainResultOperator)
{
_queryPartsAggregator.ExplainPart = "EXPLAIN ";
}
else if (resultOperator is AnyResultOperator)
{
_queryPartsAggregator.QueryType = _isSubQuery ? N1QlQueryType.Any : N1QlQueryType.AnyMainQuery;
}
else if (resultOperator is AllResultOperator)
{
var allResultOperator = (AllResultOperator) resultOperator;
_queryPartsAggregator.WhereAllPart = GetN1QlExpression(allResultOperator.Predicate);
_queryPartsAggregator.QueryType = _isSubQuery ? N1QlQueryType.All : N1QlQueryType.AllMainQuery;
}
base.VisitResultOperator(resultOperator, queryModel, index);
}
/// <summary>
/// Recalculates <see cref="SqlStatementBuilder.DataInfo"/> based on the <paramref name="resultOperator"/> and the
/// previous <paramref name="dataInfo"/>.
/// </summary>
protected void UpdateDataInfo(ResultOperatorBase resultOperator, SqlStatementBuilder sqlStatementBuilder, IStreamedDataInfo dataInfo)
{
sqlStatementBuilder.DataInfo = resultOperator.GetOutputDataInfo(dataInfo);
}
