Return results from bulk inserts and updates

EntityFramework.Utilities/EntityFramework.Utilities.sln

@@ -7,6 +7,11 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Tests", "Tests\Tests.csproj
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PerformanceTests", "PerformanceTests\PerformanceTests.csproj", "{B888C7A8-D29C-4ED2-B408-C74E36808E9E}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{86B2DC00-4043-4C06-8795-93BD6999B6C9}"
+	ProjectSection(SolutionItems) = preProject
+		LICENSE.txt = LICENSE.txt
+	EndProjectSection
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU

EntityFramework.Utilities/EntityFramework.Utilities/App.config

@@ -2,8 +2,8 @@
 <configuration>
   <configSections>
     <section name="entityFramework" type="System.Data.Entity.Internal.ConfigFile.EntityFrameworkSection, EntityFramework, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" requirePermission="false" />
-    <!-- For more information on Entity Framework configuration, visit http://go.microsoft.com/fwlink/?LinkID=237468 -->
-  </configSections>
+
+  <!-- For more information on Entity Framework configuration, visit http://go.microsoft.com/fwlink/?LinkID=237468 --></configSections>
   <entityFramework>
     <defaultConnectionFactory type="System.Data.Entity.Infrastructure.SqlConnectionFactory, EntityFramework">
       <parameters>

EntityFramework.Utilities/EntityFramework.Utilities/ColumnMapping.cs

@@ -6,6 +6,11 @@ namespace EntityFramework.Utilities
     public class ColumnMapping
     {
         public string NameOnObject { get; set; }
+        public string StaticValue { get; set; }
         public string NameInDatabase { get; set; }
+
+        public string DataType { get; set; }
+
+        public bool IsPrimaryKey { get; set; }
     }
 }

EntityFramework.Utilities/EntityFramework.Utilities/Configuration.cs

@@ -12,6 +12,8 @@ static Configuration(){
             Providers.Add(new SqlQueryProvider());
 
             Log = m => { };
+
+            DisableDefaultFallback = true;
 
         }
 

EntityFramework.Utilities/EntityFramework.Utilities/DatabaseExtensionMethods.cs

@@ -19,13 +19,13 @@ public static void ForceDelete(this Database db, string name = null)
                 // if you used master db as Initial Catalog, there is no need to change database
                 sqlconnection.ChangeDatabase("master");
 
-                string rollbackCommand = @"ALTER DATABASE " + name + " SET  SINGLE_USER WITH ROLLBACK IMMEDIATE;";
+                string rollbackCommand = @"ALTER DATABASE [" + name + "] SET  SINGLE_USER WITH ROLLBACK IMMEDIATE;";
 
                 SqlCommand deletecommand = new SqlCommand(rollbackCommand, sqlconnection);
 
                 deletecommand.ExecuteNonQuery();
 
-                string deleteCommand = @"DROP DATABASE " + name + ";";
+                string deleteCommand = @"DROP DATABASE [" + name + "];";
 
                 deletecommand = new SqlCommand(deleteCommand, sqlconnection);
 

EntityFramework.Utilities/EntityFramework.Utilities/EFBatchOperation.cs

@@ -20,8 +20,57 @@ public interface IEFBatchOperationBase<TContext, T> where T : class
         /// </summary>
         /// <param name="items">The items to insert</param>
         /// <param name="connection">The DbConnection to use for the insert. Only needed when for example a profiler wraps the connection. Then you need to provide a connection of the type the provider use.</param>
-        void InsertAll(IEnumerable<T> items, DbConnection connection = null);
+        /// <param name="batchSize">The size of each batch. Default depends on the provider. SqlProvider uses 15000 as default</param>        
+        void InsertAll<TEntity>(IEnumerable<TEntity> items, DbConnection connection = null, int? batchSize = null) where TEntity : class, T;
+
+
+        /// <summary>
+        /// Bulk insert all items if the Provider supports it. Otherwise it will use the default insert unless Configuration.DisableDefaultFallback is set to true in which case it would throw an exception.
+        /// </summary>
+        /// <param name="items">The items to insert</param>
+        /// <param name="connection">The DbConnection to use for the insert. Only needed when for example a profiler wraps the connection. Then you need to provide a connection of the type the provider use.</param>
+        /// <param name="batchSize">The size of each batch. Default depends on the provider. SqlProvider uses 15000 as default</param>        
+        IEnumerable<TEntity> InsertAllReturnInserted<TEntity>(IEnumerable<TEntity> items, DbConnection connection = null, int? batchSize = null) where TEntity : class, T;
         IEFBatchOperationFiltered<TContext, T> Where(Expression<Func<T, bool>> predicate);
