public RdbmsProviderCommandFactory( RdbmsProviderDefinition storageProviderDefinition, IDbCommandBuilderFactory dbCommandBuilderFactory, IRdbmsPersistenceModelProvider rdbmsPersistenceModelProvider, IObjectReaderFactory objectReaderFactory, ITableDefinitionFinder tableDefinitionFinder, IDataStoragePropertyDefinitionFactory dataStoragePropertyDefinitionFactory) { ArgumentUtility.CheckNotNull("storageProviderDefinition", storageProviderDefinition); ArgumentUtility.CheckNotNull("dbCommandBuilderFactory", dbCommandBuilderFactory); ArgumentUtility.CheckNotNull("rdbmsPersistenceModelProvider", rdbmsPersistenceModelProvider); ArgumentUtility.CheckNotNull("objectReaderFactory", objectReaderFactory); ArgumentUtility.CheckNotNull("tableDefinitionFinder", tableDefinitionFinder); ArgumentUtility.CheckNotNull("dataStoragePropertyDefinitionFactory", dataStoragePropertyDefinitionFactory); _storageProviderDefinition = storageProviderDefinition; _dbCommandBuilderFactory = dbCommandBuilderFactory; _rdbmsPersistenceModelProvider = rdbmsPersistenceModelProvider; _objectReaderFactory = objectReaderFactory; _tableDefinitionFinder = tableDefinitionFinder; _dataStoragePropertyDefinitionFactory = dataStoragePropertyDefinitionFactory; // ReSharper disable DoNotCallOverridableMethodsInConstructor _lookupCommandFactory = CreateLookupCommandFactory(); _relationLookupCommandFactory = CreateRelationLookupCommandFactory(); _saveCommandFactory = CreateSaveCommandFactory(); _queryCommandFactory = CreateQueryCommandFactory(); // ReSharper restore DoNotCallOverridableMethodsInConstructor }
public new IExecuteResult Execute(Expression query) { InitializeProviderMode(); var annotations = new SqlNodeAnnotations(); var queries = BuildQuery(query, annotations); var queryInfo = queries[queries.Length - 1]; //queryInfo.CommandText = new MySqlFormatter().Format(queryInfo.Query); IObjectReaderFactory readerFactory = null; ICompiledSubQuery[] subQueries = null; if (queryInfo.ResultShape == ResultShape.Singleton) { subQueries = CompileSubQueries(queryInfo.Query); readerFactory = GetReaderFactory(queryInfo.Query, queryInfo.ResultType); } else if (queryInfo.ResultShape == ResultShape.Sequence) { subQueries = CompileSubQueries(queryInfo.Query); readerFactory = GetReaderFactory(queryInfo.Query, TypeSystem.GetElementType(queryInfo.ResultType)); } return(ExecuteAll(query, queries, readerFactory, null, subQueries)); }
public override void SetUp() { base.SetUp(); _dbCommandBuilderFactoryStrictMock = MockRepository.GenerateStrictMock <IDbCommandBuilderFactory>(); _objectReaderFactoryStrictMock = MockRepository.GenerateStrictMock <IObjectReaderFactory>(); _dataStoragePropertyDefinitionFactoryStrictMock = MockRepository.GenerateStrictMock <IDataStoragePropertyDefinitionFactory> (); _factory = new QueryCommandFactory( _objectReaderFactoryStrictMock, _dbCommandBuilderFactoryStrictMock, _dataStoragePropertyDefinitionFactoryStrictMock); _dataContainerReader1Stub = MockRepository.GenerateStub <IObjectReader <DataContainer> >(); _resultRowReaderStub = MockRepository.GenerateStub <IObjectReader <IQueryResultRow> >(); _queryParameter1 = new QueryParameter("first", DomainObjectIDs.Order1); _queryParameter2 = new QueryParameter("second", DomainObjectIDs.Order3.Value); _queryParameter3 = new QueryParameter("third", DomainObjectIDs.Official1); var collection = new QueryParameterCollection { _queryParameter1, _queryParameter2, _queryParameter3 }; _queryStub = MockRepository.GenerateStub <IQuery>(); _queryStub.Stub(stub => stub.Statement).Return("statement"); _queryStub.Stub(stub => stub.Parameters).Return(new QueryParameterCollection(collection, true)); _property1 = ObjectIDStoragePropertyDefinitionObjectMother.Create("Test"); _property2 = SimpleStoragePropertyDefinitionObjectMother.CreateStorageProperty(); _property3 = SerializedObjectIDStoragePropertyDefinitionObjectMother.Create("Test"); }
public override void SetUp() { base.SetUp(); _rdbmsPersistenceModelProvider = new RdbmsPersistenceModelProvider(); _dbCommandBuilderFactoryStrictMock = MockRepository.GenerateStrictMock <IDbCommandBuilderFactory>(); _objectReaderFactoryStrictMock = MockRepository.GenerateStrictMock <IObjectReaderFactory>(); _dbCommandBuilderStub = MockRepository.GenerateStub <IDbCommandBuilder> (); _dataContainerReaderStub = MockRepository.GenerateStub <IObjectReader <DataContainer> > (); _objectIDReaderStub = MockRepository.GenerateStub <IObjectReader <ObjectID> > (); _fakeStorageProviderCommandFactory = MockRepository.GenerateStub <IStorageProviderCommandFactory <IRdbmsProviderCommandExecutionContext> >(); _factory = new RelationLookupCommandFactory( _fakeStorageProviderCommandFactory, _dbCommandBuilderFactoryStrictMock, _rdbmsPersistenceModelProvider, _objectReaderFactoryStrictMock); _tableDefinition = TableDefinitionObjectMother.Create(TestDomainStorageProviderDefinition, new EntityNameDefinition(null, "Table1")); _unionViewDefinition = UnionViewDefinitionObjectMother.Create( TestDomainStorageProviderDefinition, new EntityNameDefinition(null, "ViewName"), _tableDefinition); _foreignKeyValue = CreateObjectID(_tableDefinition); _foreignKeyStoragePropertyDefinitionStrictMock = MockRepository.GenerateStrictMock <IRdbmsStoragePropertyDefinition>(); _fakeComparedColumns = new[] { new ColumnValue(ColumnDefinitionObjectMother.IDColumn, _foreignKeyValue.Value) }; }
public override void SetUp() { base.SetUp(); _tableDefinitionFinder = new TableDefinitionFinder(new RdbmsPersistenceModelProvider()); _dbCommandBuilderFactoryStrictMock = MockRepository.GenerateStrictMock <IDbCommandBuilderFactory>(); _objectReaderFactoryStrictMock = MockRepository.GenerateStrictMock <IObjectReaderFactory>(); _dbCommandBuilder1Stub = MockRepository.GenerateStub <IDbCommandBuilder>(); _dbCommandBuilder2Stub = MockRepository.GenerateStub <IDbCommandBuilder>(); _timestampReader1Stub = MockRepository.GenerateStub <IObjectReader <Tuple <ObjectID, object> > > (); _timestampReader2Stub = MockRepository.GenerateStub <IObjectReader <Tuple <ObjectID, object> > > (); _dataContainerReader1Stub = MockRepository.GenerateStub <IObjectReader <DataContainer> > (); _dataContainerReader2Stub = MockRepository.GenerateStub <IObjectReader <DataContainer> > (); _factory = new LookupCommandFactory( TestDomainStorageProviderDefinition, _dbCommandBuilderFactoryStrictMock, _objectReaderFactoryStrictMock, _tableDefinitionFinder); _tableDefinition1 = TableDefinitionObjectMother.Create(TestDomainStorageProviderDefinition); _tableDefinition2 = TableDefinitionObjectMother.Create(TestDomainStorageProviderDefinition); _objectID1 = CreateObjectID(_tableDefinition1); _objectID2 = CreateObjectID(_tableDefinition1); _objectID3 = CreateObjectID(_tableDefinition2); }
public IEnumerable <T> GetResult <T>() { MetaType metaType = null; // Check the inheritance hierarchy of each mapped result row type // for the function. if (this.function != null) { foreach (MetaType mt in function.ResultRowTypes) { metaType = mt.InheritanceTypes.SingleOrDefault(it => it.Type == typeof(T)); if (metaType != null) { break; } } } if (metaType == null) { if (_readerProvider == null) { throw Error.ArgumentTypeMismatch("provider"); } metaType = _readerProvider.Services.Model.GetMetaType(typeof(T)); } IObjectReaderFactory factory = this.provider.GetDefaultFactory(metaType); IObjectReader objReader = factory.GetNextResult(this.session, false); if (objReader == null) { this.Dispose(); return(null); } return(new SingleResult <T>(new OneTimeEnumerable <T>((IEnumerator <T>)objReader), this.executeResult, _readerProvider.Services.Context)); }
internal CompiledSubQuery(QueryInfo queryInfo, IObjectReaderFactory factory, ReadOnlyCollection<Provider.NodeTypes.SqlParameter> parameters, ICompiledSubQuery[] subQueries) { this.queryInfo = queryInfo; this.factory = factory; this.parameters = parameters; this.subQueries = subQueries; }
// Methods public CompiledSubQuery(QueryInfo queryInfo, IObjectReaderFactory factory, ReadOnlyCollection <SqlParameter> parameters, ICompiledSubQuery[] subQueries) { this.queryInfo = queryInfo; this.factory = factory; this.parameters = parameters; this.subQueries = subQueries; }
internal CompiledSubQuery(QueryInfo queryInfo, IObjectReaderFactory factory, ReadOnlyCollection <Provider.NodeTypes.SqlParameter> parameters, ICompiledSubQuery[] subQueries) { this.queryInfo = queryInfo; this.factory = factory; this.parameters = parameters; this.subQueries = subQueries; }
internal AdoCompiledQuery(IReaderProvider provider, Expression query, QueryInfo[] queryInfos, IObjectReaderFactory factory, ICompiledSubQuery[] subQueries) { this.originalShape = provider.Services.Context.LoadOptions; this.query = query; this.queryInfos = queryInfos; this.factory = factory; this.subQueries = subQueries; }
internal void AddFactory(Type elementType, Type dataReaderType, object mapping, DataLoadOptions options, SqlExpression projection, IObjectReaderFactory factory) { this.list.AddFirst(new LinkedListNode<CacheInfo>(new CacheInfo(elementType, dataReaderType, mapping, options, projection, factory))); if(this.list.Count > this.maxCacheSize) { this.list.RemoveLast(); } }
// Methods internal CompiledQuery(SqlProvider provider, Expression query, QueryInfo[] queryInfos, IObjectReaderFactory factory, ICompiledSubQuery[] subQueries) { originalShape = provider.services.Context.LoadOptions; this.query = query; this.queryInfos = queryInfos; this.factory = factory; this.subQueries = subQueries; }
public CacheInfo(Type elementType, Type dataReaderType, object mapping, DataLoadOptions options, SqlExpression projection, IObjectReaderFactory factory) { this.elementType = elementType; this.dataReaderType = dataReaderType; this.options = options; this.mapping = mapping; this.projection = projection; this.factory = factory; }
internal void AddFactory(Type elementType, Type dataReaderType, object mapping, DataLoadOptions options, SqlExpression projection, IObjectReaderFactory factory) { list.AddFirst(new LinkedListNode <CacheInfo>(new CacheInfo(elementType, dataReaderType, mapping, options, projection, factory))); if (list.Count > maxCacheSize) { list.RemoveLast(); } }
// Methods internal CompiledSubQuery(QueryInfo queryInfo, IObjectReaderFactory factory, IList <SqlParameter> parameters, ICompiledSubQuery[] subQueries, string connectionString, SqlProvider provider) { this.queryInfo = queryInfo; queryInfo.CommandText = new MySqlFormatter(provider).Format(queryInfo.Query); this.factory = factory; this.parameters = parameters; this.subQueries = subQueries; this.connectionString = connectionString; }
public QueryCommandFactory( IObjectReaderFactory objectReaderFactory, IDbCommandBuilderFactory dbCommandBuilderFactory, IDataStoragePropertyDefinitionFactory dataStoragePropertyDefinitionFactory) { ArgumentUtility.CheckNotNull("objectReaderFactory", objectReaderFactory); ArgumentUtility.CheckNotNull("dbCommandBuilderFactory", dbCommandBuilderFactory); ArgumentUtility.CheckNotNull("dataStoragePropertyDefinitionFactory", dataStoragePropertyDefinitionFactory); _objectReaderFactory = objectReaderFactory; _dbCommandBuilderFactory = dbCommandBuilderFactory; _dataStoragePropertyDefinitionFactory = dataStoragePropertyDefinitionFactory; }
public LookupCommandFactory( StorageProviderDefinition storageProviderDefinition, IDbCommandBuilderFactory dbCommandBuilderFactory, IObjectReaderFactory objectReaderFactory, ITableDefinitionFinder tableDefinitionFinder) { ArgumentUtility.CheckNotNull("storageProviderDefinition", storageProviderDefinition); ArgumentUtility.CheckNotNull("dbCommandBuilderFactory", dbCommandBuilderFactory); ArgumentUtility.CheckNotNull("objectReaderFactory", objectReaderFactory); ArgumentUtility.CheckNotNull("tableDefinitionFinder", tableDefinitionFinder); _storageProviderDefinition = storageProviderDefinition; _dbCommandBuilderFactory = dbCommandBuilderFactory; _objectReaderFactory = objectReaderFactory; _tableDefinitionFinder = tableDefinitionFinder; }
public RelationLookupCommandFactory( IStorageProviderCommandFactory <IRdbmsProviderCommandExecutionContext> storageProviderCommandFactory, IDbCommandBuilderFactory dbCommandBuilderFactory, IRdbmsPersistenceModelProvider rdbmsPersistenceModelProvider, IObjectReaderFactory objectReaderFactory) { ArgumentUtility.CheckNotNull("storageProviderCommandFactory", storageProviderCommandFactory); ArgumentUtility.CheckNotNull("dbCommandBuilderFactory", dbCommandBuilderFactory); ArgumentUtility.CheckNotNull("rdbmsPersistenceModelProvider", rdbmsPersistenceModelProvider); ArgumentUtility.CheckNotNull("objectReaderFactory", objectReaderFactory); _storageProviderCommandFactory = storageProviderCommandFactory; _dbCommandBuilderFactory = dbCommandBuilderFactory; _rdbmsPersistenceModelProvider = rdbmsPersistenceModelProvider; _objectReaderFactory = objectReaderFactory; }
//private new void Initialize(IDataServices dataServices, IDbConnection connection) //{ // services = dataServices; // conManager = new SqlConnectionManager(this, (DbConnection)connection, 100); // var type = typeof(ALinq.Oracle.DataReader); // readerCompiler = new ObjectReaderCompiler(type, services); // InitializeProviderMode(); //} internal override ICompiledSubQuery CompileSubQuery(SqlNode query, Type elementType, ReadOnlyCollection <SqlParameter> parameters) { query = SqlDuplicator.Copy(query); var annotations = new SqlNodeAnnotations(); var queries = BuildQuery(ResultShape.Sequence, TypeSystem.GetSequenceType(elementType), query, parameters, annotations); var queryInfo = queries[0]; //Set CommandText queryInfo.CommandText = new OracleFormatter(this).Format(queryInfo.Query); ICompiledSubQuery[] subQueries = CompileSubQueries(queryInfo.Query); IObjectReaderFactory readerFactory = GetReaderFactory(queryInfo.Query, elementType); CheckSqlCompatibility(queries, annotations); return(new CompiledSubQuery(queryInfo, readerFactory, parameters, subQueries)); }
public IObjectReaderFactory Compile(SqlExpression expression, Type elementType) { object mapping = this.services.Context.Mapping.Identity; DataLoadOptions options = this.services.Context.LoadOptions; IObjectReaderFactory factory = null; ObjectReaderFactoryCache cache = null; bool canBeCompared = SqlProjectionComparer.CanBeCompared(expression); if (canBeCompared) { cache = (ObjectReaderFactoryCache)Thread.GetData(cacheSlot); if (cache == null) { cache = new ObjectReaderFactoryCache(maxReaderCacheSize); Thread.SetData(cacheSlot, cache); } factory = cache.GetFactory(elementType, this.dataReaderType, mapping, options, expression); } if (factory == null) { DynamicTypeGenerator gen = new DynamicTypeGenerator(this, elementType); #if DEBUG if (ObjectReaderCompiler.CaptureModule != null) { this.CompileCapturedMethod(gen, expression, elementType); } #endif DynamicMethod dm = this.CompileDynamicMethod(gen, expression, elementType); Type fnMatType = typeof(Func <,>).MakeGenericType(typeof(ObjectMaterializer <>).MakeGenericType(this.dataReaderType), elementType); var fnMaterialize = (Delegate)dm.CreateDelegate(fnMatType); Type factoryType = typeof(ObjectReaderFactory <,>).MakeGenericType(this.dataReaderType, elementType); factory = (IObjectReaderFactory)Activator.CreateInstance( factoryType, BindingFlags.Instance | BindingFlags.NonPublic, null, new object[] { fnMaterialize, gen.NamedColumns, gen.Globals, gen.Locals }, null ); if (canBeCompared) { expression = new SourceExpressionRemover().VisitExpression(expression); cache.AddFactory(elementType, this.dataReaderType, mapping, options, expression, factory); } } return(factory); }
public IObjectReaderFactory Compile(SqlExpression expression, Type elementType) { //-------------------------SOURCE CODE-------------------------- object identity = this.services.Context.Mapping.Identity; //-------------------------------------------------------------- //var bf = BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.GetProperty; //object identity = typeof(MetaModel).InvokeMember("Identity", bf, null, services.Context.Mapping, null); //-------------------------------------------------------------- DataLoadOptions loadOptions = services.Context.LoadOptions; IObjectReaderFactory factory = null; ReaderFactoryCache data = null; bool flag = SqlProjectionComparer.CanBeCompared(expression); if (flag) { data = (ReaderFactoryCache)Thread.GetData(cacheSlot); if (data == null) { data = new ReaderFactoryCache(maxReaderCacheSize); Thread.SetData(cacheSlot, data); } factory = data.GetFactory(elementType, dataReaderType, identity, loadOptions, expression); } if (factory == null) { var gen = new Generator(this, elementType); DynamicMethod method = CompileDynamicMethod(gen, expression, elementType); var t = typeof(ObjectMaterializer <>).MakeGenericType(new[] { dataReaderType }); var delegateType = typeof(Func <,>).MakeGenericType(new[] { t, elementType }); var delegate2 = method.CreateDelegate(delegateType); factory = (IObjectReaderFactory) Activator.CreateInstance(typeof(ObjectReaderFactory <,>).MakeGenericType(new[] { dataReaderType, elementType }), BindingFlags.NonPublic | BindingFlags.Instance, null, new object[] { delegate2, gen.NamedColumns, gen.Globals, gen.Locals }, null); if (flag) { expression = new SourceExpressionRemover().VisitExpression(expression); data.AddFactory(elementType, dataReaderType, identity, loadOptions, expression, factory); } } return(factory); }
internal override ICompiledSubQuery CompileSubQuery(SqlNode query, Type elementType, ReadOnlyCollection <SqlParameter> parameters) { query = SqlDuplicator.Copy(query); var annotations = new SqlNodeAnnotations(); QueryInfo[] queries = BuildQuery(ResultShape.Sequence, TypeSystem.GetSequenceType(elementType), query, parameters, annotations); QueryInfo queryInfo = queries[0]; ICompiledSubQuery[] subQueries = this.CompileSubQueries(queryInfo.Query); var formatter = new MySqlFormatter(this); for (int i = 0; i < subQueries.Length; i++) { var subQuery = (CompiledSubQuery)subQueries[i]; subQuery.QueryInfo.CommandText = formatter.Format(subQuery.QueryInfo.Query); } IObjectReaderFactory readerFactory = this.GetReaderFactory(queryInfo.Query, elementType); CheckSqlCompatibility(queries, annotations); return(new CompiledSubQuery(queryInfo, readerFactory, parameters, subQueries, connectionString, this)); }
/// <summary> /// Executes all queries /// </summary> /// <param name="query">The query.</param> /// <param name="queryInfos">The query infos.</param> /// <param name="factory">The factory.</param> /// <param name="userArguments">The user arguments.</param> /// <param name="subQueries">The sub queries.</param> /// <returns></returns> IExecuteResult IProvider.ExecuteAll(Expression query, QueryInfo[] queryInfos, IObjectReaderFactory factory, object[] userArguments, ICompiledSubQuery[] subQueries) { return this.ExecuteAll(query, queryInfos, factory, userArguments, subQueries); }
IExecuteResult IProvider.Execute(Expression query, QueryInfo queryInfo, IObjectReaderFactory factory, object[] parentArgs, object[] userArgs, ICompiledSubQuery[] subQueries, object lastResult) { return this.Execute(query, queryInfo, factory, parentArgs, userArgs, subQueries, lastResult); }
private IExecuteResult ExecuteAll(Expression query, QueryInfo[] queryInfos, IObjectReaderFactory factory, object[] userArguments, ICompiledSubQuery[] subQueries) { IExecuteResult result = null; object lastResult = null; for(int i = 0, n = queryInfos.Length; i < n; i++) { if(i < n - 1) { result = this.Execute(query, queryInfos[i], null, null, userArguments, subQueries, lastResult); } else { result = this.Execute(query, queryInfos[i], factory, null, userArguments, subQueries, lastResult); } if(queryInfos[i].ResultShape == ResultShape.Return) { lastResult = result.ReturnValue; } } return result; }
private IExecuteResult Execute(Expression query, QueryInfo queryInfo, IObjectReaderFactory factory, object[] parentArgs, object[] userArgs, ICompiledSubQuery[] subQueries, object lastResult) { this.InitializeProviderMode(); DbConnection con = _conManager.UseConnection(this); try { DbCommand cmd = con.CreateCommand(); cmd.CommandText = queryInfo.CommandText; cmd.Transaction = _conManager.Transaction; cmd.CommandTimeout = _commandTimeout; AssignParameters(cmd, queryInfo.Parameters, userArgs, lastResult); LogCommand(_log, cmd); _queryCount += 1; switch(queryInfo.ResultShape) { default: case ResultShape.Return: { return new ExecuteResult(cmd, queryInfo.Parameters, null, cmd.ExecuteNonQuery(), true); } case ResultShape.Singleton: { DbDataReader reader = cmd.ExecuteReader(); IObjectReader objReader = factory.Create(reader, true, this, parentArgs, userArgs, subQueries); _conManager.UseConnection(objReader.Session); try { IEnumerable sequence = (IEnumerable)Activator.CreateInstance( typeof(OneTimeEnumerable<>).MakeGenericType(queryInfo.ResultType), BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new object[] { objReader }, null ); object value = null; MethodCallExpression mce = query as MethodCallExpression; MethodInfo sequenceMethod = null; if(mce != null && ( mce.Method.DeclaringType == typeof(Queryable) || mce.Method.DeclaringType == typeof(Enumerable)) ) { switch(mce.Method.Name) { case "First": case "FirstOrDefault": case "SingleOrDefault": sequenceMethod = TypeSystem.FindSequenceMethod(mce.Method.Name, sequence); break; case "Single": default: sequenceMethod = TypeSystem.FindSequenceMethod("Single", sequence); break; } } else { sequenceMethod = TypeSystem.FindSequenceMethod("SingleOrDefault", sequence); } // When dynamically invoking the sequence method, we want to // return the inner exception if the invocation fails if(sequenceMethod != null) { try { value = sequenceMethod.Invoke(null, new object[] { sequence }); } catch(TargetInvocationException tie) { if(tie.InnerException != null) { throw tie.InnerException; } throw; } } return new ExecuteResult(cmd, queryInfo.Parameters, objReader.Session, value); } finally { objReader.Dispose(); } } case ResultShape.Sequence: { DbDataReader reader = cmd.ExecuteReader(); IObjectReader objReader = factory.Create(reader, true, this, parentArgs, userArgs, subQueries); _conManager.UseConnection(objReader.Session); IEnumerable sequence = (IEnumerable)Activator.CreateInstance( typeof(OneTimeEnumerable<>).MakeGenericType(TypeSystem.GetElementType(queryInfo.ResultType)), BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new object[] { objReader }, null ); if(typeof(IQueryable).IsAssignableFrom(queryInfo.ResultType)) { sequence = sequence.AsQueryable(); } ExecuteResult result = new ExecuteResult(cmd, queryInfo.Parameters, objReader.Session); MetaFunction function = this.GetFunction(query); if(function != null && !function.IsComposable) { sequence = (IEnumerable)Activator.CreateInstance( typeof(SingleResult<>).MakeGenericType(TypeSystem.GetElementType(queryInfo.ResultType)), BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new object[] { sequence, result, _services.Context }, null ); } result.ReturnValue = sequence; return result; } case ResultShape.MultipleResults: { DbDataReader reader = cmd.ExecuteReader(); IObjectReaderSession session = _readerCompiler.CreateSession(reader, this, parentArgs, userArgs, subQueries); _conManager.UseConnection(session); MetaFunction function = this.GetFunction(query); ExecuteResult result = new ExecuteResult(cmd, queryInfo.Parameters, session); result.ReturnValue = new MultipleResults(this, function, session, result); return result; } } } finally { _conManager.ReleaseConnection(this); } }
public void Register(int index, IObjectReaderFactory factory) { _factories.Add(index, factory); }
public void RegisterReaderFactory(int order, IObjectReaderFactory objectReaderFactory) { this._readerFactory.Register(order, objectReaderFactory); }
internal override IExecuteResult Execute(Expression query, QueryInfo queryInfo, IObjectReaderFactory factory, object[] parentArgs, object[] userArgs, ICompiledSubQuery[] subQueries, object lastResult) { IExecuteResult result3; InitializeProviderMode(); DbConnection connection = conManager.UseConnection(this); try { #if FREE var count = GetTabesCount(connection); Debug.Assert(count > 0); if (count > Constants.LimitedTablesCount) { throw ALinq.SqlClient.Error.TablesLimited(); } #endif DbCommand cmd = connection.CreateCommand(); cmd.CommandText = queryInfo.CommandText; cmd.Transaction = conManager.Transaction; cmd.CommandTimeout = CommandTimeout; cmd.CommandType = (queryInfo.Query is SqlStoredProcedureCall) ? CommandType.StoredProcedure : CommandType.Text; AssignParameters(cmd, queryInfo.Parameters, userArgs, lastResult); //if (queryInfo.Query is SqlStoredProcedureCall) LogCommand(Log, cmd); queryCount++; switch (queryInfo.ResultShape) { case ResultShape.Singleton: { DbDataReader reader = CreateRereader(cmd.ExecuteReader()); IObjectReader reader2 = factory.Create(reader, true, this, parentArgs, userArgs, subQueries); conManager.UseConnection(reader2.Session); try { var objType = typeof(OneTimeEnumerable <>).MakeGenericType(new[] { queryInfo.ResultType }); var bf1 = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance; var args = new object[] { reader2 }; var sequence = (IEnumerable)Activator.CreateInstance(objType, bf1, null, args, null); object obj2 = null; var expression = query as MethodCallExpression; MethodInfo info; if ((expression != null) && ((expression.Method.DeclaringType == typeof(Queryable)) || (expression.Method.DeclaringType == typeof(Enumerable)))) { string name = expression.Method.Name; if (name != null) { if ((!(name == "First") && !(name == "FirstOrDefault")) && !(name == "SingleOrDefault")) { if (name == "Single") { } } else { info = TypeSystem.FindSequenceMethod(expression.Method.Name, sequence); goto Label_01DE; } } info = TypeSystem.FindSequenceMethod("Single", sequence); } else { info = TypeSystem.FindSequenceMethod("SingleOrDefault", sequence); } Label_01DE: if (info != null) { try { obj2 = info.Invoke(null, new object[] { sequence }); } catch (TargetInvocationException exception) { if (exception.InnerException != null) { throw exception.InnerException; } throw; } } return(CreateExecuteResult(cmd, queryInfo.Parameters, reader2.Session, obj2)); } finally { reader2.Dispose(); } } case ResultShape.Sequence: break; case ResultShape.MultipleResults: { DbDataReader reader5 = CreateRereader(cmd.ExecuteReader()); IObjectReaderSession user = readerCompiler.CreateSession(reader5, this, parentArgs, userArgs, subQueries); conManager.UseConnection(user); MetaFunction function2 = GetFunction(query); var executeResult = CreateExecuteResult(cmd, queryInfo.Parameters, user); executeResult.ReturnValue = new MultipleResults(this, function2, user, executeResult); return(executeResult); } default: return(CreateExecuteResult(cmd, queryInfo.Parameters, null, cmd.ExecuteNonQuery(), true)); } DbDataReader reader3 = CreateRereader(cmd.ExecuteReader()); IObjectReader reader4 = factory.Create(reader3, true, this, parentArgs, userArgs, subQueries); conManager.UseConnection(reader4.Session); var t = typeof(OneTimeEnumerable <>).MakeGenericType(new[] { TypeSystem.GetElementType(queryInfo.ResultType) }); var flags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance; var objs = new object[] { reader4 }; var source = (IEnumerable)Activator.CreateInstance(t, flags, null, objs, null); if (typeof(IQueryable).IsAssignableFrom(queryInfo.ResultType)) { source = source.AsQueryable(); } var result = CreateExecuteResult(cmd, queryInfo.Parameters, reader4.Session); MetaFunction function = GetFunction(query); if ((function != null) && !function.IsComposable) { t = typeof(SingleResult <>).MakeGenericType(new[] { TypeSystem.GetElementType(queryInfo.ResultType) }); flags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance; objs = new object[] { source, result, services.Context }; source = (IEnumerable)Activator.CreateInstance(t, flags, null, objs, null); } result.ReturnValue = source; result3 = result; } finally { conManager.ReleaseConnection(this); } return(result3); }