Update source to 1.4.26

Update source to 1.4.26

Author: zzzprojects

src/Z.EntityFramework.Plus.EF5.NET40/BatchUpdate/BatchUpdate.cs

@@ -436,11 +436,13 @@ public DbCommand CreateCommand(IQueryable query, IEntityType entity, List<Tuple<
 
 #if EFCORE
                 // ADD Parameter
-                foreach (var parameter in queryContext.ParameterValues)
+                foreach (var relationalParameter in relationalCommand.Parameters)
                 {
+                    var parameter = queryContext.ParameterValues[relationalParameter.InvariantName];
+
                     var param = command.CreateParameter();
-                    param.ParameterName = parameter.Key;
-                    param.Value = parameter.Value;
+                    param.ParameterName = relationalParameter.InvariantName;
+                    param.Value = parameter;
 
                     command.Parameters.Add(param);
                 }
@@ -617,6 +619,7 @@ public List<Tuple<string, object>> GetInnerValues<T>(IQueryable<T> query, Expres
 
                     // Add the destination name
                     valueSql = valueSql.Replace("[x]", "B");
+                    valueSql = valueSql.Replace("[c]", "B");
 #endif
                     destinationValues.Add(new Tuple<string, object>(columnName, Expression.Constant(valueSql)));
                 }
@@ -692,6 +695,20 @@ public Dictionary<string, object> ResolveUpdateFromQueryDictValues<T>(Expression
                 }
                 else
                 {
+                    // FIX all member access to remove variable
+                    memberExpression = memberExpression.Visit((MemberExpression m) =>
+                    {
+                        if (m.Expression.NodeType == ExpressionType.Constant)
+                        {
+                            var lambda = Expression.Lambda(m, null);
+                            var value = lambda.Compile().DynamicInvoke();
+                            var c =  Expression.Constant(value);
+                            return c;
+                        }
+
+                        return m;
+                    });
+
                     // ADD expression, the expression will be resolved later
                     dictValues.Add(propertyName, memberExpression);
                 }

src/Z.EntityFramework.Plus.EF5.NET40/Properties/AssemblyInfo.cs

@@ -18,5 +18,5 @@
 [assembly: AssemblyCulture("")]
 [assembly: ComVisible(false)]
 [assembly: Guid("e4c2af73-caeb-4429-bcb6-0a359484e064")]
-[assembly: AssemblyVersion("1.4.19")]
-[assembly: AssemblyFileVersion("1.4.19")]
+[assembly: AssemblyVersion("1.4.26")]
+[assembly: AssemblyFileVersion("1.4.26")]

src/Z.EntityFramework.Plus.EF5.NET40/QueryFilter/Extensions/DbContext.SetFiltered.cs

@@ -0,0 +1,44 @@
+// Description: Entity Framework Bulk Operations & Utilities (EF Bulk SaveChanges, Insert, Update, Delete, Merge | LINQ Query Cache, Deferred, Filter, IncludeFilter, IncludeOptimize | Audit)
+// Website & Documentation: https://github.com/zzzprojects/Entity-Framework-Plus
+// Forum & Issues: https://github.com/zzzprojects/EntityFramework-Plus/issues
+// License: https://github.com/zzzprojects/EntityFramework-Plus/blob/master/LICENSE
+// More projects: http://www.zzzprojects.com/
+// Copyright © ZZZ Projects Inc. 2014 - 2016. All rights reserved.
+
+
+#if EFCORE
+using System;
+using System.Linq;
+#if EF5 || EF6
+using System.Data.Entity;
+
+#elif EFCORE
+using Microsoft.EntityFrameworkCore;
+
+#endif
+
+namespace Z.EntityFramework.Plus
+{
+    public static partial class QueryFilterExtensions
+    {
+        public static IQueryable<T> SetFiltered<T>(this DbContext context) where T : class
+        {
+            var filterContext = QueryFilterManager.AddOrGetFilterContext(context);
+
+            if (filterContext.FilterSetByType.ContainsKey(typeof(T)))
+            {
+                var set = filterContext.FilterSetByType[typeof(T)];
+
+                if (set.Count == 1)
+                {
+                    return (IQueryable<T>) set[0].DbSetProperty.GetValue(context);
+                }
+                throw new Exception(ExceptionMessage.QueryFilter_SetFilteredManyFound);
+            }
+
+            throw new Exception(ExceptionMessage.QueryFilter_SetFilteredNotFound);
+        }
+    }
+}
+
+#endif

src/Z.EntityFramework.Plus.EF5.NET40/QueryFilter/QueryFilterContext.cs

@@ -78,6 +78,25 @@ public BaseQueryFilter AddFilter<T>(object key, Func<IQueryable<T>, IQueryable<T
             return queryFilter;
         }
 
+        /// <summary>Filter the query using context filters associated with specified keys.</summary>
+        /// <typeparam name="T">Generic type parameter.</typeparam>
+        /// <param name="query">The query to filter using context filters associated with specified keys.</param>
+        /// <returns>The query filtered using context filters associated with specified keys.</returns>
+        public IQueryable<T> ApplyFilter<T>(IQueryable<T> query)
+        {
+            object newQuery = query;
+
+            foreach (var filter in Filters)
+            {
+                if (filter.Value.IsDefaultEnabled)
+                {
+                    newQuery = (IQueryable) filter.Value.ApplyFilter<T>(newQuery);
+                }
+            }
+
+            return (IQueryable<T>) newQuery;
+        }
+
         /// <summary>Filter the query using context filters associated with specified keys.</summary>
         /// <typeparam name="T">The type of elements of the query.</typeparam>
         /// <param name="query">The query to filter using context filters associated with specified keys.</param>

src/Z.EntityFramework.Plus.EF5.NET40/QueryFuture/BaseQueryFuture.cs

@@ -69,6 +69,11 @@ public abstract class BaseQueryFuture
         /// <value>The query connection.</value>
         internal CreateEntityRelationConnection QueryConnection { get; set; }
 
+        public virtual void ExecuteInMemory()
+        {
+            
+        }
+
         /// <summary>Creates executor and get command.</summary>
         /// <returns>The new executor and get command.</returns>
         public virtual IRelationalCommand CreateExecutorAndGetCommand(out RelationalQueryContext queryContext)
@@ -204,9 +209,9 @@ public IEnumerator<T> GetQueryEnumerator<T>(DbDataReader reader)
             var createMethod = resultShaperFactory.GetType().GetMethod("Create", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
 
 #if EF5
-            var create = createMethod.Invoke(resultShaperFactory, new object[] {reader, Query.Context, Query.Context.MetadataWorkspace, MergeOption.AppendOnly, false});
+            var create = createMethod.Invoke(resultShaperFactory, new object[] {reader, Query.Context, Query.Context.MetadataWorkspace, Query.MergeOption, false});
 #elif EF6
-            var create = createMethod.Invoke(resultShaperFactory, new object[] { reader, Query.Context, Query.Context.MetadataWorkspace, MergeOption.AppendOnly, false, true });
+            var create = createMethod.Invoke(resultShaperFactory, new object[] { reader, Query.Context, Query.Context.MetadataWorkspace, Query.MergeOption, false, true });
 #endif
 
             // REFLECTION: Query.QueryState.GetExecutionPlan(null).ResultShaperFactory.Create(parameters).GetEnumerator()
@@ -222,5 +227,10 @@ public IEnumerator<T> GetQueryEnumerator<T>(DbDataReader reader)
             return queryEnumerable.GetEnumerator();
 #endif
         }
+
+        public virtual void GetResultDirectly()
+        {
+
+        }
     }
 }