+
+
+        /// <summary>
+        /// Bulk update all items if the Provider supports it. Otherwise it will use the default update unless Configuration.DisableDefaultFallback is set to true in which case it would throw an exception.
+        /// </summary>
+        /// <typeparam name="TEntity"></typeparam>
+        /// <param name="items">The items to update</param>
+        /// <param name="updateSpecification">Define which columns to update</param>
+        /// <param name="connection">The DbConnection to use for the insert. Only needed when for example a profiler wraps the connection. Then you need to provide a connection of the type the provider use.</param>
+        /// <param name="batchSize">The size of each batch. Default depends on the provider. SqlProvider uses 15000 as default</param>
+        void UpdateAll<TEntity>(IEnumerable<TEntity> items, Action<UpdateSpecification<TEntity>> updateSpecification, DbConnection connection = null, int? batchSize = null) where TEntity : class, T;
+
+
+
+        /// <summary>
+        /// Bulk update all items if the Provider supports it. Otherwise it will use the default update unless Configuration.DisableDefaultFallback is set to true in which case it would throw an exception.
+        /// </summary>
+        /// <typeparam name="TEntity"></typeparam>
+        /// <param name="items">The items to update</param>
+        /// <param name="updateSpecification">Define which columns to update</param>
+        /// <param name="connection">The DbConnection to use for the insert. Only needed when for example a profiler wraps the connection. Then you need to provide a connection of the type the provider use.</param>
+        /// <param name="batchSize">The size of each batch. Default depends on the provider. SqlProvider uses 15000 as default</param>
+        IEnumerable<TEntity> UpdateAllReturnUpdated<TEntity>(IEnumerable<TEntity> items, Action<UpdateSpecification<TEntity>> updateSpecification, DbConnection connection = null, int? batchSize = null) where TEntity : class, T;
+    }
+
+    public class UpdateSpecification<T>
+    {
+        /// <summary>
+        /// Set each column you want to update, Columns that belong to the primary key cannot be updated.
+        /// </summary>
+        /// <param name="properties"></param>
+        /// <returns></returns>
+        public UpdateSpecification<T> ColumnsToUpdate(params Expression<Func<T, object>>[] properties)
+        {
+            Properties = properties;
+            return this;
+        }
+
+        public Expression<Func<T, object>>[] Properties { get; set; }
     }
 
     public interface IEFBatchOperationFiltered<TContext, T>
