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,6 +43,9 @@ namespace DynamORM.Tests.Modify
             return Database.Table<users>();
         }
 
+        /// <summary>
+        /// Tests the bulk insert.
+        /// </summary>
         [Test]
         public void TestBulkInsert()
         {

DynamORM/DynamicDatabase.cs

@@ -287,26 +287,60 @@ 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;
             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.InsertCommandText))
+                        {
+                            cmd.CommandText = mapper.InsertCommandText;
+
+                            foreach (var col in mapper.ColumnsMap.Values
+                                .Where(di => !di.Ignore && di.InsertCommandParameter != null)
+                                .OrderBy(di => di.InsertCommandParameter.Ordinal))
+                            {
+                                var para = cmd.CreateParameter();
+                                para.ParameterName = col.InsertCommandParameter.Name;
+                                para.DbType = col.InsertCommandParameter.Type;
+                                cmd.Parameters.Add(para);
+
+                                parameters[para] = col;
+                            }
+                        }
+                        else
                         {
                             DynamicPropertyInvoker currentprop = null;
                             var temp = new Dictionary<string, DynamicPropertyInvoker>();
-		                var parameters = new Dictionary<IDbDataParameter, DynamicPropertyInvoker>();
+                            int ord = 0;
 
                             var ib = Insert<T>()
                                 .SetVirtualMode(true)
                                 .CreateTemporaryParameterAction(p => temp[p.Name] = currentprop)
-		                    .CreateParameterAction((p, cp) => parameters[cp] = temp[p.Name]);
+                                .CreateParameterAction((p, cp) =>
+                                {
+                                    parameters[cp] = temp[p.Name];
+                                    parameters[cp].InsertCommandParameter = new DynamicPropertyInvoker.ParameterSpec
+                                    {
+                                        Name = cp.ParameterName,
+                                        Type = cp.DbType,
+                                        Ordinal = ord++,
+                                    };
+                                });
 
                             foreach (var prop in mapper.PropertyMap)
                                 if (!mapper.Ignored.Contains(prop.Key))
@@ -314,12 +348,19 @@ namespace DynamORM
                                     var col = mapper.PropertyMap.TryGetValue(prop.Key) ?? prop.Key;
                                     currentprop = mapper.ColumnsMap.TryGetValue(col.ToLower());
 
+                                    if (currentprop.Ignore)
+                                        continue;
+
                                     if (currentprop.Get != null)
                                         ib.Insert(col, null);
                                 }
 
                             ib.FillCommand(cmd);
 
+                            // Cache command
+                            mapper.InsertCommandText = cmd.CommandText;
+                        }
+
                         foreach (var o in e)
                         {
                             foreach (var m in parameters)
@@ -330,12 +371,18 @@ namespace DynamORM
 
                         tra.Commit();
                     }
-	            	catch
+                    catch (Exception ex)
                     {
                         if (tra != null)
                             tra.Rollback();
 
-	            		throw;
+                        affected = 0;
+
+                        var exCmd = new StringBuilder();
+                        cmd.Dump(exCmd);
+
+                        throw new InvalidOperationException(exCmd.ToString(), ex);
+                    }
                 }
             }
 
@@ -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
@@ -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
     }
 }