Merge branch 'master' of https://github.com/SamSaffron/dapper-dot-net

Conflicts:
	Dapper.Contrib/SqlMapperExtensions.cs

.gitignore

@@ -2,4 +2,9 @@
 bin/
 obj/
 /*.user
-_Resharper*
\ No newline at end of file
+_Resharper*
+.hgtags
+NuGet.exe
+*.user
+*.nupkg
+.docstats

Dapper NET35/Dapper NET35.csproj

@@ -8,8 +8,8 @@
     <ProjectGuid>{B26305D8-3A89-4D68-A981-9BBF378B81FA}</ProjectGuid>
     <OutputType>Library</OutputType>
     <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>Dapper_NET35</RootNamespace>
-    <AssemblyName>Dapper NET35</AssemblyName>
+    <RootNamespace>Dapper</RootNamespace>
+    <AssemblyName>Dapper</AssemblyName>
     <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
   </PropertyGroup>
@@ -36,7 +36,6 @@
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Data" />
-    <Reference Include="System.Data.Linq" />
   </ItemGroup>
   <ItemGroup>
     <Compile Include="..\Dapper\Properties\AssemblyInfo.cs">

Dapper.Contrib.Tests/Dapper.Contrib.Tests.csproj

@@ -65,6 +65,10 @@
       <Project>{C2FC4DF5-C8D1-4EA8-8E0C-85A3793EB0BB}</Project>
       <Name>Dapper.Contrib</Name>
     </ProjectReference>
+    <ProjectReference Include="..\Dapper.SqlBuilder\Dapper.SqlBuilder.csproj">
+      <Project>{BF782EF1-2B0F-42FA-9DD0-928454A94C6D}</Project>
+      <Name>Dapper.SqlBuilder</Name>
+    </ProjectReference>
     <ProjectReference Include="..\Dapper\Dapper.csproj">
       <Project>{DAF737E1-05B5-4189-A5AA-DAC6233B64D7}</Project>
       <Name>Dapper</Name>

Dapper.Contrib.Tests/Tests.cs

@@ -4,6 +4,9 @@
 using System.Linq;
 using System.Reflection;
 using Dapper.Contrib.Extensions;
+using System.Collections.Generic;
+using System;
+using Dapper;
 
 
 namespace Dapper.Contrib.Tests
@@ -100,5 +103,52 @@ public void InsertGetUpdate()
                 connection.Update(notrackedUser).IsEqualTo(false);   //returns false, user not found
             }
         }
+
+        public void BuilderSelectClause()
+        {
+            using (var connection = GetOpenConnection())
+            {
+                var rand = new Random(8675309);
+                var data = new List<User>();
+                for (int i = 0; i < 100; i++)
+                {
+                    var nU = new User { Age = rand.Next(70), Id = i, Name = Guid.NewGuid().ToString() };
+                    data.Add(nU);
+                    nU.Id = (int)connection.Insert<User>(nU);
+                }
+
+                var builder = new SqlBuilder();
+                var justId = builder.AddTemplate("SELECT /**select**/ FROM Users");
+                var all = builder.AddTemplate("SELECT Name, /**select**/, Age FROM Users");
+
+                builder.Select("Id");
+
+                var ids = connection.Query<int>(justId.RawSql, justId.Parameters);
+                var users = connection.Query<User>(all.RawSql, all.Parameters);
+
+                foreach (var u in data)
+                {
+                    if (!ids.Any(i => u.Id == i)) throw new Exception("Missing ids in select");
+                    if (!users.Any(a => a.Id == u.Id && a.Name == u.Name && a.Age == u.Age)) throw new Exception("Missing users in select");
+                }
+            }
+        }
+
+        public void BuilderTemplateWOComposition()
+        {
+            var builder = new SqlBuilder();
+            var template = builder.AddTemplate("SELECT COUNT(*) FROM Users WHERE Age = @age", new {age = 5});
+
+            if (template.RawSql == null) throw new Exception("RawSql null");
+            if (template.Parameters == null) throw new Exception("Parameters null");
+
+            using (var connection = GetOpenConnection())
+            {
+                connection.Insert(new User { Age = 5, Name = "Testy McTestington" });
+
+                if (connection.Query<int>(template.RawSql, template.Parameters).Single() != 1)
+                    throw new Exception("Query failed");
+            }
+        }
     }
 }

