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 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 override SqlExpression VisitClientQuery(SqlClientQuery cq)
{
Type clientElementType = cq.Query.NodeType == SqlNodeType.Multiset ? TypeSystem.GetElementType(cq.ClrType) : cq.ClrType;
ICompiledSubQuery c = this.provider.CompileSubQuery(cq.Query.Select, clientElementType, cq.Parameters.AsReadOnly());
cq.Ordinal = this.subQueries.Count;
this.subQueries.Add(c);
return(cq);
}
internal override SqlExpression VisitClientQuery(SqlClientQuery cq)
{
Type elementType = (cq.Query.NodeType == SqlNodeType.Multiset)
? TypeSystem.GetElementType(cq.ClrType)
: cq.ClrType;
ICompiledSubQuery item = provider.CompileSubQuery(cq.Query.Select,
elementType, new ReadOnlyCollection <SqlParameter>(cq.Parameters));
cq.Ordinal = subQueries.Count;
subQueries.Add(item);
return(cq);
}
public override IEnumerable ExecuteSubQuery(int iSubQuery, object[] parentArgs)
{
if (session.ParentArguments != null)
{
int length = session.ParentArguments.Length;
var destinationArray = new object[length + parentArgs.Length];
Array.Copy(session.ParentArguments, destinationArray, length);
Array.Copy(parentArgs, 0, destinationArray, length, parentArgs.Length);
parentArgs = destinationArray;
}
ICompiledSubQuery query = session.SubQueries[iSubQuery];
return((IEnumerable)query.Execute(session.Provider, parentArgs, session.UserArguments).ReturnValue);
}
public override IEnumerable ExecuteSubQuery(int iSubQuery, object[] parentArgs)
{
if (this.Session.ParentArguments != null)
{
// Create array to accumulate args, and add both parent
// args and the supplied args to the array
int nParent = this.Session.ParentArguments.Length;
object[] tmp = new object[nParent + parentArgs.Length];
Array.Copy(this.Session.ParentArguments, tmp, nParent);
Array.Copy(parentArgs, 0, tmp, nParent, parentArgs.Length);
parentArgs = tmp;
}
ICompiledSubQuery subQuery = this.Session.SubQueries[iSubQuery];
IEnumerable results = (IEnumerable)subQuery.Execute(this.Session.Provider, parentArgs, this.Session.UserArguments).ReturnValue;
return(results);
}
/// <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 IObjectReaderSession CreateSession(DbDataReader reader, IReaderProvider provider, object[] parentArgs, object[] userArgs, ICompiledSubQuery[] subQueries)
{
Type sessionType = typeof(ObjectReaderSession<>).MakeGenericType(this.dataReaderType);
return (IObjectReaderSession)Activator.CreateInstance(sessionType, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null,
new object[] { reader, provider, parentArgs, userArgs, subQueries }, null);
}
