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