Dapper.Contrib/SqlMapperExtensions.cs

@@ -29,9 +29,11 @@ public interface IProxy
 
         private static IEnumerable<PropertyInfo> KeyPropertiesCache(Type type)
         {
-            if (KeyProperties.ContainsKey(type.TypeHandle))
+
+            IEnumerable<PropertyInfo> pi;
+            if (KeyProperties.TryGetValue(type.TypeHandle,out pi))
             {
-                return KeyProperties[type.TypeHandle];
+                return pi;
             }
 
             var allProperties = TypePropertiesCache(type);
@@ -51,9 +53,10 @@ private static IEnumerable<PropertyInfo> KeyPropertiesCache(Type type)
         }
         private static IEnumerable<PropertyInfo> TypePropertiesCache(Type type)
         {
-            if (TypeProperties.ContainsKey(type.TypeHandle))
+            IEnumerable<PropertyInfo> pis;
+            if (TypeProperties.TryGetValue(type.TypeHandle, out pis))
             {
-                return TypeProperties[type.TypeHandle];
+                return pis;
             }
 
             var properties = type.GetProperties().Where(IsWriteable);
@@ -325,9 +328,10 @@ public static T GetInterfaceProxy<T>()
             {
                 Type typeOfT = typeof(T);
 
-                if (TypeCache.ContainsKey(typeOfT))
+                object k;
+                if (TypeCache.TryGetValue(typeOfT, out k))
                 {
-                    return (T)TypeCache[typeOfT];
+                    return (T)k;
                 }
                 var assemblyBuilder = GetAsmBuilder(typeOfT.Name);
 

Dapper.Rainbow/Dapper.Rainbow.csproj

+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>8.0.30703</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{21BC6EA8-3D10-4CC9-A1B3-9FAD59F7D1BB}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Dapper.Rainbow</RootNamespace>
+    <AssemblyName>Dapper.Rainbow</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Database.cs" />
+    <Compile Include="Snapshotter.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\Dapper\Dapper.csproj">
+      <Project>{DAF737E1-05B5-4189-A5AA-DAC6233B64D7}</Project>
+      <Name>Dapper</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Dapper.Rainbow.nuspec" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
\ No newline at end of file

Dapper.Rainbow/Dapper.Rainbow.nuspec

+<?xml version="1.0"?>
+<package >
+  <metadata>
+    <id>Dapper.Rainbow</id>
+    <version>0.1.1</version>
+    <title>Dapper.Rainbow</title>
+    <authors>Sam Saffron</authors>
+    <owners>Sam Saffron</owners>
+    <licenseUrl>http://www.apache.org/licenses/LICENSE-2.0</licenseUrl>
+    <projectUrl>http://code.google.com/p/dapper-dot-net/</projectUrl>
+    <requireLicenseAcceptance>false</requireLicenseAcceptance>
+    <description>
+      Trivial micro-orm implemented on Dapper, provides with CRUD helpers. 
+    </description>
+    <summary>
+      A demo is available at https://gist.github.com/1599013 .
+      The implementation was extracted from http://data.stackexchange.com source at: http://code.google.com/p/stack-exchange-data-explorer/ .
+      Data explorer uses "Rainbow" exclusively for all database access.
+    </summary>
+    <releaseNotes>* version 0.1 </releaseNotes>
+    <copyright>Copyright Sam Saffron 2012</copyright>
+    <tags>orm dapper micro-orm</tags>
+    <dependencies>
+      <dependency id="Dapper" version="1.8" />
+    </dependencies>
+  </metadata>
+  <files>
+    <file src="bin\Release\Dapper.Rainbow.dll" target="lib\net40" />
+  </files>
+</package>
\ No newline at end of file

Dapper.Rainbow/Properties/AssemblyInfo.cs

+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("Dapper.Rainbow")]
+[assembly: AssemblyDescription("I sample mini ORM implementation using Dapper")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Dapper.Rainbow")]
+[assembly: AssemblyCopyright("Sam Saffron Copyright ©  2012")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("e763c106-eef4-4654-afcc-c28fded057e5")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("0.1.0.0")]
+[assembly: AssemblyFileVersion("0.1.0.0")]

Dapper.Rainbow/Snapshotter.cs

+/*
+ License: http://www.apache.org/licenses/LICENSE-2.0 
+ Home page: http://code.google.com/p/dapper-dot-net/
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Web;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace Dapper
+{
+    public static class Snapshotter
+    {
+        public static Snapshot<T> Start<T>(T obj)
+        {
+            return new Snapshot<T>(obj);
+        }
+
+        public class Snapshot<T>
+        {
+            static Func<T, T> cloner;
+            static Func<T, T, List<Change>> differ;
+            T memberWiseClone;
+            T trackedObject;
+
+            public Snapshot(T original)
+            {
+                memberWiseClone = Clone(original);
+                trackedObject = original;
+            }
+
+            public class Change
+            {
+                public string Name { get; set; }
+                public object NewValue { get; set; }
+            }
+
+            public DynamicParameters Diff()
+            {
+                return Diff(memberWiseClone, trackedObject);
+            }
+
+
+            private static T Clone(T myObject)
+            {
+                cloner = cloner ?? GenerateCloner();
+                return cloner(myObject);
+            }
+
+            private static DynamicParameters Diff(T original, T current)
+            {
+                var dm = new DynamicParameters();
+                differ = differ ?? GenerateDiffer();
+                foreach (var pair in differ(original, current))
+                {
+                    dm.Add(pair.Name, pair.NewValue);
+                }
+                return dm;
+            }
+
+
+            static List<PropertyInfo> RelevantProperties()
+            {
+                return typeof(T).GetProperties(BindingFlags.Instance | BindingFlags.Public)
+                    .Where(p =>
+                        p.GetSetMethod() != null &&
+                        p.GetGetMethod() != null &&
+                        (p.PropertyType.IsValueType ||
+                            p.PropertyType == typeof(string) ||
+                            (p.PropertyType.IsGenericType && p.PropertyType.GetGenericTypeDefinition() == typeof(Nullable<>)))
+                        ).ToList();
+            }
+
+
+            private static bool AreEqual<U>(U first, U second)
+            {
+                if (first == null && second == null) return true;
+                if (first == null && second != null) return false;
+                return first.Equals(second);
+            }
+
+            private static Func<T, T, List<Change>> GenerateDiffer()
+            {
+
+                var dm = new DynamicMethod("DoDiff", typeof(List<Change>), new Type[] { typeof(T), typeof(T) }, true);
+
+                var il = dm.GetILGenerator();
+                // change list
+                il.DeclareLocal(typeof(List<Change>));
+                il.DeclareLocal(typeof(Change));
+                il.DeclareLocal(typeof(object)); // boxed change
+
+                il.Emit(OpCodes.Newobj, typeof(List<Change>).GetConstructor(Type.EmptyTypes));
+                // [list]
+                il.Emit(OpCodes.Stloc_0);
+
+                foreach (var prop in RelevantProperties())
+                {
+                    // []
+                    il.Emit(OpCodes.Ldarg_0);
+                    // [original]
+                    il.Emit(OpCodes.Callvirt, prop.GetGetMethod());
+                    // [original prop val]
+                    il.Emit(OpCodes.Ldarg_1);
+                    // [original prop val, current]
+                    il.Emit(OpCodes.Callvirt, prop.GetGetMethod());
+                    // [original prop val, current prop val]
+
+                    il.Emit(OpCodes.Dup);
+                    // [original prop val, current prop val, current prop val]
+
+                    if (prop.PropertyType != typeof(string))
+                    {
+                        il.Emit(OpCodes.Box, prop.PropertyType);
+                        // [original prop val, current prop val, current prop val boxed]
+                    }
+
+                    il.Emit(OpCodes.Stloc_2);
+                    // [original prop val, current prop val]
+
+                    il.EmitCall(OpCodes.Call, typeof(Snapshot<T>).GetMethod("AreEqual", BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(new Type[] { prop.PropertyType }), null);
+                    // [result] 
+
+                    Label skip = il.DefineLabel();
+                    il.Emit(OpCodes.Brtrue_S, skip);
+                    // []
+
+                    il.Emit(OpCodes.Newobj, typeof(Change).GetConstructor(Type.EmptyTypes));
+                    // [change]
+                    il.Emit(OpCodes.Dup);
+                    // [change,change]
+
+                    il.Emit(OpCodes.Stloc_1);
+                    // [change]
+
+                    il.Emit(OpCodes.Ldstr, prop.Name);
+                    // [change, name]
+                    il.Emit(OpCodes.Callvirt, typeof(Change).GetMethod("set_Name"));
+                    // []
+
+                    il.Emit(OpCodes.Ldloc_1);
+                    // [change]
+
+                    il.Emit(OpCodes.Ldloc_2);
+                    // [change, boxed]
+
+                    il.Emit(OpCodes.Callvirt, typeof(Change).GetMethod("set_NewValue"));
+                    // []
+
+                    il.Emit(OpCodes.Ldloc_0);
+                    // [change list]
+                    il.Emit(OpCodes.Ldloc_1);
+                    // [change list, change]
+                    il.Emit(OpCodes.Callvirt, typeof(List<Change>).GetMethod("Add"));
+                    // []
+
+                    il.MarkLabel(skip);
+                }
+
+                il.Emit(OpCodes.Ldloc_0);
+                // [change list]
+                il.Emit(OpCodes.Ret);
+
+                return (Func<T, T, List<Change>>)dm.CreateDelegate(typeof(Func<T, T, List<Change>>));
+            }
+
+
+            // adapted from http://stackoverflow.com/a/966466/17174
+            private static Func<T, T> GenerateCloner()
+            {
+                Delegate myExec = null;
+                var dm = new DynamicMethod("DoClone", typeof(T), new Type[] { typeof(T) }, true);
+                var ctor = typeof(T).GetConstructor(new Type[] { });
+
+                var il = dm.GetILGenerator();
+
+                il.DeclareLocal(typeof(T));
+
+                il.Emit(OpCodes.Newobj, ctor);
+                il.Emit(OpCodes.Stloc_0);
+
+                foreach (var prop in RelevantProperties())
+                {
+                    il.Emit(OpCodes.Ldloc_0);
+                    // [clone]
+                    il.Emit(OpCodes.Ldarg_0);
+                    // [clone, source]
+                    il.Emit(OpCodes.Callvirt, prop.GetGetMethod());
+                    // [clone, source val]
+                    il.Emit(OpCodes.Callvirt, prop.GetSetMethod());
+                    // []
+                }
+
+                // Load new constructed obj on eval stack -> 1 item on stack
+                il.Emit(OpCodes.Ldloc_0);
+                // Return constructed object.   --> 0 items on stack
+                il.Emit(OpCodes.Ret);
+
+                myExec = dm.CreateDelegate(typeof(Func<T, T>));
+
+                return (Func<T, T>)myExec;
+            }
+        }
+    }
+}
+

Dapper.SqlBuilder/Dapper.SqlBuilder.csproj

+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>8.0.30703</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{BF782EF1-2B0F-42FA-9DD0-928454A94C6D}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Dapper.SqlBuilder</RootNamespace>
+    <AssemblyName>Dapper.SqlBuilder</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="SqlBuilder.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\Dapper\Dapper.csproj">
+      <Project>{DAF737E1-05B5-4189-A5AA-DAC6233B64D7}</Project>
+      <Name>Dapper</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
\ No newline at end of file

Dapper.SqlBuilder/Properties/AssemblyInfo.cs

+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("Dapper.SqlBuilder")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Dapper.SqlBuilder")]
+[assembly: AssemblyCopyright("Copyright ©  2012")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("27491c26-c95d-44e5-b907-30559ef11265")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

Dapper.SqlBuilder/SqlBuilder.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Dapper
+{
+    public class SqlBuilder
+    {
+        Dictionary<string, Clauses> data = new Dictionary<string, Clauses>();
+        int seq;
+
+        class Clause
+        {
+            public string Sql { get; set; }
+            public object Parameters { get; set; }
+        }
+
+        class Clauses : List<Clause>
+        {
+            string joiner;
+            string prefix;
+            string postfix;
+
+            public Clauses(string joiner, string prefix = "", string postfix = "")
+            {
+                this.joiner = joiner;
+                this.prefix = prefix;
+                this.postfix = postfix;
+            }
+
+            public string ResolveClauses(DynamicParameters p)
+            {
+                foreach (var item in this)
+                {
+                    p.AddDynamicParams(item.Parameters);
+                }
+                return prefix + string.Join(joiner, this.Select(c => c.Sql)) + postfix;
+            }
+        }
+
+        public class Template
+        {
+            readonly string sql;
+            readonly SqlBuilder builder;
+            readonly object initParams;
+            int dataSeq = -1; // Unresolved
+
+            public Template(SqlBuilder builder, string sql, dynamic parameters)
+            {
+                this.initParams = parameters;
+                this.sql = sql;
+                this.builder = builder;
+            }
+
+            static System.Text.RegularExpressions.Regex regex =
+                new System.Text.RegularExpressions.Regex(@"\/\*\*.+\*\*\/", System.Text.RegularExpressions.RegexOptions.Compiled | System.Text.RegularExpressions.RegexOptions.Multiline);
+
+            void ResolveSql()
+            {
+                if (dataSeq != builder.seq)
+                {
+                    DynamicParameters p = new DynamicParameters(initParams);
+
+                    rawSql = sql;
+
+                    foreach (var pair in builder.data)
+                    {
+                        rawSql = rawSql.Replace("/**" + pair.Key + "**/", pair.Value.ResolveClauses(p));
+                    }
+                    parameters = p;
+
+                    // replace all that is left with empty
+                    rawSql = regex.Replace(rawSql, "");
+
+                    dataSeq = builder.seq;
+                }
+            }
+
+            string rawSql;
+            object parameters;
+
+            public string RawSql { get { ResolveSql(); return rawSql; } }
+            public object Parameters { get { ResolveSql(); return parameters; } }
+        }
+
+
+        public SqlBuilder()
+        {
+        }
+
+        public Template AddTemplate(string sql, dynamic parameters = null)
+        {
+            return new Template(this, sql, parameters);
+        }
+
+        void AddClause(string name, string sql, object parameters, string joiner, string prefix = "", string postfix = "")
+        {
+            Clauses clauses;
+            if (!data.TryGetValue(name, out clauses))
+            {
+                clauses = new Clauses(joiner, prefix, postfix);
+                data[name] = clauses;
+            }
+            clauses.Add(new Clause { Sql = sql, Parameters = parameters });
+            seq++;
+        }
+
+
+        public SqlBuilder LeftJoin(string sql, dynamic parameters = null)
+        {
+            AddClause("leftjoin", sql, parameters, joiner: "\nLEFT JOIN ", prefix: "\nLEFT JOIN ", postfix: "\n");
+            return this;
+        }
+
+        public SqlBuilder Where(string sql, dynamic parameters = null)
+        {
+            AddClause("where", sql, parameters, " AND ", prefix: "WHERE ", postfix: "\n");
+            return this;
+        }
+
+        public SqlBuilder OrderBy(string sql, dynamic parameters = null)
+        {
+            AddClause("orderby", sql, parameters, " , ", prefix: "ORDER BY ", postfix: "\n");
+            return this;
+        }
+
+        public SqlBuilder Select(string sql, dynamic parameters = null)
+        {
+            AddClause("select", sql, parameters, " , ", prefix: "", postfix: "\n");
+            return this;
+        }
+
+        public SqlBuilder AddParameters(dynamic parameters)
+        {
+            AddClause("--parameters", "", parameters, "");
+            return this;
+        }
+
+        public SqlBuilder Join(string sql, dynamic parameters = null)
+        {
+            AddClause("join", sql, parameters, joiner: "\nJOIN ", prefix: "\nJOIN ", postfix: "\n");
+            return this;
+        }
+
+        public SqlBuilder GroupBy(string sql, dynamic parameters = null)
+        {
+            AddClause("groupby", sql, parameters, joiner: " , ", prefix: "\nGROUP BY ", postfix: "\n");
+            return this;
+        }
+
+        public SqlBuilder Having(string sql, dynamic parameters = null)
+        {
+            AddClause("having", sql, parameters, joiner: "\nAND ", prefix: "HAVING ", postfix: "\n");
+            return this;
+        }
+    }
+}

