public override IStreamedDataInfo GetOutputDataInfo(IStreamedDataInfo inputInfo)
{
var sequenceInfo = (StreamedSequenceInfo)inputInfo;
CheckSequenceItemType(sequenceInfo, _itemType);
return(new StreamedSequenceInfo(typeof(IQueryable <>).MakeGenericType(_itemType), new QuerySourceReferenceExpression(this)));
}
/// <summary>
/// Used
/// </summary>
/// <param name="inputInfo"></param>
/// <returns></returns>
public override IStreamedDataInfo GetOutputDataInfo(IStreamedDataInfo inputInfo)
{
//
// Build up the tuple type
//
var seqInfo = inputInfo as StreamedSequenceInfo;
if (seqInfo == null)
throw new ArgumentException("Input info is not of type StreamSequenceInfo");
var seqType = seqInfo.ItemExpression.Type;
var tupleType = typeof(Tuple<,>).MakeGenericType(seqType, seqType);
//
// Now we have to build an expression that does the transformation.
//
var newTutpleExpr = Expression.New(tupleType.GetConstructor(new Type[] { seqType, seqType }),
seqInfo.ItemExpression,
seqInfo.ItemExpression);
//
// Return the stream info
//
return new StreamedSequenceInfo(typeof(IQueryable<>).MakeGenericType(tupleType), newTutpleExpr);
}
public SqlStatement(
IStreamedDataInfo dataInfo,
Expression selectProjection,
IEnumerable <SqlTable> sqlTables,
Expression whereCondition,
Expression groupByExpression,
IEnumerable <Ordering> orderings,
Expression topExpression,
bool isDistinctQuery,
Expression rowNumberSelector,
Expression currentRowNumberOffset)
{
ArgumentUtility.CheckNotNull("dataInfo", dataInfo);
ArgumentUtility.CheckNotNull("selectProjection", selectProjection);
ArgumentUtility.CheckNotNull("sqlTables", sqlTables);
ArgumentUtility.CheckNotNull("orderings", orderings);
if (whereCondition != null && whereCondition.Type != typeof(bool))
{
throw ArgumentUtility.CreateArgumentTypeException("whereCondition", whereCondition.Type, typeof(bool));
}
_dataInfo = dataInfo;
_selectProjection = selectProjection;
_sqlTables = sqlTables.ToArray();
_orderings = orderings.ToArray();
_whereCondition = whereCondition;
_topExpression = topExpression;
_isDistinctQuery = isDistinctQuery;
_rowNumberSelector = rowNumberSelector;
_currentRowNumberOffset = currentRowNumberOffset;
_groupByExpression = groupByExpression;
}
public override IStreamedDataInfo GetOutputDataInfo(IStreamedDataInfo inputInfo)
{
var sequenceInfo = ArgumentUtility.CheckNotNullAndType <StreamedSequenceInfo> ("inputInfo", inputInfo);
CheckSequenceItemType(sequenceInfo, _itemType);
return(new StreamedSequenceInfo(typeof(IQueryable <>).MakeGenericType(_itemType), new QuerySourceReferenceExpression(this)));
}
/// <inheritdoc />
public override IStreamedDataInfo GetOutputDataInfo(IStreamedDataInfo inputInfo)
{
ArgumentUtility.CheckNotNullAndType <StreamedSequenceInfo> ("inputInfo", inputInfo);
var aggregatedType = Func.Type.GetGenericArguments()[0];
if (!aggregatedType.IsAssignableFrom(Seed.Type))
{
var message = string.Format(
"The seed expression and the aggregating function don't have matching types. The seed is of type '{0}', but the function aggregates '{1}'.",
Seed.Type,
aggregatedType);
throw new InvalidOperationException(message);
}
var resultTransformedType = OptionalResultSelector != null?OptionalResultSelector.Type.GetGenericArguments()[0] : null;
if (resultTransformedType != null && aggregatedType != resultTransformedType)
{
var message = string.Format(
"The aggregating function and the result selector don't have matching types. The function aggregates type '{0}', but the result selector "
+ "takes '{1}'.",
aggregatedType,
resultTransformedType);
throw new InvalidOperationException(message);
}
var resultType = GetResultType();
return(new StreamedScalarValueInfo(resultType));
}
/// <summary>
/// Used
/// </summary>
/// <param name="inputInfo"></param>
/// <returns></returns>
public override IStreamedDataInfo GetOutputDataInfo(IStreamedDataInfo inputInfo)
{
//
// Build up the tuple type
//
var seqInfo = inputInfo as StreamedSequenceInfo;
if (seqInfo == null)
{
throw new ArgumentException("Input info is not of type StreamSequenceInfo");
}
var seqType = seqInfo.ItemExpression.Type;
var tupleType = typeof(Tuple <,>).MakeGenericType(seqType, seqType);
//
// Now we have to build an expression that does the transformation.
//
var newTutpleExpr = Expression.New(tupleType.GetConstructor(new Type[] { seqType, seqType }),
seqInfo.ItemExpression,
seqInfo.ItemExpression);
//
// Return the stream info
//
return(new StreamedSequenceInfo(typeof(IQueryable <>).MakeGenericType(tupleType), newTutpleExpr));
}
public virtual Expression HandleResultOperator(
EntityQueryModelVisitor entityQueryModelVisitor,
IStreamedDataInfo streamedDataInfo,
ResultOperatorBase resultOperator,
QueryModel queryModel)
{
Check.NotNull(entityQueryModelVisitor, "entityQueryModelVisitor");
Check.NotNull(streamedDataInfo, "streamedDataInfo");
Check.NotNull(resultOperator, "resultOperator");
Check.NotNull(queryModel, "queryModel");
var relationalQueryModelVisitor
= (RelationalQueryModelVisitor)entityQueryModelVisitor;
var sqlSelect
= relationalQueryModelVisitor.TryGetSqlSelect(queryModel.MainFromClause);
Func <SqlSelect, ResultOperatorBase, bool> resultHandler;
if (!_resultHandlers.TryGetValue(resultOperator.GetType(), out resultHandler) ||
sqlSelect == null ||
resultHandler(sqlSelect, resultOperator))
{
return(_resultOperatorHandler
.HandleResultOperator(
entityQueryModelVisitor,
streamedDataInfo,
resultOperator,
queryModel));
}
return(null);
}
public SqlStatement (
IStreamedDataInfo dataInfo,
Expression selectProjection,
IEnumerable<SqlTable> sqlTables,
Expression whereCondition,
Expression groupByExpression,
IEnumerable<Ordering> orderings,
Expression topExpression,
bool isDistinctQuery,
Expression rowNumberSelector,
Expression currentRowNumberOffset)
{
ArgumentUtility.CheckNotNull ("dataInfo", dataInfo);
ArgumentUtility.CheckNotNull ("selectProjection", selectProjection);
ArgumentUtility.CheckNotNull ("sqlTables", sqlTables);
ArgumentUtility.CheckNotNull ("orderings", orderings);
if (whereCondition != null && whereCondition.Type != typeof (bool))
throw ArgumentUtility.CreateArgumentTypeException ("whereCondition", whereCondition.Type, typeof (bool));
_dataInfo = dataInfo;
_selectProjection = selectProjection;
_sqlTables = sqlTables.ToArray();
_orderings = orderings.ToArray();
_whereCondition = whereCondition;
_topExpression = topExpression;
_isDistinctQuery = isDistinctQuery;
_rowNumberSelector = rowNumberSelector;
_currentRowNumberOffset = currentRowNumberOffset;
_groupByExpression = groupByExpression;
}
public override IStreamedDataInfo GetOutputDataInfo(IStreamedDataInfo inputInfo)
{
var sequenceInfo = (StreamedSequenceInfo)inputInfo;
return(new StreamedSequenceInfo(
typeof(IQueryable <>).MakeGenericType(CastItemType),
GetNewItemExpression(sequenceInfo.ItemExpression)));
}
public override IStreamedDataInfo GetOutputDataInfo(IStreamedDataInfo inputInfo)
{
var sequenceInfo = ArgumentUtility.CheckNotNullAndType <StreamedSequenceInfo> ("inputInfo", inputInfo);
Type resultType = GetResultType(sequenceInfo.ResultItemType);
return(new StreamedScalarValueInfo(resultType));
}
public override IStreamedDataInfo GetOutputDataInfo(IStreamedDataInfo inputInfo)
{
var sequenceInfo = (StreamedSequenceInfo)inputInfo;
Type resultType = GetResultType(sequenceInfo.ResultItemType);
return(new StreamedScalarValueInfo(resultType));
}
public override IStreamedDataInfo GetOutputDataInfo(IStreamedDataInfo inputInfo)
{
var sequenceInfo = ArgumentUtility.CheckNotNullAndType <StreamedSequenceInfo> ("inputInfo", inputInfo);
return(new StreamedSequenceInfo(
typeof(IQueryable <>).MakeGenericType(CastItemType),
GetNewItemExpression(sequenceInfo.ItemExpression)));
}
public virtual bool Equals(IStreamedDataInfo obj)
{
var objAsLinqQueryRequestDataInfo = obj as LinqQueryRequestDataInfo;
if (objAsLinqQueryRequestDataInfo == null)
{
return false;
}
return ReturnDefaultWhenEmpty == objAsLinqQueryRequestDataInfo.ReturnDefaultWhenEmpty;
}
/// <inheritdoc />
public override IStreamedDataInfo GetOutputDataInfo(IStreamedDataInfo inputInfo)
{
var sequenceInfo = ArgumentUtility.CheckNotNullAndType <StreamedSequenceInfo> ("inputInfo", inputInfo);
var expectedItemType = GetExpectedItemType();
CheckSequenceItemType(sequenceInfo, expectedItemType);
return(new StreamedScalarValueInfo(Func.Body.Type));
}
/// <inheritdoc />
public override IStreamedDataInfo GetOutputDataInfo(IStreamedDataInfo inputInfo)
{
var sequenceInfo = (StreamedSequenceInfo)inputInfo;
var expectedItemType = GetExpectedItemType();
CheckSequenceItemType(sequenceInfo, expectedItemType);
return(new StreamedScalarValueInfo(Func.Body.Type));
}
public virtual bool Equals(IStreamedDataInfo obj)
{
if (obj == null)
return false;
if (GetType () != obj.GetType ())
return false;
var other = (StreamedValueInfo) obj;
return DataType.Equals (other.DataType);
}
public virtual bool Equals(IStreamedDataInfo obj)
{
var objAsLinqQueryRequestDataInfo = obj as LinqQueryRequestDataInfo;
if (objAsLinqQueryRequestDataInfo == null)
{
return(false);
}
return(ReturnDefaultWhenEmpty == objAsLinqQueryRequestDataInfo.ReturnDefaultWhenEmpty);
}
/// <inheritdoc />
public override IStreamedDataInfo GetOutputDataInfo(IStreamedDataInfo inputInfo)
{
if (inputInfo == null)
{
throw new ArgumentNullException(nameof(inputInfo));
}
if (!(inputInfo is StreamedSequenceInfo streamedSequenceInfo))
{
throw new ArgumentException($"{nameof(inputInfo)} must be of type {typeof(StreamedSequenceInfo)}");
}
return(GetOutputDataInfo(streamedSequenceInfo));
}
protected override Expression VisitSubQueryExpression(SubQueryExpression expression)
{
resultOperators.AddRange(
expression.QueryModel.ResultOperators
.Where(r => rewrittenTypes.Any(t => t.IsInstanceOfType(r))));
resultOperators.ForEach(f => expression.QueryModel.ResultOperators.Remove(f));
evaluationType = expression.QueryModel.SelectClause.GetOutputDataInfo();
if (expression.QueryModel.ResultOperators.Count == 0 && expression.QueryModel.BodyClauses.Count == 0)
{
return(expression.QueryModel.MainFromClause.FromExpression);
}
return(base.VisitSubQueryExpression(expression));
}
public virtual bool Equals(IStreamedDataInfo obj)
{
if (obj == null)
{
return(false);
}
if (GetType() != obj.GetType())
{
return(false);
}
var other = (StreamedValueInfo)obj;
return(DataType.Equals(other.DataType));
}
protected void AddMappingForItemExpression(ISqlPreparationContext context, IStreamedDataInfo dataInfo, Expression replacement)
{
Assertion.DebugAssert(dataInfo is StreamedSequenceInfo);
// Later ResultOperatorHandlers might have expressions that access the value streaming out from this result operator. These expressions must
// be updated to get their input expression (the ItemExpression of sqlStatement.DataInfo) from the sub-statement table we just created.
// Therefore, register an expression mapping from the ItemExpression to the new SqlTable.
// (We cannot use the sqlStatement.SelectExpression for the mapping because that expression has already been transformed and therefore will
// not compare equal to the expressions of the later result operators as long as we can only compare expressions by reference. The
// ItemExpression, on the other hand, should compare fine because it is inserted by reference into the result operators' expressions during
// the front-end's lambda resolution process.)
var itemExpressionNowInSqlTable = ((StreamedSequenceInfo)dataInfo).ItemExpression;
context.AddExpressionMapping(itemExpressionNowInSqlTable, replacement);
}
public virtual bool Equals(IStreamedDataInfo obj)
{
if (obj == null)
{
return(false);
}
if (GetType() != obj.GetType())
{
return(false);
}
var other = (StreamedSequenceInfo)obj;
return(DataType.Equals(other.DataType) && ItemExpression.Equals(other.ItemExpression));
}
protected override Expression VisitSubQueryExpression(SubQueryExpression expression)
{
this.resultOperators.AddRange(
expression.QueryModel.ResultOperators
.Where(r => rewrittenTypes.Any(t => t.IsAssignableFrom(r.GetType()))));
this.resultOperators.ForEach(f => expression.QueryModel.ResultOperators.Remove(f));
this.evaluationType = expression.QueryModel.SelectClause.GetOutputDataInfo();
if (expression.QueryModel.ResultOperators.Count == 0)
{
return(expression.QueryModel.MainFromClause.FromExpression);
}
return(base.VisitSubQueryExpression(expression));
}
public override IStreamedDataInfo GetOutputDataInfo(IStreamedDataInfo inputInfo)
{
var sequenceInfo = ArgumentUtility.CheckNotNullAndType <StreamedSequenceInfo> ("inputInfo", inputInfo);
if (!sequenceInfo.ResultItemType.GetTypeInfo().IsAssignableFrom(Item.Type.GetTypeInfo()))
{
var message = string.Format(
"The items of the input sequence of type '{0}' are not compatible with the item expression of type '{1}'.",
sequenceInfo.ResultItemType,
Item.Type);
throw new ArgumentException(message, "inputInfo");
}
return(new StreamedScalarValueInfo(typeof(bool)));
}
public override IStreamedDataInfo GetOutputDataInfo(IStreamedDataInfo inputInfo)
{
if (inputInfo == null)
{
throw new ArgumentNullException("inputInfo");
}
var sequenceInfo = inputInfo as StreamedSequenceInfo;
if (sequenceInfo == null)
{
throw new ArgumentException(string.Format("Parameter 'inputInfo' has unexpected type '{0}'.", inputInfo.GetType()));
}
return(GetOutputDataInfo(sequenceInfo));
}
public override IStreamedDataInfo GetOutputDataInfo(IStreamedDataInfo inputInfo)
{
var returnDefaultWhenEmpty = false;
var inputAsStreamedSingle = inputInfo as StreamedSingleValueInfo;
if (inputAsStreamedSingle != null)
{
// If the incoming stream is a StreamedSingleValueInfo (i.e. .First() or .Single()),
// retain the ReturnDefaultWhenEmpty property. This will cause it to be applied to
// the created LinqQueryRequest.
returnDefaultWhenEmpty = inputAsStreamedSingle.ReturnDefaultWhenEmpty;
}
return(new LinqQueryRequestDataInfo(returnDefaultWhenEmpty));
}
public override void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
{
base.VisitMainFromClause(fromClause, queryModel);
ResultOperatorExpressionRewriter rewriter = new ResultOperatorExpressionRewriter();
fromClause.TransformExpressions(rewriter.Rewrite);
if (fromClause.FromExpression.NodeType == ExpressionType.Constant)
{
System.Type expressionType = queryModel.MainFromClause.FromExpression.Type;
if (expressionType.IsGenericType && expressionType.GetGenericTypeDefinition() == typeof(NhQueryable<>))
{
queryModel.MainFromClause.ItemType = expressionType.GetGenericArguments()[0];
}
}
this.resultOperators.AddRange(rewriter.ResultOperators);
this.evaluationType = rewriter.EvaluationType;
}
public override void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
{
base.VisitMainFromClause(fromClause, queryModel);
ResultOperatorExpressionRewriter rewriter = new ResultOperatorExpressionRewriter();
fromClause.TransformExpressions(rewriter.Rewrite);
if (fromClause.FromExpression.NodeType == ExpressionType.Constant)
{
System.Type expressionType = queryModel.MainFromClause.FromExpression.Type;
if (expressionType.IsGenericType && expressionType.GetGenericTypeDefinition() == typeof(NhQueryable<>))
{
queryModel.MainFromClause.ItemType = expressionType.GetGenericArguments()[0];
}
}
this.resultOperators.AddRange(rewriter.ResultOperators);
this.evaluationType = rewriter.EvaluationType;
}
public virtual Expression HandleResultOperator(
EntityQueryModelVisitor entityQueryModelVisitor,
IStreamedDataInfo streamedDataInfo,
ResultOperatorBase resultOperator,
QueryModel queryModel)
{
Check.NotNull(entityQueryModelVisitor, "entityQueryModelVisitor");
Check.NotNull(streamedDataInfo, "streamedDataInfo");
Check.NotNull(resultOperator, "resultOperator");
Check.NotNull(queryModel, "queryModel");
return
(Expression.Call(
_executeResultOperatorMethodInfo
.MakeGenericMethod(
entityQueryModelVisitor.StreamedSequenceInfo.ResultItemType,
streamedDataInfo.DataType),
entityQueryModelVisitor.Expression,
Expression.Constant(resultOperator),
Expression.Constant(entityQueryModelVisitor.StreamedSequenceInfo)));
}
public virtual Expression HandleResultOperator(
EntityQueryModelVisitor entityQueryModelVisitor,
IStreamedDataInfo streamedDataInfo,
ResultOperatorBase resultOperator,
QueryModel queryModel)
{
Check.NotNull(entityQueryModelVisitor, "entityQueryModelVisitor");
Check.NotNull(streamedDataInfo, "streamedDataInfo");
Check.NotNull(resultOperator, "resultOperator");
Check.NotNull(queryModel, "queryModel");
Func <Expression, Type, ResultOperatorBase, Expression> asyncHandler;
if (!_asyncHandlers.TryGetValue(resultOperator.GetType(), out asyncHandler))
{
// TODO: Implement the rest...
throw new NotImplementedException();
}
return(asyncHandler(
entityQueryModelVisitor.Expression,
entityQueryModelVisitor.StreamedSequenceInfo.ResultItemType,
resultOperator));
}
public override IStreamedDataInfo GetOutputDataInfo(IStreamedDataInfo inputInfo)
{
return(new StreamedScalarValueInfo(typeof(int)));
}
public override IStreamedDataInfo GetOutputDataInfo(IStreamedDataInfo inputInfo)
{
ArgumentUtility.CheckNotNullAndType <StreamedSequenceInfo> ("inputInfo", inputInfo);
return(new StreamedScalarValueInfo(typeof(int)));
}
public override IStreamedDataInfo GetOutputDataInfo(IStreamedDataInfo inputInfo)
{
return(inputInfo);
}
public sealed override IStreamedDataInfo GetOutputDataInfo (IStreamedDataInfo inputInfo)
{
var inputSequenceInfo = ArgumentUtility.CheckNotNullAndType<StreamedSequenceInfo> ("inputInfo", inputInfo);
return GetOutputDataInfo (inputSequenceInfo);
}
/// <summary> /// Gets information about the data streamed out of this <see cref="ResultOperatorBase"/>. This contains the result type a query would have if /// it ended with this <see cref="ResultOperatorBase"/>, and it optionally includes an <see cref="StreamedSequenceInfo.ItemExpression"/> describing /// the streamed sequence's items. /// </summary> /// <param name="inputInfo">Information about the data produced by the preceding <see cref="ResultOperatorBase"/>, or the <see cref="SelectClause"/> /// of the query if no previous <see cref="ResultOperatorBase"/> exists.</param> /// <returns>Gets information about the data streamed out of this <see cref="ResultOperatorBase"/>.</returns> public abstract IStreamedDataInfo GetOutputDataInfo(IStreamedDataInfo inputInfo);
public ResultOperatorRewriterResult(IEnumerable <ResultOperatorBase> rewrittenOperators, IStreamedDataInfo evaluationType)
{
this.RewrittenOperators = rewrittenOperators;
this.EvaluationType = evaluationType;
}
public override IStreamedDataInfo GetOutputDataInfo(IStreamedDataInfo inputInfo)
{
throw new NotImplementedException();
}
protected override Expression VisitSubQueryExpression(SubQueryExpression expression)
{
this.resultOperators.AddRange(
expression.QueryModel.ResultOperators
.Where(r => rewrittenTypes.Any(t => t.IsAssignableFrom(r.GetType()))));
this.resultOperators.ForEach(f => expression.QueryModel.ResultOperators.Remove(f));
this.evaluationType = expression.QueryModel.SelectClause.GetOutputDataInfo();
if (expression.QueryModel.ResultOperators.Count == 0)
{
return expression.QueryModel.MainFromClause.FromExpression;
}
return base.VisitSubQueryExpression(expression);
}
public override IStreamedDataInfo GetOutputDataInfo (IStreamedDataInfo inputInfo)
{
var inputSequenceInfo = ArgumentUtility.CheckNotNullAndType<StreamedSequenceInfo> ("inputInfo", inputInfo);
return new StreamedSequenceInfo (typeof (IQueryable<>).MakeGenericType (inputSequenceInfo.ResultItemType), inputSequenceInfo.ItemExpression);
}
public ResultOperatorRewriterResult(IEnumerable<ResultOperatorBase> rewrittenOperators, IStreamedDataInfo evaluationType)
{
this.RewrittenOperators = rewrittenOperators;
this.EvaluationType = evaluationType;
}
protected override Expression VisitSubQueryExpression(SubQueryExpression expression)
{
resultOperators.AddRange(
expression.QueryModel.ResultOperators
.Where(r => rewrittenTypes.Any(t => t.IsInstanceOfType(r))));
resultOperators.ForEach(f => expression.QueryModel.ResultOperators.Remove(f));
evaluationType = expression.QueryModel.SelectClause.GetOutputDataInfo();
if (expression.QueryModel.ResultOperators.Count == 0 && expression.QueryModel.BodyClauses.Count == 0)
{
return expression.QueryModel.MainFromClause.FromExpression;
}
return base.VisitSubQueryExpression(expression);
}
public override IStreamedDataInfo GetOutputDataInfo (IStreamedDataInfo inputInfo)
{
var inputSequenceInfo = ArgumentUtility.CheckNotNullAndType<StreamedSequenceInfo> ("inputInfo", inputInfo);
return new StreamedSingleValueInfo (inputSequenceInfo.ItemExpression.Type, ReturnDefaultWhenEmpty);
}
public override IStreamedDataInfo GetOutputDataInfo(IStreamedDataInfo inputInfo)
{
return inputInfo;
}