src/Z.EntityFramework.Plus.EF5.NET40/QueryFuture/Extensions/IQueryable`/Future.cs

@@ -34,9 +34,21 @@ public static QueryFutureEnumerable<T> Future<T>(this IQueryable<T> query)
             var futureBatch = QueryFutureManager.AddOrGetBatch(objectQuery.Context);
             var futureQuery = new QueryFutureEnumerable<T>(futureBatch, objectQuery);
 #elif EFCORE
-            var context = query.GetDbContext();
-            var futureBatch = QueryFutureManager.AddOrGetBatch(context);
-            var futureQuery = new QueryFutureEnumerable<T>(futureBatch, query);
+            QueryFutureBatch futureBatch;
+            QueryFutureEnumerable<T> futureQuery;
+            if (query.IsInMemoryQueryContext())
+            {
+                var context = query.GetInMemoryContext();
+                futureBatch = QueryFutureManager.AddOrGetBatch(context);
+                futureBatch.IsInMemory = true;
+                futureQuery = new QueryFutureEnumerable<T>(futureBatch, query);
+            }
+            else
+            {
+                var context = query.GetDbContext();
+                futureBatch = QueryFutureManager.AddOrGetBatch(context);
+                futureQuery = new QueryFutureEnumerable<T>(futureBatch, query);
+            }
 #endif
             futureBatch.Queries.Add(futureQuery);
 

src/Z.EntityFramework.Plus.EF5.NET40/QueryFuture/Extensions/IQueryable`/FutureValue.cs