Dapper.sln

@@ -13,6 +13,10 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Dapper.Contrib.Tests", "Dap
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DapperTests NET35", "DapperTests NET35\DapperTests NET35.csproj", "{3BAA9F79-BA0A-4092-B47B-20170DD47989}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Dapper.SqlBuilder", "Dapper.SqlBuilder\Dapper.SqlBuilder.csproj", "{BF782EF1-2B0F-42FA-9DD0-928454A94C6D}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Dapper.Rainbow", "Dapper.Rainbow\Dapper.Rainbow.csproj", "{21BC6EA8-3D10-4CC9-A1B3-9FAD59F7D1BB}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -83,6 +87,26 @@ Global
 		{3BAA9F79-BA0A-4092-B47B-20170DD47989}.Release|Mixed Platforms.Build.0 = Release|x86
 		{3BAA9F79-BA0A-4092-B47B-20170DD47989}.Release|x86.ActiveCfg = Release|x86
 		{3BAA9F79-BA0A-4092-B47B-20170DD47989}.Release|x86.Build.0 = Release|x86
+		{BF782EF1-2B0F-42FA-9DD0-928454A94C6D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{BF782EF1-2B0F-42FA-9DD0-928454A94C6D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{BF782EF1-2B0F-42FA-9DD0-928454A94C6D}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
+		{BF782EF1-2B0F-42FA-9DD0-928454A94C6D}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
+		{BF782EF1-2B0F-42FA-9DD0-928454A94C6D}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{BF782EF1-2B0F-42FA-9DD0-928454A94C6D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{BF782EF1-2B0F-42FA-9DD0-928454A94C6D}.Release|Any CPU.Build.0 = Release|Any CPU
+		{BF782EF1-2B0F-42FA-9DD0-928454A94C6D}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
+		{BF782EF1-2B0F-42FA-9DD0-928454A94C6D}.Release|Mixed Platforms.Build.0 = Release|Any CPU
+		{BF782EF1-2B0F-42FA-9DD0-928454A94C6D}.Release|x86.ActiveCfg = Release|Any CPU
+		{21BC6EA8-3D10-4CC9-A1B3-9FAD59F7D1BB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{21BC6EA8-3D10-4CC9-A1B3-9FAD59F7D1BB}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{21BC6EA8-3D10-4CC9-A1B3-9FAD59F7D1BB}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
+		{21BC6EA8-3D10-4CC9-A1B3-9FAD59F7D1BB}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
+		{21BC6EA8-3D10-4CC9-A1B3-9FAD59F7D1BB}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{21BC6EA8-3D10-4CC9-A1B3-9FAD59F7D1BB}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{21BC6EA8-3D10-4CC9-A1B3-9FAD59F7D1BB}.Release|Any CPU.Build.0 = Release|Any CPU
+		{21BC6EA8-3D10-4CC9-A1B3-9FAD59F7D1BB}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
+		{21BC6EA8-3D10-4CC9-A1B3-9FAD59F7D1BB}.Release|Mixed Platforms.Build.0 = Release|Any CPU
+		{21BC6EA8-3D10-4CC9-A1B3-9FAD59F7D1BB}.Release|x86.ActiveCfg = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

Dapper/Dapper.csproj

@@ -22,6 +22,8 @@
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <DocumentationFile>bin\Debug\Dapper.XML</DocumentationFile>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
@@ -36,7 +38,6 @@
     <Reference Include="System.Core" />
     <Reference Include="Microsoft.CSharp" />
     <Reference Include="System.Data" />
-    <Reference Include="System.Data.Linq" />
   </ItemGroup>
   <ItemGroup>
     <Compile Include="SqlMapper.cs" />

Dapper/Properties/AssemblyInfo.cs

@@ -32,5 +32,5 @@
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.6.0.0")]
-[assembly: AssemblyFileVersion("1.6.0.0")]
+[assembly: AssemblyVersion("1.8.0.0")]
+[assembly: AssemblyFileVersion("1.8.0.0")]

Dapper/dapper.nuspec

@@ -2,7 +2,7 @@
 <package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
   <metadata schemaVersion="2">
     <id>Dapper</id>
-    <version>1.6</version>
+    <version>1.8</version>
     <title>Dapper dot net</title>
     <authors>Sam Saffron,Marc Gravell</authors>
     <owners>Sam Saffron,Marc Gravell</owners>
@@ -11,15 +11,24 @@
     <requireLicenseAcceptance>false</requireLicenseAcceptance>
     <description>A high performance Micro-ORM supporting Sql Server, MySQL, Sqlite, SqlCE, Firebird etc..</description>
     <summary>A high performance Micro-ORM</summary>
-    <tags>orm,sql,micro-orm</tags>
+    <tags>orm sql micro-orm</tags>
     <frameworkAssemblies>
-      <frameworkAssembly assemblyName="System.Core" targetFramework=".NETFramework4.0-Client, .NETFramework4.0" />
-      <frameworkAssembly assemblyName="System" targetFramework=".NETFramework4.0-Client, .NETFramework4.0" />
-      <frameworkAssembly assemblyName="System.Data" targetFramework=".NETFramework4.0-Client, .NETFramework4.0" />
+      <frameworkAssembly assemblyName="System.Core"/>
+      <frameworkAssembly assemblyName="System"/>
+      <frameworkAssembly assemblyName="System.Data"/>
       <frameworkAssembly assemblyName="Microsoft.CSharp" targetFramework=".NETFramework4.0-Client, .NETFramework4.0" />
     </frameworkAssemblies>
+    <releaseNotes>
+      * 1.8 - Started release notes
+      *       Important: Dapper is now shipping as a DLL which will work on .net 3.5 or .net 4.0,
+      *          This improves the debugging experience as you no longer break into dapper when SQL fails.
+      *       Added: ParameterNames on DynamicParameters
+    </releaseNotes>
   </metadata>
   <files>
-    <file src="SqlMapper.cs" target="content\Dapper\SqlMapper.cs" />
+    <file src="bin\Release\Dapper.dll" target="lib\net40" />
+    <file src="bin\Release\Dapper.pdb" target="lib\net40" />
+    <file src="..\Dapper NET35\bin\Release\Dapper.dll" target="lib\net35" />
+    <file src="..\Dapper NET35\bin\Release\Dapper.pdb" target="lib\net35" />
   </files>
 </package>
\ No newline at end of file

Tests/DapperTests.csproj

@@ -183,7 +183,7 @@
       <LastGenOutput>DataClasses.designer.cs</LastGenOutput>
       <SubType>Designer</SubType>
     </None>
-    <None Include="packages.config" />
+    <None Include="packages.config" />   
     <None Include="Properties\Settings.settings">
       <Generator>SettingsSingleFileGenerator</Generator>
       <LastGenOutput>Settings.Designer.cs</LastGenOutput>

Tests/PerformanceTests.cs

 using System;
 using System.Collections.Generic;
+using System.Data;
 using System.Data.Linq;
 using System.Data.SqlClient;
 using System.Diagnostics;
@@ -9,6 +10,8 @@
 using Massive;
 using NHibernate.Criterion;
 using NHibernate.Linq;
+using ServiceStack.OrmLite;
+using ServiceStack.OrmLite.SqlServer;
 using SqlMapper.Linq2Sql;
 using SqlMapper.NHibernate;
 using Dapper.Contrib.Extensions;
@@ -191,6 +194,11 @@ public void Run(int iterations)
 			// Soma
 			var somadb = new Soma.Core.Db(new SomaConfig());
 			tests.Add(id => somadb.Find<Post>(id), "Soma");
+
+            //ServiceStack's OrmLite:
+            OrmLiteConfig.DialectProvider = SqlServerOrmLiteDialectProvider.Instance; //Using SQL Server
+            IDbCommand ormLiteCmd = Program.GetOpenConnection().CreateCommand();
+            tests.Add(id => ormLiteCmd.QueryById<Post>(id), "OrmLite QueryById");
             
             // HAND CODED 
 

Tests/Program.cs

@@ -4,6 +4,7 @@
 
 namespace SqlMapper
 {
+    [ServiceStack.DataAnnotations.Alias("Posts")]
 	[Soma.Core.Table(Name = "Posts")]
     class Post
     {

Tests/Properties/DataSources/SqlMapper.EntityFramework.tempdbEntities1.datasource

+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    This file is automatically generated by Visual Studio .Net. It is 
+    used to store generic object data source configuration information.  
+    Renaming the file extension or editing the content of this file may   
+    cause the file to be unrecognizable by the program.
+-->
+<GenericObjectDataSource DisplayName="tempdbEntities1" Identifier="SqlMapper.EntityFramework.tempdbEntities1" ProviderType="Microsoft.VisualStudio.DataDesign.DataSourceProviders.EntityDataModel.EdmDataSourceProvider" Version="1.0" xmlns="urn:schemas-microsoft-com:xml-msdatasource">
+   <TypeInfo>SqlMapper.EntityFramework.tempdbEntities1, EntityFramework.Model.Designer.cs, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null</TypeInfo>
+</GenericObjectDataSource>
\ No newline at end of file