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 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; }