DynamORM.Tests/DynamORM.Tests.csproj

@@ -77,7 +77,6 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="DynamicClassBuilderTest.cs" />
     <Compile Include="Helpers\Dynamic\DynamicParserTests.cs" />
     <Compile Include="Helpers\PoolingTests.cs" />
     <Compile Include="Modify\DynamicModificationTests.cs" />

DynamORM.Tests/Modify/DynamicTypeSchemaModificationTests.cs

@@ -43,24 +43,27 @@ namespace DynamORM.Tests.Modify
             return Database.Table<users>();
         }
 
+        /// <summary>
+        /// Tests the bulk insert.
+        /// </summary>
         [Test]
         public void TestBulkInsert()
         {
-        	Assert.AreEqual(2, Database.Insert<users>(new List<users>
+            Assert.AreEqual(2, Database.Insert<users>(new List<users>
-        	{
+            {
                 new users
                 {
-                	id = 1001,
+                    id = 1001,
-                	login = "a",
+                    login = "a",
                 },
                 new users
                 {
-                	id = 1002,
+                    id = 1002,
-                	login = "b",
+                    login = "b",
                 }
-        	}));
+            }));
 
-        	Assert.AreEqual(2, Database.Delete<users>().Where(u => u.users.id.In(1001, 1002)).Execute());
+            Assert.AreEqual(2, Database.Delete<users>().Where(u => u.users.id.In(1001, 1002)).Execute());
         }
     }
 }

DynamORM/DynamicDatabase.cs

@@ -287,57 +287,104 @@ namespace DynamORM
             return new DynamicInsertQueryBuilder(this).Table(typeof(T));
         }
 
