mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
3006 lines
145 KiB
C#
3006 lines
145 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Linq.Expressions;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Reflection.Emit;
|
|
using System.Data;
|
|
using System.Data.Common;
|
|
using System.Data.Linq;
|
|
using System.Data.Linq.Mapping;
|
|
using System.Data.Linq.Provider;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Runtime.Versioning;
|
|
using System.Security;
|
|
using System.Security.Permissions;
|
|
using System.Threading;
|
|
|
|
namespace System.Data.Linq.SqlClient {
|
|
using System.Data.Linq.SqlClient.Implementation;
|
|
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Diagnostics;
|
|
#if ILGEN || DEBUG
|
|
namespace Implementation {
|
|
/// <summary>
|
|
/// Internal interface type defining the operations dynamic materialization functions need to perform when
|
|
/// materializing objects, without reflecting/invoking privates.
|
|
/// <remarks>This interface is required because our anonymously hosted materialization delegates
|
|
/// run under partial trust and cannot access non-public members of types in the fully trusted
|
|
/// framework assemblies.</remarks>
|
|
/// </summary>
|
|
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Materializer", Justification = "Spelling is correct.")]
|
|
[SuppressMessage("Microsoft.Design", "CA1012:AbstractTypesShouldNotHaveConstructors", Justification = "Unknown reason.")]
|
|
public abstract class ObjectMaterializer<TDataReader> where TDataReader : DbDataReader {
|
|
// These are public fields rather than properties for access speed
|
|
[SuppressMessage("Microsoft.Design", "CA1051:DoNotDeclareVisibleInstanceFields", Justification = "Microsoft: This is a public type that is not intended for public use.")]
|
|
public int[] Ordinals;
|
|
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Globals", Justification = "Spelling is correct.")]
|
|
[SuppressMessage("Microsoft.Design", "CA1051:DoNotDeclareVisibleInstanceFields", Justification = "Microsoft: This is a public type that is not intended for public use.")]
|
|
public object[] Globals;
|
|
[SuppressMessage("Microsoft.Design", "CA1051:DoNotDeclareVisibleInstanceFields", Justification = "Microsoft: This is a public type that is not intended for public use.")]
|
|
public object[] Locals;
|
|
[SuppressMessage("Microsoft.Design", "CA1051:DoNotDeclareVisibleInstanceFields", Justification = "Microsoft: This is a public type that is not intended for public use.")]
|
|
public object[] Arguments;
|
|
[SuppressMessage("Microsoft.Design", "CA1051:DoNotDeclareVisibleInstanceFields", Justification = "Microsoft: This is a public type that is not intended for public use.")]
|
|
public TDataReader DataReader;
|
|
[SuppressMessage("Microsoft.Design", "CA1051:DoNotDeclareVisibleInstanceFields", Justification = "Microsoft: This is a public type that is not intended for public use.")]
|
|
public DbDataReader BufferReader;
|
|
|
|
public ObjectMaterializer() {
|
|
DataReader = default(TDataReader);
|
|
}
|
|
|
|
public abstract object InsertLookup(int globalMetaType, object instance);
|
|
public abstract void SendEntityMaterialized(int globalMetaType, object instance);
|
|
public abstract IEnumerable ExecuteSubQuery(int iSubQuery, object[] args);
|
|
|
|
[SuppressMessage("Microsoft.Design", "CA1004:GenericMethodsShouldProvideTypeParameter", Justification = "Microsoft: Generic parameters are required for strong-typing of the return type.")]
|
|
public abstract IEnumerable<T> GetLinkSource<T>(int globalLink, int localFactory, object[] keyValues);
|
|
|
|
[SuppressMessage("Microsoft.Design", "CA1004:GenericMethodsShouldProvideTypeParameter", Justification = "Microsoft: Generic parameters are required for strong-typing of the return type.")]
|
|
public abstract IEnumerable<T> GetNestedLinkSource<T>(int globalLink, int localFactory, object instance);
|
|
public abstract bool Read();
|
|
public abstract bool CanDeferLoad { get; }
|
|
|
|
[SuppressMessage("Microsoft.Design", "CA1000:DoNotDeclareStaticMembersOnGenericTypes", Justification = "xiaoruda: The method has to be static because it's used in our generated code and there is no instance of the type.")]
|
|
[SuppressMessage("Microsoft.Design", "CA1004:GenericMethodsShouldProvideTypeParameter", Justification = "Microsoft: Generic parameters are required for strong-typing of the return type.")]
|
|
public static IEnumerable<TOutput> Convert<TOutput>(IEnumerable source) {
|
|
foreach (object value in source) {
|
|
yield return DBConvert.ChangeType<TOutput>(value);
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Design", "CA1000:DoNotDeclareStaticMembersOnGenericTypes", Justification = "xiaoruda: The method has to be static because it's used in our generated code and there is no instance of the type.")]
|
|
public static IGrouping<TKey, TElement> CreateGroup<TKey, TElement>(TKey key, IEnumerable<TElement> items) {
|
|
return new ObjectReaderCompiler.Group<TKey, TElement>(key, items);
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Design", "CA1000:DoNotDeclareStaticMembersOnGenericTypes", Justification = "xiaoruda: The method has to be static because it's used in our generated code and there is no instance of the type.")]
|
|
public static IOrderedEnumerable<TElement> CreateOrderedEnumerable<TElement>(IEnumerable<TElement> items) {
|
|
return new ObjectReaderCompiler.OrderedResults<TElement>(items);
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Design", "CA1000:DoNotDeclareStaticMembersOnGenericTypes", Justification = "xiaoruda: The method has to be static because it's used in our generated code and there is no instance of the type.")]
|
|
public static Exception ErrorAssignmentToNull(Type type) {
|
|
return Error.CannotAssignNull(type);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal class ObjectReaderCompiler : IObjectReaderCompiler {
|
|
Type dataReaderType;
|
|
IDataServices services;
|
|
|
|
MethodInfo miDRisDBNull;
|
|
MethodInfo miBRisDBNull;
|
|
FieldInfo readerField;
|
|
FieldInfo bufferReaderField;
|
|
|
|
FieldInfo ordinalsField;
|
|
FieldInfo globalsField;
|
|
FieldInfo argsField;
|
|
|
|
#if DEBUG
|
|
static AssemblyBuilder captureAssembly;
|
|
static ModuleBuilder captureModule;
|
|
static string captureAssemblyFilename;
|
|
static int iCaptureId;
|
|
|
|
internal static int GetNextId() {
|
|
return iCaptureId++;
|
|
}
|
|
|
|
internal static ModuleBuilder CaptureModule {
|
|
get { return captureModule; }
|
|
}
|
|
|
|
[ResourceExposure(ResourceScope.Machine)] // filename parameter later used by other methods.
|
|
internal static void StartCaptureToFile(string filename) {
|
|
if (captureAssembly == null) {
|
|
string dir = System.IO.Path.GetDirectoryName(filename);
|
|
if (dir.Length == 0) dir = null;
|
|
string name = System.IO.Path.GetFileName(filename);
|
|
AssemblyName assemblyName = new AssemblyName(System.IO.Path.GetFileNameWithoutExtension(name));
|
|
captureAssembly = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Save, dir);
|
|
captureModule = captureAssembly.DefineDynamicModule(name);
|
|
captureAssemblyFilename = filename;
|
|
}
|
|
}
|
|
|
|
[ResourceExposure(ResourceScope.None)] // Exposure is via StartCaptureToFile method.
|
|
[ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)] // Assembly.Save method call.
|
|
internal static void StopCapture() {
|
|
if (captureAssembly != null) {
|
|
captureAssembly.Save(captureAssemblyFilename);
|
|
captureAssembly = null;
|
|
}
|
|
}
|
|
|
|
internal static void SetMaxReaderCacheSize(int size) {
|
|
if (size <= 1) {
|
|
throw Error.ArgumentOutOfRange("size");
|
|
}
|
|
maxReaderCacheSize = size;
|
|
}
|
|
#endif
|
|
static LocalDataStoreSlot cacheSlot = Thread.AllocateDataSlot();
|
|
static int maxReaderCacheSize = 10;
|
|
|
|
static ObjectReaderCompiler() {
|
|
}
|
|
|
|
internal ObjectReaderCompiler(Type dataReaderType, IDataServices services) {
|
|
this.dataReaderType = dataReaderType;
|
|
this.services = services;
|
|
|
|
this.miDRisDBNull = dataReaderType.GetMethod("IsDBNull", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
|
|
this.miBRisDBNull = typeof(DbDataReader).GetMethod("IsDBNull", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
|
|
|
|
Type orbType = typeof(ObjectMaterializer<>).MakeGenericType(this.dataReaderType);
|
|
this.ordinalsField = orbType.GetField("Ordinals", BindingFlags.Instance | BindingFlags.Public);
|
|
this.globalsField = orbType.GetField("Globals", BindingFlags.Instance | BindingFlags.Public);
|
|
this.argsField = orbType.GetField("Arguments", BindingFlags.Instance | BindingFlags.Public);
|
|
this.readerField = orbType.GetField("DataReader", BindingFlags.Instance | BindingFlags.Public);
|
|
this.bufferReaderField = orbType.GetField("BufferReader", BindingFlags.Instance | BindingFlags.Public);
|
|
|
|
System.Diagnostics.Debug.Assert(
|
|
this.miDRisDBNull != null &&
|
|
this.miBRisDBNull != null &&
|
|
this.readerField != null &&
|
|
this.bufferReaderField != null &&
|
|
this.ordinalsField != null &&
|
|
this.globalsField != null &&
|
|
this.argsField != null
|
|
);
|
|
}
|
|
|
|
[ResourceExposure(ResourceScope.None)] // Consumed by Thread.AllocateDataSource result being unique.
|
|
[ResourceConsumption(ResourceScope.AppDomain, ResourceScope.AppDomain)] // Thread.GetData method call.
|
|
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
|
|
public IObjectReaderFactory Compile(SqlExpression expression, Type elementType) {
|
|
object mapping = this.services.Context.Mapping.Identity;
|
|
DataLoadOptions options = this.services.Context.LoadOptions;
|
|
IObjectReaderFactory factory = null;
|
|
ReaderFactoryCache cache = null;
|
|
bool canBeCompared = SqlProjectionComparer.CanBeCompared(expression);
|
|
if (canBeCompared) {
|
|
cache = (ReaderFactoryCache)Thread.GetData(cacheSlot);
|
|
if (cache == null) {
|
|
cache = new ReaderFactoryCache(maxReaderCacheSize);
|
|
Thread.SetData(cacheSlot, cache);
|
|
}
|
|
factory = cache.GetFactory(elementType, this.dataReaderType, mapping, options, expression);
|
|
}
|
|
if (factory == null) {
|
|
Generator gen = new Generator(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;
|
|
}
|
|
|
|
private class SourceExpressionRemover : SqlDuplicator.DuplicatingVisitor {
|
|
internal SourceExpressionRemover()
|
|
: base(true) {
|
|
}
|
|
internal override SqlNode Visit(SqlNode node) {
|
|
node = base.Visit(node);
|
|
if (node != null) {
|
|
node.ClearSourceExpression();
|
|
}
|
|
return node;
|
|
}
|
|
internal override SqlExpression VisitColumnRef(SqlColumnRef cref) {
|
|
SqlExpression result = base.VisitColumnRef(cref);
|
|
if (result != null && result == cref) {
|
|
// reference to outer scope, don't propogate references to expressions or aliases
|
|
SqlColumn col = cref.Column;
|
|
SqlColumn newcol = new SqlColumn(col.ClrType, col.SqlType, col.Name, col.MetaMember, null, col.SourceExpression);
|
|
newcol.Ordinal = col.Ordinal;
|
|
result = new SqlColumnRef(newcol);
|
|
newcol.ClearSourceExpression();
|
|
}
|
|
return result;
|
|
}
|
|
internal override SqlExpression VisitAliasRef(SqlAliasRef aref) {
|
|
SqlExpression result = base.VisitAliasRef(aref);
|
|
if (result != null && result == aref) {
|
|
// reference to outer scope, don't propogate references to expressions or aliases
|
|
SqlAlias alias = aref.Alias;
|
|
SqlAlias newalias = new SqlAlias(new SqlNop(aref.ClrType, aref.SqlType, null));
|
|
return new SqlAliasRef(newalias);
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
|
|
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);
|
|
}
|
|
|
|
#if DEBUG
|
|
private void CompileCapturedMethod(Generator gen, SqlExpression expression, Type elementType) {
|
|
TypeBuilder tb = ObjectReaderCompiler.CaptureModule.DefineType("reader_type_" + ObjectReaderCompiler.GetNextId());
|
|
MethodBuilder mb = tb.DefineMethod(
|
|
"Read_" + elementType.Name,
|
|
MethodAttributes.Static | MethodAttributes.Public,
|
|
CallingConventions.Standard,
|
|
elementType,
|
|
new Type[] { typeof(ObjectMaterializer<>).MakeGenericType(this.dataReaderType) }
|
|
);
|
|
gen.GenerateBody(mb.GetILGenerator(), (SqlExpression)SqlDuplicator.Copy(expression));
|
|
tb.CreateType();
|
|
}
|
|
#endif
|
|
|
|
private DynamicMethod CompileDynamicMethod(Generator gen, SqlExpression expression, Type elementType) {
|
|
Type objectReaderType = typeof(ObjectMaterializer<>).MakeGenericType(this.dataReaderType);
|
|
DynamicMethod dm = new DynamicMethod(
|
|
"Read_" + elementType.Name,
|
|
elementType,
|
|
new Type[] { objectReaderType },
|
|
true
|
|
);
|
|
gen.GenerateBody(dm.GetILGenerator(), expression);
|
|
return dm;
|
|
}
|
|
|
|
class ReaderFactoryCache {
|
|
int maxCacheSize;
|
|
LinkedList<CacheInfo> list;
|
|
|
|
class CacheInfo {
|
|
internal Type elementType;
|
|
internal Type dataReaderType;
|
|
internal object mapping;
|
|
internal DataLoadOptions options;
|
|
internal SqlExpression projection;
|
|
internal IObjectReaderFactory 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 ReaderFactoryCache(int maxCacheSize) {
|
|
this.maxCacheSize = maxCacheSize;
|
|
this.list = new LinkedList<CacheInfo>();
|
|
}
|
|
|
|
internal IObjectReaderFactory GetFactory(Type elementType, Type dataReaderType, object mapping, DataLoadOptions options, SqlExpression projection) {
|
|
for (LinkedListNode<CacheInfo> info = this.list.First; info != null; info = info.Next) {
|
|
if (elementType == info.Value.elementType &&
|
|
dataReaderType == info.Value.dataReaderType &&
|
|
mapping == info.Value.mapping &&
|
|
DataLoadOptions.ShapesAreEquivalent(options, info.Value.options) &&
|
|
SqlProjectionComparer.AreSimilar(projection, info.Value.projection)
|
|
) {
|
|
// move matching item to head of list to reset its lifetime
|
|
this.list.Remove(info);
|
|
this.list.AddFirst(info);
|
|
return info.Value.factory;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
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();
|
|
}
|
|
}
|
|
}
|
|
|
|
internal class SqlProjectionComparer {
|
|
[SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification = "These issues are related to our use of if-then and case statements for node types, which adds to the complexity count however when reviewed they are easy to navigate and understand.")]
|
|
internal static bool CanBeCompared(SqlExpression node) {
|
|
if (node == null) {
|
|
return true;
|
|
}
|
|
switch (node.NodeType) {
|
|
case SqlNodeType.New: {
|
|
SqlNew new1 = (SqlNew)node;
|
|
for (int i = 0, n = new1.Args.Count; i < n; i++) {
|
|
if (!CanBeCompared(new1.Args[i])) {
|
|
return false;
|
|
}
|
|
}
|
|
for (int i = 0, n = new1.Members.Count; i < n; i++) {
|
|
if (!CanBeCompared(new1.Members[i].Expression)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
case SqlNodeType.ColumnRef:
|
|
case SqlNodeType.Value:
|
|
case SqlNodeType.UserColumn:
|
|
return true;
|
|
case SqlNodeType.Link: {
|
|
SqlLink l1 = (SqlLink)node;
|
|
for (int i = 0, c = l1.KeyExpressions.Count; i < c; ++i) {
|
|
if (!CanBeCompared(l1.KeyExpressions[i])) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
case SqlNodeType.OptionalValue:
|
|
return CanBeCompared(((SqlOptionalValue)node).Value);
|
|
case SqlNodeType.ValueOf:
|
|
case SqlNodeType.OuterJoinedValue:
|
|
return CanBeCompared(((SqlUnary)node).Operand);
|
|
case SqlNodeType.Lift:
|
|
return CanBeCompared(((SqlLift)node).Expression);
|
|
case SqlNodeType.Grouping: {
|
|
SqlGrouping g1 = (SqlGrouping)node;
|
|
return CanBeCompared(g1.Key) && CanBeCompared(g1.Group);
|
|
}
|
|
case SqlNodeType.ClientArray: {
|
|
if (node.SourceExpression.NodeType != ExpressionType.NewArrayInit &&
|
|
node.SourceExpression.NodeType != ExpressionType.NewArrayBounds) {
|
|
return false;
|
|
}
|
|
SqlClientArray a1 = (SqlClientArray)node;
|
|
for (int i = 0, n = a1.Expressions.Count; i < n; i++) {
|
|
if (!CanBeCompared(a1.Expressions[i])) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
case SqlNodeType.ClientCase: {
|
|
SqlClientCase c1 = (SqlClientCase)node;
|
|
for (int i = 0, n = c1.Whens.Count; i < n; i++) {
|
|
if (!CanBeCompared(c1.Whens[i].Match) ||
|
|
!CanBeCompared(c1.Whens[i].Value)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
case SqlNodeType.SearchedCase: {
|
|
SqlSearchedCase c1 = (SqlSearchedCase)node;
|
|
for (int i = 0, n = c1.Whens.Count; i < n; i++) {
|
|
if (!CanBeCompared(c1.Whens[i].Match) ||
|
|
!CanBeCompared(c1.Whens[i].Value)) {
|
|
return false;
|
|
}
|
|
}
|
|
return CanBeCompared(c1.Else);
|
|
}
|
|
case SqlNodeType.TypeCase: {
|
|
SqlTypeCase c1 = (SqlTypeCase)node;
|
|
if (!CanBeCompared(c1.Discriminator)) {
|
|
return false;
|
|
}
|
|
for (int i = 0, c = c1.Whens.Count; i < c; ++i) {
|
|
if (!CanBeCompared(c1.Whens[i].Match)) {
|
|
return false;
|
|
}
|
|
if (!CanBeCompared(c1.Whens[i].TypeBinding)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
case SqlNodeType.DiscriminatedType:
|
|
return CanBeCompared(((SqlDiscriminatedType)node).Discriminator);
|
|
case SqlNodeType.JoinedCollection: {
|
|
SqlJoinedCollection j1 = (SqlJoinedCollection)node;
|
|
return CanBeCompared(j1.Count) && CanBeCompared(j1.Expression);
|
|
}
|
|
case SqlNodeType.Member:
|
|
return CanBeCompared(((SqlMember)node).Expression);
|
|
case SqlNodeType.MethodCall: {
|
|
SqlMethodCall mc = (SqlMethodCall)node;
|
|
if (mc.Object != null && !CanBeCompared(mc.Object)) {
|
|
return false;
|
|
}
|
|
for (int i = 0, n = mc.Arguments.Count; i < n; i++) {
|
|
if (!CanBeCompared(mc.Arguments[0])) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
case SqlNodeType.ClientQuery:
|
|
return true;
|
|
case SqlNodeType.ClientParameter:
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Maintainability", "CA1506:AvoidExcessiveClassCoupling", Justification = "These issues are related to our use of if-then and case statements for node types, which adds to the complexity count however when reviewed they are easy to navigate and understand.")]
|
|
[SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification = "These issues are related to our use of if-then and case statements for node types, which adds to the complexity count however when reviewed they are easy to navigate and understand.")]
|
|
internal static bool AreSimilar(SqlExpression node1, SqlExpression node2) {
|
|
if (node1 == node2) {
|
|
return true;
|
|
}
|
|
if (node1 == null || node2 == null) {
|
|
return false;
|
|
}
|
|
if (node1.NodeType != node2.NodeType ||
|
|
node1.ClrType != node2.ClrType ||
|
|
node1.SqlType != node2.SqlType) {
|
|
return false;
|
|
}
|
|
switch (node1.NodeType) {
|
|
case SqlNodeType.New: {
|
|
SqlNew new1 = (SqlNew)node1;
|
|
SqlNew new2 = (SqlNew)node2;
|
|
if (new1.Args.Count != new2.Args.Count ||
|
|
new1.Members.Count != new2.Members.Count) {
|
|
return false;
|
|
}
|
|
for (int i = 0, n = new1.Args.Count; i < n; i++) {
|
|
if (!AreSimilar(new1.Args[i], new2.Args[i])) {
|
|
return false;
|
|
}
|
|
}
|
|
for (int i = 0, n = new1.Members.Count; i < n; i++) {
|
|
if (!MetaPosition.AreSameMember(new1.Members[i].Member, new2.Members[i].Member) ||
|
|
!AreSimilar(new1.Members[i].Expression, new2.Members[i].Expression)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
case SqlNodeType.ColumnRef: {
|
|
SqlColumnRef cref1 = (SqlColumnRef)node1;
|
|
SqlColumnRef cref2 = (SqlColumnRef)node2;
|
|
return cref1.Column.Ordinal == cref2.Column.Ordinal;
|
|
}
|
|
case SqlNodeType.Link: {
|
|
SqlLink l1 = (SqlLink)node1;
|
|
SqlLink l2 = (SqlLink)node2;
|
|
if (!MetaPosition.AreSameMember(l1.Member.Member, l2.Member.Member)) {
|
|
return false;
|
|
}
|
|
if (l1.KeyExpressions.Count != l2.KeyExpressions.Count) {
|
|
return false;
|
|
}
|
|
for (int i = 0, c = l1.KeyExpressions.Count; i < c; ++i) {
|
|
if (!AreSimilar(l1.KeyExpressions[i], l2.KeyExpressions[i])) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
case SqlNodeType.Value:
|
|
return Object.Equals(((SqlValue)node1).Value, ((SqlValue)node2).Value);
|
|
case SqlNodeType.OptionalValue: {
|
|
SqlOptionalValue ov1 = (SqlOptionalValue)node1;
|
|
SqlOptionalValue ov2 = (SqlOptionalValue)node2;
|
|
return AreSimilar(ov1.Value, ov2.Value);
|
|
}
|
|
case SqlNodeType.ValueOf:
|
|
case SqlNodeType.OuterJoinedValue:
|
|
return AreSimilar(((SqlUnary)node1).Operand, ((SqlUnary)node2).Operand);
|
|
case SqlNodeType.Lift:
|
|
return AreSimilar(((SqlLift)node1).Expression, ((SqlLift)node2).Expression);
|
|
case SqlNodeType.Grouping: {
|
|
SqlGrouping g1 = (SqlGrouping)node1;
|
|
SqlGrouping g2 = (SqlGrouping)node2;
|
|
return AreSimilar(g1.Key, g2.Key) && AreSimilar(g1.Group, g2.Group);
|
|
}
|
|
case SqlNodeType.ClientArray: {
|
|
SqlClientArray a1 = (SqlClientArray)node1;
|
|
SqlClientArray a2 = (SqlClientArray)node2;
|
|
if (a1.Expressions.Count != a2.Expressions.Count) {
|
|
return false;
|
|
}
|
|
for (int i = 0, n = a1.Expressions.Count; i < n; i++) {
|
|
if (!AreSimilar(a1.Expressions[i], a2.Expressions[i])) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
case SqlNodeType.UserColumn:
|
|
return ((SqlUserColumn)node1).Name == ((SqlUserColumn)node2).Name;
|
|
case SqlNodeType.ClientCase: {
|
|
SqlClientCase c1 = (SqlClientCase)node1;
|
|
SqlClientCase c2 = (SqlClientCase)node2;
|
|
if (c1.Whens.Count != c2.Whens.Count) {
|
|
return false;
|
|
}
|
|
for (int i = 0, n = c1.Whens.Count; i < n; i++) {
|
|
if (!AreSimilar(c1.Whens[i].Match, c2.Whens[i].Match) ||
|
|
!AreSimilar(c1.Whens[i].Value, c2.Whens[i].Value)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
case SqlNodeType.SearchedCase: {
|
|
SqlSearchedCase c1 = (SqlSearchedCase)node1;
|
|
SqlSearchedCase c2 = (SqlSearchedCase)node2;
|
|
if (c1.Whens.Count != c2.Whens.Count) {
|
|
return false;
|
|
}
|
|
for (int i = 0, n = c1.Whens.Count; i < n; i++) {
|
|
if (!AreSimilar(c1.Whens[i].Match, c2.Whens[i].Match) ||
|
|
!AreSimilar(c1.Whens[i].Value, c2.Whens[i].Value))
|
|
return false;
|
|
}
|
|
return AreSimilar(c1.Else, c2.Else);
|
|
}
|
|
case SqlNodeType.TypeCase: {
|
|
SqlTypeCase c1 = (SqlTypeCase)node1;
|
|
SqlTypeCase c2 = (SqlTypeCase)node2;
|
|
if (!AreSimilar(c1.Discriminator, c2.Discriminator)) {
|
|
return false;
|
|
}
|
|
if (c1.Whens.Count != c2.Whens.Count) {
|
|
return false;
|
|
}
|
|
for (int i = 0, c = c1.Whens.Count; i < c; ++i) {
|
|
if (!AreSimilar(c1.Whens[i].Match, c2.Whens[i].Match)) {
|
|
return false;
|
|
}
|
|
if (!AreSimilar(c1.Whens[i].TypeBinding, c2.Whens[i].TypeBinding)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
case SqlNodeType.DiscriminatedType: {
|
|
SqlDiscriminatedType dt1 = (SqlDiscriminatedType)node1;
|
|
SqlDiscriminatedType dt2 = (SqlDiscriminatedType)node2;
|
|
return AreSimilar(dt1.Discriminator, dt2.Discriminator);
|
|
}
|
|
case SqlNodeType.JoinedCollection: {
|
|
SqlJoinedCollection j1 = (SqlJoinedCollection)node1;
|
|
SqlJoinedCollection j2 = (SqlJoinedCollection)node2;
|
|
return AreSimilar(j1.Count, j2.Count) && AreSimilar(j1.Expression, j2.Expression);
|
|
}
|
|
case SqlNodeType.Member: {
|
|
SqlMember m1 = (SqlMember)node1;
|
|
SqlMember m2 = (SqlMember)node2;
|
|
return m1.Member == m2.Member && AreSimilar(m1.Expression, m2.Expression);
|
|
}
|
|
case SqlNodeType.ClientQuery: {
|
|
SqlClientQuery cq1 = (SqlClientQuery)node1;
|
|
SqlClientQuery cq2 = (SqlClientQuery)node2;
|
|
if (cq1.Arguments.Count != cq2.Arguments.Count) {
|
|
return false;
|
|
}
|
|
for (int i = 0, n = cq1.Arguments.Count; i < n; i++) {
|
|
if (!AreSimilar(cq1.Arguments[i], cq2.Arguments[i])) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
case SqlNodeType.MethodCall: {
|
|
SqlMethodCall mc1 = (SqlMethodCall)node1;
|
|
SqlMethodCall mc2 = (SqlMethodCall)node2;
|
|
if (mc1.Method != mc2.Method || !AreSimilar(mc1.Object, mc2.Object)) {
|
|
return false;
|
|
}
|
|
if (mc1.Arguments.Count != mc2.Arguments.Count) {
|
|
return false;
|
|
}
|
|
for (int i = 0, n = mc1.Arguments.Count; i < n; i++) {
|
|
if (!AreSimilar(mc1.Arguments[i], mc2.Arguments[i])) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
case SqlNodeType.ClientParameter:
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
class SideEffectChecker : SqlVisitor {
|
|
bool hasSideEffect;
|
|
|
|
internal bool HasSideEffect(SqlNode node) {
|
|
this.hasSideEffect = false;
|
|
this.Visit(node);
|
|
return this.hasSideEffect;
|
|
}
|
|
|
|
internal override SqlExpression VisitJoinedCollection(SqlJoinedCollection jc) {
|
|
this.hasSideEffect = true;
|
|
return jc;
|
|
}
|
|
|
|
internal override SqlExpression VisitClientQuery(SqlClientQuery cq) {
|
|
return cq;
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Maintainability", "CA1506:AvoidExcessiveClassCoupling", Justification = "Unknown reason.")]
|
|
class Generator {
|
|
ObjectReaderCompiler compiler;
|
|
ILGenerator gen;
|
|
List<object> globals;
|
|
List<NamedColumn> namedColumns;
|
|
LocalBuilder locDataReader;
|
|
Type elementType;
|
|
int nLocals;
|
|
Dictionary<MetaAssociation, int> associationSubQueries;
|
|
SideEffectChecker sideEffectChecker = new SideEffectChecker();
|
|
|
|
internal Generator(ObjectReaderCompiler compiler, Type elementType) {
|
|
this.compiler = compiler;
|
|
this.elementType = elementType;
|
|
this.associationSubQueries = new Dictionary<MetaAssociation,int>();
|
|
}
|
|
|
|
internal void GenerateBody(ILGenerator generator, SqlExpression expression) {
|
|
this.gen = generator;
|
|
this.globals = new List<object>();
|
|
this.namedColumns = new List<NamedColumn>();
|
|
// prepare locDataReader
|
|
this.locDataReader = generator.DeclareLocal(this.compiler.dataReaderType);
|
|
generator.Emit(OpCodes.Ldarg_0);
|
|
generator.Emit(OpCodes.Ldfld, this.compiler.readerField);
|
|
generator.Emit(OpCodes.Stloc, this.locDataReader);
|
|
|
|
this.GenerateExpressionForType(expression, this.elementType);
|
|
|
|
generator.Emit(OpCodes.Ret);
|
|
}
|
|
|
|
internal object[] Globals {
|
|
get { return this.globals.ToArray(); }
|
|
}
|
|
|
|
internal NamedColumn[] NamedColumns {
|
|
get { return this.namedColumns.ToArray(); }
|
|
}
|
|
|
|
internal int Locals {
|
|
get { return this.nLocals; }
|
|
}
|
|
|
|
#if DEBUG
|
|
private int stackDepth;
|
|
#endif
|
|
|
|
private Type Generate(SqlNode node) {
|
|
return this.Generate(node, null);
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily", Justification = "Microsoft: Cast is dependent on node type and casts do not happen unecessarily in a single code path.")]
|
|
[SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification = "These issues are related to our use of if-then and case statements for node types, which adds to the complexity count however when reviewed they are easy to navigate and understand.")]
|
|
private Type Generate(SqlNode node, LocalBuilder locInstance) {
|
|
#if DEBUG
|
|
try {
|
|
stackDepth++;
|
|
System.Diagnostics.Debug.Assert(stackDepth < 500);
|
|
#endif
|
|
switch (node.NodeType) {
|
|
case SqlNodeType.New:
|
|
return this.GenerateNew((SqlNew)node);
|
|
case SqlNodeType.ColumnRef:
|
|
return this.GenerateColumnReference((SqlColumnRef)node);
|
|
case SqlNodeType.ClientQuery:
|
|
return this.GenerateClientQuery((SqlClientQuery)node, locInstance);
|
|
case SqlNodeType.JoinedCollection:
|
|
return this.GenerateJoinedCollection((SqlJoinedCollection)node);
|
|
case SqlNodeType.Link:
|
|
return this.GenerateLink((SqlLink)node, locInstance);
|
|
case SqlNodeType.Value:
|
|
return this.GenerateValue((SqlValue)node);
|
|
case SqlNodeType.ClientParameter:
|
|
return this.GenerateClientParameter((SqlClientParameter)node);
|
|
case SqlNodeType.ValueOf:
|
|
return this.GenerateValueOf((SqlUnary)node);
|
|
case SqlNodeType.OptionalValue:
|
|
return this.GenerateOptionalValue((SqlOptionalValue)node);
|
|
case SqlNodeType.OuterJoinedValue:
|
|
return this.Generate(((SqlUnary)node).Operand);
|
|
case SqlNodeType.Lift:
|
|
return this.GenerateLift((SqlLift)node);
|
|
case SqlNodeType.Grouping:
|
|
return this.GenerateGrouping((SqlGrouping)node);
|
|
case SqlNodeType.ClientArray:
|
|
return this.GenerateClientArray((SqlClientArray)node);
|
|
case SqlNodeType.UserColumn:
|
|
return this.GenerateUserColumn((SqlUserColumn)node);
|
|
case SqlNodeType.ClientCase:
|
|
return this.GenerateClientCase((SqlClientCase)node, false, locInstance);
|
|
case SqlNodeType.SearchedCase:
|
|
return this.GenerateSearchedCase((SqlSearchedCase)node);
|
|
case SqlNodeType.TypeCase:
|
|
return this.GenerateTypeCase((SqlTypeCase)node);
|
|
case SqlNodeType.DiscriminatedType:
|
|
return this.GenerateDiscriminatedType((SqlDiscriminatedType)node);
|
|
case SqlNodeType.Member:
|
|
return this.GenerateMember((SqlMember)node);
|
|
case SqlNodeType.MethodCall:
|
|
return this.GenerateMethodCall((SqlMethodCall)node);
|
|
default:
|
|
throw Error.CouldNotTranslateExpressionForReading(node.SourceExpression);
|
|
}
|
|
#if DEBUG
|
|
}
|
|
finally {
|
|
stackDepth--;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
private void GenerateAccessBufferReader() {
|
|
gen.Emit(OpCodes.Ldarg_0);
|
|
gen.Emit(OpCodes.Ldfld, this.compiler.bufferReaderField);
|
|
}
|
|
|
|
private void GenerateAccessDataReader() {
|
|
gen.Emit(OpCodes.Ldloc, this.locDataReader);
|
|
}
|
|
|
|
private void GenerateAccessOrdinals() {
|
|
gen.Emit(OpCodes.Ldarg_0);
|
|
gen.Emit(OpCodes.Ldfld, this.compiler.ordinalsField);
|
|
}
|
|
|
|
private void GenerateAccessGlobals() {
|
|
gen.Emit(OpCodes.Ldarg_0);
|
|
gen.Emit(OpCodes.Ldfld, this.compiler.globalsField);
|
|
}
|
|
|
|
private void GenerateAccessArguments() {
|
|
gen.Emit(OpCodes.Ldarg_0);
|
|
gen.Emit(OpCodes.Ldfld, this.compiler.argsField);
|
|
}
|
|
|
|
private Type GenerateValue(SqlValue value) {
|
|
return this.GenerateConstant(value.ClrType, value.Value);
|
|
}
|
|
|
|
private Type GenerateClientParameter(SqlClientParameter cp) {
|
|
Delegate d = cp.Accessor.Compile();
|
|
int iGlobal = this.AddGlobal(d.GetType(), d);
|
|
this.GenerateGlobalAccess(iGlobal, d.GetType());
|
|
this.GenerateAccessArguments();
|
|
MethodInfo miInvoke = d.GetType().GetMethod(
|
|
"Invoke",
|
|
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
|
|
null,
|
|
new Type[] { typeof(object[]) },
|
|
null
|
|
);
|
|
System.Diagnostics.Debug.Assert(miInvoke != null);
|
|
gen.Emit(GetMethodCallOpCode(miInvoke), miInvoke);
|
|
return d.Method.ReturnType;
|
|
}
|
|
|
|
private Type GenerateValueOf(SqlUnary u) {
|
|
System.Diagnostics.Debug.Assert(TypeSystem.IsNullableType(u.Operand.ClrType));
|
|
this.GenerateExpressionForType(u.Operand, u.Operand.ClrType);
|
|
LocalBuilder loc = gen.DeclareLocal(u.Operand.ClrType);
|
|
gen.Emit(OpCodes.Stloc, loc);
|
|
gen.Emit(OpCodes.Ldloca, loc);
|
|
this.GenerateGetValue(u.Operand.ClrType);
|
|
return u.ClrType;
|
|
}
|
|
|
|
private Type GenerateOptionalValue(SqlOptionalValue opt) {
|
|
System.Diagnostics.Debug.Assert(opt.HasValue.ClrType == typeof(int?));
|
|
|
|
Label labIsNull = gen.DefineLabel();
|
|
Label labExit = gen.DefineLabel();
|
|
|
|
Type actualType = this.Generate(opt.HasValue);
|
|
System.Diagnostics.Debug.Assert(TypeSystem.IsNullableType(actualType));
|
|
LocalBuilder loc = gen.DeclareLocal(actualType);
|
|
gen.Emit(OpCodes.Stloc, loc);
|
|
gen.Emit(OpCodes.Ldloca, loc);
|
|
this.GenerateHasValue(actualType);
|
|
gen.Emit(OpCodes.Brfalse, labIsNull);
|
|
|
|
this.GenerateExpressionForType(opt.Value, opt.ClrType);
|
|
gen.Emit(OpCodes.Br_S, labExit);
|
|
|
|
gen.MarkLabel(labIsNull);
|
|
this.GenerateConstant(opt.ClrType, null);
|
|
|
|
gen.MarkLabel(labExit);
|
|
return opt.ClrType;
|
|
}
|
|
|
|
private Type GenerateLift(SqlLift lift) {
|
|
return this.GenerateExpressionForType(lift.Expression, lift.ClrType);
|
|
}
|
|
|
|
private Type GenerateClientArray(SqlClientArray ca) {
|
|
if (!ca.ClrType.IsArray) {
|
|
throw Error.CannotMaterializeList(ca.ClrType);
|
|
}
|
|
Type elemType = TypeSystem.GetElementType(ca.ClrType);
|
|
this.GenerateConstInt(ca.Expressions.Count);
|
|
gen.Emit(OpCodes.Newarr, elemType);
|
|
for (int i = 0, n = ca.Expressions.Count; i < n; i++) {
|
|
gen.Emit(OpCodes.Dup);
|
|
this.GenerateConstInt(i);
|
|
this.GenerateExpressionForType(ca.Expressions[i], elemType);
|
|
this.GenerateArrayAssign(elemType);
|
|
}
|
|
return ca.ClrType;
|
|
}
|
|
|
|
private Type GenerateMember(SqlMember m) {
|
|
FieldInfo fi = m.Member as FieldInfo;
|
|
if (fi != null) {
|
|
this.GenerateExpressionForType(m.Expression, m.Expression.ClrType);
|
|
gen.Emit(OpCodes.Ldfld, fi);
|
|
return fi.FieldType;
|
|
}
|
|
else {
|
|
PropertyInfo pi = (PropertyInfo)m.Member;
|
|
return this.GenerateMethodCall(new SqlMethodCall(m.ClrType, m.SqlType, pi.GetGetMethod(), m.Expression, null, m.SourceExpression));
|
|
}
|
|
}
|
|
|
|
private Type GenerateMethodCall(SqlMethodCall mc) {
|
|
ParameterInfo[] pis = mc.Method.GetParameters();
|
|
if (mc.Object != null) {
|
|
Type actualType = this.GenerateExpressionForType(mc.Object, mc.Object.ClrType);
|
|
if (actualType.IsValueType) {
|
|
LocalBuilder loc = gen.DeclareLocal(actualType);
|
|
gen.Emit(OpCodes.Stloc, loc);
|
|
gen.Emit(OpCodes.Ldloca, loc);
|
|
}
|
|
}
|
|
for (int i = 0, n = mc.Arguments.Count; i < n; i++) {
|
|
ParameterInfo pi = pis[i];
|
|
Type pType = pi.ParameterType;
|
|
if (pType.IsByRef) {
|
|
pType = pType.GetElementType();
|
|
this.GenerateExpressionForType(mc.Arguments[i], pType);
|
|
LocalBuilder loc = gen.DeclareLocal(pType);
|
|
gen.Emit(OpCodes.Stloc, loc);
|
|
gen.Emit(OpCodes.Ldloca, loc);
|
|
}
|
|
else {
|
|
this.GenerateExpressionForType(mc.Arguments[i], pType);
|
|
}
|
|
}
|
|
OpCode callOpCode = GetMethodCallOpCode(mc.Method);
|
|
if (mc.Object != null && TypeSystem.IsNullableType(mc.Object.ClrType) && callOpCode == OpCodes.Callvirt){
|
|
gen.Emit(OpCodes.Constrained, mc.Object.ClrType);
|
|
}
|
|
gen.Emit(callOpCode, mc.Method);
|
|
|
|
return mc.Method.ReturnType;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Cannot use Call for virtual methods - it results in unverifiable code. Ensure we're using the correct op code.
|
|
/// </summary>
|
|
private static OpCode GetMethodCallOpCode(MethodInfo mi) {
|
|
return (mi.IsStatic || mi.DeclaringType.IsValueType) ? OpCodes.Call : OpCodes.Callvirt;
|
|
}
|
|
|
|
private Type GenerateNew(SqlNew sn) {
|
|
LocalBuilder locInstance = gen.DeclareLocal(sn.ClrType);
|
|
LocalBuilder locStoreInMember = null;
|
|
Label labNewExit = gen.DefineLabel();
|
|
Label labAlreadyCached = gen.DefineLabel();
|
|
|
|
// read all arg values
|
|
if (sn.Args.Count > 0) {
|
|
ParameterInfo[] pis = sn.Constructor.GetParameters();
|
|
for (int i = 0, n = sn.Args.Count; i < n; i++) {
|
|
this.GenerateExpressionForType(sn.Args[i], pis[i].ParameterType);
|
|
}
|
|
}
|
|
|
|
// construct the new instance
|
|
if (sn.Constructor != null) {
|
|
gen.Emit(OpCodes.Newobj, sn.Constructor);
|
|
gen.Emit(OpCodes.Stloc, locInstance);
|
|
}
|
|
else if (sn.ClrType.IsValueType) {
|
|
gen.Emit(OpCodes.Ldloca, locInstance);
|
|
gen.Emit(OpCodes.Initobj, sn.ClrType);
|
|
}
|
|
else {
|
|
ConstructorInfo ci = sn.ClrType.GetConstructor(System.Type.EmptyTypes);
|
|
gen.Emit(OpCodes.Newobj, ci);
|
|
gen.Emit(OpCodes.Stloc, locInstance);
|
|
}
|
|
|
|
// read/write key bindings if there are any
|
|
foreach (SqlMemberAssign ma in sn.Members.OrderBy(m => sn.MetaType.GetDataMember(m.Member).Ordinal)) {
|
|
MetaDataMember mm = sn.MetaType.GetDataMember(ma.Member);
|
|
if (mm.IsPrimaryKey) {
|
|
this.GenerateMemberAssignment(mm, locInstance, ma.Expression, null);
|
|
}
|
|
}
|
|
|
|
int iMeta = 0;
|
|
|
|
if (sn.MetaType.IsEntity) {
|
|
LocalBuilder locCached = gen.DeclareLocal(sn.ClrType);
|
|
locStoreInMember = gen.DeclareLocal(typeof(bool));
|
|
Label labExit = gen.DefineLabel();
|
|
|
|
iMeta = this.AddGlobal(typeof(MetaType), sn.MetaType);
|
|
Type orbType = typeof(ObjectMaterializer<>).MakeGenericType(this.compiler.dataReaderType);
|
|
|
|
// this.InsertLookup(metaType, locInstance)
|
|
gen.Emit(OpCodes.Ldarg_0);
|
|
this.GenerateConstInt(iMeta);
|
|
gen.Emit(OpCodes.Ldloc, locInstance);
|
|
MethodInfo miInsertLookup = orbType.GetMethod(
|
|
"InsertLookup",
|
|
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
|
|
null,
|
|
new Type[] { typeof(int), typeof(object) },
|
|
null
|
|
);
|
|
|
|
System.Diagnostics.Debug.Assert(miInsertLookup != null);
|
|
gen.Emit(GetMethodCallOpCode(miInsertLookup), miInsertLookup);
|
|
gen.Emit(OpCodes.Castclass, sn.ClrType);
|
|
gen.Emit(OpCodes.Stloc, locCached);
|
|
|
|
// if cached != instance then already cached
|
|
gen.Emit(OpCodes.Ldloc, locCached);
|
|
gen.Emit(OpCodes.Ldloc, locInstance);
|
|
gen.Emit(OpCodes.Ceq);
|
|
gen.Emit(OpCodes.Brfalse, labAlreadyCached);
|
|
|
|
this.GenerateConstInt(1);
|
|
gen.Emit(OpCodes.Stloc, locStoreInMember);
|
|
gen.Emit(OpCodes.Br_S, labExit);
|
|
|
|
gen.MarkLabel(labAlreadyCached);
|
|
gen.Emit(OpCodes.Ldloc, locCached);
|
|
gen.Emit(OpCodes.Stloc, locInstance);
|
|
// signal to not store loaded values in instance...
|
|
this.GenerateConstInt(0);
|
|
gen.Emit(OpCodes.Stloc, locStoreInMember);
|
|
|
|
gen.MarkLabel(labExit);
|
|
}
|
|
|
|
// read/write non-key bindings
|
|
foreach (SqlMemberAssign ma in sn.Members.OrderBy(m => sn.MetaType.GetDataMember(m.Member).Ordinal)) {
|
|
MetaDataMember mm = sn.MetaType.GetDataMember(ma.Member);
|
|
if (!mm.IsPrimaryKey) {
|
|
this.GenerateMemberAssignment(mm, locInstance, ma.Expression, locStoreInMember);
|
|
}
|
|
}
|
|
|
|
if (sn.MetaType.IsEntity) {
|
|
// don't call SendEntityMaterialized if we already had the instance cached
|
|
gen.Emit(OpCodes.Ldloc, locStoreInMember);
|
|
this.GenerateConstInt(0);
|
|
gen.Emit(OpCodes.Ceq);
|
|
gen.Emit(OpCodes.Brtrue, labNewExit);
|
|
|
|
// send entity materialized event
|
|
gen.Emit(OpCodes.Ldarg_0);
|
|
this.GenerateConstInt(iMeta);
|
|
gen.Emit(OpCodes.Ldloc, locInstance);
|
|
Type orbType = typeof(ObjectMaterializer<>).MakeGenericType(this.compiler.dataReaderType);
|
|
MethodInfo miRaiseEvent = orbType.GetMethod(
|
|
"SendEntityMaterialized",
|
|
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
|
|
null,
|
|
new Type[] { typeof(int), typeof(object) },
|
|
null
|
|
);
|
|
System.Diagnostics.Debug.Assert(miRaiseEvent != null);
|
|
gen.Emit(GetMethodCallOpCode(miRaiseEvent), miRaiseEvent);
|
|
}
|
|
|
|
gen.MarkLabel(labNewExit);
|
|
gen.Emit(OpCodes.Ldloc, locInstance);
|
|
|
|
return sn.ClrType;
|
|
}
|
|
|
|
private void GenerateMemberAssignment(MetaDataMember mm, LocalBuilder locInstance, SqlExpression expr, LocalBuilder locStoreInMember) {
|
|
MemberInfo m = mm.StorageMember != null ? mm.StorageMember : mm.Member;
|
|
Type memberType = TypeSystem.GetMemberType(m);
|
|
|
|
// check for deferrable member & deferred source expression
|
|
if (IsDeferrableExpression(expr) &&
|
|
(this.compiler.services.Context.LoadOptions == null ||
|
|
!this.compiler.services.Context.LoadOptions.IsPreloaded(mm.Member))
|
|
) {
|
|
// we can only defer deferrable members
|
|
if (mm.IsDeferred) {
|
|
// determine at runtime if we are allowed to defer load
|
|
gen.Emit(OpCodes.Ldarg_0);
|
|
Type orbType = typeof(ObjectMaterializer<>).MakeGenericType(this.compiler.dataReaderType);
|
|
PropertyInfo piCanDeferLoad = orbType.GetProperty("CanDeferLoad");
|
|
System.Diagnostics.Debug.Assert(piCanDeferLoad != null);
|
|
MethodInfo miCanDeferLoad = piCanDeferLoad.GetGetMethod();
|
|
gen.Emit(GetMethodCallOpCode(miCanDeferLoad), miCanDeferLoad);
|
|
|
|
// if we can't defer load then jump over the code that does the defer loading
|
|
Label labEndDeferLoad = gen.DefineLabel();
|
|
gen.Emit(OpCodes.Brfalse, labEndDeferLoad);
|
|
|
|
// execute the defer load operation
|
|
if (memberType.IsGenericType) {
|
|
Type genType = memberType.GetGenericTypeDefinition();
|
|
if (genType == typeof(EntitySet<>)) {
|
|
this.GenerateAssignDeferredEntitySet(mm, locInstance, expr, locStoreInMember);
|
|
}
|
|
else if (genType == typeof(EntityRef<>) || genType == typeof(Link<>)) {
|
|
this.GenerateAssignDeferredReference(mm, locInstance, expr, locStoreInMember);
|
|
}
|
|
else {
|
|
throw Error.DeferredMemberWrongType();
|
|
}
|
|
}
|
|
else {
|
|
throw Error.DeferredMemberWrongType();
|
|
}
|
|
gen.MarkLabel(labEndDeferLoad);
|
|
}
|
|
else {
|
|
// behavior for non-deferred members w/ deferrable expressions is to load nothing
|
|
}
|
|
}
|
|
else if (memberType.IsGenericType && memberType.GetGenericTypeDefinition() == typeof(EntitySet<>)) {
|
|
this.GenerateAssignEntitySet(mm, locInstance, expr, locStoreInMember);
|
|
}
|
|
else {
|
|
this.GenerateAssignValue(mm, locInstance, expr, locStoreInMember);
|
|
}
|
|
}
|
|
|
|
private void GenerateAssignValue(MetaDataMember mm, LocalBuilder locInstance, SqlExpression expr, LocalBuilder locStoreInMember) {
|
|
MemberInfo m = mm.StorageMember != null ? mm.StorageMember : mm.Member;
|
|
if (!IsAssignable(m)) {
|
|
throw Error.CannotAssignToMember(m.Name);
|
|
}
|
|
Type memberType = TypeSystem.GetMemberType(m);
|
|
|
|
Label labExit = gen.DefineLabel();
|
|
|
|
bool hasSideEffect = this.HasSideEffect(expr);
|
|
|
|
if (locStoreInMember != null && !hasSideEffect) {
|
|
gen.Emit(OpCodes.Ldloc, locStoreInMember);
|
|
this.GenerateConstInt(0);
|
|
gen.Emit(OpCodes.Ceq);
|
|
gen.Emit(OpCodes.Brtrue, labExit);
|
|
}
|
|
|
|
this.GenerateExpressionForType(expr, memberType, mm.DeclaringType.IsEntity ? locInstance : null);
|
|
LocalBuilder locValue = gen.DeclareLocal(memberType);
|
|
|
|
gen.Emit(OpCodes.Stloc, locValue);
|
|
|
|
if (locStoreInMember != null && hasSideEffect) {
|
|
gen.Emit(OpCodes.Ldloc, locStoreInMember);
|
|
this.GenerateConstInt(0);
|
|
gen.Emit(OpCodes.Ceq);
|
|
gen.Emit(OpCodes.Brtrue, labExit);
|
|
}
|
|
|
|
this.GenerateLoadForMemberAccess(locInstance);
|
|
gen.Emit(OpCodes.Ldloc, locValue);
|
|
this.GenerateStoreMember(m);
|
|
|
|
gen.MarkLabel(labExit);
|
|
}
|
|
|
|
private static bool IsAssignable(MemberInfo member) {
|
|
FieldInfo fi = member as FieldInfo;
|
|
if (fi != null) {
|
|
return true;
|
|
}
|
|
PropertyInfo pi = member as PropertyInfo;
|
|
if (pi != null) {
|
|
return pi.CanWrite;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private void GenerateAssignDeferredEntitySet(MetaDataMember mm, LocalBuilder locInstance, SqlExpression expr, LocalBuilder locStoreInMember) {
|
|
MemberInfo m = mm.StorageMember != null ? mm.StorageMember : mm.Member;
|
|
Type memberType = TypeSystem.GetMemberType(m);
|
|
System.Diagnostics.Debug.Assert(memberType.IsGenericType && memberType.GetGenericTypeDefinition() == typeof(EntitySet<>));
|
|
Label labExit = gen.DefineLabel();
|
|
Type argType = typeof(IEnumerable<>).MakeGenericType(memberType.GetGenericArguments());
|
|
|
|
bool hasSideEffect = this.HasSideEffect(expr);
|
|
|
|
if (locStoreInMember != null && !hasSideEffect) {
|
|
gen.Emit(OpCodes.Ldloc, locStoreInMember);
|
|
this.GenerateConstInt(0);
|
|
gen.Emit(OpCodes.Ceq);
|
|
gen.Emit(OpCodes.Brtrue, labExit);
|
|
}
|
|
|
|
Type eType = this.GenerateDeferredSource(expr, locInstance);
|
|
System.Diagnostics.Debug.Assert(argType.IsAssignableFrom(eType));
|
|
LocalBuilder locSource = gen.DeclareLocal(eType);
|
|
gen.Emit(OpCodes.Stloc, locSource);
|
|
|
|
if (locStoreInMember != null && hasSideEffect) {
|
|
gen.Emit(OpCodes.Ldloc, locStoreInMember);
|
|
this.GenerateConstInt(0);
|
|
gen.Emit(OpCodes.Ceq);
|
|
gen.Emit(OpCodes.Brtrue, labExit);
|
|
}
|
|
|
|
// if member is directly writeable, check for null entityset
|
|
if (m is FieldInfo || (m is PropertyInfo && ((PropertyInfo)m).CanWrite)) {
|
|
Label labFetch = gen.DefineLabel();
|
|
this.GenerateLoadForMemberAccess(locInstance);
|
|
this.GenerateLoadMember(m);
|
|
gen.Emit(OpCodes.Ldnull);
|
|
gen.Emit(OpCodes.Ceq);
|
|
gen.Emit(OpCodes.Brfalse, labFetch);
|
|
|
|
// create new entity set
|
|
this.GenerateLoadForMemberAccess(locInstance);
|
|
ConstructorInfo ci = memberType.GetConstructor(System.Type.EmptyTypes);
|
|
System.Diagnostics.Debug.Assert(ci != null);
|
|
gen.Emit(OpCodes.Newobj, ci);
|
|
this.GenerateStoreMember(m);
|
|
|
|
gen.MarkLabel(labFetch);
|
|
}
|
|
|
|
// set the source
|
|
this.GenerateLoadForMemberAccess(locInstance);
|
|
this.GenerateLoadMember(m);
|
|
gen.Emit(OpCodes.Ldloc, locSource);
|
|
MethodInfo miSetSource = memberType.GetMethod("SetSource", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[] { argType }, null);
|
|
System.Diagnostics.Debug.Assert(miSetSource != null);
|
|
gen.Emit(GetMethodCallOpCode(miSetSource), miSetSource);
|
|
|
|
gen.MarkLabel(labExit);
|
|
}
|
|
|
|
private bool HasSideEffect(SqlNode node) {
|
|
return this.sideEffectChecker.HasSideEffect(node);
|
|
}
|
|
|
|
private void GenerateAssignEntitySet(MetaDataMember mm, LocalBuilder locInstance, SqlExpression expr, LocalBuilder locStoreInMember) {
|
|
MemberInfo m = mm.StorageMember != null ? mm.StorageMember : mm.Member;
|
|
Type memberType = TypeSystem.GetMemberType(m);
|
|
System.Diagnostics.Debug.Assert(memberType.IsGenericType && memberType.GetGenericTypeDefinition() == typeof(EntitySet<>));
|
|
Label labExit = gen.DefineLabel();
|
|
Type argType = typeof(IEnumerable<>).MakeGenericType(memberType.GetGenericArguments());
|
|
|
|
bool hasSideEffect = this.HasSideEffect(expr);
|
|
|
|
if (locStoreInMember != null && !hasSideEffect) {
|
|
gen.Emit(OpCodes.Ldloc, locStoreInMember);
|
|
this.GenerateConstInt(0);
|
|
gen.Emit(OpCodes.Ceq);
|
|
gen.Emit(OpCodes.Brtrue, labExit);
|
|
}
|
|
|
|
Type eType = this.Generate(expr, mm.DeclaringType.IsEntity ? locInstance : null);
|
|
System.Diagnostics.Debug.Assert(argType.IsAssignableFrom(eType));
|
|
LocalBuilder locSource = gen.DeclareLocal(eType);
|
|
gen.Emit(OpCodes.Stloc, locSource);
|
|
|
|
if (locStoreInMember != null && hasSideEffect) {
|
|
gen.Emit(OpCodes.Ldloc, locStoreInMember);
|
|
this.GenerateConstInt(0);
|
|
gen.Emit(OpCodes.Ceq);
|
|
gen.Emit(OpCodes.Brtrue, labExit);
|
|
}
|
|
|
|
// if member is directly writeable, check for null entityset
|
|
if (m is FieldInfo || (m is PropertyInfo && ((PropertyInfo)m).CanWrite)) {
|
|
Label labFetch = gen.DefineLabel();
|
|
this.GenerateLoadForMemberAccess(locInstance);
|
|
this.GenerateLoadMember(m);
|
|
gen.Emit(OpCodes.Ldnull);
|
|
gen.Emit(OpCodes.Ceq);
|
|
gen.Emit(OpCodes.Brfalse, labFetch);
|
|
|
|
// create new entity set
|
|
this.GenerateLoadForMemberAccess(locInstance);
|
|
ConstructorInfo ci = memberType.GetConstructor(System.Type.EmptyTypes);
|
|
System.Diagnostics.Debug.Assert(ci != null);
|
|
gen.Emit(OpCodes.Newobj, ci);
|
|
this.GenerateStoreMember(m);
|
|
|
|
gen.MarkLabel(labFetch);
|
|
}
|
|
|
|
// set the source
|
|
this.GenerateLoadForMemberAccess(locInstance);
|
|
this.GenerateLoadMember(m);
|
|
gen.Emit(OpCodes.Ldloc, locSource);
|
|
MethodInfo miAssign = memberType.GetMethod("Assign", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[] { argType }, null);
|
|
System.Diagnostics.Debug.Assert(miAssign != null);
|
|
gen.Emit(GetMethodCallOpCode(miAssign), miAssign);
|
|
|
|
gen.MarkLabel(labExit);
|
|
}
|
|
|
|
private void GenerateAssignDeferredReference(MetaDataMember mm, LocalBuilder locInstance, SqlExpression expr, LocalBuilder locStoreInMember) {
|
|
MemberInfo m = mm.StorageMember != null ? mm.StorageMember : mm.Member;
|
|
Type memberType = TypeSystem.GetMemberType(m);
|
|
System.Diagnostics.Debug.Assert(
|
|
memberType.IsGenericType &&
|
|
(memberType.GetGenericTypeDefinition() == typeof(EntityRef<>) ||
|
|
memberType.GetGenericTypeDefinition() == typeof(Link<>))
|
|
);
|
|
Label labExit = gen.DefineLabel();
|
|
Type argType = typeof(IEnumerable<>).MakeGenericType(memberType.GetGenericArguments());
|
|
|
|
bool hasSideEffect = this.HasSideEffect(expr);
|
|
|
|
if (locStoreInMember != null && !hasSideEffect) {
|
|
gen.Emit(OpCodes.Ldloc, locStoreInMember);
|
|
this.GenerateConstInt(0);
|
|
gen.Emit(OpCodes.Ceq);
|
|
gen.Emit(OpCodes.Brtrue, labExit);
|
|
}
|
|
|
|
Type eType = this.GenerateDeferredSource(expr, locInstance);
|
|
if (!argType.IsAssignableFrom(eType)) {
|
|
throw Error.CouldNotConvert(argType, eType);
|
|
}
|
|
|
|
LocalBuilder locSource = gen.DeclareLocal(eType);
|
|
gen.Emit(OpCodes.Stloc, locSource);
|
|
|
|
if (locStoreInMember != null && hasSideEffect) {
|
|
gen.Emit(OpCodes.Ldloc, locStoreInMember);
|
|
this.GenerateConstInt(0);
|
|
gen.Emit(OpCodes.Ceq);
|
|
gen.Emit(OpCodes.Brtrue, labExit);
|
|
}
|
|
|
|
this.GenerateLoadForMemberAccess(locInstance);
|
|
gen.Emit(OpCodes.Ldloc, locSource);
|
|
ConstructorInfo ci = memberType.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[] { argType }, null);
|
|
System.Diagnostics.Debug.Assert(ci != null);
|
|
gen.Emit(OpCodes.Newobj, ci);
|
|
this.GenerateStoreMember(m);
|
|
|
|
gen.MarkLabel(labExit);
|
|
}
|
|
|
|
private void GenerateLoadForMemberAccess(LocalBuilder loc) {
|
|
if (loc.LocalType.IsValueType) {
|
|
gen.Emit(OpCodes.Ldloca, loc);
|
|
}
|
|
else {
|
|
gen.Emit(OpCodes.Ldloc, loc);
|
|
}
|
|
}
|
|
|
|
private bool IsDeferrableExpression(SqlExpression expr) {
|
|
if (expr.NodeType == SqlNodeType.Link) {
|
|
return true;
|
|
}
|
|
else if (expr.NodeType == SqlNodeType.ClientCase) {
|
|
SqlClientCase c = (SqlClientCase)expr;
|
|
foreach (SqlClientWhen when in c.Whens) {
|
|
if (!IsDeferrableExpression(when.Value)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private Type GenerateGrouping(SqlGrouping grp) {
|
|
Type[] typeArgs = grp.ClrType.GetGenericArguments();
|
|
|
|
this.GenerateExpressionForType(grp.Key, typeArgs[0]);
|
|
this.Generate(grp.Group);
|
|
|
|
Type orbType = typeof(ObjectMaterializer<>).MakeGenericType(this.compiler.dataReaderType);
|
|
MethodInfo miCreateGroup = TypeSystem.FindStaticMethod(orbType, "CreateGroup", new Type[] { typeArgs[0], typeof(IEnumerable<>).MakeGenericType(typeArgs[1]) }, typeArgs);
|
|
System.Diagnostics.Debug.Assert(miCreateGroup != null);
|
|
gen.Emit(OpCodes.Call, miCreateGroup);
|
|
|
|
return miCreateGroup.ReturnType;
|
|
}
|
|
|
|
private Type GenerateLink(SqlLink link, LocalBuilder locInstance) {
|
|
gen.Emit(OpCodes.Ldarg_0);
|
|
|
|
// iGlobalLink arg
|
|
int iGlobalLink = this.AddGlobal(typeof(MetaDataMember), link.Member);
|
|
this.GenerateConstInt(iGlobalLink);
|
|
|
|
// iLocalFactory arg
|
|
int iLocalFactory = this.AllocateLocal();
|
|
this.GenerateConstInt(iLocalFactory);
|
|
|
|
Type elemType = link.Member.IsAssociation && link.Member.Association.IsMany
|
|
? TypeSystem.GetElementType(link.Member.Type)
|
|
: link.Member.Type;
|
|
|
|
MethodInfo mi = null;
|
|
if (locInstance != null) {
|
|
// load instance for 'instance' arg
|
|
gen.Emit(OpCodes.Ldloc, locInstance);
|
|
|
|
// call GetNestedLinkSource on ObjectReaderBase
|
|
mi = typeof(ObjectMaterializer<>).MakeGenericType(this.compiler.dataReaderType).GetMethod("GetNestedLinkSource", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
|
|
System.Diagnostics.Debug.Assert(mi != null);
|
|
MethodInfo miGLS = mi.MakeGenericMethod(elemType);
|
|
gen.Emit(GetMethodCallOpCode(miGLS), miGLS);
|
|
}
|
|
else {
|
|
// create array of key values for 'keyValues' arg
|
|
this.GenerateConstInt(link.KeyExpressions.Count);
|
|
gen.Emit(OpCodes.Newarr, typeof(object));
|
|
|
|
// intialize key values
|
|
for (int i = 0, n = link.KeyExpressions.Count; i < n; i++) {
|
|
gen.Emit(OpCodes.Dup);
|
|
this.GenerateConstInt(i);
|
|
this.GenerateExpressionForType(link.KeyExpressions[i], typeof(object));
|
|
this.GenerateArrayAssign(typeof(object));
|
|
}
|
|
|
|
// call GetLinkSource on ObjectReaderBase
|
|
mi = typeof(ObjectMaterializer<>).MakeGenericType(this.compiler.dataReaderType).GetMethod("GetLinkSource", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
|
|
System.Diagnostics.Debug.Assert(mi != null);
|
|
MethodInfo miGLS = mi.MakeGenericMethod(elemType);
|
|
gen.Emit(GetMethodCallOpCode(miGLS), miGLS);
|
|
}
|
|
|
|
return typeof(IEnumerable<>).MakeGenericType(elemType);
|
|
}
|
|
|
|
private Type GenerateDeferredSource(SqlExpression expr, LocalBuilder locInstance) {
|
|
if (expr.NodeType == SqlNodeType.ClientCase) {
|
|
return this.GenerateClientCase((SqlClientCase)expr, true, locInstance);
|
|
}
|
|
else if (expr.NodeType == SqlNodeType.Link) {
|
|
return this.GenerateLink((SqlLink)expr, locInstance);
|
|
}
|
|
else {
|
|
throw Error.ExpressionNotDeferredQuerySource();
|
|
}
|
|
}
|
|
|
|
private Type GenerateClientQuery(SqlClientQuery cq, LocalBuilder locInstance) {
|
|
Type clientElementType = cq.Query.NodeType == SqlNodeType.Multiset ? TypeSystem.GetElementType(cq.ClrType) : cq.ClrType;
|
|
|
|
gen.Emit(OpCodes.Ldarg_0); // ObjectReaderBase
|
|
this.GenerateConstInt(cq.Ordinal); // iSubQuery
|
|
|
|
// create array of subquery parent args
|
|
this.GenerateConstInt(cq.Arguments.Count);
|
|
gen.Emit(OpCodes.Newarr, typeof(object));
|
|
|
|
// intialize arg values
|
|
for (int i = 0, n = cq.Arguments.Count; i < n; i++) {
|
|
gen.Emit(OpCodes.Dup);
|
|
this.GenerateConstInt(i);
|
|
Type clrType = cq.Arguments[i].ClrType;
|
|
if (cq.Arguments[i].NodeType == SqlNodeType.ColumnRef) {
|
|
SqlColumnRef cref = (SqlColumnRef)cq.Arguments[i];
|
|
if (clrType.IsValueType && !TypeSystem.IsNullableType(clrType)) {
|
|
clrType = typeof(Nullable<>).MakeGenericType(clrType);
|
|
}
|
|
this.GenerateColumnAccess(clrType, cref.SqlType, cref.Column.Ordinal, null);
|
|
}
|
|
else {
|
|
this.GenerateExpressionForType(cq.Arguments[i], cq.Arguments[i].ClrType);
|
|
}
|
|
if (clrType.IsValueType) {
|
|
gen.Emit(OpCodes.Box, clrType);
|
|
}
|
|
this.GenerateArrayAssign(typeof(object));
|
|
}
|
|
|
|
MethodInfo miExecute = typeof(ObjectMaterializer<>).MakeGenericType(this.compiler.dataReaderType)
|
|
.GetMethod("ExecuteSubQuery", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
|
|
System.Diagnostics.Debug.Assert(miExecute != null);
|
|
gen.Emit(GetMethodCallOpCode(miExecute), miExecute);
|
|
|
|
Type actualType = typeof(IEnumerable<>).MakeGenericType(clientElementType);
|
|
gen.Emit(OpCodes.Castclass, actualType);
|
|
|
|
Type resultType = typeof(List<>).MakeGenericType(clientElementType);
|
|
this.GenerateConvertToType(actualType, resultType);
|
|
|
|
return resultType;
|
|
}
|
|
|
|
private Type GenerateJoinedCollection(SqlJoinedCollection jc) {
|
|
LocalBuilder locCount = gen.DeclareLocal(typeof(int));
|
|
LocalBuilder locHasRows = gen.DeclareLocal(typeof(bool));
|
|
Type joinElementType = jc.Expression.ClrType;
|
|
Type listType = typeof(List<>).MakeGenericType(joinElementType);
|
|
LocalBuilder locList = gen.DeclareLocal(listType);
|
|
|
|
// count = xxx
|
|
this.GenerateExpressionForType(jc.Count, typeof(int));
|
|
gen.Emit(OpCodes.Stloc, locCount);
|
|
|
|
// list = new List<T>(count)
|
|
gen.Emit(OpCodes.Ldloc, locCount);
|
|
ConstructorInfo ci = listType.GetConstructor(new Type[] { typeof(int) });
|
|
System.Diagnostics.Debug.Assert(ci != null);
|
|
gen.Emit(OpCodes.Newobj, ci);
|
|
gen.Emit(OpCodes.Stloc, locList);
|
|
|
|
// hasRows = true
|
|
gen.Emit(OpCodes.Ldc_I4_1);
|
|
gen.Emit(OpCodes.Stloc, locHasRows);
|
|
|
|
// start loop
|
|
Label labLoopTest = gen.DefineLabel();
|
|
Label labLoopTop = gen.DefineLabel();
|
|
LocalBuilder locI = gen.DeclareLocal(typeof(int));
|
|
gen.Emit(OpCodes.Ldc_I4_0);
|
|
gen.Emit(OpCodes.Stloc, locI);
|
|
gen.Emit(OpCodes.Br, labLoopTest);
|
|
|
|
gen.MarkLabel(labLoopTop);
|
|
// loop interior
|
|
|
|
// if (i > 0 && hasRows) { hasRows = this.Read(); }
|
|
gen.Emit(OpCodes.Ldloc, locI);
|
|
gen.Emit(OpCodes.Ldc_I4_0);
|
|
gen.Emit(OpCodes.Cgt);
|
|
gen.Emit(OpCodes.Ldloc, locHasRows);
|
|
gen.Emit(OpCodes.And);
|
|
Label labNext = gen.DefineLabel();
|
|
gen.Emit(OpCodes.Brfalse, labNext);
|
|
|
|
// this.Read()
|
|
gen.Emit(OpCodes.Ldarg_0);
|
|
Type orbType = typeof(ObjectMaterializer<>).MakeGenericType(this.compiler.dataReaderType);
|
|
MethodInfo miRead = orbType.GetMethod("Read", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
|
|
System.Diagnostics.Debug.Assert(miRead != null);
|
|
gen.Emit(GetMethodCallOpCode(miRead), miRead);
|
|
gen.Emit(OpCodes.Stloc, locHasRows);
|
|
|
|
gen.MarkLabel(labNext);
|
|
// if (hasRows) { list.Add(expr); }
|
|
Label labNext2 = gen.DefineLabel();
|
|
gen.Emit(OpCodes.Ldloc, locHasRows);
|
|
gen.Emit(OpCodes.Brfalse, labNext2);
|
|
gen.Emit(OpCodes.Ldloc, locList);
|
|
this.GenerateExpressionForType(jc.Expression, joinElementType);
|
|
MethodInfo miAdd = listType.GetMethod("Add", BindingFlags.Instance | BindingFlags.Public, null, new Type[] { joinElementType }, null);
|
|
System.Diagnostics.Debug.Assert(miAdd != null);
|
|
gen.Emit(GetMethodCallOpCode(miAdd), miAdd);
|
|
|
|
gen.MarkLabel(labNext2);
|
|
// loop bottom
|
|
// i = i + 1
|
|
gen.Emit(OpCodes.Ldloc, locI);
|
|
gen.Emit(OpCodes.Ldc_I4_1);
|
|
gen.Emit(OpCodes.Add);
|
|
gen.Emit(OpCodes.Stloc, locI);
|
|
|
|
// loop test
|
|
// i < count && hasRows
|
|
gen.MarkLabel(labLoopTest);
|
|
gen.Emit(OpCodes.Ldloc, locI);
|
|
gen.Emit(OpCodes.Ldloc, locCount);
|
|
gen.Emit(OpCodes.Clt);
|
|
gen.Emit(OpCodes.Ldloc, locHasRows);
|
|
gen.Emit(OpCodes.And);
|
|
gen.Emit(OpCodes.Brtrue, labLoopTop);
|
|
|
|
// return list;
|
|
gen.Emit(OpCodes.Ldloc, locList);
|
|
|
|
return listType;
|
|
}
|
|
|
|
private Type GenerateExpressionForType(SqlExpression expr, Type type) {
|
|
return this.GenerateExpressionForType(expr, type, null);
|
|
}
|
|
|
|
private Type GenerateExpressionForType(SqlExpression expr, Type type, LocalBuilder locInstance) {
|
|
Type actualType = this.Generate(expr, locInstance);
|
|
this.GenerateConvertToType(actualType, type);
|
|
return type;
|
|
}
|
|
|
|
private void GenerateConvertToType(Type actualType, Type expectedType, Type readerMethodType) {
|
|
GenerateConvertToType(readerMethodType, actualType);
|
|
GenerateConvertToType(actualType, expectedType);
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Maintainability", "CA1505:AvoidUnmaintainableCode", Justification = "These issues are related to our use of if-then and case statements for node types, which adds to the complexity count however when reviewed they are easy to navigate and understand.")]
|
|
[SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification = "These issues are related to our use of if-then and case statements for node types, which adds to the complexity count however when reviewed they are easy to navigate and understand.")]
|
|
private void GenerateConvertToType(Type actualType, Type expectedType) {
|
|
if (expectedType != actualType &&
|
|
!(!actualType.IsValueType && actualType.IsSubclassOf(expectedType))
|
|
) {
|
|
Type genActualType = actualType.IsGenericType ? actualType.GetGenericTypeDefinition() : null;
|
|
Type genExpectedType = expectedType.IsGenericType ? expectedType.GetGenericTypeDefinition() : null;
|
|
Type[] genExpectedTypeArgs = genExpectedType != null ? expectedType.GetGenericArguments() : null;
|
|
|
|
Type elemType = TypeSystem.GetElementType(actualType);
|
|
Type seqType = TypeSystem.GetSequenceType(elemType);
|
|
bool actualIsSequence = seqType.IsAssignableFrom(actualType);
|
|
|
|
if (expectedType == typeof(object) && actualType.IsValueType) {
|
|
gen.Emit(OpCodes.Box, actualType);
|
|
}
|
|
else if (actualType == typeof(object) && expectedType.IsValueType) {
|
|
gen.Emit(OpCodes.Unbox_Any, expectedType);
|
|
}
|
|
// is one type an explicit subtype of the other?
|
|
else if ((actualType.IsSubclassOf(expectedType) || expectedType.IsSubclassOf(actualType))
|
|
&& !actualType.IsValueType && !expectedType.IsValueType) {
|
|
// (T)expr
|
|
gen.Emit(OpCodes.Castclass, expectedType);
|
|
}
|
|
// do we expected a sequence of a different element type?
|
|
else if (genExpectedType == typeof(IEnumerable<>) && actualIsSequence) {
|
|
if (elementType.IsInterface ||
|
|
genExpectedTypeArgs[0].IsInterface ||
|
|
elementType.IsSubclassOf(genExpectedTypeArgs[0]) ||
|
|
genExpectedTypeArgs[0].IsSubclassOf(elementType) ||
|
|
TypeSystem.GetNonNullableType(elementType) == TypeSystem.GetNonNullableType(genExpectedTypeArgs[0])
|
|
) {
|
|
// reference or nullable conversion use seq.Cast<E>()
|
|
MethodInfo miCast = TypeSystem.FindSequenceMethod("Cast", new Type[] { seqType }, genExpectedTypeArgs[0]);
|
|
System.Diagnostics.Debug.Assert(miCast != null);
|
|
gen.Emit(OpCodes.Call, miCast);
|
|
}
|
|
else {
|
|
// otherwise use orb.Convert<E>(sequence)
|
|
Type orbType = typeof(ObjectMaterializer<>).MakeGenericType(this.compiler.dataReaderType);
|
|
MethodInfo miConvert = TypeSystem.FindStaticMethod(orbType, "Convert", new Type[] { seqType }, genExpectedTypeArgs[0]);
|
|
System.Diagnostics.Debug.Assert(miConvert != null);
|
|
gen.Emit(OpCodes.Call, miConvert);
|
|
}
|
|
}
|
|
// Do we have a sequence where we wanted a singleton?
|
|
else if (expectedType == elemType && actualIsSequence) {
|
|
// seq.SingleOrDefault()
|
|
MethodInfo miFirst = TypeSystem.FindSequenceMethod("SingleOrDefault", new Type[] { seqType }, expectedType);
|
|
System.Diagnostics.Debug.Assert(miFirst != null);
|
|
gen.Emit(OpCodes.Call, miFirst);
|
|
}
|
|
// do we have a non-nullable value where we want a nullable value?
|
|
else if (TypeSystem.IsNullableType(expectedType) &&
|
|
TypeSystem.GetNonNullableType(expectedType) == actualType) {
|
|
// new Nullable<T>(expr)
|
|
ConstructorInfo ci = expectedType.GetConstructor(new Type[] { actualType });
|
|
gen.Emit(OpCodes.Newobj, ci);
|
|
}
|
|
// do we have a nullable value where we want a non-nullable value?
|
|
else if (TypeSystem.IsNullableType(actualType) &&
|
|
TypeSystem.GetNonNullableType(actualType) == expectedType) {
|
|
// expr.GetValueOrDefault()
|
|
LocalBuilder loc = gen.DeclareLocal(actualType);
|
|
gen.Emit(OpCodes.Stloc, loc);
|
|
gen.Emit(OpCodes.Ldloca, loc);
|
|
this.GenerateGetValueOrDefault(actualType);
|
|
}
|
|
// do we have a value when we want an EntityRef or Link of that value
|
|
else if (genExpectedType == typeof(EntityRef<>) || genExpectedType == typeof(Link<>)) {
|
|
if (actualType.IsAssignableFrom(genExpectedTypeArgs[0])) {
|
|
// new T(expr)
|
|
if (actualType != genExpectedTypeArgs[0]) {
|
|
// Ensure that the actual runtime type of the value is
|
|
// compatible. For example, in inheritance scenarios
|
|
// the Type of the value can vary from row to row.
|
|
this.GenerateConvertToType(actualType, genExpectedTypeArgs[0]);
|
|
}
|
|
ConstructorInfo ci = expectedType.GetConstructor(new Type[] { genExpectedTypeArgs[0] });
|
|
System.Diagnostics.Debug.Assert(ci != null);
|
|
gen.Emit(OpCodes.Newobj, ci);
|
|
}
|
|
else if (seqType.IsAssignableFrom(actualType)) {
|
|
// new T(seq.SingleOrDefault())
|
|
MethodInfo miFirst = TypeSystem.FindSequenceMethod("SingleOrDefault", new Type[] { seqType }, elemType);
|
|
System.Diagnostics.Debug.Assert(miFirst != null);
|
|
gen.Emit(OpCodes.Call, miFirst);
|
|
ConstructorInfo ci = expectedType.GetConstructor(new Type[] { elemType });
|
|
System.Diagnostics.Debug.Assert(ci != null);
|
|
gen.Emit(OpCodes.Newobj, ci);
|
|
}
|
|
else {
|
|
throw Error.CannotConvertToEntityRef(actualType);
|
|
}
|
|
}
|
|
// do we have a sequence when we want IQueryable/IOrderedQueryable?
|
|
else if ((expectedType == typeof(IQueryable) ||
|
|
expectedType == typeof(IOrderedQueryable))
|
|
&& typeof(IEnumerable).IsAssignableFrom(actualType)) {
|
|
// seq.AsQueryable()
|
|
MethodInfo miAsQueryable = TypeSystem.FindQueryableMethod("AsQueryable", new Type[] { typeof(IEnumerable) });
|
|
System.Diagnostics.Debug.Assert(miAsQueryable != null);
|
|
gen.Emit(OpCodes.Call, miAsQueryable);
|
|
if (genExpectedType == typeof(IOrderedQueryable)) {
|
|
gen.Emit(OpCodes.Castclass, expectedType);
|
|
}
|
|
}
|
|
// do we have a sequence when we want IQuerayble<T>/IOrderedQueryable<T>?
|
|
else if ((genExpectedType == typeof(IQueryable<>) ||
|
|
genExpectedType == typeof(IOrderedQueryable<>)) &&
|
|
actualIsSequence
|
|
) {
|
|
if (elemType != genExpectedTypeArgs[0]) {
|
|
seqType = typeof(IEnumerable<>).MakeGenericType(genExpectedTypeArgs);
|
|
this.GenerateConvertToType(actualType, seqType);
|
|
elemType = genExpectedTypeArgs[0];
|
|
}
|
|
// seq.AsQueryable()
|
|
MethodInfo miAsQueryable = TypeSystem.FindQueryableMethod("AsQueryable", new Type[] { seqType }, elemType);
|
|
System.Diagnostics.Debug.Assert(miAsQueryable != null);
|
|
gen.Emit(OpCodes.Call, miAsQueryable);
|
|
if (genExpectedType == typeof(IOrderedQueryable<>)) {
|
|
gen.Emit(OpCodes.Castclass, expectedType);
|
|
}
|
|
}
|
|
// do we have a sequence when we want IOrderedEnumerable?
|
|
else if (genExpectedType == typeof(IOrderedEnumerable<>) && actualIsSequence) {
|
|
if (elemType != genExpectedTypeArgs[0]) {
|
|
seqType = typeof(IEnumerable<>).MakeGenericType(genExpectedTypeArgs);
|
|
this.GenerateConvertToType(actualType, seqType);
|
|
elemType = genExpectedTypeArgs[0];
|
|
}
|
|
// new OrderedResults<E>(seq)
|
|
Type orbType = typeof(ObjectMaterializer<>).MakeGenericType(this.compiler.dataReaderType);
|
|
MethodInfo miCreateOrderedEnumerable = TypeSystem.FindStaticMethod(orbType, "CreateOrderedEnumerable", new Type[] { seqType }, elemType);
|
|
System.Diagnostics.Debug.Assert(miCreateOrderedEnumerable != null);
|
|
gen.Emit(OpCodes.Call, miCreateOrderedEnumerable);
|
|
}
|
|
// do we have a sequence when we want EntitySet<T> ?
|
|
else if (genExpectedType == typeof(EntitySet<>) && actualIsSequence) {
|
|
if (elemType != genExpectedTypeArgs[0]) {
|
|
seqType = typeof(IEnumerable<>).MakeGenericType(genExpectedTypeArgs);
|
|
this.GenerateConvertToType(actualType, seqType);
|
|
actualType = seqType;
|
|
elemType = genExpectedTypeArgs[0];
|
|
}
|
|
// loc = new EntitySet<E>(); loc.Assign(seq); loc
|
|
LocalBuilder locSeq = gen.DeclareLocal(actualType);
|
|
gen.Emit(OpCodes.Stloc, locSeq);
|
|
|
|
ConstructorInfo ci = expectedType.GetConstructor(System.Type.EmptyTypes);
|
|
System.Diagnostics.Debug.Assert(ci != null);
|
|
gen.Emit(OpCodes.Newobj, ci);
|
|
LocalBuilder locEs = gen.DeclareLocal(expectedType);
|
|
gen.Emit(OpCodes.Stloc, locEs);
|
|
|
|
gen.Emit(OpCodes.Ldloc, locEs);
|
|
gen.Emit(OpCodes.Ldloc, locSeq);
|
|
MethodInfo miAssign = expectedType.GetMethod("Assign", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[] { seqType }, null);
|
|
System.Diagnostics.Debug.Assert(miAssign != null);
|
|
gen.Emit(GetMethodCallOpCode(miAssign), miAssign);
|
|
|
|
gen.Emit(OpCodes.Ldloc, locEs);
|
|
}
|
|
// do we have a sequence when we want something assignable from List<T>?
|
|
else if (typeof(IEnumerable).IsAssignableFrom(expectedType) &&
|
|
actualIsSequence &&
|
|
expectedType.IsAssignableFrom(typeof(List<>).MakeGenericType(elemType))
|
|
) {
|
|
// new List<E>(seq)
|
|
Type listType = typeof(List<>).MakeGenericType(elemType);
|
|
ConstructorInfo ci = listType.GetConstructor(new Type[] { seqType });
|
|
System.Diagnostics.Debug.Assert(ci != null);
|
|
gen.Emit(OpCodes.Newobj, ci);
|
|
}
|
|
// do we have a sequence when we want T[]?
|
|
else if (expectedType.IsArray && expectedType.GetArrayRank() == 1 &&
|
|
!actualType.IsArray && seqType.IsAssignableFrom(actualType) &&
|
|
expectedType.GetElementType().IsAssignableFrom(elemType)
|
|
) {
|
|
// seq.ToArray()
|
|
MethodInfo miToArray = TypeSystem.FindSequenceMethod("ToArray", new Type[] { seqType }, elemType);
|
|
System.Diagnostics.Debug.Assert(miToArray != null);
|
|
gen.Emit(OpCodes.Call, miToArray);
|
|
}
|
|
// do we have a sequence when we want some other collection type?
|
|
else if (expectedType.IsClass &&
|
|
typeof(ICollection<>).MakeGenericType(elemType).IsAssignableFrom(expectedType) &&
|
|
expectedType.GetConstructor(System.Type.EmptyTypes) != null &&
|
|
seqType.IsAssignableFrom(actualType)
|
|
) {
|
|
throw Error.GeneralCollectionMaterializationNotSupported();
|
|
}
|
|
// do we have an int when we want a bool?
|
|
else if (expectedType == typeof(bool) && actualType == typeof(int)) {
|
|
// expr != 0
|
|
Label labZero = gen.DefineLabel();
|
|
Label labExit = gen.DefineLabel();
|
|
gen.Emit(OpCodes.Ldc_I4_0);
|
|
gen.Emit(OpCodes.Ceq);
|
|
gen.Emit(OpCodes.Brtrue_S, labZero);
|
|
gen.Emit(OpCodes.Ldc_I4_1);
|
|
gen.Emit(OpCodes.Br_S, labExit);
|
|
gen.MarkLabel(labZero);
|
|
gen.Emit(OpCodes.Ldc_I4_0);
|
|
gen.MarkLabel(labExit);
|
|
}
|
|
else {
|
|
// last-ditch attempt: convert at runtime using DBConvert
|
|
// DBConvert.ChangeType(type, expr)
|
|
if (actualType.IsValueType) {
|
|
gen.Emit(OpCodes.Box, actualType);
|
|
}
|
|
gen.Emit(OpCodes.Ldtoken, expectedType);
|
|
MethodInfo miGetTypeFromHandle = typeof(Type).GetMethod("GetTypeFromHandle", BindingFlags.Static | BindingFlags.Public);
|
|
System.Diagnostics.Debug.Assert(miGetTypeFromHandle != null);
|
|
gen.Emit(OpCodes.Call, miGetTypeFromHandle);
|
|
MethodInfo miChangeType = typeof(DBConvert).GetMethod("ChangeType", BindingFlags.Static | BindingFlags.Public, null, new Type[] { typeof(object), typeof(Type) }, null);
|
|
System.Diagnostics.Debug.Assert(miChangeType != null);
|
|
gen.Emit(OpCodes.Call, miChangeType);
|
|
if (expectedType.IsValueType) {
|
|
gen.Emit(OpCodes.Unbox_Any, expectedType);
|
|
}
|
|
else if (expectedType != typeof(object)) {
|
|
gen.Emit(OpCodes.Castclass, expectedType);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private Type GenerateColumnReference(SqlColumnRef cref) {
|
|
this.GenerateColumnAccess(cref.ClrType, cref.SqlType, cref.Column.Ordinal, null);
|
|
return cref.ClrType;
|
|
}
|
|
|
|
private Type GenerateUserColumn(SqlUserColumn suc) {
|
|
// if the user column is not named, it must be the only one!
|
|
if (string.IsNullOrEmpty(suc.Name)) {
|
|
this.GenerateColumnAccess(suc.ClrType, suc.SqlType, 0, null);
|
|
return suc.ClrType;
|
|
}
|
|
int iName = this.namedColumns.Count;
|
|
this.namedColumns.Add(new NamedColumn(suc.Name, suc.IsRequired));
|
|
|
|
Label labNotDefined = gen.DefineLabel();
|
|
Label labExit = gen.DefineLabel();
|
|
LocalBuilder locOrdinal = gen.DeclareLocal(typeof(int));
|
|
|
|
// ordinal = session.ordinals[i]
|
|
this.GenerateAccessOrdinals();
|
|
this.GenerateConstInt(iName);
|
|
this.GenerateArrayAccess(typeof(int), false);
|
|
gen.Emit(OpCodes.Stloc, locOrdinal);
|
|
|
|
// if (ordinal < 0) goto labNotDefined
|
|
gen.Emit(OpCodes.Ldloc, locOrdinal);
|
|
this.GenerateConstInt(0);
|
|
gen.Emit(OpCodes.Clt);
|
|
gen.Emit(OpCodes.Brtrue, labNotDefined);
|
|
|
|
// access column at ordinal position
|
|
this.GenerateColumnAccess(suc.ClrType, suc.SqlType, 0, locOrdinal);
|
|
gen.Emit(OpCodes.Br_S, labExit);
|
|
|
|
// not defined?
|
|
gen.MarkLabel(labNotDefined);
|
|
this.GenerateDefault(suc.ClrType, false);
|
|
|
|
gen.MarkLabel(labExit);
|
|
|
|
return suc.ClrType;
|
|
}
|
|
|
|
private void GenerateColumnAccess(Type cType, ProviderType pType, int ordinal, LocalBuilder locOrdinal) {
|
|
Type rType = pType.GetClosestRuntimeType();
|
|
MethodInfo readerMethod = this.GetReaderMethod(this.compiler.dataReaderType, rType);
|
|
MethodInfo bufferMethod = this.GetReaderMethod(typeof(DbDataReader), rType);
|
|
|
|
Label labIsNull = gen.DefineLabel();
|
|
Label labExit = gen.DefineLabel();
|
|
Label labReadFromBuffer = gen.DefineLabel();
|
|
|
|
// if (buffer != null) goto ReadFromBuffer
|
|
this.GenerateAccessBufferReader();
|
|
gen.Emit(OpCodes.Ldnull);
|
|
gen.Emit(OpCodes.Ceq);
|
|
gen.Emit(OpCodes.Brfalse, labReadFromBuffer);
|
|
|
|
// read from DataReader
|
|
// this.reader.IsNull?
|
|
this.GenerateAccessDataReader();
|
|
if (locOrdinal != null)
|
|
gen.Emit(OpCodes.Ldloc, locOrdinal);
|
|
else
|
|
this.GenerateConstInt(ordinal);
|
|
gen.Emit(GetMethodCallOpCode(this.compiler.miDRisDBNull), this.compiler.miDRisDBNull);
|
|
gen.Emit(OpCodes.Brtrue, labIsNull);
|
|
|
|
// this.reader.GetXXX()
|
|
this.GenerateAccessDataReader();
|
|
if (locOrdinal != null)
|
|
gen.Emit(OpCodes.Ldloc, locOrdinal);
|
|
else
|
|
this.GenerateConstInt(ordinal);
|
|
gen.Emit(GetMethodCallOpCode(readerMethod), readerMethod);
|
|
this.GenerateConvertToType(rType, cType, readerMethod.ReturnType);
|
|
gen.Emit(OpCodes.Br_S, labExit);
|
|
|
|
// read from BUFFER
|
|
gen.MarkLabel(labReadFromBuffer);
|
|
|
|
// this.bufferReader.IsNull?
|
|
this.GenerateAccessBufferReader();
|
|
if (locOrdinal != null)
|
|
gen.Emit(OpCodes.Ldloc, locOrdinal);
|
|
else
|
|
this.GenerateConstInt(ordinal);
|
|
gen.Emit(GetMethodCallOpCode(this.compiler.miBRisDBNull), this.compiler.miBRisDBNull);
|
|
gen.Emit(OpCodes.Brtrue, labIsNull);
|
|
|
|
// this.bufferReader.GetXXX()
|
|
this.GenerateAccessBufferReader();
|
|
if (locOrdinal != null)
|
|
gen.Emit(OpCodes.Ldloc, locOrdinal);
|
|
else
|
|
this.GenerateConstInt(ordinal);
|
|
gen.Emit(GetMethodCallOpCode(bufferMethod), bufferMethod);
|
|
this.GenerateConvertToType(rType, cType, bufferMethod.ReturnType);
|
|
gen.Emit(OpCodes.Br_S, labExit);
|
|
|
|
// return NULL
|
|
gen.MarkLabel(labIsNull);
|
|
this.GenerateDefault(cType);
|
|
|
|
gen.MarkLabel(labExit);
|
|
}
|
|
|
|
private Type GenerateClientCase(SqlClientCase scc, bool isDeferred, LocalBuilder locInstance) {
|
|
LocalBuilder locDiscriminator = gen.DeclareLocal(scc.Expression.ClrType);
|
|
this.GenerateExpressionForType(scc.Expression, scc.Expression.ClrType);
|
|
gen.Emit(OpCodes.Stloc, locDiscriminator);
|
|
|
|
Label labNext = gen.DefineLabel();
|
|
Label labEnd = gen.DefineLabel();
|
|
for (int i = 0, n = scc.Whens.Count; i < n; i++) {
|
|
if (i > 0) {
|
|
gen.MarkLabel(labNext);
|
|
labNext = gen.DefineLabel();
|
|
}
|
|
SqlClientWhen when = scc.Whens[i];
|
|
if (when.Match != null) {
|
|
gen.Emit(OpCodes.Ldloc, locDiscriminator);
|
|
this.GenerateExpressionForType(when.Match, scc.Expression.ClrType);
|
|
this.GenerateEquals(locDiscriminator.LocalType);
|
|
gen.Emit(OpCodes.Brfalse, labNext);
|
|
}
|
|
if (isDeferred) {
|
|
this.GenerateDeferredSource(when.Value, locInstance);
|
|
}
|
|
else {
|
|
this.GenerateExpressionForType(when.Value, scc.ClrType);
|
|
}
|
|
gen.Emit(OpCodes.Br, labEnd);
|
|
}
|
|
gen.MarkLabel(labEnd);
|
|
|
|
return scc.ClrType;
|
|
}
|
|
|
|
private Type GenerateTypeCase(SqlTypeCase stc) {
|
|
LocalBuilder locDiscriminator = gen.DeclareLocal(stc.Discriminator.ClrType);
|
|
this.GenerateExpressionForType(stc.Discriminator, stc.Discriminator.ClrType);
|
|
gen.Emit(OpCodes.Stloc, locDiscriminator);
|
|
|
|
Label labNext = gen.DefineLabel();
|
|
Label labEnd = gen.DefineLabel();
|
|
bool hasDefault = false;
|
|
|
|
for (int i = 0, n = stc.Whens.Count; i < n; i++) {
|
|
if (i > 0) {
|
|
gen.MarkLabel(labNext);
|
|
labNext = gen.DefineLabel();
|
|
}
|
|
SqlTypeCaseWhen when = stc.Whens[i];
|
|
if (when.Match != null) {
|
|
gen.Emit(OpCodes.Ldloc, locDiscriminator);
|
|
SqlValue vMatch = when.Match as SqlValue;
|
|
System.Diagnostics.Debug.Assert(vMatch != null);
|
|
this.GenerateConstant(locDiscriminator.LocalType, vMatch.Value);
|
|
this.GenerateEquals(locDiscriminator.LocalType);
|
|
gen.Emit(OpCodes.Brfalse, labNext);
|
|
}
|
|
else {
|
|
System.Diagnostics.Debug.Assert(i == n - 1);
|
|
hasDefault = true;
|
|
}
|
|
this.GenerateExpressionForType(when.TypeBinding, stc.ClrType);
|
|
gen.Emit(OpCodes.Br, labEnd);
|
|
}
|
|
gen.MarkLabel(labNext);
|
|
if (!hasDefault) {
|
|
this.GenerateConstant(stc.ClrType, null);
|
|
}
|
|
gen.MarkLabel(labEnd);
|
|
|
|
return stc.ClrType;
|
|
}
|
|
|
|
private Type GenerateDiscriminatedType(SqlDiscriminatedType dt) {
|
|
System.Diagnostics.Debug.Assert(dt.ClrType == typeof(Type));
|
|
|
|
LocalBuilder locDiscriminator = gen.DeclareLocal(dt.Discriminator.ClrType);
|
|
this.GenerateExpressionForType(dt.Discriminator, dt.Discriminator.ClrType);
|
|
gen.Emit(OpCodes.Stloc, locDiscriminator);
|
|
|
|
return this.GenerateDiscriminatedType(dt.TargetType, locDiscriminator, dt.Discriminator.SqlType);
|
|
}
|
|
|
|
private Type GenerateDiscriminatedType(MetaType targetType, LocalBuilder locDiscriminator, ProviderType discriminatorType) {
|
|
System.Diagnostics.Debug.Assert(targetType != null && locDiscriminator != null);
|
|
|
|
MetaType defType = null;
|
|
Label labNext = gen.DefineLabel();
|
|
Label labEnd = gen.DefineLabel();
|
|
foreach (MetaType imt in targetType.InheritanceTypes) {
|
|
if (imt.InheritanceCode != null) {
|
|
if (imt.IsInheritanceDefault) {
|
|
defType = imt;
|
|
}
|
|
// disc == code?
|
|
gen.Emit(OpCodes.Ldloc, locDiscriminator);
|
|
object code = InheritanceRules.InheritanceCodeForClientCompare(imt.InheritanceCode, discriminatorType);
|
|
this.GenerateConstant(locDiscriminator.LocalType, code);
|
|
this.GenerateEquals(locDiscriminator.LocalType);
|
|
gen.Emit(OpCodes.Brfalse, labNext);
|
|
|
|
this.GenerateConstant(typeof(Type), imt.Type);
|
|
gen.Emit(OpCodes.Br, labEnd);
|
|
|
|
gen.MarkLabel(labNext);
|
|
labNext = gen.DefineLabel();
|
|
}
|
|
}
|
|
gen.MarkLabel(labNext);
|
|
if (defType != null) {
|
|
this.GenerateConstant(typeof(Type), defType.Type);
|
|
}
|
|
else {
|
|
this.GenerateDefault(typeof(Type));
|
|
}
|
|
|
|
gen.MarkLabel(labEnd);
|
|
|
|
return typeof(Type);
|
|
}
|
|
|
|
private Type GenerateSearchedCase(SqlSearchedCase ssc) {
|
|
Label labNext = gen.DefineLabel();
|
|
Label labEnd = gen.DefineLabel();
|
|
for (int i = 0, n = ssc.Whens.Count; i < n; i++) {
|
|
if (i > 0) {
|
|
gen.MarkLabel(labNext);
|
|
labNext = gen.DefineLabel();
|
|
}
|
|
SqlWhen when = ssc.Whens[i];
|
|
if (when.Match != null) {
|
|
this.GenerateExpressionForType(when.Match, typeof(bool)); // test
|
|
this.GenerateConstInt(0);
|
|
gen.Emit(OpCodes.Ceq);
|
|
gen.Emit(OpCodes.Brtrue, labNext);
|
|
}
|
|
this.GenerateExpressionForType(when.Value, ssc.ClrType);
|
|
gen.Emit(OpCodes.Br, labEnd);
|
|
}
|
|
gen.MarkLabel(labNext);
|
|
if (ssc.Else != null) {
|
|
this.GenerateExpressionForType(ssc.Else, ssc.ClrType);
|
|
}
|
|
gen.MarkLabel(labEnd);
|
|
return ssc.ClrType;
|
|
}
|
|
|
|
private void GenerateEquals(Type type) {
|
|
switch (Type.GetTypeCode(type)) {
|
|
case TypeCode.Object:
|
|
case TypeCode.String:
|
|
case TypeCode.DBNull:
|
|
if (type.IsValueType) {
|
|
LocalBuilder locLeft = gen.DeclareLocal(type);
|
|
LocalBuilder locRight = gen.DeclareLocal(type);
|
|
gen.Emit(OpCodes.Stloc, locRight);
|
|
gen.Emit(OpCodes.Stloc, locLeft);
|
|
gen.Emit(OpCodes.Ldloc, locLeft);
|
|
gen.Emit(OpCodes.Box, type);
|
|
gen.Emit(OpCodes.Ldloc, locRight);
|
|
gen.Emit(OpCodes.Box, type);
|
|
}
|
|
MethodInfo miEquals = typeof(object).GetMethod("Equals", BindingFlags.Static | BindingFlags.Public);
|
|
System.Diagnostics.Debug.Assert(miEquals != null);
|
|
gen.Emit(GetMethodCallOpCode(miEquals), miEquals);
|
|
break;
|
|
default:
|
|
gen.Emit(OpCodes.Ceq);
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void GenerateDefault(Type type) {
|
|
this.GenerateDefault(type, true);
|
|
}
|
|
|
|
private void GenerateDefault(Type type, bool throwIfNotNullable) {
|
|
if (type.IsValueType) {
|
|
if (!throwIfNotNullable || TypeSystem.IsNullableType(type)) {
|
|
LocalBuilder loc = gen.DeclareLocal(type);
|
|
gen.Emit(OpCodes.Ldloca, loc);
|
|
gen.Emit(OpCodes.Initobj, type);
|
|
gen.Emit(OpCodes.Ldloc, loc);
|
|
}
|
|
else {
|
|
gen.Emit(OpCodes.Ldtoken, type);
|
|
gen.Emit(OpCodes.Call, typeof(Type).GetMethod(
|
|
"GetTypeFromHandle", BindingFlags.Static | BindingFlags.Public));
|
|
|
|
MethodInfo mi = typeof(ObjectMaterializer<>)
|
|
.MakeGenericType(this.compiler.dataReaderType)
|
|
.GetMethod("ErrorAssignmentToNull", BindingFlags.Static | BindingFlags.Public);
|
|
System.Diagnostics.Debug.Assert(mi != null);
|
|
gen.Emit(OpCodes.Call, mi);
|
|
gen.Emit(OpCodes.Throw);
|
|
}
|
|
}
|
|
else {
|
|
gen.Emit(OpCodes.Ldnull);
|
|
}
|
|
}
|
|
|
|
private static Type[] readMethodSignature = new Type[] { typeof(int) };
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "Unknown reason.")]
|
|
private MethodInfo GetReaderMethod(Type readerType, Type valueType) {
|
|
if (valueType.IsEnum)
|
|
valueType = valueType.BaseType;
|
|
|
|
TypeCode tc = Type.GetTypeCode(valueType);
|
|
string name;
|
|
if (tc == TypeCode.Single) {
|
|
name = "GetFloat";
|
|
}
|
|
else {
|
|
name = "Get" + valueType.Name;
|
|
}
|
|
|
|
MethodInfo readerMethod = readerType.GetMethod(
|
|
name,
|
|
BindingFlags.Instance | BindingFlags.Public,
|
|
null,
|
|
readMethodSignature,
|
|
null
|
|
);
|
|
|
|
if (readerMethod == null) {
|
|
readerMethod = readerType.GetMethod(
|
|
"GetValue",
|
|
BindingFlags.Instance | BindingFlags.Public,
|
|
null,
|
|
readMethodSignature,
|
|
null
|
|
);
|
|
}
|
|
System.Diagnostics.Debug.Assert(readerMethod != null);
|
|
return readerMethod;
|
|
}
|
|
|
|
private void GenerateHasValue(Type nullableType) {
|
|
MethodInfo mi = nullableType.GetMethod("get_HasValue", BindingFlags.Instance | BindingFlags.Public);
|
|
gen.Emit(OpCodes.Call, mi);
|
|
}
|
|
|
|
private void GenerateGetValue(Type nullableType) {
|
|
MethodInfo mi = nullableType.GetMethod("get_Value", BindingFlags.Instance | BindingFlags.Public);
|
|
gen.Emit(OpCodes.Call, mi);
|
|
}
|
|
|
|
private void GenerateGetValueOrDefault(Type nullableType) {
|
|
MethodInfo mi = nullableType.GetMethod("GetValueOrDefault", System.Type.EmptyTypes);
|
|
gen.Emit(OpCodes.Call, mi);
|
|
}
|
|
|
|
private Type GenerateGlobalAccess(int iGlobal, Type type) {
|
|
this.GenerateAccessGlobals();
|
|
if (type.IsValueType) {
|
|
this.GenerateConstInt(iGlobal);
|
|
gen.Emit(OpCodes.Ldelem_Ref);
|
|
Type varType = typeof(StrongBox<>).MakeGenericType(type);
|
|
gen.Emit(OpCodes.Castclass, varType);
|
|
FieldInfo fi = varType.GetField("Value", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly);
|
|
gen.Emit(OpCodes.Ldfld, fi);
|
|
}
|
|
else {
|
|
this.GenerateConstInt(iGlobal);
|
|
gen.Emit(OpCodes.Ldelem_Ref);
|
|
this.GenerateConvertToType(typeof(object), type);
|
|
gen.Emit(OpCodes.Castclass, type);
|
|
}
|
|
return type;
|
|
}
|
|
|
|
private int AddGlobal(Type type, object value) {
|
|
int iGlobal = this.globals.Count;
|
|
if (type.IsValueType) {
|
|
this.globals.Add(Activator.CreateInstance(typeof(StrongBox<>).MakeGenericType(type), new object[] { value }));
|
|
}
|
|
else {
|
|
this.globals.Add(value);
|
|
}
|
|
return iGlobal;
|
|
}
|
|
|
|
private int AllocateLocal() {
|
|
return this.nLocals++;
|
|
}
|
|
|
|
private void GenerateStoreMember(MemberInfo mi) {
|
|
FieldInfo fi = mi as FieldInfo;
|
|
if (fi != null) {
|
|
gen.Emit(OpCodes.Stfld, fi);
|
|
}
|
|
else {
|
|
PropertyInfo pi = (PropertyInfo)mi;
|
|
MethodInfo meth = pi.GetSetMethod(true);
|
|
System.Diagnostics.Debug.Assert(meth != null);
|
|
gen.Emit(GetMethodCallOpCode(meth), meth);
|
|
}
|
|
}
|
|
|
|
private void GenerateLoadMember(MemberInfo mi) {
|
|
FieldInfo fi = mi as FieldInfo;
|
|
if (fi != null) {
|
|
gen.Emit(OpCodes.Ldfld, fi);
|
|
}
|
|
else {
|
|
PropertyInfo pi = (PropertyInfo)mi;
|
|
MethodInfo meth = pi.GetGetMethod(true);
|
|
gen.Emit(GetMethodCallOpCode(meth), meth);
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1804:RemoveUnusedLocals", Justification = "Microsoft: The variable tc for which the rule fires is used in both a Debug.Assert and in a switch statement")]
|
|
private void GenerateArrayAssign(Type type) {
|
|
// This method was copied out of the expression compiler codebase.
|
|
// Since DLINQ doesn't currently consume array indexers most of this
|
|
// function goes unused. Currently, the DLINQ materializer only
|
|
// accesses only ararys of objects and array of integers.
|
|
// The code is comment out to improve code coverage test.
|
|
// If you see one of the following assert fails, try to enable
|
|
// the comment out code.
|
|
|
|
if (type.IsEnum) {
|
|
gen.Emit(OpCodes.Stelem, type);
|
|
}
|
|
else {
|
|
TypeCode tc = Type.GetTypeCode(type);
|
|
|
|
switch (tc) {
|
|
case TypeCode.SByte:
|
|
case TypeCode.Byte:
|
|
gen.Emit(OpCodes.Stelem_I1);
|
|
break;
|
|
case TypeCode.Int16:
|
|
case TypeCode.UInt16:
|
|
gen.Emit(OpCodes.Stelem_I2);
|
|
break;
|
|
case TypeCode.Int32:
|
|
case TypeCode.UInt32:
|
|
gen.Emit(OpCodes.Stelem_I4);
|
|
break;
|
|
case TypeCode.Int64:
|
|
case TypeCode.UInt64:
|
|
gen.Emit(OpCodes.Stelem_I8);
|
|
break;
|
|
case TypeCode.Single:
|
|
gen.Emit(OpCodes.Stelem_R4);
|
|
break;
|
|
case TypeCode.Double:
|
|
gen.Emit(OpCodes.Stelem_R8);
|
|
break;
|
|
default:
|
|
if (type.IsValueType) {
|
|
gen.Emit(OpCodes.Stelem, type);
|
|
}
|
|
else {
|
|
gen.Emit(OpCodes.Stelem_Ref);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "address", Justification = "Microsoft: See comments in source. Usage commented out to improve code coverage test")]
|
|
private Type GenerateArrayAccess(Type type, bool address) {
|
|
// This method was copied out of the expression compiler codebase.
|
|
// Since DLINQ doesn't currently consume array indexers most of this
|
|
// function goes unused. Currently, the DLINQ materializer only
|
|
// accesses arrays of objects and array of integers.
|
|
// The code is comment out to improve code coverage test.
|
|
// If you see one of the following asserts fails, try to enable
|
|
// the comment out code.
|
|
|
|
System.Diagnostics.Debug.Assert(address == false);
|
|
|
|
// if (address)
|
|
// {
|
|
// gen.Emit(OpCodes.Ldelema);
|
|
// return type.MakeByRefType();
|
|
// }
|
|
// else
|
|
{
|
|
if (type.IsEnum) {
|
|
System.Diagnostics.Debug.Assert(false);
|
|
// gen.Emit(OpCodes.Ldelem, type);
|
|
}
|
|
else {
|
|
TypeCode tc = Type.GetTypeCode(type);
|
|
System.Diagnostics.Debug.Assert(tc == TypeCode.Int32);
|
|
|
|
switch (tc) {
|
|
//case TypeCode.SByte:
|
|
// gen.Emit(OpCodes.Ldelem_I1);
|
|
// break;
|
|
//case TypeCode.Int16:
|
|
// gen.Emit(OpCodes.Ldelem_I2);
|
|
// break;
|
|
case TypeCode.Int32:
|
|
gen.Emit(OpCodes.Ldelem_I4);
|
|
break;
|
|
//case TypeCode.Int64:
|
|
// gen.Emit(OpCodes.Ldelem_I8);
|
|
// break;
|
|
//case TypeCode.Single:
|
|
// gen.Emit(OpCodes.Ldelem_R4);
|
|
// break;
|
|
//case TypeCode.Double:
|
|
// gen.Emit(OpCodes.Ldelem_R8);
|
|
// break;
|
|
//default:
|
|
// if (type.IsValueType) {
|
|
// gen.Emit(OpCodes.Ldelem, type);
|
|
// }
|
|
// else {
|
|
// gen.Emit(OpCodes.Ldelem_Ref);
|
|
// }
|
|
// break;
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
}
|
|
|
|
private Type GenerateConstant(Type type, object value) {
|
|
if (value == null) {
|
|
if (type.IsValueType) {
|
|
LocalBuilder loc = gen.DeclareLocal(type);
|
|
gen.Emit(OpCodes.Ldloca, loc);
|
|
gen.Emit(OpCodes.Initobj, type);
|
|
gen.Emit(OpCodes.Ldloc, loc);
|
|
}
|
|
else {
|
|
gen.Emit(OpCodes.Ldnull);
|
|
}
|
|
}
|
|
else {
|
|
TypeCode tc = Type.GetTypeCode(type);
|
|
switch (tc) {
|
|
case TypeCode.Boolean:
|
|
this.GenerateConstInt((bool)value ? 1 : 0);
|
|
break;
|
|
case TypeCode.SByte:
|
|
this.GenerateConstInt((SByte)value);
|
|
gen.Emit(OpCodes.Conv_I1);
|
|
break;
|
|
case TypeCode.Int16:
|
|
this.GenerateConstInt((Int16)value);
|
|
gen.Emit(OpCodes.Conv_I2);
|
|
break;
|
|
case TypeCode.Int32:
|
|
this.GenerateConstInt((Int32)value);
|
|
break;
|
|
case TypeCode.Int64:
|
|
gen.Emit(OpCodes.Ldc_I8, (Int64)value);
|
|
break;
|
|
case TypeCode.Single:
|
|
gen.Emit(OpCodes.Ldc_R4, (float)value);
|
|
break;
|
|
case TypeCode.Double:
|
|
gen.Emit(OpCodes.Ldc_R8, (double)value);
|
|
break;
|
|
default:
|
|
int iGlobal = this.AddGlobal(type, value);
|
|
return this.GenerateGlobalAccess(iGlobal, type);
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
|
|
|
|
private void GenerateConstInt(int value) {
|
|
switch (value) {
|
|
case 0:
|
|
gen.Emit(OpCodes.Ldc_I4_0);
|
|
break;
|
|
case 1:
|
|
gen.Emit(OpCodes.Ldc_I4_1);
|
|
break;
|
|
case 2:
|
|
gen.Emit(OpCodes.Ldc_I4_2);
|
|
break;
|
|
case 3:
|
|
gen.Emit(OpCodes.Ldc_I4_3);
|
|
break;
|
|
case 4:
|
|
gen.Emit(OpCodes.Ldc_I4_4);
|
|
break;
|
|
case 5:
|
|
gen.Emit(OpCodes.Ldc_I4_5);
|
|
break;
|
|
case 6:
|
|
gen.Emit(OpCodes.Ldc_I4_6);
|
|
break;
|
|
case 7:
|
|
gen.Emit(OpCodes.Ldc_I4_7);
|
|
break;
|
|
case 8:
|
|
gen.Emit(OpCodes.Ldc_I4_8);
|
|
break;
|
|
default:
|
|
if (value == -1) {
|
|
gen.Emit(OpCodes.Ldc_I4_M1);
|
|
}
|
|
else if (value >= -127 && value < 128) {
|
|
gen.Emit(OpCodes.Ldc_I4_S, (sbyte)value);
|
|
}
|
|
else {
|
|
gen.Emit(OpCodes.Ldc_I4, value);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
struct NamedColumn {
|
|
string name;
|
|
bool isRequired;
|
|
internal NamedColumn(string name, bool isRequired) {
|
|
this.name = name;
|
|
this.isRequired = isRequired;
|
|
}
|
|
internal string Name {
|
|
get { return this.name; }
|
|
}
|
|
internal bool IsRequired {
|
|
get { return this.isRequired; }
|
|
}
|
|
}
|
|
|
|
class ObjectReaderFactory<TDataReader, TObject> : IObjectReaderFactory
|
|
where TDataReader : DbDataReader {
|
|
Func<ObjectMaterializer<TDataReader>, TObject> fnMaterialize;
|
|
NamedColumn[] namedColumns;
|
|
object[] globals;
|
|
int nLocals;
|
|
|
|
internal ObjectReaderFactory(
|
|
Func<ObjectMaterializer<TDataReader>, TObject> fnMaterialize,
|
|
NamedColumn[] namedColumns,
|
|
object[] globals,
|
|
int nLocals
|
|
) {
|
|
this.fnMaterialize = fnMaterialize;
|
|
this.namedColumns = namedColumns;
|
|
this.globals = globals;
|
|
this.nLocals = nLocals;
|
|
}
|
|
|
|
public IObjectReader Create(DbDataReader dataReader, bool disposeDataReader, IReaderProvider provider, object[] parentArgs, object[] userArgs, ICompiledSubQuery[] subQueries) {
|
|
ObjectReaderSession<TDataReader> session = new ObjectReaderSession<TDataReader>((TDataReader)dataReader, provider, parentArgs, userArgs, subQueries);
|
|
return session.CreateReader<TObject>(this.fnMaterialize, this.namedColumns, this.globals, this.nLocals, disposeDataReader);
|
|
}
|
|
|
|
public IObjectReader GetNextResult(IObjectReaderSession session, bool disposeDataReader) {
|
|
ObjectReaderSession<TDataReader> ors = (ObjectReaderSession<TDataReader>)session;
|
|
IObjectReader reader = ors.GetNextResult<TObject>(this.fnMaterialize, this.namedColumns, this.globals, this.nLocals, disposeDataReader);
|
|
if (reader == null && disposeDataReader) {
|
|
ors.Dispose();
|
|
}
|
|
return reader;
|
|
}
|
|
}
|
|
|
|
abstract class ObjectReaderBase<TDataReader> : ObjectMaterializer<TDataReader>
|
|
where TDataReader : DbDataReader {
|
|
protected ObjectReaderSession<TDataReader> session;
|
|
bool hasRead;
|
|
bool hasCurrentRow;
|
|
bool isFinished;
|
|
IDataServices services;
|
|
|
|
internal ObjectReaderBase(
|
|
ObjectReaderSession<TDataReader> session,
|
|
NamedColumn[] namedColumns,
|
|
object[] globals,
|
|
object[] arguments,
|
|
int nLocals
|
|
)
|
|
: base() {
|
|
this.session = session;
|
|
this.services = session.Provider.Services;
|
|
this.DataReader = session.DataReader;
|
|
this.Globals = globals;
|
|
this.Arguments = arguments;
|
|
if (nLocals > 0) {
|
|
this.Locals = new object[nLocals];
|
|
}
|
|
if (this.session.IsBuffered) {
|
|
this.Buffer();
|
|
}
|
|
this.Ordinals = this.GetColumnOrdinals(namedColumns);
|
|
}
|
|
|
|
// This method is called from within this class's constructor (through a call to Buffer()) so it is sealed to prevent
|
|
// derived classes from overriding it. See FxCop rule CA2214 for more information on why this is necessary.
|
|
public override sealed bool Read() {
|
|
if (this.isFinished) {
|
|
return false;
|
|
}
|
|
if (this.BufferReader != null) {
|
|
this.hasCurrentRow = this.BufferReader.Read();
|
|
}
|
|
else {
|
|
this.hasCurrentRow = this.DataReader.Read();
|
|
}
|
|
if (!this.hasCurrentRow) {
|
|
this.isFinished = true;
|
|
this.session.Finish(this);
|
|
}
|
|
this.hasRead = true;
|
|
return this.hasCurrentRow;
|
|
}
|
|
|
|
internal bool IsBuffered {
|
|
get { return this.BufferReader != null; }
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Globalization", "CA1306:SetLocaleForDataTypes", Justification = "Microsoft: Used only as a buffer and never used for string comparison.")]
|
|
internal void Buffer() {
|
|
if (this.BufferReader == null && (this.hasCurrentRow || !this.hasRead)) {
|
|
if (this.session.IsBuffered) {
|
|
this.BufferReader = this.session.GetNextBufferedReader();
|
|
}
|
|
else {
|
|
DataSet ds = new DataSet();
|
|
ds.EnforceConstraints = false;
|
|
DataTable bufferTable = new DataTable();
|
|
ds.Tables.Add(bufferTable);
|
|
string[] names = this.session.GetActiveNames();
|
|
bufferTable.Load(new Rereader(this.DataReader, this.hasCurrentRow, null), LoadOption.OverwriteChanges);
|
|
this.BufferReader = new Rereader(bufferTable.CreateDataReader(), false, names);
|
|
}
|
|
if (this.hasCurrentRow) {
|
|
this.Read();
|
|
}
|
|
}
|
|
}
|
|
|
|
public override object InsertLookup(int iMetaType, object instance) {
|
|
MetaType mType = (MetaType)this.Globals[iMetaType];
|
|
return this.services.InsertLookupCachedObject(mType, instance);
|
|
}
|
|
|
|
public override void SendEntityMaterialized(int iMetaType, object instance) {
|
|
MetaType mType = (MetaType)this.Globals[iMetaType];
|
|
this.services.OnEntityMaterialized(mType, instance);
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
public override bool CanDeferLoad {
|
|
get { return this.services.Context.DeferredLoadingEnabled; }
|
|
}
|
|
|
|
public override IEnumerable<T> GetLinkSource<T>(int iGlobalLink, int iLocalFactory, object[] keyValues) {
|
|
IDeferredSourceFactory factory = (IDeferredSourceFactory)this.Locals[iLocalFactory];
|
|
if (factory == null) {
|
|
MetaDataMember member = (MetaDataMember)this.Globals[iGlobalLink];
|
|
factory = this.services.GetDeferredSourceFactory(member);
|
|
this.Locals[iLocalFactory] = factory;
|
|
}
|
|
return (IEnumerable<T>)factory.CreateDeferredSource(keyValues);
|
|
}
|
|
|
|
public override IEnumerable<T> GetNestedLinkSource<T>(int iGlobalLink, int iLocalFactory, object instance) {
|
|
IDeferredSourceFactory factory = (IDeferredSourceFactory)this.Locals[iLocalFactory];
|
|
if (factory == null) {
|
|
MetaDataMember member = (MetaDataMember)this.Globals[iGlobalLink];
|
|
factory = this.services.GetDeferredSourceFactory(member);
|
|
this.Locals[iLocalFactory] = factory;
|
|
}
|
|
return (IEnumerable<T>)factory.CreateDeferredSource(instance);
|
|
}
|
|
|
|
private int[] GetColumnOrdinals(NamedColumn[] namedColumns) {
|
|
DbDataReader reader = null;
|
|
if (this.BufferReader != null) {
|
|
reader = this.BufferReader;
|
|
}
|
|
else {
|
|
reader = this.DataReader;
|
|
}
|
|
if (namedColumns == null || namedColumns.Length == 0) {
|
|
return null;
|
|
}
|
|
int[] columnOrdinals = new int[namedColumns.Length];
|
|
Dictionary<string, int> lookup = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
|
|
//we need to compare the quoted names on both sides
|
|
//because the designer might quote the name unnecessarily
|
|
for (int i = 0, n = reader.FieldCount; i < n; i++) {
|
|
lookup[SqlIdentifier.QuoteCompoundIdentifier(reader.GetName(i))] = i;
|
|
}
|
|
for (int i = 0, n = namedColumns.Length; i < n; i++) {
|
|
int ordinal;
|
|
if (lookup.TryGetValue(SqlIdentifier.QuoteCompoundIdentifier(namedColumns[i].Name), out ordinal)) {
|
|
columnOrdinals[i] = ordinal;
|
|
}
|
|
else if (namedColumns[i].IsRequired) {
|
|
throw Error.RequiredColumnDoesNotExist(namedColumns[i].Name);
|
|
}
|
|
else {
|
|
columnOrdinals[i] = -1;
|
|
}
|
|
}
|
|
return columnOrdinals;
|
|
}
|
|
}
|
|
|
|
class ObjectReader<TDataReader, TObject>
|
|
: ObjectReaderBase<TDataReader>, IEnumerator<TObject>, IObjectReader, IDisposable
|
|
where TDataReader : DbDataReader {
|
|
Func<ObjectMaterializer<TDataReader>, TObject> fnMaterialize;
|
|
TObject current;
|
|
bool disposeSession;
|
|
|
|
internal ObjectReader(
|
|
ObjectReaderSession<TDataReader> session,
|
|
NamedColumn[] namedColumns,
|
|
object[] globals,
|
|
object[] arguments,
|
|
int nLocals,
|
|
bool disposeSession,
|
|
Func<ObjectMaterializer<TDataReader>, TObject> fnMaterialize
|
|
)
|
|
: base(session, namedColumns, globals, arguments, nLocals) {
|
|
this.disposeSession = disposeSession;
|
|
this.fnMaterialize = fnMaterialize;
|
|
}
|
|
|
|
public IObjectReaderSession Session {
|
|
get { return this.session; }
|
|
}
|
|
|
|
public void Dispose() {
|
|
#if PERFORMANCE_BUILD
|
|
if (this.CollectQueryPerf) {
|
|
timer.Stop();
|
|
started = false;
|
|
pcSqlQueryEnumGetCurrent.IncrementBy(timer.Duration);
|
|
bpcSqlQueryEnumGetCurrent.Increment();
|
|
}
|
|
#endif
|
|
// Technically, calling GC.SuppressFinalize is not required because the class does not
|
|
// have a finalizer, but it does no harm, protects against the case where a finalizer is added
|
|
// in the future, and prevents an FxCop warning.
|
|
GC.SuppressFinalize(this);
|
|
if (this.disposeSession) {
|
|
this.session.Dispose();
|
|
}
|
|
}
|
|
|
|
public bool MoveNext() {
|
|
#if PERFORMANCE_BUILD
|
|
if (this.CollectQueryPerf) {
|
|
if (!started) {
|
|
started = true;
|
|
timer.Start();
|
|
}
|
|
}
|
|
#endif
|
|
if (this.Read()) {
|
|
this.current = this.fnMaterialize(this);
|
|
return true;
|
|
}
|
|
else {
|
|
this.current = default(TObject);
|
|
this.Dispose();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public TObject Current {
|
|
get { return this.current; }
|
|
}
|
|
|
|
public void Reset() {
|
|
}
|
|
|
|
object IEnumerator.Current {
|
|
get {
|
|
return this.Current;
|
|
}
|
|
}
|
|
|
|
#if PERFORMANCE_BUILD
|
|
PerformanceCounter pcSqlQueryEnumGetCurrent = null;
|
|
PerformanceCounter bpcSqlQueryEnumGetCurrent = null;
|
|
PerfTimer timer = null;
|
|
bool collectQueryPerf;
|
|
bool collectQueryPerfInitialized = false;
|
|
bool started;
|
|
|
|
private bool CollectQueryPerf {
|
|
get {
|
|
if (!collectQueryPerfInitialized) {
|
|
collectQueryPerf = this.enumerable.session.context.CollectQueryPerf;
|
|
if (collectQueryPerf) {
|
|
pcSqlQueryEnumGetCurrent = new PerformanceCounter("DLinq", "SqlQueryEnumGetCurrentElapsedTime", false);
|
|
bpcSqlQueryEnumGetCurrent = new PerformanceCounter("DLinq", "SqlQueryEnumGetCurrentElapsedTimeBase", false);
|
|
timer = new PerfTimer();
|
|
}
|
|
collectQueryPerfInitialized = true;
|
|
}
|
|
return this.collectQueryPerf;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
class ObjectReaderSession<TDataReader> : IObjectReaderSession, IDisposable, IConnectionUser
|
|
where TDataReader : DbDataReader {
|
|
TDataReader dataReader;
|
|
ObjectReaderBase<TDataReader> currentReader;
|
|
IReaderProvider provider;
|
|
List<DbDataReader> buffer;
|
|
int iNextBufferedReader;
|
|
bool isDisposed;
|
|
bool isDataReaderDisposed;
|
|
bool hasResults;
|
|
object[] parentArgs;
|
|
object[] userArgs;
|
|
ICompiledSubQuery[] subQueries;
|
|
|
|
internal ObjectReaderSession(
|
|
TDataReader dataReader,
|
|
IReaderProvider provider,
|
|
object[] parentArgs,
|
|
object[] userArgs,
|
|
ICompiledSubQuery[] subQueries
|
|
) {
|
|
this.dataReader = dataReader;
|
|
this.provider = provider;
|
|
this.parentArgs = parentArgs;
|
|
this.userArgs = userArgs;
|
|
this.subQueries = subQueries;
|
|
this.hasResults = true;
|
|
}
|
|
|
|
internal ObjectReaderBase<TDataReader> CurrentReader {
|
|
get { return this.currentReader; }
|
|
}
|
|
|
|
internal TDataReader DataReader {
|
|
get { return this.dataReader; }
|
|
}
|
|
|
|
internal IReaderProvider Provider {
|
|
get { return this.provider; }
|
|
}
|
|
|
|
internal object[] ParentArguments {
|
|
get { return this.parentArgs; }
|
|
}
|
|
|
|
internal object[] UserArguments {
|
|
get { return this.userArgs; }
|
|
}
|
|
|
|
internal ICompiledSubQuery[] SubQueries {
|
|
get { return this.subQueries; }
|
|
}
|
|
|
|
internal void Finish(ObjectReaderBase<TDataReader> finishedReader) {
|
|
if (this.currentReader == finishedReader) {
|
|
this.CheckNextResults();
|
|
}
|
|
}
|
|
|
|
private void CheckNextResults() {
|
|
this.hasResults = !this.dataReader.IsClosed && this.dataReader.NextResult();
|
|
this.currentReader = null;
|
|
if (!this.hasResults) {
|
|
this.Dispose();
|
|
}
|
|
}
|
|
|
|
internal DbDataReader GetNextBufferedReader() {
|
|
if (this.iNextBufferedReader < this.buffer.Count) {
|
|
return this.buffer[this.iNextBufferedReader++];
|
|
}
|
|
System.Diagnostics.Debug.Assert(false);
|
|
return null;
|
|
}
|
|
|
|
public bool IsBuffered {
|
|
get { return this.buffer != null; }
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Globalization", "CA1306:SetLocaleForDataTypes", Justification = "Microsoft: Used only as a buffer and never used for string comparison.")]
|
|
public void Buffer() {
|
|
if (this.buffer == null) {
|
|
if (this.currentReader != null && !this.currentReader.IsBuffered) {
|
|
this.currentReader.Buffer();
|
|
this.CheckNextResults();
|
|
}
|
|
// buffer anything remaining in the session
|
|
this.buffer = new List<DbDataReader>();
|
|
while (this.hasResults) {
|
|
DataSet ds = new DataSet();
|
|
ds.EnforceConstraints = false;
|
|
DataTable tb = new DataTable();
|
|
ds.Tables.Add(tb);
|
|
string[] names = this.GetActiveNames();
|
|
tb.Load(new Rereader(this.dataReader, false, null), LoadOption.OverwriteChanges);
|
|
this.buffer.Add(new Rereader(tb.CreateDataReader(), false, names));
|
|
this.CheckNextResults();
|
|
}
|
|
}
|
|
}
|
|
|
|
internal string[] GetActiveNames() {
|
|
string[] names = new string[this.DataReader.FieldCount];
|
|
for (int i = 0, n = this.DataReader.FieldCount; i < n; i++) {
|
|
names[i] = this.DataReader.GetName(i);
|
|
}
|
|
return names;
|
|
}
|
|
|
|
public void CompleteUse() {
|
|
this.Buffer();
|
|
}
|
|
|
|
public void Dispose() {
|
|
if (!this.isDisposed) {
|
|
// Technically, calling GC.SuppressFinalize is not required because the class does not
|
|
// have a finalizer, but it does no harm, protects against the case where a finalizer is added
|
|
// in the future, and prevents an FxCop warning.
|
|
GC.SuppressFinalize(this);
|
|
this.isDisposed = true;
|
|
if (!this.isDataReaderDisposed) {
|
|
this.isDataReaderDisposed = true;
|
|
this.dataReader.Dispose();
|
|
}
|
|
this.provider.ConnectionManager.ReleaseConnection(this);
|
|
}
|
|
}
|
|
|
|
internal ObjectReader<TDataReader, TObject> CreateReader<TObject>(
|
|
Func<ObjectMaterializer<TDataReader>, TObject> fnMaterialize,
|
|
NamedColumn[] namedColumns,
|
|
object[] globals,
|
|
int nLocals,
|
|
bool disposeDataReader
|
|
) {
|
|
ObjectReader<TDataReader, TObject> objectReader =
|
|
new ObjectReader<TDataReader, TObject>(this, namedColumns, globals, this.userArgs, nLocals, disposeDataReader, fnMaterialize);
|
|
this.currentReader = objectReader;
|
|
return objectReader;
|
|
}
|
|
|
|
internal ObjectReader<TDataReader, TObject> GetNextResult<TObject>(
|
|
Func<ObjectMaterializer<TDataReader>, TObject> fnMaterialize,
|
|
NamedColumn[] namedColumns,
|
|
object[] globals,
|
|
int nLocals,
|
|
bool disposeDataReader
|
|
) {
|
|
// skip forward to next results
|
|
if (this.buffer != null) {
|
|
if (this.iNextBufferedReader >= this.buffer.Count) {
|
|
return null;
|
|
}
|
|
}
|
|
else {
|
|
if (this.currentReader != null) {
|
|
// buffer current reader
|
|
this.currentReader.Buffer();
|
|
this.CheckNextResults();
|
|
}
|
|
if (!this.hasResults) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
ObjectReader<TDataReader, TObject> objectReader =
|
|
new ObjectReader<TDataReader, TObject>(this, namedColumns, globals, this.userArgs, nLocals, disposeDataReader, fnMaterialize);
|
|
|
|
this.currentReader = objectReader;
|
|
return objectReader;
|
|
}
|
|
}
|
|
|
|
class Rereader : DbDataReader, IDisposable {
|
|
bool first;
|
|
DbDataReader reader;
|
|
string[] names;
|
|
|
|
internal Rereader(DbDataReader reader, bool hasCurrentRow, string[] names) {
|
|
this.reader = reader;
|
|
this.first = hasCurrentRow;
|
|
this.names = names;
|
|
}
|
|
|
|
public override bool Read() {
|
|
if (this.first) {
|
|
this.first = false;
|
|
return true;
|
|
}
|
|
return this.reader.Read();
|
|
}
|
|
|
|
public override string GetName(int i) {
|
|
if (this.names != null) {
|
|
return this.names[i];
|
|
}
|
|
return reader.GetName(i);
|
|
}
|
|
|
|
public override void Close() { }
|
|
public override bool NextResult() { return false; }
|
|
|
|
public override int Depth { get { return reader.Depth; } }
|
|
public override bool IsClosed { get { return reader.IsClosed; } }
|
|
public override int RecordsAffected { get { return reader.RecordsAffected; } }
|
|
public override DataTable GetSchemaTable() { return reader.GetSchemaTable(); }
|
|
|
|
public override int FieldCount { get { return reader.FieldCount; } }
|
|
public override object this[int i] { get { return reader[i]; } }
|
|
public override object this[string name] { get { return reader[name]; } }
|
|
public override bool GetBoolean(int i) { return reader.GetBoolean(i); }
|
|
public override byte GetByte(int i) { return reader.GetByte(i); }
|
|
public override long GetBytes(int i, long fieldOffset, byte[] buffer, int bufferOffset, int length) { return reader.GetBytes(i, fieldOffset, buffer, bufferOffset, length); }
|
|
public override char GetChar(int i) { return reader.GetChar(i); }
|
|
public override long GetChars(int i, long fieldOffset, char[] buffer, int bufferOffset, int length) { return reader.GetChars(i, fieldOffset, buffer, bufferOffset, length); }
|
|
public override string GetDataTypeName(int i) { return reader.GetDataTypeName(i); }
|
|
public override DateTime GetDateTime(int i) { return reader.GetDateTime(i); }
|
|
public override decimal GetDecimal(int i) { return reader.GetDecimal(i); }
|
|
public override double GetDouble(int i) { return reader.GetDouble(i); }
|
|
public override Type GetFieldType(int i) { return reader.GetFieldType(i); }
|
|
public override float GetFloat(int i) { return reader.GetFloat(i); }
|
|
public override Guid GetGuid(int i) { return reader.GetGuid(i); }
|
|
public override short GetInt16(int i) { return reader.GetInt16(i); }
|
|
public override int GetInt32(int i) { return reader.GetInt32(i); }
|
|
public override long GetInt64(int i) { return reader.GetInt64(i); }
|
|
public override int GetOrdinal(string name) { return reader.GetOrdinal(name); }
|
|
public override string GetString(int i) { return reader.GetString(i); }
|
|
public override object GetValue(int i) { return reader.GetValue(i); }
|
|
public override int GetValues(object[] values) { return reader.GetValues(values); }
|
|
public override bool IsDBNull(int i) { return reader.IsDBNull(i); }
|
|
|
|
public override IEnumerator GetEnumerator() {
|
|
return this.reader.GetEnumerator();
|
|
}
|
|
public override bool HasRows {
|
|
get { return this.first || this.reader.HasRows; }
|
|
}
|
|
}
|
|
|
|
internal class Group<K, T> : IGrouping<K, T>, IEnumerable<T>, IEnumerable {
|
|
K key;
|
|
IEnumerable<T> items;
|
|
|
|
internal Group(K key, IEnumerable<T> items) {
|
|
this.key = key;
|
|
this.items = items;
|
|
}
|
|
|
|
K IGrouping<K, T>.Key {
|
|
get { return this.key; }
|
|
}
|
|
|
|
IEnumerator IEnumerable.GetEnumerator() {
|
|
return (IEnumerator)this.GetEnumerator();
|
|
}
|
|
|
|
public IEnumerator<T> GetEnumerator() {
|
|
return this.items.GetEnumerator();
|
|
}
|
|
}
|
|
|
|
internal class OrderedResults<T> : IOrderedEnumerable<T>, IEnumerable<T> {
|
|
List<T> values;
|
|
internal OrderedResults(IEnumerable<T> results) {
|
|
this.values = results as List<T>;
|
|
if (this.values == null)
|
|
this.values = new List<T>(results);
|
|
}
|
|
IOrderedEnumerable<T> IOrderedEnumerable<T>.CreateOrderedEnumerable<K>(Func<T, K> keySelector, IComparer<K> comparer, bool descending) {
|
|
throw Error.NotSupported();
|
|
}
|
|
IEnumerator IEnumerable.GetEnumerator() {
|
|
return ((IEnumerable)this.values).GetEnumerator();
|
|
}
|
|
IEnumerator<T> IEnumerable<T>.GetEnumerator() {
|
|
return this.values.GetEnumerator();
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|