@@ -66,17 +115,60 @@ public static IEFBatchOperationBase<TContext, T> For<TContext, T>(TContext conte
         /// </summary>
         /// <param name="items">The items to insert</param>
         /// <param name="connection">The DbConnection to use for the insert. Only needed when for example a profiler wraps the connection. Then you need to provide a connection of the type the provider use.</param>
-        public void InsertAll(IEnumerable<T> items, DbConnection connection = null)
+        /// <param name="batchSize">The size of each batch. Default depends on the provider. SqlProvider uses 15000 as default</param>
+        public void InsertAll<TEntity>(IEnumerable<TEntity> items, DbConnection connection = null, int? batchSize = null) where TEntity : class, T
         {
             var con = context.Connection as EntityConnection;
-            if (con == null)
+            if (con == null && connection == null)
             {
                 Configuration.Log("No provider could be found because the Connection didn't implement System.Data.EntityClient.EntityConnection");
                 Fallbacks.DefaultInsertAll(context, items);
             }
 
             var connectionToUse = connection ?? con.StoreConnection;
+            var currentType = typeof(TEntity);
+            var provider = Configuration.Providers.FirstOrDefault(p => p.CanHandle(connectionToUse));
+            if (provider != null && provider.CanInsert)
+            {
+
+                var mapping = EntityFramework.Utilities.EfMappingFactory.GetMappingsForContext(this.dbContext);
+                var typeMapping = mapping.TypeMappings[typeof(T)];
+                var tableMapping = typeMapping.TableMappings.First();
+
+                var isComplext = tableMapping.PropertyMappings.Any(x => x.IsComplex);
+
+                var properties = tableMapping.PropertyMappings
+                    .Where(p => currentType.IsSubclassOf(p.ForEntityType) || p.ForEntityType == currentType)
+                    .Select(p => new ColumnMapping { NameInDatabase = p.ColumnName, NameOnObject = p.PropertyName }).ToList();
+                if (tableMapping.TPHConfiguration != null)
+                {
+                    properties.Add(new ColumnMapping
+                    {
+                        NameInDatabase = tableMapping.TPHConfiguration.ColumnName,
+                        StaticValue = tableMapping.TPHConfiguration.Mappings[typeof(TEntity)]
+                    });
+                }
+
+                provider.InsertItems(items, tableMapping.Schema, tableMapping.TableName, properties, connectionToUse, batchSize);
+            }
+            else
+            {
+                Configuration.Log("Found provider: " + (provider == null ? "[]" : provider.GetType().Name) + " for " + connectionToUse.GetType().Name);
+                Fallbacks.DefaultInsertAll(context, items);
+            }
+        }
+
+        public IEnumerable<TEntity> InsertAllReturnInserted<TEntity>(IEnumerable<TEntity> items, DbConnection connection = null, int? batchSize = null) where TEntity : class, T
+        {
+            var con = context.Connection as EntityConnection;
+            if (con == null && connection == null)
+            {
+                Configuration.Log("No provider could be found because the Connection didn't implement System.Data.EntityClient.EntityConnection");
+                Fallbacks.DefaultInsertAll(context, items);
+            }
 
+            var connectionToUse = connection ?? con.StoreConnection;
+            var currentType = typeof(TEntity);
             var provider = Configuration.Providers.FirstOrDefault(p => p.CanHandle(connectionToUse));
             if (provider != null && provider.CanInsert)
             {
@@ -85,15 +177,109 @@ public void InsertAll(IEnumerable<T> items, DbConnection connection = null)
                 var typeMapping = mapping.TypeMappings[typeof(T)];
                 var tableMapping = typeMapping.TableMappings.First();
 
-                var properties = tableMapping.PropertyMappings.Select(p => new ColumnMapping { NameInDatabase = p.ColumnName, NameOnObject = p.PropertyName }).ToList();
+                var complex = tableMapping.PropertyMappings.Any(x => x.IsComplex);
+
+                var properties = tableMapping.PropertyMappings
+                    .Where(p => currentType.IsSubclassOf(p.ForEntityType) || p.ForEntityType == currentType)
+                    .Select(p => new ColumnMapping { NameInDatabase = p.ColumnName, NameOnObject = p.PropertyName, DataType=p.DataType,IsPrimaryKey = p.IsPrimaryKey }).ToList();
+                if (tableMapping.TPHConfiguration != null)
+                {
+                    properties.Add(new ColumnMapping
+                    {
+                        NameInDatabase = tableMapping.TPHConfiguration.ColumnName,
+                        StaticValue = tableMapping.TPHConfiguration.Mappings[typeof(TEntity)]
+                    });
+                }
 
-                provider.InsertItems(items, tableMapping.Schema, tableMapping.TableName, properties, connectionToUse);
+                return provider.InsertItemsReturnInserted(items, tableMapping.Schema, tableMapping.TableName, properties, connectionToUse, batchSize,dbContext);
             }
             else
             {
                 Configuration.Log("Found provider: " + (provider == null ? "[]" : provider.GetType().Name) + " for " + connectionToUse.GetType().Name);
                 Fallbacks.DefaultInsertAll(context, items);
             }
+            return new List<TEntity>();
+        }
+
+
+        public void UpdateAll<TEntity>(IEnumerable<TEntity> items, Action<UpdateSpecification<TEntity>> updateSpecification, DbConnection connection = null, int? batchSize = null) where TEntity : class, T
+        {
+            var con = context.Connection as EntityConnection;
+            if (con == null && connection == null)
+            {
+                Configuration.Log("No provider could be found because the Connection didn't implement System.Data.EntityClient.EntityConnection");
+                Fallbacks.DefaultInsertAll(context, items);
+            }
+
+            var connectionToUse = connection ?? con.StoreConnection;
+            var currentType = typeof(TEntity);
+            var provider = Configuration.Providers.FirstOrDefault(p => p.CanHandle(connectionToUse));
+            if (provider != null && provider.CanBulkUpdate)
+            {
+
+                var mapping = EntityFramework.Utilities.EfMappingFactory.GetMappingsForContext(this.dbContext);
+                var typeMapping = mapping.TypeMappings[typeof(T)];
+                var tableMapping = typeMapping.TableMappings.First();
+
+                var properties = tableMapping.PropertyMappings
+                    .Where(p => currentType.IsSubclassOf(p.ForEntityType) || p.ForEntityType == currentType)
+                    .Select(p => new ColumnMapping { 
+                        NameInDatabase = p.ColumnName, 
+                        NameOnObject = p.PropertyName, 
+                        DataType = p.DataTypeFull,
+                        IsPrimaryKey = p.IsPrimaryKey
+                     }).ToList();
+
+                var spec = new UpdateSpecification<TEntity>();
+                updateSpecification(spec);
+                provider.UpdateItems(items, tableMapping.Schema, tableMapping.TableName, properties, connectionToUse, batchSize, spec);
+            }
+            else
+            {
+                Configuration.Log("Found provider: " + (provider == null ? "[]" : provider.GetType().Name) + " for " + connectionToUse.GetType().Name);
+                Fallbacks.DefaultInsertAll(context, items);
+            }
+        }
+
+        public IEnumerable<TEntity> UpdateAllReturnUpdated<TEntity>(IEnumerable<TEntity> items, Action<UpdateSpecification<TEntity>> updateSpecification, DbConnection connection = null, int? batchSize = null) where TEntity : class, T
+        {
+            var con = context.Connection as EntityConnection;
+            if (con == null && connection == null)
+            {
+                Configuration.Log("No provider could be found because the Connection didn't implement System.Data.EntityClient.EntityConnection");
+                Fallbacks.DefaultInsertAll(context, items);
+            }
+
+            var connectionToUse = connection ?? con.StoreConnection;
+            var currentType = typeof(TEntity);
+            var provider = Configuration.Providers.FirstOrDefault(p => p.CanHandle(connectionToUse));
+            if (provider != null && provider.CanBulkUpdate)
+            {
+
+                var mapping = EfMappingFactory.GetMappingsForContext(this.dbContext);
+                var typeMapping = mapping.TypeMappings[typeof(T)];
+                var tableMapping = typeMapping.TableMappings.First();
+                var complex = tableMapping.PropertyMappings.Any(x => x.IsComplex);
+                var properties = tableMapping.PropertyMappings
+                    .Where(p => currentType.IsSubclassOf(p.ForEntityType) || p.ForEntityType == currentType)
+                    .Select(p => new ColumnMapping
+                    {
+                        NameInDatabase = p.ColumnName,
+                        NameOnObject = p.PropertyName,
+                        DataType = p.DataTypeFull,
+                        IsPrimaryKey = p.IsPrimaryKey
+                    }).ToList();
+
+                var spec = new UpdateSpecification<TEntity>();
+                updateSpecification(spec);
+                return provider.UpdateItemsReturnUpdated(items, tableMapping.Schema, tableMapping.TableName, properties, connectionToUse, batchSize, spec, dbContext);
+            }
+            else
+            {
+                Configuration.Log("Found provider: " + (provider == null ? "[]" : provider.GetType().Name) + " for " + connectionToUse.GetType().Name);
+                Fallbacks.DefaultInsertAll(context, items);
+                return null;
+            }
         }
 
         public IEFBatchOperationFiltered<TContext, T> Where(Expression<Func<T, bool>> predicate)
@@ -166,5 +352,8 @@ public int Update<TP>(Expression<Func<T, TP>> prop, Expression<Func<T, TP>> modi
                 return Fallbacks.DefaultUpdate(context, this.predicate, prop, modifier);
             }
         }
+
+
+
     }
 }

EntityFramework.Utilities/EntityFramework.Utilities/EFDataReader.cs

@@ -19,6 +19,11 @@ public EFDataReader(IEnumerable<T> items, IEnumerable<ColumnMapping> properties)
             Properties = properties.Select(p => p.NameOnObject).ToList();
             Accessors = properties.Select(p =>
             {
+                if (p.StaticValue != null)
+                {
+                    Func<T,object> func = x => p.StaticValue;
+                    return func;
+                }
 
                 var parts = p.NameOnObject.Split('.');