+        /// <summary>Bulk insert objects into database.</summary>
+        /// <typeparam name="T">Type of objects to insert.</typeparam>
+        /// <param name="e">Enumerable containing instances of objects to insert.</param>
+        /// <returns>Number of inserted rows.</returns>
         public virtual int Insert<T>(IEnumerable<T> e) where T : class
         {
-        	int affected = 0;
+            int affected = 0;
-	        var mapper = DynamicMapperCache.GetMapper(typeof(T));
+            var mapper = DynamicMapperCache.GetMapper(typeof(T));
 
             if (mapper != null)
-	            using (var con = Open())
+            {
-	            using (var tra = con.BeginTransaction())
+                using (var con = Open())
-	            using (var cmd = con.CreateCommand())
+                using (var tra = con.BeginTransaction())
-	            {
+                using (var cmd = con.CreateCommand())
-	            	try
+                {
-	            	{
+                    try
-		                DynamicPropertyInvoker currentprop = null;
+                    {
-		                var temp = new Dictionary<string, DynamicPropertyInvoker>();
+                        var parameters = new Dictionary<IDbDataParameter, DynamicPropertyInvoker>();
-		                var parameters = new Dictionary<IDbDataParameter, DynamicPropertyInvoker>();
 
-		                var ib = Insert<T>()
+                        if (!string.IsNullOrEmpty(mapper.InsertCommandText))
-		                    .SetVirtualMode(true)
+                        {
-		                    .CreateTemporaryParameterAction(p => temp[p.Name] = currentprop)
+                            cmd.CommandText = mapper.InsertCommandText;
-		                    .CreateParameterAction((p, cp) => parameters[cp] = temp[p.Name]);
 
-	                    foreach (var prop in mapper.PropertyMap)
+                            foreach (var col in mapper.ColumnsMap.Values
-	                        if (!mapper.Ignored.Contains(prop.Key))
+                                .Where(di => !di.Ignore && di.InsertCommandParameter != null)
-	                        {
+                                .OrderBy(di => di.InsertCommandParameter.Ordinal))
-	                            var col = mapper.PropertyMap.TryGetValue(prop.Key) ?? prop.Key;
+                            {
-	                            currentprop = mapper.ColumnsMap.TryGetValue(col.ToLower());
+                                var para = cmd.CreateParameter();
+                                para.ParameterName = col.InsertCommandParameter.Name;
+                                para.DbType = col.InsertCommandParameter.Type;
+                                cmd.Parameters.Add(para);
 
-	                            if (currentprop.Get != null)
+                                parameters[para] = col;
-	                            	ib.Insert(col, null);
+                            }
-	                        }
+                        }
+                        else
+                        {
+                            DynamicPropertyInvoker currentprop = null;
+                            var temp = new Dictionary<string, DynamicPropertyInvoker>();
+                            int ord = 0;
 
-	                    ib.FillCommand(cmd);
+                            var ib = Insert<T>()
+                                .SetVirtualMode(true)
+                                .CreateTemporaryParameterAction(p => temp[p.Name] = currentprop)
+                                .CreateParameterAction((p, cp) =>
+                                {
+                                    parameters[cp] = temp[p.Name];
+                                    parameters[cp].InsertCommandParameter = new DynamicPropertyInvoker.ParameterSpec
+                                    {
+                                        Name = cp.ParameterName,
+                                        Type = cp.DbType,
+                                        Ordinal = ord++,
+                                    };
+                                });
 
-	                    foreach (var o in e) 
+                            foreach (var prop in mapper.PropertyMap)
-	                    {
+                                if (!mapper.Ignored.Contains(prop.Key))
-	                        foreach (var m in parameters) 
+                                {
-	                        	m.Key.Value = m.Value.Get(o);
+                                    var col = mapper.PropertyMap.TryGetValue(prop.Key) ?? prop.Key;
+                                    currentprop = mapper.ColumnsMap.TryGetValue(col.ToLower());
 
-	                        affected += cmd.ExecuteNonQuery();
+                                    if (currentprop.Ignore)
-	                    }
+                                        continue;
 
-		                tra.Commit();
+                                    if (currentprop.Get != null)
-		            }
+                                        ib.Insert(col, null);
-	            	catch
+                                }
-	            	{
-	            		if (tra != null)
-	            			tra.Rollback();
 
-	            		throw;
+                            ib.FillCommand(cmd);
-	            	}
+
-	            }
+                            // Cache command
+                            mapper.InsertCommandText = cmd.CommandText;
+                        }
+
+                        foreach (var o in e)
+                        {
+                            foreach (var m in parameters)
+                                m.Key.Value = m.Value.Get(o);
+
+                            affected += cmd.ExecuteNonQuery();
+                        }
+
+                        tra.Commit();
+                    }
+                    catch (Exception ex)
+                    {
+                        if (tra != null)
+                            tra.Rollback();
+
+                        affected = 0;
+
+                        var exCmd = new StringBuilder();
+                        cmd.Dump(exCmd);
+
+                        throw new InvalidOperationException(exCmd.ToString(), ex);
+                    }
+                }
+            }
 
             return affected;
         }
@@ -366,6 +413,113 @@ namespace DynamORM
             return new DynamicUpdateQueryBuilder(this).Table(typeof(T));
         }
 
