public object Execute(Expression expression)
        {
            TranslateResult result = this.Translate(expression);

            if (result.SQLCommand != null)
            {
                this.misession.Do(result.SQLCommand);
            }

            Type elementType = TypeSystem.GetElementType(expression.Type);

            IDataReader        reader       = this.readerfactory.GetReaderFor(result.TableName);
            EntityMaterializer materializer = this.entityfactory.CreateMaterializerFor(result.TableName, reader);

            if (result.Projector != null)
            {
                Delegate projector = result.Projector.Compile();

                return(Activator.CreateInstance(typeof(ProjectionReader <>).MakeGenericType(elementType),
                                                new object[] { reader, projector }));
            }
            else
            {
                return(Activator.CreateInstance(typeof(RowList <>).MakeGenericType(elementType),
                                                new object[] { reader, materializer }));
            }
        }
 public EntityQueryExecutor(DataContext context)
 {
     _context    = context;
     _connection = context.Database.Connection;
     //_transaction = transaction;
     _materializer = new EntityMaterializer(context);
 }
Beispiel #3
0
        public virtual EntityMaterializer CreateEntityMaterializer(DbTableInfo table, IList <DbColumnInfo> columns)
        {
            var matzr = new EntityMaterializer(table);

            foreach (var col in columns)
            {
                matzr.AddColumn(col);
            }
            return(matzr);
        }
        // RI: new stuff, optimized entity reader
        protected virtual Expression GetOutputTableReader(TableExpression tableExpression,
                                                          ParameterExpression dataRecordParameter, ParameterExpression sessionParameter,
                                                          TranslationContext context)
        {
            // Note: we have to create materializer each time, because column indexes in output can change from query to query
            var entMatzer   = new EntityMaterializer(tableExpression.TableInfo);
            var allColExprs = RegisterAllColumns(tableExpression, context);

            foreach (var col in allColExprs)
            {
                var colIndex = RegisterOutputValue(col, context);
                entMatzer.AddColumn(col.ColumnInfo, colIndex);
            }
            var entMatzerConst = Expression.Constant(entMatzer);
            var callReadEntity = Expression.Call(entMatzerConst, EntityMaterializer.ReadMethodInfo, dataRecordParameter, sessionParameter);
            var convExpr       = Expression.Convert(callReadEntity, tableExpression.Type);

            return(convExpr);
        }
Beispiel #5
0
 public RowEnumerator(IDataReader recordSelector, EntityMaterializer entityFactory)
 {
     this.datareader    = recordSelector;
     this.entityfactory = entityFactory;
 }
 public RowList(IMapInfoDataReader reader, EntityMaterializer factory)
 {
     this.reader        = reader;
     this.entityfactory = factory;
 }