@@ -34,9 +34,21 @@ public static QueryFutureValue<TResult> FutureValue<TResult>(this IQueryable<TRe
             var futureBatch = QueryFutureManager.AddOrGetBatch(objectQuery.Context);
             var futureQuery = new QueryFutureValue<TResult>(futureBatch, objectQuery);
 #elif EFCORE
-            var context = query.GetDbContext();
-            var futureBatch = QueryFutureManager.AddOrGetBatch(context);
-            var futureQuery = new QueryFutureValue<TResult>(futureBatch, query);
+            QueryFutureBatch futureBatch;
+            QueryFutureValue<TResult> futureQuery;
+            if (query.IsInMemoryQueryContext())
+            {
+                var context = query.GetInMemoryContext();
+                futureBatch = QueryFutureManager.AddOrGetBatch(context);
+                futureBatch.IsInMemory = true;
+                futureQuery = new QueryFutureValue<TResult>(futureBatch, query);
+            }
+            else
+            {
+                var context = query.GetDbContext();
+                futureBatch = QueryFutureManager.AddOrGetBatch(context);
+                futureQuery = new QueryFutureValue<TResult>(futureBatch, query);
+            }
 #endif
             futureBatch.Queries.Add(futureQuery);
 

src/Z.EntityFramework.Plus.EF5.NET40/QueryFuture/Extensions/QueryDeferred/FutureValue.cs

@@ -26,9 +26,22 @@ public static QueryFutureValue<TResult> FutureValue<TResult>(this QueryDeferred<
             var futureBatch = QueryFutureManager.AddOrGetBatch(objectQuery.Context);
             var futureQuery = new QueryFutureValue<TResult>(futureBatch, objectQuery);
 #elif EFCORE
-            var context = query.Query.GetDbContext();
-            var futureBatch = QueryFutureManager.AddOrGetBatch(context);
-            var futureQuery = new QueryFutureValue<TResult>(futureBatch, query.Query);
+            QueryFutureBatch futureBatch;
+            QueryFutureValue<TResult> futureQuery;
+            if (query.Query.IsInMemoryQueryContext())
+            {
+                var context = query.Query.GetInMemoryContext();
+                futureBatch = QueryFutureManager.AddOrGetBatch(context);
+                futureBatch.IsInMemory = true;
+                futureQuery = new QueryFutureValue<TResult>(futureBatch, query.Query);
+                futureQuery.InMemoryDeferredQuery = query;
+            }
+            else
+            {
+                var context = query.Query.GetDbContext();
+                futureBatch = QueryFutureManager.AddOrGetBatch(context);
+                futureQuery = new QueryFutureValue<TResult>(futureBatch, query.Query);
+            }
 #endif
             futureBatch.Queries.Add(futureQuery);
 

src/Z.EntityFramework.Plus.EF5.NET40/QueryFuture/QueryFutureBatch.cs

@@ -56,6 +56,8 @@ public QueryFutureBatch(DbContext context)
         public ObjectContext Context { get; set; }
 #elif EFCORE
         public DbContext Context { get; set; }
+
+        public bool IsInMemory { get; set; }
 #endif
 
         /// <summary>Gets or sets deferred query lists waiting to be executed.</summary>
@@ -65,9 +67,31 @@ public QueryFutureBatch(DbContext context)
         /// <summary>Executes deferred query lists.</summary>
         public void ExecuteQueries()
         {
+            if (Queries.Count == 0)
+            {
+                // Already all executed
+                return;
+            }
+
+            if (Queries.Count == 1)
+            {
+                Queries[0].GetResultDirectly();
+                Queries.Clear();
+                return;
+            }
+
 #if EF5 || EF6
             var connection = (EntityConnection) Context.Connection;
 #elif EFCORE
+            if (IsInMemory)
+            {
+                foreach (var query in Queries)
+                {
+                    query.ExecuteInMemory();
+                }
+                return;
+            }
+
             var connection = Context.Database.GetDbConnection();
 #endif
             var command = CreateCommandCombined();
@@ -243,15 +267,27 @@ protected DbCommand CreateCommandCombined()
 
                     if (isOracle)
                     {
+#if NETSTANDARD1_3
+                        SetOracleDbType(command.GetType().GetTypeInfo().Assembly, param, 121);
+#else
                         SetOracleDbType(command.GetType().Assembly, param, 121);
+#endif
                     }
                     else if (isOracleManaged)
                     {
+#if NETSTANDARD1_3
+                        SetOracleManagedDbType(command.GetType().GetTypeInfo().Assembly, param, 121);
+#else
                         SetOracleManagedDbType(command.GetType().Assembly, param, 121);
+#endif
                     }
                     else if (isOracleDevArt)
                     {
+#if NETSTANDARD1_3
+                        SetOracleDevArtDbType(command.GetType().GetTypeInfo().Assembly, param, 7);
+#else
                         SetOracleDevArtDbType(command.GetType().Assembly, param, 7);
+#endif
                     }
 
 

src/Z.EntityFramework.Plus.EF5.NET40/QueryFuture/QueryFutureEnumerable.cs

@@ -8,6 +8,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Data.Common;
+using System.Linq;
 #if EF5
 using System.Data.Objects;
 
@@ -78,8 +79,19 @@ IEnumerator IEnumerable.GetEnumerator()
         /// <param name="reader">The reader returned from the query execution.</param>
         public override void SetResult(DbDataReader reader)
         {
+            if (reader.GetType().FullName.Contains("Oracle"))
+            {
+                var reader2 = new QueryFutureOracleDbReader(reader);
+                reader = reader2;
+            }
+            
             var enumerator = GetQueryEnumerator<T>(reader);
 
+            SetResult(enumerator);
+        }
+
+        public void SetResult(IEnumerator<T> enumerator)
+        {
             // Enumerate on all items
             var list = new List<T>();
             while (enumerator.MoveNext())
@@ -90,5 +102,20 @@ public override void SetResult(DbDataReader reader)
 
             HasValue = true;
         }
+
+#if EFCORE
+        public override void ExecuteInMemory()
+        {
+            HasValue = true;
+            _result = ((IQueryable<T>) Query).ToList();
+        }
+#endif
+        public override void GetResultDirectly()
+        {
+            var query = ((IQueryable<T>)Query);
+            var enumerator = query.GetEnumerator();
+
+            SetResult(enumerator);
+        }
     }
 }