+        /// <summary>Bulk update objects into database.</summary>
+        /// <typeparam name="T">Type of objects to update.</typeparam>
+        /// <param name="e">Enumerable containing instances of objects to update.</param>
+        /// <returns>Number of updated rows.</returns>
+        public virtual int Update<T>(IEnumerable<T> e) where T : class
+        {
+            int affected = 0;
+            var mapper = DynamicMapperCache.GetMapper(typeof(T));
+
+            if (mapper != null)
+            {
+                using (var con = Open())
+                using (var tra = con.BeginTransaction())
+                using (var cmd = con.CreateCommand())
+                {
+                    try
+                    {
+                        var parameters = new Dictionary<IDbDataParameter, DynamicPropertyInvoker>();
+
+                        if (!string.IsNullOrEmpty(mapper.UpdateCommandText))
+                        {
+                            cmd.CommandText = mapper.UpdateCommandText;
+
+                            foreach (var col in mapper.ColumnsMap.Values
+                                .Where(di => !di.Ignore && di.UpdateCommandParameter != null)
+                                .OrderBy(di => di.UpdateCommandParameter.Ordinal))
+                            {
+                                var para = cmd.CreateParameter();
+                                para.ParameterName = col.UpdateCommandParameter.Name;
+                                para.DbType = col.UpdateCommandParameter.Type;
+                                cmd.Parameters.Add(para);
+
+                                parameters[para] = col;
+                            }
+                        }
+                        else
+                        {
+                            DynamicPropertyInvoker currentprop = null;
+                            var temp = new Dictionary<string, DynamicPropertyInvoker>();
+                            int ord = 0;
+
+                            var ib = Update<T>()
+                                .SetVirtualMode(true)
+                                .CreateTemporaryParameterAction(p => temp[p.Name] = currentprop)
+                                .CreateParameterAction((p, cp) =>
+                                {
+                                    parameters[cp] = temp[p.Name];
+                                    parameters[cp].UpdateCommandParameter = new DynamicPropertyInvoker.ParameterSpec
+                                    {
+                                        Name = cp.ParameterName,
+                                        Type = cp.DbType,
+                                        Ordinal = ord++,
+                                    };
+                                });
+
+                            foreach (var prop in mapper.PropertyMap)
+                                if (!mapper.Ignored.Contains(prop.Key))
+                                {
+                                    var col = mapper.PropertyMap.TryGetValue(prop.Key) ?? prop.Key;
+                                    currentprop = mapper.ColumnsMap.TryGetValue(col.ToLower());
+
+                                    if (currentprop.Ignore)
+                                        continue;
+
+                                    if (currentprop.Get != null)
+                                    {
+                                        if (currentprop.Column != null && currentprop.Column.IsKey)
+                                            ib.Where(col, null);
+                                        else
+                                            ib.Values(col, null);
+                                    }
+                                }
+
+                            ib.FillCommand(cmd);
+
+                            // Cache command
+                            mapper.UpdateCommandText = cmd.CommandText;
+                        }
+
+                        foreach (var o in e)
+                        {
+                            foreach (var m in parameters)
+                                m.Key.Value = m.Value.Get(o);
+
+                            affected += cmd.ExecuteNonQuery();
+                        }
+
+                        tra.Commit();
+                    }
+                    catch (Exception ex)
+                    {
+                        if (tra != null)
+                            tra.Rollback();
+
+                        affected = 0;
+
+                        var exCmd = new StringBuilder();
+                        cmd.Dump(exCmd);
+
+                        throw new InvalidOperationException(exCmd.ToString(), ex);
+                    }
+                }
+            }
+
+            return affected;
+        }
+
         /// <summary>
         /// Adds to the <code>DELETE FROM</code> clause the contents obtained by parsing the dynamic lambda expressions given. The supported
         /// formats are:

DynamORM/Mapper/DynamicPropertyInvoker.cs

@@ -27,6 +27,7 @@
 */
 
 using System;
+using System.Data;
 using System.Linq.Expressions;
 using System.Reflection;
 
@@ -35,6 +36,15 @@ namespace DynamORM.Mapper
     /// <summary>Dynamic property invoker.</summary>
     public class DynamicPropertyInvoker
     {
+        internal class ParameterSpec
+        {
+            public string Name { get; set; }
+
+            public DbType Type { get; set; }
+
+            public int Ordinal { get; set; }
+        }
+
         /// <summary>Gets the type of property.</summary>
         public Type Type { get; private set; }
 
@@ -105,5 +115,13 @@ namespace DynamORM.Mapper
                     Expression.Convert(valueParm, property.PropertyType)),
                     objParm, valueParm).Compile();
         }
+
+        #region Type command cache
+
+        internal ParameterSpec InsertCommandParameter { get; set; }
+
+        internal ParameterSpec UpdateCommandParameter { get; set; }
+
+        #endregion Type command cache
     }
 }

DynamORM/Mapper/DynamicTypeMap.cs

@@ -28,7 +28,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Linq.Expressions;
 
 namespace DynamORM.Mapper
@@ -94,7 +93,7 @@ namespace DynamORM.Mapper
                 propertyMap.Add(pi.Name, col);
 
                 if (val.Ignore)
-                	ignored.Add(pi.Name);
+                    ignored.Add(pi.Name);
             }
 
             ColumnsMap = columnMap;
@@ -136,5 +135,13 @@ namespace DynamORM.Mapper
 
             return destination;
         }
+
+        #region Type command cache
+
+        internal string InsertCommandText { get; set; }
+
+        internal string UpdateCommandText { get; set; }
+
+        #endregion Type command cache
     }
 }