DynamORM.sln

@@ -63,7 +63,7 @@ Global
 		{F747AA57-BEA7-4FB8-B371-546296789AEF}.Release|x86.Build.0 = Release|x86
 	EndGlobalSection
 	GlobalSection(MonoDevelopProperties) = preSolution
-		StartupItem = AmalgamationTool\AmalgamationTool.csproj
+		StartupItem = Tester\Tester.csproj
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

DynamORM/DynamORM.csproj

@@ -103,6 +103,7 @@
     <Compile Include="Mapper\IgnoreAttribute.cs" />
     <Compile Include="Mapper\TableAttribute.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="DynamicExpando.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 

DynamORM/DynamicDatabase.cs

@@ -1006,14 +1006,15 @@ namespace DynamORM
         /// <param name="owner">Owner of table from which extract column info.</param>
         /// <returns>List of <see cref="DynamicSchemaColumn"/> objects .
         /// If your database doesn't get those values in upper case (like most of the databases) you should override this method.</returns>
-        protected virtual IEnumerable<DynamicSchemaColumn> ReadSchema(string table, string owner)
+        protected virtual IList<DynamicSchemaColumn> ReadSchema(string table, string owner)
         {
             using (var con = Open())
             using (var cmd = con.CreateCommand()
                 .SetCommand(string.Format("SELECT * FROM {0}{1} WHERE 1 = 0",
                     !string.IsNullOrEmpty(owner) ? string.Format("{0}.", DecorateName(owner)) : string.Empty,
                     DecorateName(table))))
-                return ReadSchema(cmd).ToList();
+                return ReadSchema(cmd)
+                    .ToList();
         }
 
         /// <summary>Get schema describing objects from reader.</summary>
