Ejemplo n.º 1
0
 protected BatchExpression UpdateBatch(BatchExpression batch, Expression input, LambdaExpression operation, Expression batchSize, Expression stream)
 {
     if (input != batch.Input || operation != batch.Operation || batchSize != batch.BatchSize || stream != batch.Stream)
     {
         return(new BatchExpression(input, operation, batchSize, stream));
     }
     return(batch);
 }
Ejemplo n.º 2
0
        protected virtual Expression VisitBatch(BatchExpression batch)
        {
            var operation = (LambdaExpression)this.Visit(batch.Operation);
            var batchSize = this.Visit(batch.BatchSize);
            var stream    = this.Visit(batch.Stream);

            return(this.UpdateBatch(batch, batch.Input, operation, batchSize, stream));
        }
Ejemplo n.º 3
0
 protected override Expression VisitBatch(BatchExpression batch)
 {
     if (this.linguist.Language.AllowsMultipleCommands || !IsMultipleCommands(batch.Operation.Body as CommandExpression))
     {
         return(this.BuildExecuteBatch(batch));
     }
     else
     {
         var source = this.Visit(batch.Input);
         var op     = this.Visit(batch.Operation.Body);
         var fn     = Expression.Lambda(op, batch.Operation.Parameters[1]);
         return(Expression.Call(typeof(ExecutionBuilder), nameof(ExecutionBuilder.Batch), new Type[] { TypeHelper.GetElementType(source.Type), batch.Operation.Body.Type }, source, fn, batch.Stream));
     }
 }
Ejemplo n.º 4
0
        protected virtual Expression BuildExecuteBatch(BatchExpression batch)
        {
            // parameterize query
            Expression operation = this.Parameterize(batch.Operation.Body);

            string       commandText = this.linguist.Format(operation);
            var          namedValues = NamedValueGatherer.Gather(operation);
            QueryCommand command     = new QueryCommand(commandText, namedValues.Select(v => new QueryParameter(v.Name, v.Type, v.QueryType)));

            Expression[] values = namedValues.Select(v => Expression.Convert(this.Visit(v.Value), typeof(object))).ToArray();

            Expression paramSets = Expression.Call(typeof(Enumerable), nameof(Enumerable.Select), new Type[] { batch.Operation.Parameters[1].Type, typeof(object[]) },
                                                   batch.Input,
                                                   Expression.Lambda(Expression.NewArrayInit(typeof(object), values), new[] { batch.Operation.Parameters[1] })
                                                   );

            Expression plan = null;

            ProjectionExpression projection = ProjectionFinder.FindProjection(operation);

            if (projection != null)
            {
                var saveScope = this.scope;
                this.scope = new Scope(this.scope, projection.Select.Alias, projection.Select.Columns);
                this.scope = saveScope;

                var entity = EntityFinder.Find(projection.Projector);
                command = new QueryCommand(command.CommandText, command.Parameters);

                plan = Expression.Call(this.executor, nameof(QueryExecutor.ExecuteBatch), new Type[] { projection.Projector.Type },
                                       Expression.Constant(command),
                                       paramSets,
                                       batch.BatchSize,
                                       batch.Stream
                                       );
            }
            else
            {
                plan = Expression.Call(this.executor, nameof(QueryExecutor.ExecuteBatch), null,
                                       Expression.Constant(command),
                                       paramSets,
                                       batch.BatchSize,
                                       batch.Stream
                                       );
            }

            return(plan);
        }
Ejemplo n.º 5
0
 protected virtual Expression VisitBatch(BatchExpression batch)
 {
     this.Write("Batch(");
     this.WriteLine(Indentation.Inner);
     this.Visit(batch.Input);
     this.Write(",");
     this.WriteLine(Indentation.Same);
     this.Visit(batch.Operation);
     this.Write(",");
     this.WriteLine(Indentation.Same);
     this.Visit(batch.BatchSize);
     this.Write(", ");
     this.Visit(batch.Stream);
     this.WriteLine(Indentation.Outer);
     this.Write(")");
     return(batch);
 }
Ejemplo n.º 6
0
 protected virtual bool CompareBatch(BatchExpression x, BatchExpression y)
 {
     return(this.Compare(x.Input, y.Input) && this.Compare(x.Operation, y.Operation) &&
            this.Compare(x.BatchSize, y.BatchSize) && this.Compare(x.Stream, y.Stream));
 }