@@ -1023,7 +1024,8 @@ namespace DynamORM
         protected virtual IEnumerable<DynamicSchemaColumn> ReadSchema(IDbCommand cmd)
         {
             using (var rdr = cmd.ExecuteReader(CommandBehavior.SchemaOnly | CommandBehavior.KeyInfo))
-                foreach (DataRow col in rdr.GetSchemaTable().Rows)
+            using (var st = rdr.GetSchemaTable())
+                foreach (DataRow col in st.Rows)
                 {
                     var c = col.RowToDynamicUpper();
 
@@ -1061,7 +1063,8 @@ namespace DynamORM
             if (databaseSchemaSupport && !Schema.ContainsKey(tableName.ToLower()))
             {
                 schema = ReadSchema(tableName, owner)
-                    .Distinct()
+                    .Where(x => x.Name != null)
+                    .DistinctBy(x => x.Name)
                     .ToDictionary(k => k.Name.ToLower(), k => k);
 
                 Schema[tableName.ToLower()] = schema;

DynamORM/DynamicExtensions.cs

@@ -819,6 +819,15 @@ namespace DynamORM
             return b.Execute().ToList();
         }
 
+        /// <summary>Turns an <see cref="IDynamicSelectQueryBuilder"/> to a Dynamic list of things with specified type.</summary>
+        /// <typeparam name="T">Type of object to map on.</typeparam>
+        /// <param name="b">Ready to execute builder.</param>
+        /// <returns>List of things.</returns>
+        public static List<T> ToList<T>(this IDynamicSelectQueryBuilder b) where T : class
+        {
+            return b.Execute<T>().ToList();
+        }
+
         /// <summary>Sets the on create temporary parameter action.</summary>
         /// <typeparam name="T">Class implementing <see cref="IDynamicQueryBuilder"/> interface.</typeparam>
         /// <param name="b">The builder on which set delegate.</param>
@@ -941,22 +950,27 @@ namespace DynamORM
             return result;
         }
 
-        /// <summary>Turns an <see cref="IDynamicSelectQueryBuilder"/> to a Dynamic list of things with specified type.</summary>
-        /// <typeparam name="T">Type of object to map on.</typeparam>
-        /// <param name="b">Ready to execute builder.</param>
-        /// <returns>List of things.</returns>
-        public static List<T> ToList<T>(this IDynamicSelectQueryBuilder b) where T : class
-        {
-            return b.Execute<T>().ToList();
-        }
-
         /// <summary>Turns the dictionary into an ExpandoObject.</summary>
         /// <param name="d">Dictionary to convert.</param>
         /// <returns>Converted dictionary.</returns>
         public static dynamic ToDynamic(this IDictionary<string, object> d)
+        {
+            var result = new DynamicExpando();
+            var dict = (IDictionary<string, object>)result;
+
+            foreach (var prop in d)
+                dict.Add(prop.Key, prop.Value);
+
+            return result;
+        }
+
+        /// <summary>Turns the dictionary into an ExpandoObject.</summary>
+        /// <param name="d">Dictionary to convert.</param>
+        /// <returns>Converted dictionary.</returns>
+        public static dynamic ToExpando(this IDictionary<string, object> d)
         {
             var result = new ExpandoObject();
-            var dict = result as IDictionary<string, object>;
+            var dict = (IDictionary<string, object>)result;
 
             foreach (var prop in d)
                 dict.Add(prop.Key, prop.Value);
@@ -969,13 +983,62 @@ namespace DynamORM
         /// <returns>Converted object.</returns>
         public static dynamic ToDynamic(this object o)
         {
-            var result = new ExpandoObject();
-            var dict = result as IDictionary<string, object>;
             var ot = o.GetType();
 
-            if (ot == typeof(ExpandoObject))
+            if (ot == typeof(ExpandoObject) || ot == typeof(DynamicExpando))
                 return o;
 
+            var result = new DynamicExpando();
+            var dict = (IDictionary<string, object>)result;
+
+            if (o is IDictionary<string, object>)
+                ((IDictionary<string, object>)o)
+                    .ToList()
+                    .ForEach(kvp => dict.Add(kvp.Key, kvp.Value));
+            else if (ot == typeof(NameValueCollection) || ot.IsSubclassOf(typeof(NameValueCollection)))
+            {
+                var nameValue = (NameValueCollection)o;
+                nameValue.Cast<string>()
+                    .Select(key => new KeyValuePair<string, object>(key, nameValue[key]))
+                    .ToList()
+                    .ForEach(i => dict.Add(i));
+            }
+            else
+            {
+                var mapper = DynamicMapperCache.GetMapper(ot);
+
+                if (mapper != null)
+                {
+                    foreach (var item in mapper.ColumnsMap.Values)
+                        if (item.Get != null)
+                            dict.Add(item.Name, item.Get(o));
+                }
+                else
+                {
+                    var props = ot.GetProperties();
+
+                    foreach (var item in props)
+                        if (item.CanRead)
+                            dict.Add(item.Name, item.GetValue(o, null));
+                }
+            }
+
+            return result;
+        }
+
+        /// <summary>Turns the object into an ExpandoObject.</summary>
+        /// <param name="o">Object to convert.</param>
+        /// <returns>Converted object.</returns>
+        public static dynamic ToExpando(this object o)
+        {
+            var ot = o.GetType();
+
+            if (ot == typeof(ExpandoObject) || ot == typeof(DynamicExpando))
+                return o;
+
+            var result = new ExpandoObject();
+            var dict = (IDictionary<string, object>)result;
+
             if (o is IDictionary<string, object>)
                 ((IDictionary<string, object>)o)
                     .ToList()
@@ -1016,13 +1079,27 @@ namespace DynamORM
         /// <returns>Generated dynamic object.</returns>
         public static dynamic RowToDynamic(this DataRow r)
         {
-            dynamic e = new ExpandoObject();
+            dynamic e = new DynamicExpando();
-            var d = e as IDictionary<string, object>;
 
             int len = r.Table.Columns.Count;
 
             for (int i = 0; i < len; i++)
-                d.Add(r.Table.Columns[i].ColumnName, r.IsNull(i) ? null : r[i]);
+                ((IDictionary<string, object>)e).Add(r.Table.Columns[i].ColumnName, r.IsNull(i) ? null : r[i]);
+
+            return e;
+        }
+
+        /// <summary>Convert data row row into dynamic object.</summary>
+        /// <param name="r">DataRow from which read.</param>
+        /// <returns>Generated dynamic object.</returns>
+        public static dynamic RowToExpando(this DataRow r)
+        {
+            dynamic e = new ExpandoObject();
+
+            int len = r.Table.Columns.Count;
+
+            for (int i = 0; i < len; i++)
+                ((IDictionary<string, object>)e).Add(r.Table.Columns[i].ColumnName, r.IsNull(i) ? null : r[i]);
 
             return e;
         }
@@ -1032,13 +1109,40 @@ namespace DynamORM
         /// <returns>Generated dynamic object.</returns>
         public static dynamic RowToDynamicUpper(this DataRow r)
         {
-            dynamic e = new ExpandoObject();
+            dynamic e = new DynamicExpando();
-            var d = e as IDictionary<string, object>;
 
             int len = r.Table.Columns.Count;
 
             for (int i = 0; i < len; i++)
-                d.Add(r.Table.Columns[i].ColumnName.ToUpper(), r.IsNull(i) ? null : r[i]);
+                ((IDictionary<string, object>)e).Add(r.Table.Columns[i].ColumnName.ToUpper(), r.IsNull(i) ? null : r[i]);
+
+            return e;
+        }
+
+        /// <summary>Convert data row row into dynamic object (upper case key).</summary>
+        /// <param name="r">DataRow from which read.</param>
+        /// <returns>Generated dynamic object.</returns>
+        public static dynamic RowToExpandoUpper(this DataRow r)
+        {
+            // ERROR: Memory leak
+            dynamic e = new ExpandoObject();
+
+            int len = r.Table.Columns.Count;
+
+            for (int i = 0; i < len; i++)
+                ((IDictionary<string, object>)e).Add(r.Table.Columns[i].ColumnName.ToUpper(), r.IsNull(i) ? null : r[i]);
+
+            return e;
+        }
+
+        internal static Dictionary<string, object> RowToDynamicUpperDict(this DataRow r)
+        {
+            dynamic e = new Dictionary<string, object>();
+
+            int len = r.Table.Columns.Count;
+
+            for (int i = 0; i < len; i++)
+                e.Add(r.Table.Columns[i].ColumnName.ToUpper(), r.IsNull(i) ? null : r[i]);
 
             return e;
         }
@@ -1047,6 +1151,29 @@ namespace DynamORM
         /// <param name="r">Reader from which read.</param>
         /// <returns>Generated dynamic object.</returns>
         public static dynamic RowToDynamic(this IDataReader r)
+        {
+            dynamic e = new DynamicExpando();
+            var d = e as IDictionary<string, object>;
+
+            int c = r.FieldCount;
+            for (int i = 0; i < c; i++)
+                try
+            {
+                d.Add(r.GetName(i), r.IsDBNull(i) ? null : r[i]);
+            }
+            catch (ArgumentException argex)
+            {
+                throw new ArgumentException(
+                    string.Format("Field '{0}' is defined more than once in a query.", r.GetName(i)), "Column name or alias", argex);
+            }
+
+            return e;
+        }
+
+        /// <summary>Convert reader row into dynamic object.</summary>
+        /// <param name="r">Reader from which read.</param>
+        /// <returns>Generated dynamic object.</returns>
+        public static dynamic RowToExpando(this IDataReader r)
         {
             dynamic e = new ExpandoObject();
             var d = e as IDictionary<string, object>;

DynamORM/Helpers/Dynamics/DynamicParser.cs

@@ -75,16 +75,18 @@ namespace DynamORM.Helpers.Dynamics
                 {
                 }
 
-                private DynamicMetaObject GetBinder(Func<Node, Node> newNodeFunc)
+                // Func was cool but caused memory leaks
+                private DynamicMetaObject GetBinder(Node newNode)
                 {
                     var o = (Node)this.Value;
-                    var node = newNodeFunc(o);
+                    o.Parser.Last = newNode;
-                    o.Parser.Last = node;
+
+                    newNode.Parser = o.Parser;
 
                     var p = Expression.Variable(typeof(Node), "ret");
-                    var exp = Expression.Block(new ParameterExpression[] { p }, Expression.Assign(p, Expression.Constant(node)));
+                    var exp = Expression.Block(new ParameterExpression[] { p }, Expression.Assign(p, Expression.Constant(newNode)));
 
-                    return new MetaNode(exp, this.Restrictions, node);
+                    return new MetaNode(exp, this.Restrictions, newNode);
                 }
 
                 /// <summary>
@@ -96,7 +98,7 @@ namespace DynamORM.Helpers.Dynamics
                 /// </returns>
                 public override DynamicMetaObject BindGetMember(GetMemberBinder binder)
                 {
-                    return GetBinder(x => new GetMember(x, binder.Name) { Parser = x.Parser });
+                    return GetBinder(new GetMember((Node)this.Value, binder.Name));
                 }
 
                 /// <summary>
@@ -109,7 +111,7 @@ namespace DynamORM.Helpers.Dynamics
                 /// </returns>
                 public override DynamicMetaObject BindSetMember(SetMemberBinder binder, DynamicMetaObject value)
                 {
-                    return GetBinder(x => new SetMember(x, binder.Name, value.Value) { Parser = x.Parser });
+                    return GetBinder(new SetMember((Node)this.Value, binder.Name, value.Value));
                 }
 
                 /// <summary>
@@ -122,7 +124,7 @@ namespace DynamORM.Helpers.Dynamics
                 /// </returns>
                 public override DynamicMetaObject BindGetIndex(GetIndexBinder binder, DynamicMetaObject[] indexes)
                 {
-                    return GetBinder(x => new GetIndex(x, indexes.Select(m => m.Value).ToArray()) { Parser = x.Parser });
+                    return GetBinder(new GetIndex((Node)this.Value, indexes.Select(m => m.Value).ToArray()));
                 }
 
                 /// <summary>
@@ -136,7 +138,7 @@ namespace DynamORM.Helpers.Dynamics
                 /// </returns>
                 public override DynamicMetaObject BindSetIndex(SetIndexBinder binder, DynamicMetaObject[] indexes, DynamicMetaObject value)
                 {
-                    return GetBinder(x => new SetIndex(x, indexes.Select(m => m.Value).ToArray(), value.Value) { Parser = x.Parser });
+                    return GetBinder(new SetIndex((Node)this.Value, indexes.Select(m => m.Value).ToArray(), value.Value));
                 }
 
                 /// <summary>
@@ -149,7 +151,7 @@ namespace DynamORM.Helpers.Dynamics
                 /// </returns>
                 public override DynamicMetaObject BindInvoke(InvokeBinder binder, DynamicMetaObject[] args)
                 {
-                    return GetBinder(x => new Invoke(x, args.Select(m => m.Value).ToArray()) { Parser = x.Parser });
+                    return GetBinder(new Invoke((Node)this.Value, args.Select(m => m.Value).ToArray()));
                 }
 
                 /// <summary>
@@ -162,7 +164,7 @@ namespace DynamORM.Helpers.Dynamics
                 /// </returns>
                 public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args)
                 {
-                    return GetBinder(x => new Method(x, binder.Name, args.Select(m => m.Value).ToArray()) { Parser = x.Parser });
+                    return GetBinder(new Method((Node)this.Value, binder.Name, args.Select(m => m.Value).ToArray()));
                 }
 
                 /// <summary>
@@ -175,7 +177,7 @@ namespace DynamORM.Helpers.Dynamics
                 /// </returns>
                 public override DynamicMetaObject BindBinaryOperation(BinaryOperationBinder binder, DynamicMetaObject arg)
                 {
-                    return GetBinder(x => new Binary(x, binder.Operation, arg.Value) { Parser = x.Parser });
+                    return GetBinder(new Binary((Node)this.Value, binder.Operation, arg.Value));
                 }
 
                 /// <summary>

DynamORM/Helpers/Dynamics/DynamicProxy.cs

@@ -78,6 +78,7 @@ namespace DynamORM.Helpers.Dynamics
                     {
                         try
                         {
+                            // TODO: MAke this work... open instance delegate would be nice
                             return Delegate.CreateDelegate(Expression.GetDelegateType(v.GetParameters().Select(t => t.ParameterType).Concat(new[] { v.ReflectedType }).ToArray()), _proxy, v.Name);
                         }
                         catch (ArgumentException)

DynamORM/Helpers/UnclassifiedExtensions.cs

@@ -27,6 +27,7 @@
 */
 
 using System;
+using System.Collections.Generic;
 
 namespace DynamORM.Helpers
 {
@@ -71,5 +72,19 @@ namespace DynamORM.Helpers
             return obj != null && obj != DBNull.Value ?
                 func(obj) : elseFunc != null ? elseFunc() : default(R);
         }
+
+        /// <summary>Simple distinct by selector extension.</summary>
+        /// <returns>The enumerator of elements distinct by specified selector.</returns>
+        /// <param name="source">Source collection.</param>
+        /// <param name="keySelector">Distinct key selector.</param>
+        /// <typeparam name="R">The enumerable element type parameter.</typeparam>
+        /// <typeparam name="T">The selector type parameter.</typeparam>
+        public static IEnumerable<R> DistinctBy<R, T>(this IEnumerable<R> source, Func<R, T> keySelector)
+        {
+            HashSet<T> seenKeys = new HashSet<T>();
+            foreach (R element in source)
+                if (seenKeys.Add(keySelector(element)))
+                    yield return element;
+        }
     }
 }

Tester/Program.cs

@@ -1,6 +1,9 @@
 using System;
 using System.Linq;
+using DynamORM;
 using DynamORM.Mapper;
+using System.Collections.Generic;
+using System.Dynamic;
 
 namespace Tester
 {
@@ -30,27 +33,171 @@ namespace Tester
 
         private static DynamORM.DynamicDatabase GetORM()
         {
-            return new DynamORM.DynamicDatabase(System.Data.SqlClient.SqlClientFactory.Instance,
+            //return new DynamORM.DynamicDatabase(System.Data.SqlClient.SqlClientFactory.Instance,
-                "packet size=4096;User Id=sa;Password=sa123;data source=192.168.1.9,1433;initial catalog=MOM_SIERPC_WMS_TEST;",
+            //    "packet size=4096;User Id=sa;Password=sa123;data source=192.168.1.9,1433;initial catalog=MOM_SIERPC_WMS_TEST;",
+            //    DynamORM.DynamicDatabaseOptions.SingleConnection | DynamORM.DynamicDatabaseOptions.SingleTransaction |
+            //    DynamORM.DynamicDatabaseOptions.SupportSchema | DynamORM.DynamicDatabaseOptions.SupportTop);
+            return new DynamORM.DynamicDatabase(System.Data.SQLite.SQLiteFactory.Instance,
+                "Data Source=test.db3;",
                 DynamORM.DynamicDatabaseOptions.SingleConnection | DynamORM.DynamicDatabaseOptions.SingleTransaction |
-                DynamORM.DynamicDatabaseOptions.SupportSchema | DynamORM.DynamicDatabaseOptions.SupportTop);
+                DynamORM.DynamicDatabaseOptions.SupportSchema | DynamORM.DynamicDatabaseOptions.SupportLimitOffset);
         }
 
         private static void Main(string[] args)
         {
+            using (var db = GetORM())
+            using (var con = db.Open())
+            using (var cmd = con.CreateCommand())
+                new List<string>()
+                {
+                    @"CREATE TABLE IF NOT EXISTS Test(id int NOT NULL PRIMARY KEY, val text);",
+                    @"DELETE FROM Test;",
+                    @"INSERT INTO Test VALUES(1, 'Test');",
+                }.ForEach(x =>
+                    cmd.SetCommand(x)
+                        .ExecuteNonQuery());
+
             Console.Out.WriteLine("Press ENTER to launch bombardment... or q and ENTER to quit.");
             while (Console.In.ReadLine() != "q")
             {
                 Console.Out.WriteLine("Bombardment...");
+
+                long membefore = GC.GetTotalMemory(true);
+
                 BombsAway();
 
-                Console.Out.WriteLine("Done.");
+                GC.WaitForPendingFinalizers();
+                GC.Collect();
+
+                Console.Out.WriteLine("Mem Before: {0}, Mem After: {1}. Done.", membefore, GC.GetTotalMemory(true));
             }
         }
 
         private static void BombsAway()
         {
+            string test_str = string.Empty;
+
+            for (int y = 0; y < 10; y++)
+            {
+                string val = null;
                 for (int i = 0; i < 1000; i++)
+                {
+                    dynamic o = new ExpandoObject();
+                    o.Test = "123";
+                    o.Test2 = 123;
+                    o.Test3 = true;
+                    o.Test4 = (object)null;
+
+                    val = o.Test;
+                    val = o.Test2.ToString();
+                }
+
+                GC.WaitForPendingFinalizers();
+                GC.Collect();
+
+                Console.Out.WriteLine("Expr: [ExpandoObject only], Mem: {0}", GC.GetTotalMemory(true));
+            }
+
+            for (int y = 0; y < 10; y++)
+            {
+                string val = null;
+
+                for (int i = 0; i < 1000; i++)
+                {
+                    dynamic o = new ExpandoObject();
+                    var d = o as IDictionary<string, object>;
+                    d.Add("Test", "123");
+                    d.Add("Test2", 123);
+                    d.Add("Test3", true);
+                    d.Add("Test4", null);
+
+                    val = o.Test;
+                    val = o.Test2.ToString();
+                }
+
+                GC.WaitForPendingFinalizers();
+                GC.Collect();
+
+                Console.Out.WriteLine("Expr: [ExpandoObject as Dict], Mem: {0}", GC.GetTotalMemory(true));
+            }
+
+            /*for (int y = 0; y < 10; y++)
+            {
+                Func<dynamic, object> f = x => x.To == 0;
+                for (int i = 0; i < 1000; i++)
+                    using (var p = DynamORM.Helpers.Dynamics.DynamicParser.Parse(f))
+                        test_str = p.ToString();
+
+                GC.WaitForPendingFinalizers();
+                GC.Collect();
+
+                Console.Out.WriteLine("Expr: {0}, Mem: {1}", test_str, GC.GetTotalMemory(true));
+            }*/
+
+            for (int y = 0; y < 10; y++)
+            {
+                using (var dbt = GetORM())
+                using (dbt.Table("Test"))
+                    ;
+
+                GC.WaitForPendingFinalizers();
+                GC.Collect();
+
+                Console.Out.WriteLine("Expr: [Create and destroy ORM], Mem: {0}", GC.GetTotalMemory(true));
+            }
+                
+            //using (var db = GetORM())
+            {
+                for (int y = 0; y < 10; y++)
+                {
+                    using (var db = GetORM())
+                        for (int i = 0; i < 1000; i++)
+                            test_str = ((int)db.Table("Test").Scalar("SELECT id FROM Test;")).ToString();
+
+                    GC.WaitForPendingFinalizers();
+                    GC.Collect();
+
+                    Console.Out.WriteLine("Expr: [db.Table(\"Test\").Scalar(\"SELECT id FROM Test;\")] = {0}, Mem: {1}", test_str, GC.GetTotalMemory(true));
+                }
+
+                for (int y = 0; y < 10; y++)
+                {
+                    using (var db = GetORM())
+                        for (int i = 0; i < 1000; i++)
+                            test_str = ((int)db.Table("Test").Scalar(columns: "id")).ToString();
+
+                    GC.WaitForPendingFinalizers();
+                    GC.Collect();
+
+                    Console.Out.WriteLine("Expr: [db.Table(\"Test\").Scalar(columns: \"id\")] = {0}, Mem: {1}", test_str, GC.GetTotalMemory(true));
+                }
+
+                for (int y = 0; y < 10; y++)
+                {
+                    using (var db = GetORM())
+                        for (int i = 0; i < 1000; i++)
+                            test_str = db.From(x => x.Test.As(x.t)).Where(t => t.id == 1).ToList().First().val;
+
+                    GC.WaitForPendingFinalizers();
+                    GC.Collect();
+
+                    Console.Out.WriteLine("Expr: [db.From(x => x.Test.As(x.t)).Where(t => t.id == 1).ToList().First().val] = {0}, Mem: {1}", test_str, GC.GetTotalMemory(true));
+                }
+
+                for (int y = 0; y < 10; y++)
+                {
+                    using (var db = GetORM())
+                        for (int i = 0; i < 1000; i++)
+                            test_str = ((int)db.From(x => x.Test.As(x.t)).Where(t => t.id == 1).Select(t => t.id).Scalar()).ToString();
+
+                    GC.WaitForPendingFinalizers();
+                    GC.Collect();
+
+                    Console.Out.WriteLine("Expr: [db.From(x => x.Test.As(x.t)).Where(t => t.id == 1).Select(t => t.id).Scalar()] = {0}, Mem: {1}", test_str, GC.GetTotalMemory(true));
+                }
+            }
+
+            /*for (int i = 0; i < 1000; i++)
                 using (var db = GetORM())
                 {
                     //var session = db.From(x => x.mom_Sessions.As(x.s))
@@ -69,7 +216,7 @@ namespace Tester
 
                     //var session = (db.Table().Query("SELECT * FROM mom_Sessions WHERE ms_id = @0 AND ms_mus_id = @1", Guid.Empty, Guid.Empty)
                     //    as IEnumerable<dynamic>).FirstOrDefault();
-                }
+                }*/
         }
     }
 }

Tester/Tester.csproj

@@ -23,6 +23,7 @@
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <Externalconsole>true</Externalconsole>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
     <PlatformTarget>x86</PlatformTarget>
@@ -32,11 +33,9 @@
     <DefineConstants>TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <Externalconsole>true</Externalconsole>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="Npgsql">
-      <HintPath>..\..\..\..\..\Development\Source\TED\Demo\Libraries\Npgsql.dll</HintPath>
-    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Xml.Linq" />
@@ -44,6 +43,9 @@
     <Reference Include="Microsoft.CSharp" />
     <Reference Include="System.Data" />
     <Reference Include="System.Xml" />
+    <Reference Include="System.Data.SQLite">
+      <HintPath>..\..\..\Libs\SQLite\x86\System.Data.SQLite.dll</HintPath>
+    </Reference>
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Program.cs" />
@@ -55,6 +57,9 @@
       <Name>DynamORM</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <Content Include="ProfilingSessions\Session20141128_203722.sdps" />
+  </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.