added marr.datamapper source code for easy debugging.

Marr.Data/Converters/BooleanIntConverter.cs

@@ -0,0 +1,78 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Marr.Data.Mapping;
+
+namespace Marr.Data.Converters
+{
+    public class BooleanIntConverter : IConverter
+    {
+        public object FromDB(ColumnMap map, object dbValue)
+        {
+            if (dbValue == DBNull.Value)
+            {
+                return DBNull.Value;
+            }
+
+            int val = (int)dbValue;
+
+            if (val == 1)
+            {
+                return true;
+            }
+            else if (val == 0)
+            {
+                return false;
+            }
+            else
+            {
+                throw new ConversionException(
+                    string.Format(
+                    "The BooleanCharConverter could not convert the value '{0}' to a boolean.",
+                    dbValue));
+            }
+        }
+
+        public object ToDB(object clrValue)
+        {
+            bool? val = (bool?)clrValue;
+
+            if (val == true)
+            {
+                return 1;
+            }
+            else if (val == false)
+            {
+                return 0;
+            }
+            else
+            {
+                return DBNull.Value;
+            }
+        }
+
+        public Type DbType
+        {
+            get
+            {
+                return typeof(int);
+            }
+        }
+    }
+}

Marr.Data/Converters/BooleanYNConverter.cs

@@ -0,0 +1,78 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Marr.Data.Mapping;
+
+namespace Marr.Data.Converters
+{
+    public class BooleanYNConverter : IConverter
+    {
+        public object FromDB(ColumnMap map, object dbValue)
+        {
+            if (dbValue == DBNull.Value)
+            {
+                return DBNull.Value;
+            }
+
+            string val = dbValue.ToString();
+
+            if (val == "Y")
+            {
+                return true;
+            }
+            else if (val == "N")
+            {
+                return false;
+            }
+            else
+            {
+                throw new ConversionException(
+                    string.Format(
+                    "The BooleanYNConverter could not convert the value '{0}' to a boolean.",
+                    dbValue));
+            }
+        }
+
+        public object ToDB(object clrValue)
+        {
+            bool? val = (bool?)clrValue;
+
+            if (val == true)
+            {
+                return "Y";
+            }
+            else if (val == false)
+            {
+                return "N";
+            }
+            else
+            {
+                return DBNull.Value;
+            }
+        }
+
+        public Type DbType
+        {
+            get
+            {
+                return typeof(string);
+            }
+        }
+    }
+}

Marr.Data/Converters/CastConverter.cs

@@ -0,0 +1,49 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Marr.Data.Converters
+{
+    public class CastConverter<TClr, TDb> : Marr.Data.Converters.IConverter
+        where TClr : IConvertible
+        where TDb : IConvertible
+    {
+        #region IConversion Members
+
+        public Type DbType
+        {
+            get { return typeof(TDb); }
+        }
+
+        public object FromDB(Marr.Data.Mapping.ColumnMap map, object dbValue)
+        {
+            TDb val = (TDb)dbValue;
+            return val.ToType(typeof(TClr), System.Globalization.CultureInfo.InvariantCulture);
+        }
+
+        public object ToDB(object clrValue)
+        {
+            TClr val = (TClr)clrValue;
+            return val.ToType(typeof(TDb), System.Globalization.CultureInfo.InvariantCulture);
+        }
+
+        #endregion
+    }
+}
+

Marr.Data/Converters/ConversionException.cs

@@ -0,0 +1,29 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Marr.Data.Converters
+{
+    public class ConversionException : Exception
+    {
+        public ConversionException(string message)
+            : base(message)
+        { }
+    }
+}

Marr.Data/Converters/EnumIntConverter.cs

@@ -0,0 +1,50 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Marr.Data.Mapping;
+
+namespace Marr.Data.Converters
+{
+    public class EnumIntConverter : IConverter
+    {
+        public object FromDB(ColumnMap map, object dbValue)
+        {
+            if (dbValue == null || dbValue == DBNull.Value)
+                return null;
+            else
+                return Enum.ToObject(map.FieldType, (int)dbValue);
+        }
+
+        public object ToDB(object clrValue)
+        {
+            if (clrValue == null)
+                return DBNull.Value;
+            else
+                return (int)clrValue;
+        }
+
+        public Type DbType
+        {
+            get
+            {
+                return typeof(int);
+            }
+        }
+    }
+}

Marr.Data/Converters/EnumStringConverter.cs

@@ -0,0 +1,50 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Marr.Data.Mapping;
+
+namespace Marr.Data.Converters
+{
+    public class EnumStringConverter : IConverter
+    {
+        public object FromDB(ColumnMap map, object dbValue)
+        {
+            if (dbValue == null || dbValue == DBNull.Value)
+                return null;
+            else
+                return Enum.Parse(map.FieldType, (string)dbValue);
+        }
+
+        public object ToDB(object clrValue)
+        {
+            if (clrValue == null)
+                return DBNull.Value;
+            else
+                return clrValue.ToString();
+        }
+
+        public Type DbType
+        {
+            get
+            {
+                return typeof(string);
+            }
+        }
+    }
+}

Marr.Data/Converters/IConverter.cs

@@ -0,0 +1,30 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Marr.Data.Mapping;
+
+namespace Marr.Data.Converters
+{
+    public interface IConverter
+    {
+        object FromDB(ColumnMap map, object dbValue);
+        object ToDB(object clrValue);
+        Type DbType { get; }
+    }
+}

Marr.Data/DataHelper.cs

@@ -0,0 +1,165 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Data;
+using System.Reflection;
+using Marr.Data.Mapping;
+using System.Linq.Expressions;
+
+namespace Marr.Data
+{
+    /// <summary>
+    /// This class contains misc. extension methods that are used throughout the project.
+    /// </summary>
+    internal static class DataHelper
+    {
+        public static bool HasColumn(this IDataReader dr, string columnName) 
+        { 
+            for (int i=0; i < dr.FieldCount; i++) 
+            { 
+                if (dr.GetName(i).Equals(columnName, StringComparison.InvariantCultureIgnoreCase)) 
+                    return true; 
+            } 
+            return false; 
+        }
+
+        public static string ParameterPrefix(this IDbCommand command)
+        {
+            string commandType = command.GetType().Name.ToLower();
+            return commandType.Contains("oracle") ? ":" : "@";
+        }
+        
+        /// <summary>
+        /// Returns the mapped name, or the member name.
+        /// </summary>
+        /// <param name="member"></param>
+        /// <returns></returns>
+        public static string GetTableName(this MemberInfo member)
+        {
+            string tableName = MapRepository.Instance.GetTableName(member.DeclaringType);
+            return tableName ?? member.DeclaringType.Name;
+        }
+
+        public static string GetTableName(this Type memberType)
+        {
+            return MapRepository.Instance.GetTableName(memberType);
+        }
+
+        public static string GetColumName(this IColumnInfo col, bool useAltName)
+        {
+            if (useAltName)
+            {
+                return col.TryGetAltName();
+            }
+            else
+            {
+                return col.Name;
+            }
+        }
+
+        /// <summary>
+        /// Returns the mapped column name, or the member name.
+        /// </summary>
+        /// <param name="member"></param>
+        /// <returns></returns>
+        public static string GetColumnName(Type declaringType, string propertyName, bool useAltName)
+        {
+            // Initialize column name as member name
+            string columnName = propertyName;
+
+            var columnMap = MapRepository.Instance.GetColumns(declaringType).GetByFieldName(propertyName);
+            if (useAltName)
+            {
+                columnName = columnMap.ColumnInfo.TryGetAltName();
+            }
+            else
+            {
+                columnName = columnMap.ColumnInfo.Name;
+            }
+
+            return columnName;
+        }
+
+        /// <summary>
+        /// Determines a property name from a passed in expression.
+        /// Ex:  p => p.FirstName   ->    "FirstName
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="member"></param>
+        /// <returns></returns>
+        public static string GetMemberName<T>(this Expression<Func<T, object>> member)
+        {
+            var memberExpression = (member.Body as MemberExpression);
+            if (memberExpression == null)
+            {
+                memberExpression = (member.Body as UnaryExpression).Operand as MemberExpression;
+            }
+
+            return memberExpression.Member.Name;
+        }
+
+        public static string GetMemberName(this LambdaExpression exp)
+        {
+            var memberExpression = (exp.Body as MemberExpression);
+            if (memberExpression == null)
+            {
+                memberExpression = (exp.Body as UnaryExpression).Operand as MemberExpression;
+            }
+
+            return memberExpression.Member.Name;
+        }
+
+        public static bool ContainsMember(this List<MemberInfo> list, MemberInfo member)
+        {
+            foreach (var m in list)
+            {
+                if (m.EqualsMember(member))
+                    return true;
+            }
+
+            return false;
+        }
+
+        public static bool EqualsMember(this MemberInfo member, MemberInfo otherMember)
+        {
+            return member.Name == otherMember.Name && member.DeclaringType == otherMember.DeclaringType;
+        }
+
+        /// <summary>
+        /// Determines if a type is not a complex object.
+        /// </summary>
+        public static bool IsSimpleType(Type type)
+        {
+            Type underlyingType = !IsNullableType(type) ? type : type.GetGenericArguments()[0];
+
+            return
+                underlyingType.IsPrimitive ||
+                underlyingType.Equals(typeof(string)) ||
+                underlyingType.Equals(typeof(DateTime)) ||
+                underlyingType.Equals(typeof(decimal)) ||
+                underlyingType.IsEnum;
+        }
+
+        public static bool IsNullableType(Type theType)
+        {
+            return (theType.IsGenericType && theType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)));
+        }
+
+    }
+}

Marr.Data/DataMapper.cs

@@ -0,0 +1,996 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Data;
+using System.Data.Common;
+using System.Data.SqlClient;
+using System.Reflection;
+using System.Collections;
+using System.Linq;
+using Marr.Data.Mapping;
+using Marr.Data.Converters;
+using Marr.Data.Parameters;
+using Marr.Data.QGen;
+using System.Linq.Expressions;
+using System.Diagnostics;
+
+namespace Marr.Data
+{
+    /// <summary>
+    /// This class is the main access point for making database related calls.
+    /// </summary>
+    public class DataMapper : IDataMapper
+    {
+
+        #region - Contructor, Members -
+
+        private DbProviderFactory _dbProviderFactory;
+        private string _connectionString;
+        private DbCommand _command;
+
+        /// <summary>
+        /// Initializes a DataMapper for the given provider type and connection string.
+        /// </summary>
+        /// <param name="providerName">Ex: </param>
+        /// <param name="connectionString">The database connection string.</param>
+        public DataMapper(string providerName, string connectionString)
+            : this(DbProviderFactories.GetFactory(providerName), connectionString)
+        { }
+
+        /// <summary>
+        /// A database provider agnostic initialization.
+        /// </summary>
+        /// <param name="connection">The database connection string.</param>
+        public DataMapper(DbProviderFactory dbProviderFactory, string connectionString)
+        {
+            if (dbProviderFactory == null)
+                throw new ArgumentNullException("dbProviderFactory instance cannot be null.");
+
+            if (string.IsNullOrEmpty(connectionString))
+                throw new ArgumentNullException("connectionString cannot be null or empty.");
+
+            _dbProviderFactory = dbProviderFactory;
+
+            _connectionString = connectionString;
+        }
+
+        public string ConnectionString
+        {
+            get
+            {
+                return _connectionString;
+            }
+        }
+
+        public DbProviderFactory ProviderFactory
+        {
+            get
+            {
+                return _dbProviderFactory;
+            }
+        }
+        
+        /// <summary>
+        /// Creates a new command utilizing the connection string.
+        /// </summary>
+        private DbCommand CreateNewCommand()
+        {
+            DbConnection conn = _dbProviderFactory.CreateConnection();
+            conn.ConnectionString = _connectionString;
+            DbCommand cmd = conn.CreateCommand();
+            SetSqlMode(cmd);
+            return cmd;
+        }
+
+        /// <summary>
+        /// Creates a new command utilizing the connection string with a given SQL command.
+        /// </summary>
+        private DbCommand CreateNewCommand(string sql)
+        {
+            DbCommand cmd = CreateNewCommand();
+            cmd.CommandText = sql;
+            return cmd;
+        }
+
+        /// <summary>
+        /// Gets or creates a DbCommand object.
+        /// </summary>
+        public DbCommand Command
+        {
+            get
+            {
+                // Lazy load
+                if (_command == null)
+                    _command = CreateNewCommand();
+                else
+                    SetSqlMode(_command); // Set SqlMode every time.
+
+                return _command;
+            }
+        }
+
+        #endregion
+
+        #region - Parameters -
+
+        public DbParameterCollection Parameters
+        {
+            get
+            {
+                return Command.Parameters;
+            }
+        }
+
+        public ParameterChainMethods AddParameter(string name, object value)
+        {
+            return new ParameterChainMethods(Command, name, value);
+        }
+
+        public IDbDataParameter AddParameter(IDbDataParameter parameter)
+        {
+            // Convert null values to DBNull.Value
+            if (parameter.Value == null)
+                parameter.Value = DBNull.Value;
+
+            this.Parameters.Add(parameter);
+            return parameter;
+        }
+
+        #endregion
+
+        #region - SP / SQL Mode -
+
+        private SqlModes _sqlMode = SqlModes.StoredProcedure; // Defaults to SP.
+        /// <summary>
+        /// Gets or sets a value that determines whether the DataMapper will 
+        /// use a stored procedure or a sql text command to access 
+        /// the database.  The default is stored procedure.
+        /// </summary>
+        public SqlModes SqlMode
+        {
+            get
+            {
+                return _sqlMode;
+            }
+            set
+            {
+                _sqlMode = value;
+            }
+        }
+
+        /// <summary>
+        /// Sets the DbCommand objects CommandType to the current SqlMode.
+        /// </summary>
+        /// <param name="command">The DbCommand object we are modifying.</param>
+        /// <returns>Returns the same DbCommand that was passed in.</returns>
+        private DbCommand SetSqlMode(DbCommand command)
+        {
+            if (SqlMode == SqlModes.StoredProcedure)
+                command.CommandType = CommandType.StoredProcedure;
+            else
+                command.CommandType = CommandType.Text;
+
+            return command;
+        }
+
+        #endregion
+
+        #region - ExecuteScalar, ExecuteNonQuery, ExecuteReader -
+
+        /// <summary>
+        /// Executes a stored procedure that returns a scalar value.
+        /// </summary>
+        /// <param name="sql">The SQL command to execute.</param>
+        /// <returns>A scalar value</returns>
+        public object ExecuteScalar(string sql)
+        {
+            if (string.IsNullOrEmpty(sql))
+                throw new ArgumentNullException("sql", "A SQL query or stored procedure name is required");
+            else
+                Command.CommandText = sql;
+
+            try
+            {
+                OpenConnection();
+                return Command.ExecuteScalar();
+            }
+            finally
+            {
+                CloseConnection();
+            }
+        }
+
+        /// <summary>
+        /// Executes a non query that returns an integer.
+        /// </summary>
+        /// <param name="sql">The SQL command to execute.</param>
+        /// <returns>An integer value</returns>
+        public int ExecuteNonQuery(string sql)
+        {
+            if (string.IsNullOrEmpty(sql))
+                throw new ArgumentNullException("sql", "A SQL query or stored procedure name is required");
+            else
+                Command.CommandText = sql;
+
+            try
+            {
+                OpenConnection();
+                return Command.ExecuteNonQuery();
+            }
+            finally
+            {
+                CloseConnection();
+            }
+        }
+
+        /// <summary>
+        /// Executes a DataReader that can be controlled using a Func delegate.
+        /// (Note that reader.Read() will be called automatically).
+        /// </summary>
+        /// <typeparam name="TResult">The type that will be return in the result set.</typeparam>
+        /// <param name="sql">The sql statement that will be executed.</param>
+        /// <param name="func">The function that will build the the TResult set.</param>
+        /// <returns>An IEnumerable of TResult.</returns>
+        public IEnumerable<TResult> ExecuteReader<TResult>(string sql, Func<DbDataReader, TResult> func)
+        {
+            if (string.IsNullOrEmpty(sql))
+                throw new ArgumentNullException("sql", "A SQL query or stored procedure name is required");
+            else
+                Command.CommandText = sql;
+
+            try
+            {
+                OpenConnection();
+
+                List<TResult> list = new List<TResult>();
+                DbDataReader reader = null;
+                try
+                {
+                    reader = Command.ExecuteReader();
+
+                    while (reader.Read())
+                    {
+                        list.Add(func(reader));
+                    }
+
+                    return list;
+                }
+                finally
+                {
+                    if (reader != null) reader.Close();
+                }
+            }
+            finally
+            {
+                CloseConnection();
+            }
+        }
+
+        /// <summary>
+        /// Executes a DataReader that can be controlled using an Action delegate.
+        /// </summary>
+        /// <param name="sql">The sql statement that will be executed.</param>
+        /// <param name="action">The delegate that will work with the result set.</param>
+        public void ExecuteReader(string sql, Action<DbDataReader> action)
+        {
+            if (string.IsNullOrEmpty(sql))
+                throw new ArgumentNullException("sql", "A SQL query or stored procedure name is required");
+            else
+                Command.CommandText = sql;
+
+            try
+            {
+                OpenConnection();
+
+                DbDataReader reader = null;
+                try
+                {
+                    reader = Command.ExecuteReader();
+
+                    while (reader.Read())
+                    {
+                        action(reader);
+                    }
+                }
+                finally
+                {
+                    if (reader != null) reader.Close();
+                }
+            }
+            finally
+            {
+                CloseConnection();
+            }
+        }
+
+        #endregion
+
+        #region - DataSets -
+
+        public DataSet GetDataSet(string sql)
+        {
+            return GetDataSet(sql, new DataSet(), null);
+        }
+
+        public DataSet GetDataSet(string sql, DataSet ds, string tableName)
+        {
+            if (string.IsNullOrEmpty(sql))
+                throw new ArgumentNullException("sql", "A SQL query or stored procedure name is required");
+
+            try
+            {
+                using (DbDataAdapter adapter = _dbProviderFactory.CreateDataAdapter())
+                {
+                    Command.CommandText = sql;
+                    adapter.SelectCommand = Command;
+
+                    if (ds == null)
+                        ds = new DataSet();
+
+                    OpenConnection();
+
+                    if (string.IsNullOrEmpty(tableName))
+                        adapter.Fill(ds);
+                    else
+                        adapter.Fill(ds, tableName);
+
+                    return ds;
+                }
+            }
+            finally
+            {
+                CloseConnection();  // Clears parameters
+            }
+        }
+
+        public DataTable GetDataTable(string sql)
+        {
+            return GetDataTable(sql, null, null);
+        }
+
+        public DataTable GetDataTable(string sql, DataTable dt, string tableName)
+        {
+            if (string.IsNullOrEmpty(sql))
+                throw new ArgumentNullException("sql", "A SQL query or stored procedure name is required");
+
+            try
+            {
+                using (DbDataAdapter adapter = _dbProviderFactory.CreateDataAdapter())
+                {
+                    Command.CommandText = sql;
+                    adapter.SelectCommand = Command;
+
+                    if (dt == null)
+                        dt = new DataTable();
+
+                    adapter.Fill(dt);
+
+                    if (!string.IsNullOrEmpty(tableName))
+                        dt.TableName = tableName;
+
+                    return dt;
+                }
+            }
+            finally
+            {
+                CloseConnection();  // Clears parameters
+            }
+        }
+
+        public int UpdateDataSet(DataSet ds, string sql)
+        {
+            if (string.IsNullOrEmpty(sql))
+                throw new ArgumentNullException("sql", "A SQL query or stored procedure name is required");
+
+            if (ds == null)
+                throw new ArgumentNullException("ds", "DataSet cannot be null.");
+
+            DbDataAdapter adapter = null;
+
+            try
+            {
+                adapter = _dbProviderFactory.CreateDataAdapter();
+
+                adapter.UpdateCommand = Command;
+                adapter.UpdateCommand.CommandText = sql;
+
+                return adapter.Update(ds);
+            }
+            finally
+            {
+                if (adapter.UpdateCommand != null)
+                    adapter.UpdateCommand.Dispose();
+
+                adapter.Dispose();
+            }
+        }
+
+        public int InsertDataTable(DataTable table, string insertSP)
+        {
+            return this.InsertDataTable(table, insertSP, UpdateRowSource.None);
+        }
+
+        public int InsertDataTable(DataTable dt, string sql, UpdateRowSource updateRowSource)
+        {
+            if (string.IsNullOrEmpty(sql))
+                throw new ArgumentNullException("sql", "A SQL query or stored procedure name is required");
+
+            if (dt == null)
+                throw new ArgumentNullException("dt", "DataTable cannot be null.");
+
+            DbDataAdapter adapter = null;
+
+            try
+            {
+                adapter = _dbProviderFactory.CreateDataAdapter();
+
+                adapter.InsertCommand = Command;
+                adapter.InsertCommand.CommandText = sql;
+
+                adapter.InsertCommand.UpdatedRowSource = updateRowSource;
+
+                return adapter.Update(dt);
+            }
+            finally
+            {
+                if (adapter.InsertCommand != null)
+                    adapter.InsertCommand.Dispose();
+
+                adapter.Dispose();
+            }
+        }
+
+        public int DeleteDataTable(DataTable dt, string sql)
+        {
+            if (string.IsNullOrEmpty(sql))
+                throw new ArgumentNullException("sql", "A SQL query or stored procedure name is required");
+
+            if (dt == null)
+                throw new ArgumentNullException("dt", "DataSet cannot be null.");
+
+            DbDataAdapter adapter = null;
+
+            try
+            {
+                adapter = _dbProviderFactory.CreateDataAdapter();
+
+                adapter.DeleteCommand = Command;
+                adapter.DeleteCommand.CommandText = sql;
+
+                return adapter.Update(dt);
+            }
+            finally
+            {
+                if (adapter.DeleteCommand != null)
+                    adapter.DeleteCommand.Dispose();
+
+                adapter.Dispose();
+            }
+        }
+
+        #endregion
+
+        #region - Find -
+
+        public T Find<T>(string sql)
+        {
+            return this.Find<T>(sql, default(T));
+        }
+
+        /// <summary>
+        /// Returns an entity of type T.
+        /// </summary>
+        /// <typeparam name="T">The type of entity that is to be instantiated and loaded with values.</typeparam>
+        /// <param name="sql">The SQL command to execute.</param>
+        /// <returns>An instantiated and loaded entity of type T.</returns>
+        public T Find<T>(string sql, T ent)
+        {
+            if (string.IsNullOrEmpty(sql))
+                throw new ArgumentNullException("sql", "A stored procedure name has not been specified for 'Find'.");
+
+            Type entityType = typeof(T);
+            Command.CommandText = sql;
+
+            MapRepository repository = MapRepository.Instance;
+            ColumnMapCollection mappings = repository.GetColumns(entityType);
+
+            bool isSimpleType = DataHelper.IsSimpleType(typeof(T));
+
+            try
+            {
+                OpenConnection();
+                var mappingHelper = new MappingHelper(this);
+
+                using (DbDataReader reader = Command.ExecuteReader())
+                {
+                    if (reader.Read())
+                    {
+                        if (isSimpleType)
+                        {
+                            return mappingHelper.LoadSimpleValueFromFirstColumn<T>(reader);
+                        }
+                        else
+                        {
+                            if (ent == null)
+                                ent = (T)mappingHelper.CreateAndLoadEntity<T>(mappings, reader, false);
+                            else
+                                mappingHelper.LoadExistingEntity(mappings, reader, ent, false);
+                        }
+                    }
+                }
+            }
+            finally
+            {
+                CloseConnection();
+            }
+
+            return ent;
+        }
+
+        #endregion
+
+        #region - Query -
+
+        /// <summary>
+        /// Creates a QueryBuilder that allows you to build a query.
+        /// </summary>
+        /// <typeparam name="T">The type of object that will be queried.</typeparam>
+        /// <returns>Returns a QueryBuilder of T.</returns>
+        public QueryBuilder<T> Query<T>()
+        {
+            var dialect = QGen.QueryFactory.CreateDialect(this);
+            return new QueryBuilder<T>(this, dialect);
+        }
+
+        /// <summary>
+        /// Returns the results of a query.
+        /// Uses a List of type T to return the data.
+        /// </summary>
+        /// <returns>Returns a list of the specified type.</returns>
+        public List<T> Query<T>(string sql)
+        {
+            return (List<T>)Query<T>(sql, new List<T>());
+        }
+
+        /// <summary>
+        /// Returns the results of a SP query.
+        /// </summary>
+        /// <returns>Returns a list of the specified type.</returns>
+        public ICollection<T> Query<T>(string sql, ICollection<T> entityList)
+        {
+            return Query<T>(sql, entityList, false);
+        }
+
+        internal ICollection<T> Query<T>(string sql, ICollection<T> entityList, bool useAltName)
+        {
+            if (entityList == null)
+                throw new ArgumentNullException("entityList", "ICollection instance cannot be null.");
+
+            if (string.IsNullOrEmpty(sql))
+                throw new ArgumentNullException("sql", "A query or stored procedure has not been specified for 'Query'.");
+
+            var mappingHelper = new MappingHelper(this);
+            Type entityType = typeof(T);
+            Command.CommandText = sql;
+            ColumnMapCollection mappings = MapRepository.Instance.GetColumns(entityType);
+
+            bool isSimpleType = DataHelper.IsSimpleType(typeof(T));
+
+            try
+            {
+                OpenConnection();
+                using (DbDataReader reader = Command.ExecuteReader())
+                {
+                    while (reader.Read())
+                    {
+                        if (isSimpleType)
+                        {
+                            entityList.Add(mappingHelper.LoadSimpleValueFromFirstColumn<T>(reader));
+                        }
+                        else
+                        {
+                            entityList.Add((T)mappingHelper.CreateAndLoadEntity<T>(mappings, reader, useAltName));
+                        }
+                    }
+                }
+            }
+            finally
+            {
+                CloseConnection();
+            }
+
+            return entityList;
+        }
+
+        #endregion
+
+        #region - Query to Graph -
+        
+        public List<T> QueryToGraph<T>(string sql)
+        {
+            return (List<T>)QueryToGraph<T>(sql, new List<T>());
+        }
+
+        public ICollection<T> QueryToGraph<T>(string sql, ICollection<T> entityList)
+        {
+            EntityGraph graph = new EntityGraph(typeof(T), (IList)entityList);
+            return QueryToGraph<T>(sql, graph, new List<MemberInfo>());
+        }
+
+        /// <summary>
+        /// Queries a view that joins multiple tables and returns an object graph.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="sql"></param>
+        /// <param name="entityList"></param>
+        /// <param name="entityGraph">Coordinates loading all objects in the graph..</param>
+        /// <returns></returns>
+        internal ICollection<T> QueryToGraph<T>(string sql, EntityGraph graph, List<MemberInfo> childrenToLoad)
+        {
+            if (string.IsNullOrEmpty(sql))
+                throw new ArgumentNullException("sql", "sql");
+
+            var mappingHelper = new MappingHelper(this);
+            Type parentType = typeof(T);
+            Command.CommandText = sql;
+
+            try
+            {
+                OpenConnection();
+                using (DbDataReader reader = Command.ExecuteReader())
+                {
+                    while (reader.Read())
+                    {
+                        // The entire EntityGraph is traversed for each record, 
+                        // and multiple entities are created from each view record.
+                        foreach (EntityGraph lvl in graph)
+                        {
+                            // If is child relationship entity, and childrenToLoad are specified, and entity is not listed,
+                            // then skip this entity.
+                            if (childrenToLoad.Count > 0 && !lvl.IsRoot && !childrenToLoad.ContainsMember(lvl.Member)) // lvl.Member.Name
+                            {
+                                continue;
+                            }
+
+                            if (lvl.IsNewGroup(reader))
+                            {
+                                var newEntity = mappingHelper.CreateAndLoadEntity(lvl.EntityType, lvl.Columns, reader, true);
+
+                                // Add entity to the appropriate place in the object graph
+                                lvl.AddEntity(newEntity);
+                            }
+                        }
+                    }
+                }
+            }
+            finally
+            {
+                CloseConnection();
+            }
+
+            return (ICollection<T>)graph.RootList;
+        }
+
+        #endregion
+
+        #region - Update -
+
+        public UpdateQueryBuilder<T> Update<T>()
+        {
+            return new UpdateQueryBuilder<T>(this);            
+        }
+
+        public int Update<T>(T entity, Expression<Func<T, bool>> filter)
+        {
+            return Update<T>()
+                .Entity(entity)
+                .Where(filter)
+                .Execute();
+        }
+
+        public int Update<T>(string tableName, T entity, Expression<Func<T, bool>> filter)
+        {
+            return Update<T>()
+                .TableName(tableName)
+                .Entity(entity)
+                .Where(filter)
+                .Execute();
+        }
+
+        public int Update<T>(T entity, string sql)
+        {
+            return Update<T>()
+                .Entity(entity)
+                .QueryText(sql)
+                .Execute();
+        }
+
+        #endregion
+
+        #region - Insert -
+
+        /// <summary>
+        /// Creates an InsertQueryBuilder that allows you to build an insert statement.
+        /// This method gives you the flexibility to manually configure all options of your insert statement.
+        /// Note: You must manually call the Execute() chaining method to run the query.
+        /// </summary>
+        public InsertQueryBuilder<T> Insert<T>()
+        {
+            return new InsertQueryBuilder<T>(this);
+        }
+
+        /// <summary>
+        /// Generates and executes an insert query for the given entity.
+        /// This overload will automatically run an identity query if you have mapped an auto-incrementing column,
+        /// and if an identity query has been implemented for your current database dialect.
+        /// </summary>
+        public object Insert<T>(T entity)
+        {
+            var columns = MapRepository.Instance.GetColumns(typeof(T));
+            var dialect = QueryFactory.CreateDialect(this);
+            var builder = Insert<T>().Entity(entity);
+
+            // If an auto-increment column exists and this dialect has an identity query...
+            if (columns.Exists(c => c.ColumnInfo.IsAutoIncrement) && dialect.HasIdentityQuery)
+            {
+                builder.GetIdentity();
+            }
+
+            return builder.Execute();
+        }
+
+        /// <summary>
+        /// Generates and executes an insert query for the given entity.
+        /// This overload will automatically run an identity query if you have mapped an auto-incrementing column,
+        /// and if an identity query has been implemented for your current database dialect.
+        /// </summary>
+        public object Insert<T>(string tableName, T entity)
+        {
+            var columns = MapRepository.Instance.GetColumns(typeof(T));
+            var dialect = QueryFactory.CreateDialect(this);
+            var builder = Insert<T>().Entity(entity).TableName(tableName);
+
+            // If an auto-increment column exists and this dialect has an identity query...
+            if (columns.Exists(c => c.ColumnInfo.IsAutoIncrement) && dialect.HasIdentityQuery)
+            {
+                builder.GetIdentity();
+            }
+
+            return builder.Execute();
+        }
+
+        /// <summary>
+        /// Executes an insert query for the given entity using the given sql insert statement.
+        /// This overload will automatically run an identity query if you have mapped an auto-incrementing column,
+        /// and if an identity query has been implemented for your current database dialect.
+        /// </summary>
+        public object Insert<T>(T entity, string sql)
+        {
+            var columns = MapRepository.Instance.GetColumns(typeof(T));
+            var dialect = QueryFactory.CreateDialect(this);
+            var builder = Insert<T>().Entity(entity).QueryText(sql);
+
+            // If an auto-increment column exists and this dialect has an identity query...
+            if (columns.Exists(c => c.ColumnInfo.IsAutoIncrement) && dialect.HasIdentityQuery)
+            {
+                builder.GetIdentity();
+            }
+
+            return builder.Execute();
+        }
+
+        #endregion
+
+        #region - Delete -
+
+        public int Delete<T>(Expression<Func<T, bool>> filter)
+        {
+            return Delete<T>(null, filter);
+        }
+
+        public int Delete<T>(string tableName, Expression<Func<T, bool>> filter)
+        {
+            // Remember sql mode
+            var previousSqlMode = this.SqlMode;
+            SqlMode = SqlModes.Text;
+
+            var mappingHelper = new MappingHelper(this);
+            if (tableName == null)
+            {
+                tableName = MapRepository.Instance.GetTableName(typeof(T));
+            }
+            var dialect = QGen.QueryFactory.CreateDialect(this);
+            TableCollection tables = new TableCollection();
+            tables.Add(new Table(typeof(T)));
+            var where = new WhereBuilder<T>(Command, dialect, filter, tables, false, false);
+            IQuery query = QueryFactory.CreateDeleteQuery(dialect, tables[0], where.ToString());
+            Command.CommandText = query.Generate();
+
+            int rowsAffected = 0;
+
+            try
+            {
+                OpenConnection();
+                rowsAffected = Command.ExecuteNonQuery();
+            }
+            finally
+            {
+                CloseConnection();
+            }
+
+            // Return to previous sql mode
+            SqlMode = previousSqlMode;
+
+            return rowsAffected;
+        }
+
+        #endregion
+        
+        #region - Events -
+
+        public event EventHandler OpeningConnection;
+
+        public event EventHandler ClosingConnection;
+
+        #endregion
+
+        #region - Connections / Transactions -
+
+        protected virtual void OnOpeningConnection()
+        {
+            if (OpeningConnection != null)
+                OpeningConnection(this, EventArgs.Empty);
+        }
+
+        protected virtual void OnClosingConnection()
+        {
+            WriteToTraceLog();
+
+            if (ClosingConnection != null)
+                ClosingConnection(this, EventArgs.Empty);
+        }
+
+        protected internal void OpenConnection()
+        {
+            OnOpeningConnection();
+
+            if (Command.Connection.State != ConnectionState.Open)
+                Command.Connection.Open();
+        }
+
+        protected internal void CloseConnection()
+        {
+            OnClosingConnection();
+
+            Command.Parameters.Clear();
+            Command.CommandText = string.Empty;
+
+            if (Command.Transaction == null)
+                Command.Connection.Close(); // Only close if no transaction is present
+
+            UnbindEvents();
+        }
+
+        private void WriteToTraceLog()
+        {
+            if (MapRepository.Instance.EnableTraceLogging)
+            {
+                StringBuilder sb = new StringBuilder();
+                sb.AppendLine();
+                sb.AppendLine("==== Begin Query Trace ====");
+                sb.AppendLine();
+                sb.AppendLine("QUERY TYPE:");
+                sb.AppendLine(Command.CommandType.ToString());
+                sb.AppendLine();
+                sb.AppendLine("QUERY TEXT:");
+                sb.AppendLine(Command.CommandText);
+                sb.AppendLine();
+                sb.AppendLine("PARAMETERS:");
+                foreach (IDbDataParameter p in Parameters)
+                {
+                    object val = (p.Value != null && p.Value is string) ? string.Format("\"{0}\"", p.Value) : p.Value;
+                    sb.AppendFormat("{0} = [{1}]", p.ParameterName, val ?? "NULL").AppendLine();
+                }
+                sb.AppendLine();
+                sb.AppendLine("==== End Query Trace ====");
+                sb.AppendLine();
+
+                Trace.Write(sb.ToString());
+            }
+        }
+
+        private void UnbindEvents()
+        {
+            if (OpeningConnection != null)
+                OpeningConnection = null;
+
+            if (ClosingConnection != null)
+                ClosingConnection = null;
+        }
+
+        public void BeginTransaction()
+        {
+            OpenConnection();
+            DbTransaction trans = Command.Connection.BeginTransaction();
+            Command.Transaction = trans;
+        }
+
+        public void RollBack()
+        {
+            try
+            {
+                if (Command.Transaction != null)
+                    Command.Transaction.Rollback();
+            }
+            finally
+            {
+                Command.Connection.Close();
+            }
+        }
+
+        public void Commit()
+        {
+            try
+            {
+                if (Command.Transaction != null)
+                    Command.Transaction.Commit();
+            }
+            finally
+            {
+                Command.Connection.Close();
+            }
+        }
+
+        #endregion
+
+        #region - IDisposable Members -
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this); // In case a derived class implements a finalizer
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                if (Command.Transaction != null)
+                {
+                    Command.Transaction.Dispose();
+                    Command.Transaction = null;
+                }
+
+                if (Command.Connection != null)
+                {
+                    Command.Connection.Dispose();
+                    Command.Connection = null;
+                }
+
+                if (Command != null)
+                {
+                    Command.Dispose();
+                    _command = null;
+                }
+            }
+        }
+
+        #endregion
+
+    }
+}

Marr.Data/DataMappingException.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Marr.Data
+{
+    public class DataMappingException : Exception
+    {
+        public DataMappingException()
+            : base()
+        {
+        }
+
+        public DataMappingException(string message)
+            : base(message)
+        {
+        }
+
+        public DataMappingException(string message, Exception innerException)
+            : base(message, innerException)
+        {
+        }
+    }
+}

Marr.Data/EntityGraph.cs

@@ -0,0 +1,376 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+using System.Data;
+using System.Data.Common;
+using System.Linq;
+using Marr.Data.Mapping;
+using System.Reflection;
+
+namespace Marr.Data
+{
+    /// <summary>
+    /// Holds metadata about an object graph that is being queried and eagerly loaded.
+    /// Contains all metadata needed to instantiate the object and fill it with data from a DataReader.
+    /// Does not iterate through lazy loaded child relationships.
+    /// </summary>
+    internal class EntityGraph : IEnumerable<EntityGraph>
+    {
+        private MapRepository _repos;
+        private EntityGraph _parent;
+        private Type _entityType;
+        private Relationship _relationship;
+        private ColumnMapCollection _columns;
+        private RelationshipCollection _relationships;
+        private List<EntityGraph> _children;
+        private object _entity;
+        private GroupingKeyCollection _groupingKeyColumns;
+        private Dictionary<string, EntityReference> _entityReferences;
+
+        public IList RootList { get; private set; }
+
+        /// <summary>
+        /// Recursively builds an entity graph of the given parent type.
+        /// </summary>
+        /// <param name="entityType"></param>
+        public EntityGraph(Type entityType, IList rootList)
+            : this(entityType, null, null) // Recursively constructs hierarchy
+        {
+            RootList = rootList;
+        }
+
+        /// <summary>
+        /// Recursively builds entity graph hierarchy.
+        /// </summary>
+        /// <param name="entityType"></param>
+        /// <param name="parent"></param>
+        /// <param name="relationship"></param>
+        private EntityGraph(Type entityType, EntityGraph parent, Relationship relationship)
+        {
+            _repos = MapRepository.Instance;
+
+            _entityType = entityType;
+            _parent = parent;
+            _relationship = relationship;
+            _columns = _repos.GetColumns(entityType);
+            _relationships = _repos.GetRelationships(entityType);
+            _children = new List<EntityGraph>();
+            Member = relationship != null ? relationship.Member : null;
+            _entityReferences = new Dictionary<string, EntityReference>();
+
+            // Create a new EntityGraph for each child relationship that is not lazy loaded
+            foreach (Relationship childRelationship in this.Relationships)
+            {
+                if (!childRelationship.IsLazyLoaded)
+                {
+                    _children.Add(new EntityGraph(childRelationship.RelationshipInfo.EntityType, this, childRelationship));
+                }
+            }
+        }
+
+        public MemberInfo Member { get; private set; }
+
+        /// <summary>
+        /// Gets the parent of this EntityGraph.
+        /// </summary>
+        public EntityGraph Parent
+        {
+            get
+            {
+                return _parent;
+            }
+        }
+
+        /// <summary>
+        /// Gets the Type of this EntityGraph.
+        /// </summary>
+        public Type EntityType
+        {
+            get { return _entityType; }
+        }
+
+        /// <summary>
+        /// Gets a boolean than indicates whether this entity is the root node in the graph.
+        /// </summary>
+        public bool IsRoot
+        {
+            get
+            {
+                return _parent == null;
+            }
+        }
+
+        /// <summary>
+        /// Gets a boolean that indicates whether this entity is a child.
+        /// </summary>
+        public bool IsChild
+        {
+            get
+            {
+                return _parent != null;
+            }
+        }
+
+        /// <summary>
+        /// Gets the columns mapped to this entity.
+        /// </summary>
+        public ColumnMapCollection Columns
+        {
+            get { return _columns; }
+        }
+
+        /// <summary>
+        /// Gets the relationships mapped to this entity.
+        /// </summary>
+        public RelationshipCollection Relationships
+        {
+            get { return _relationships; }
+        }
+
+        /// <summary>
+        /// A list of EntityGraph objects that hold metadata about the child entities that will be loaded.
+        /// </summary>
+        public List<EntityGraph> Children
+        {
+            get { return _children; }
+        }
+        
+        /// <summary>
+        /// Adds an entity to the appropriate place in the object graph.
+        /// </summary>
+        /// <param name="entityInstance"></param>
+        public void AddEntity(object entityInstance)
+        {
+            _entity = entityInstance;
+
+            // Add newly created entityInstance to list (Many) or set it to field (One)
+            if (this.IsRoot)
+            {
+                RootList.Add(entityInstance);
+            }
+            else if (_relationship.RelationshipInfo.RelationType == RelationshipTypes.Many)
+            {
+                var list = _parent._entityReferences[_parent.GroupingKeyColumns.GroupingKey]
+                    .ChildLists[_relationship.Member.Name];
+
+                list.Add(entityInstance);
+            }
+            else // RelationTypes.One
+            {
+                _repos.ReflectionStrategy.SetFieldValue(_parent._entity, _relationship.Member.Name, entityInstance);
+            }
+
+            EntityReference entityRef = new EntityReference(entityInstance);
+            _entityReferences.Add(GroupingKeyColumns.GroupingKey, entityRef);
+
+            InitOneToManyChildLists(entityRef);           
+        }
+
+        /// <summary>
+        /// Initializes the owning lists on many-to-many Children.
+        /// </summary>
+        /// <param name="entityInstance"></param>
+        private void InitOneToManyChildLists(EntityReference entityRef)
+        {
+            // Get a reference to the parent's the childrens' OwningLists to the parent entity
+            for (int i = 0; i < Relationships.Count; i++)
+            {
+                Relationship relationship = Relationships[i];
+                if (relationship.RelationshipInfo.RelationType == RelationshipTypes.Many)
+                {
+                    try
+                    {
+                        IList list = (IList)_repos.ReflectionStrategy.CreateInstance(relationship.MemberType);
+                        _repos.ReflectionStrategy.SetFieldValue(entityRef.Entity, relationship.Member.Name, list);
+                        
+                        // Save a reference to each 1-M list
+                        entityRef.AddChildList(relationship.Member.Name, list);
+                    }
+                    catch (Exception ex)
+                    {
+                        throw new DataMappingException(
+                            string.Format("{0}.{1} is a \"Many\" relationship type so it must derive from IList.",
+                                entityRef.Entity.GetType().Name, relationship.Member.Name),
+                            ex);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Recursively adds primary key columns from contiguous child graphs with a one-to-one relationship type to the pKeys collection..
+        /// </summary>
+        /// <param name="pKeys"></param>
+        /// <param name="entity"></param>
+        private void AddOneToOneChildKeys(ColumnMapCollection pKeys, EntityGraph entity)
+        {
+            var oneToOneChildren = entity.Children
+                .Where(c => c._relationship.RelationshipInfo.RelationType == RelationshipTypes.One);
+
+            foreach (var child in oneToOneChildren)
+            {
+                pKeys.AddRange(child.Columns.PrimaryKeys);
+                AddOneToOneChildKeys(pKeys, child);
+            }
+        }
+
+        /// <summary>
+        /// Concatenates the values of the GroupingKeys property and compares them
+        /// against the LastKeyGroup property.  Returns true if the values are different,
+        /// or false if the values are the same.
+        /// The currently concatenated keys are saved in the LastKeyGroup property.
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <returns></returns>
+        public bool IsNewGroup(DbDataReader reader)
+        {
+            bool isNewGroup = false;
+
+            // Get primary keys from parent entity and any one-to-one child entites
+            GroupingKeyCollection groupingKeyColumns = this.GroupingKeyColumns;
+
+            // Concatenate column values
+            KeyGroupInfo keyGroupInfo = groupingKeyColumns.CreateGroupingKey(reader);
+            
+            if (!keyGroupInfo.HasNullKey && !_entityReferences.ContainsKey(keyGroupInfo.GroupingKey))
+            {
+                isNewGroup = true;
+            }
+
+            return isNewGroup;
+        }
+        
+        /// <summary>
+        /// Gets the GroupingKeys for this entity.  
+        /// GroupingKeys determine when to create and add a new entity to the graph.
+        /// </summary>
+        /// <remarks>
+        /// A simple entity with no relationships will return only its PrimaryKey columns.
+        /// A parent entity with one-to-one child relationships will include its own PrimaryKeys,
+        /// and it will recursively traverse all Children with one-to-one relationships and add their PrimaryKeys.
+        /// A child entity that has a one-to-one relationship with its parent will use the same 
+        /// GroupingKeys already defined by its parent.
+        /// </remarks>
+        public GroupingKeyCollection GroupingKeyColumns
+        {
+            get
+            {
+                if (_groupingKeyColumns == null)
+                    _groupingKeyColumns = GetGroupingKeyColumns();
+
+                return _groupingKeyColumns;
+            }
+        }
+
+        /// <summary>
+        /// Gets a list of keys to group by.
+        /// </summary>
+        /// <remarks>
+        /// When converting an unnormalized set of data from a database view,
+        /// a new entity is only created when the grouping keys have changed.
+        /// NOTE: This behavior works on the assumption that the view result set
+        /// has been sorted by the root entity primary key(s), followed by the
+        /// child entity primary keys.
+        /// </remarks>
+        /// <returns></returns>
+        private GroupingKeyCollection GetGroupingKeyColumns()
+        {
+            // Get primary keys for this parent entity
+            GroupingKeyCollection groupingKeyColumns = new GroupingKeyCollection();
+            groupingKeyColumns.PrimaryKeys.AddRange(Columns.PrimaryKeys);
+
+            // The following conditions should fail with an exception:
+            // 1) Any parent entity (entity with children) must have at least one PK specified or an exception will be thrown
+            // 2) All 1-M relationship entities must have at least one PK specified
+            // * Only 1-1 entities with no children are allowed to have 0 PKs specified.
+            if ((groupingKeyColumns.PrimaryKeys.Count == 0 && _children.Count > 0) ||
+                (groupingKeyColumns.PrimaryKeys.Count == 0 && !IsRoot && _relationship.RelationshipInfo.RelationType == RelationshipTypes.Many))
+                throw new MissingPrimaryKeyException(string.Format("There are no primary key mappings defined for the following entity: '{0}'.", this.EntityType.Name));
+
+            // Add parent's keys
+            if (IsChild)
+                groupingKeyColumns.ParentPrimaryKeys.AddRange(Parent.GroupingKeyColumns);
+
+            return groupingKeyColumns;
+        }
+
+        #region IEnumerable<EntityGraph> Members
+
+        public IEnumerator<EntityGraph> GetEnumerator()
+        {
+            return TraverseGraph(this);
+        }
+
+        /// <summary>
+        /// Recursively traverses through every entity in the EntityGraph.
+        /// </summary>
+        /// <param name="entityGraph"></param>
+        /// <returns></returns>
+        private static IEnumerator<EntityGraph> TraverseGraph(EntityGraph entityGraph)
+        {
+            Stack<EntityGraph> stack = new Stack<EntityGraph>();
+            stack.Push(entityGraph);
+
+            while (stack.Count > 0)
+            {
+                EntityGraph node = stack.Pop();
+                yield return node;
+
+                foreach (EntityGraph childGraph in node.Children)
+                {
+                    stack.Push(childGraph);
+                }
+            }
+        }
+
+
+        #endregion
+
+        #region IEnumerable Members
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return this.GetEnumerator();
+        }
+
+        #endregion
+    }
+}
+
+public struct KeyGroupInfo
+{
+    private string _groupingKey;
+    private bool _hasNullKey;
+
+    public KeyGroupInfo(string groupingKey, bool hasNullKey)
+    {
+        _groupingKey = groupingKey;
+        _hasNullKey = hasNullKey;
+    }
+
+    public string GroupingKey 
+    { 
+        get { return _groupingKey; } 
+    }
+
+    public bool HasNullKey 
+    {
+        get { return _hasNullKey; } 
+    }
+}

Marr.Data/EntityMerger.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Linq.Expressions;
+
+namespace Marr.Data
+{
+    /// <summary>
+    /// This utility class allows you to join two existing entity collections.
+    /// </summary>
+    public class EntityMerger
+    {
+        /// <summary>
+        /// Joines to existing entity collections.
+        /// </summary>
+        /// <typeparam name="TParent">The parent entity type.</typeparam>
+        /// <typeparam name="TChild">The child entity type.</typeparam>
+        /// <param name="parentList">The parent entities.</param>
+        /// <param name="childList">The child entities</param>
+        /// <param name="relationship">A predicate that defines the relationship between the parent and child entities.  Returns true if they are related.</param>
+        /// <param name="mergeAction">An action that adds a related child to the parent.</param>
+        public static void Merge<TParent, TChild>(IEnumerable<TParent> parentList, IEnumerable<TChild> childList, Func<TParent, TChild, bool> relationship, Action<TParent, TChild> mergeAction)
+        {
+            foreach (TParent parent in parentList)
+            {
+                foreach (TChild child in childList)
+                {
+                    if (relationship(parent, child))
+                    {
+                        mergeAction(parent, child);
+                    }
+                }
+            }
+        }
+    }
+}

Marr.Data/EntityReference.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Collections;
+
+namespace Marr.Data
+{
+    /// <summary>
+    /// Stores an entity along with all of its 1-M IList references.
+    /// </summary>
+    public class EntityReference
+    {
+        public EntityReference(object entity)
+        {
+            Entity = entity;
+            ChildLists = new Dictionary<string, IList>();
+        }
+
+        public object Entity { get; private set; }
+        public Dictionary<string, IList> ChildLists { get; private set; }
+
+        public void AddChildList(string memberName, IList list)
+        {
+            if (ChildLists.ContainsKey(memberName))
+                ChildLists[memberName] = list;
+            else
+                ChildLists.Add(memberName, list);
+        }
+    }
+}

Marr.Data/ExtensionMethods.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Data.Common;
+
+namespace Marr.Data
+{
+    /// <summary>
+    /// This class contains public extension methods.
+    /// </summary>
+    public static class ExtensionMethods
+    {
+        /// <summary>
+        /// Gets a value from a DbDataReader by using the column name;
+        /// </summary>
+        public static T GetValue<T>(this DbDataReader reader, string columnName)
+        {
+            int ordinal = reader.GetOrdinal(columnName);
+            return (T)reader.GetValue(ordinal);
+        }
+    }
+}

Marr.Data/GroupingKeyCollection.cs

@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Marr.Data.Mapping;
+using System.Data.Common;
+
+namespace Marr.Data
+{
+    public class GroupingKeyCollection : IEnumerable<ColumnMap>
+    {
+        public GroupingKeyCollection()
+        {
+            PrimaryKeys = new ColumnMapCollection();
+            ParentPrimaryKeys = new ColumnMapCollection();
+        }
+
+        public ColumnMapCollection PrimaryKeys { get; private set; }
+        public ColumnMapCollection ParentPrimaryKeys { get; private set; }
+
+        public int Count
+        {
+            get
+            {
+                return PrimaryKeys.Count + ParentPrimaryKeys.Count;
+            }
+        }
+
+        /// <summary>
+        /// Gets the PK values that define this entity in the graph.
+        /// </summary>
+        internal string GroupingKey { get; private set; }
+
+        /// <summary>
+        /// Returns a concatented string containing the primary key values of the current record.
+        /// </summary>
+        /// <param name="reader">The open data reader.</param>
+        /// <returns>Returns the primary key value(s) as a string.</returns>
+        internal KeyGroupInfo CreateGroupingKey(DbDataReader reader)
+        {
+            StringBuilder pkValues = new StringBuilder();
+            bool hasNullValue = false;
+
+            foreach (ColumnMap pkColumn in this)
+            {
+                object pkValue = reader[pkColumn.ColumnInfo.GetColumName(true)];
+
+                if (pkValue == DBNull.Value)
+                    hasNullValue = true;
+
+                pkValues.Append(pkValue.ToString());
+            }
+
+            GroupingKey = pkValues.ToString();
+
+            return new KeyGroupInfo(GroupingKey, hasNullValue);
+        }
+
+        #region IEnumerable<ColumnMap> Members
+
+        public IEnumerator<ColumnMap> GetEnumerator()
+        {
+            foreach (ColumnMap map in ParentPrimaryKeys)
+            {
+                yield return map;
+            }
+
+            foreach (ColumnMap map in PrimaryKeys)
+            {
+                yield return map;
+            }
+        }
+
+        #endregion
+
+        #region IEnumerable Members
+
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+        {
+            return this.GetEnumerator();
+        }
+
+        #endregion
+    }
+}

Marr.Data/IDataMapper.cs

@@ -0,0 +1,220 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Data;
+using System.Data.Common;
+using System.Collections.Generic;
+using Marr.Data.Parameters;
+using System.Linq.Expressions;
+using Marr.Data.QGen;
+using System.Reflection;
+
+namespace Marr.Data
+{
+    public interface IDataMapper : IDisposable
+    {
+        #region - Contructor, Members -
+
+        string ConnectionString { get; }
+        DbProviderFactory ProviderFactory { get; }
+        DbCommand Command { get; }
+
+        /// <summary>
+        /// Gets or sets a value that determines whether the DataMapper will 
+        /// use a stored procedure or a sql text command to access 
+        /// the database.  The default is stored procedure.
+        /// </summary>
+        SqlModes SqlMode { get; set; }        
+
+        #endregion
+
+        #region - Update -
+
+        UpdateQueryBuilder<T> Update<T>();
+        int Update<T>(T entity, Expression<Func<T, bool>> filter);
+        int Update<T>(string tableName, T entity, Expression<Func<T, bool>> filter);
+        int Update<T>(T entity, string sql);
+
+        #endregion
+
+        #region - Insert -
+
+        /// <summary>
+        /// Creates an InsertQueryBuilder that allows you to build an insert statement.
+        /// This method gives you the flexibility to manually configure all options of your insert statement.
+        /// Note: You must manually call the Execute() chaining method to run the query.
+        /// </summary>
+        InsertQueryBuilder<T> Insert<T>();
+
+        /// <summary>
+        /// Generates and executes an insert query for the given entity.
+        /// This overload will automatically run an identity query if you have mapped an auto-incrementing column,
+        /// and if an identity query has been implemented for your current database dialect.
+        /// </summary>
+        object Insert<T>(T entity);
+
+        /// <summary>
+        /// Generates and executes an insert query for the given entity.
+        /// This overload will automatically run an identity query if you have mapped an auto-incrementing column,
+        /// and if an identity query has been implemented for your current database dialect.
+        /// </summary>
+        object Insert<T>(string tableName, T entity);
+
+        /// <summary>
+        /// Executes an insert query for the given entity using the given sql insert statement.
+        /// This overload will automatically run an identity query if you have mapped an auto-incrementing column,
+        /// and if an identity query has been implemented for your current database dialect.
+        /// </summary>
+        object Insert<T>(T entity, string sql);
+
+        #endregion
+
+        #region - Delete -
+
+        int Delete<T>(Expression<Func<T, bool>> filter);
+        int Delete<T>(string tableName, Expression<Func<T, bool>> filter);
+
+        #endregion
+
+        #region - Connections / Transactions -
+
+        void BeginTransaction();
+        void RollBack();
+        void Commit();
+        event EventHandler OpeningConnection;
+
+        #endregion
+
+        #region - ExecuteScalar, ExecuteNonQuery, ExecuteReader -
+
+        /// <summary>
+        /// Executes a non query that returns an integer.
+        /// </summary>
+        /// <param name="sql">The SQL command to execute.</param>
+        /// <returns>An integer value</returns>
+        int ExecuteNonQuery(string sql);
+
+        /// <summary>
+        /// Executes a stored procedure that returns a scalar value.
+        /// </summary>
+        /// <param name="sql">The SQL command to execute.</param>
+        /// <returns>A scalar value</returns>
+        object ExecuteScalar(string sql);
+
+        /// <summary>
+        /// Executes a DataReader that can be controlled using a Func delegate.
+        /// (Note that reader.Read() will be called automatically).
+        /// </summary>
+        /// <typeparam name="TResult">The type that will be return in the result set.</typeparam>
+        /// <param name="sql">The sql statement that will be executed.</param>
+        /// <param name="func">The function that will build the the TResult set.</param>
+        /// <returns>An IEnumerable of TResult.</returns>
+        IEnumerable<TResult> ExecuteReader<TResult>(string sql, Func<DbDataReader, TResult> func);
+
+        /// <summary>
+        /// Executes a DataReader that can be controlled using an Action delegate.
+        /// </summary>
+        /// <param name="sql">The sql statement that will be executed.</param>
+        /// <param name="action">The delegate that will work with the result set.</param>
+        void ExecuteReader(string sql, Action<DbDataReader> action);
+
+        #endregion
+
+        #region - DataSets -
+
+        DataSet GetDataSet(string sql);
+        DataSet GetDataSet(string sql, DataSet ds, string tableName);
+        DataTable GetDataTable(string sql, DataTable dt, string tableName);
+        DataTable GetDataTable(string sql);
+        int InsertDataTable(DataTable table, string insertSP);
+        int InsertDataTable(DataTable table, string insertSP, UpdateRowSource updateRowSource);
+        int UpdateDataSet(DataSet ds, string updateSP);
+        int DeleteDataTable(DataTable dt, string deleteSP);
+
+        #endregion
+
+        #region - Parameters -
+
+        DbParameterCollection Parameters { get; }
+        ParameterChainMethods AddParameter(string name, object value);
+        IDbDataParameter AddParameter(IDbDataParameter parameter);
+
+        #endregion
+
+        #region - Find -
+
+        /// <summary>
+        /// Returns an entity of type T.
+        /// </summary>
+        /// <typeparam name="T">The type of entity that is to be instantiated and loaded with values.</typeparam>
+        /// <param name="sql">The SQL command to execute.</param>
+        /// <returns>An instantiated and loaded entity of type T.</returns>
+        T Find<T>(string sql);
+
+        /// <summary>
+        /// Returns an entity of type T.
+        /// </summary>
+        /// <typeparam name="T">The type of entity that is to be instantiated and loaded with values.</typeparam>
+        /// <param name="sql">The SQL command to execute.</param>
+        /// <param name="ent">A previously instantiated entity that will be loaded with values.</param>
+        /// <returns>An instantiated and loaded entity of type T.</returns>
+        T Find<T>(string sql, T ent);
+
+        #endregion
+
+        #region - Query -
+
+        /// <summary>
+        /// Creates a QueryBuilder that allows you to build a query.
+        /// </summary>
+        /// <typeparam name="T">The type of object that will be queried.</typeparam>
+        /// <returns>Returns a QueryBuilder of T.</returns>
+        QueryBuilder<T> Query<T>();
+
+        /// <summary>
+        /// Returns the results of a query.
+        /// Uses a List of type T to return the data.
+        /// </summary>
+        /// <typeparam name="T">The type of object that will be queried.</typeparam>
+        /// <returns>Returns a list of the specified type.</returns>
+        List<T> Query<T>(string sql);
+
+        /// <summary>
+        /// Returns the results of a query or a stored procedure.
+        /// </summary>
+        /// <typeparam name="T">The type of object that will be queried.</typeparam>
+        /// <param name="sql">The sql query or stored procedure name to run.</param>
+        /// <param name="entityList">A previously instantiated list to populate.</param>
+        /// <returns>Returns a list of the specified type.</returns>
+        ICollection<T> Query<T>(string sql, ICollection<T> entityList);
+
+        #endregion
+
+        #region - Query to Graph -
+
+        /// <summary>
+        /// Runs a query and then tries to instantiate the entire object graph with entites.
+        /// </summary>
+        List<T> QueryToGraph<T>(string sql);
+
+        /// <summary>
+        /// Runs a query and then tries to instantiate the entire object graph with entites.
+        /// </summary>
+        ICollection<T> QueryToGraph<T>(string sql, ICollection<T> entityList);
+
+        #endregion
+    }
+}

Marr.Data/LazyLoaded.cs

@@ -0,0 +1,129 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Data.Common;
+
+namespace Marr.Data
+{
+    public interface ILazyLoaded : ICloneable
+    {
+        void Prepare(Func<IDataMapper> dbCreator, object parent);
+        void LazyLoad();
+    }
+
+    /// <summary>
+    /// Allows a field to be lazy loaded.
+    /// </summary>
+    /// <typeparam name="TChild"></typeparam>
+    public class LazyLoaded<TChild> : ILazyLoaded
+    {
+        protected TChild _child;
+        protected bool _isLoaded;
+
+        public LazyLoaded()
+        {
+        }
+
+        public LazyLoaded(TChild val)
+        {
+            _child = val;
+            _isLoaded = true;
+        }
+
+        public TChild Value
+        {
+            get
+            {
+                LazyLoad();
+                return _child;
+            }
+        }
+
+        public virtual void Prepare(Func<IDataMapper> dbCreator, object parent)
+        { }
+
+        public virtual void LazyLoad()
+        { }
+
+        public static implicit operator LazyLoaded<TChild>(TChild val)
+        {
+            return new LazyLoaded<TChild>(val);
+        }
+        
+        public static implicit operator TChild(LazyLoaded<TChild> lazy)
+        {
+            return lazy.Value;
+        }
+
+        public object Clone()
+        {
+            return this.MemberwiseClone();
+        }
+    }
+
+    /// <summary>
+    /// This is the lazy loading proxy.
+    /// </summary>
+    /// <typeparam name="TParent">The parent entity that contains the lazy loaded entity.</typeparam>
+    /// <typeparam name="TChild">The child entity that is being lazy loaded.</typeparam>
+    internal class LazyLoaded<TParent, TChild> : LazyLoaded<TChild>
+    {
+        private TParent _parent;
+        private Func<IDataMapper, TParent, TChild> _query;
+        
+        private Func<IDataMapper> _dbCreator;
+
+        internal LazyLoaded(Func<IDataMapper, TParent, TChild> query) 
+            : base()
+        {
+            _query = query;
+        }
+
+        public LazyLoaded(TChild val) 
+            : base(val)
+        {
+            _child = val;
+            _isLoaded = true;
+        }
+
+        /// <summary>
+        /// The second part of the initialization happens when the entity is being built.
+        /// </summary>
+        /// <param name="dbCreator">Knows how to instantiate a new IDataMapper.</param>
+        /// <param name="parent">The parent entity.</param>
+        public override void Prepare(Func<IDataMapper> dbCreator, object parent)
+        {
+            _dbCreator = dbCreator;
+            _parent = (TParent)parent;
+        }
+
+        public bool IsLoaded
+        {
+            get { return _isLoaded; }
+        }
+
+        public override void LazyLoad()
+        {
+            if (!_isLoaded)
+            {
+                using (IDataMapper db = _dbCreator())
+                {
+                    _child = _query(db, _parent);
+                    _isLoaded = true;
+                }
+            }
+        }
+
+        public static implicit operator LazyLoaded<TParent, TChild>(TChild val)
+        {
+            return new LazyLoaded<TParent, TChild>(val);
+        }
+
+        public static implicit operator TChild(LazyLoaded<TParent, TChild> lazy)
+        {
+            return lazy.Value;
+        }
+    }
+
+}

Marr.Data/MapRepository.cs

@@ -0,0 +1,265 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Reflection;
+using System.Data.Common;
+using Marr.Data.Converters;
+using Marr.Data.Parameters;
+using Marr.Data.Mapping;
+using Marr.Data.Mapping.Strategies;
+using Marr.Data.Reflection;
+
+namespace Marr.Data
+{
+    public class MapRepository
+    {
+        private static readonly object _tablesLock = new object();
+        private static readonly object _columnsLock = new object();
+        private static readonly object _relationshipsLock = new object();
+
+        private IDbTypeBuilder _dbTypeBuilder;
+        private Dictionary<Type, IMapStrategy> _columnMapStrategies;
+
+        internal Dictionary<Type, string> Tables { get; set; }
+        internal Dictionary<Type, ColumnMapCollection> Columns { get; set; }
+        internal Dictionary<Type, RelationshipCollection> Relationships { get; set; }
+        internal Dictionary<Type, IConverter> TypeConverters { get; set; }
+
+        // Explicit static constructor to tell C# compiler
+        // not to mark type as beforefieldinit
+        static MapRepository()
+        { }
+
+        private MapRepository()
+        {
+            Tables = new Dictionary<Type, string>();
+            Columns = new Dictionary<Type, ColumnMapCollection>();
+            Relationships = new Dictionary<Type, RelationshipCollection>();
+            TypeConverters = new Dictionary<Type, IConverter>();
+
+            // Register a default IReflectionStrategy
+            ReflectionStrategy = new CachedReflectionStrategy();
+            
+            // Register a default type converter for Enums
+            TypeConverters.Add(typeof(Enum), new Converters.EnumStringConverter());
+
+            // Register a default IDbTypeBuilder
+            _dbTypeBuilder = new Parameters.DbTypeBuilder();
+
+            _columnMapStrategies = new Dictionary<Type, IMapStrategy>();
+            RegisterDefaultMapStrategy(new AttributeMapStrategy());
+
+            EnableTraceLogging = false;
+        }
+
+        private readonly static MapRepository _instance = new MapRepository();
+
+        /// <summary>
+        /// Gets a reference to the singleton MapRepository.
+        /// </summary>
+        public static MapRepository Instance
+        {
+            get
+            {
+                return _instance;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets a boolean that determines whether debug information should be written to the trace log.
+        /// The default is false.
+        /// </summary>
+        public bool EnableTraceLogging { get; set; }
+
+        #region - Column Map Strategies -
+
+        public void RegisterDefaultMapStrategy(IMapStrategy strategy)
+        {
+            RegisterMapStrategy(typeof(object), strategy);
+        }
+
+        public void RegisterMapStrategy(Type entityType, IMapStrategy strategy)
+        {
+            if (_columnMapStrategies.ContainsKey(entityType))
+                _columnMapStrategies[entityType] = strategy;
+            else
+                _columnMapStrategies.Add(entityType, strategy);
+        }
+
+        private IMapStrategy GetMapStrategy(Type entityType)
+        {
+            if (_columnMapStrategies.ContainsKey(entityType))
+            {
+                // Return entity specific column map strategy
+                return _columnMapStrategies[entityType];
+            }
+            else
+            {
+                // Return the default column map strategy
+                return _columnMapStrategies[typeof(object)];
+            }
+        }
+
+        #endregion
+
+        #region - Table repository -
+
+        internal string GetTableName(Type entityType)
+        {
+            if (!Tables.ContainsKey(entityType))
+            {
+                lock (_tablesLock)
+                {
+                    if (!Tables.ContainsKey(entityType))
+                    {
+                        string tableName = GetMapStrategy(entityType).MapTable(entityType);
+                        Tables.Add(entityType, tableName);
+                        return tableName;
+                    }
+                }
+            }
+
+            return Tables[entityType];
+        }
+
+        #endregion
+
+        #region - Columns repository -
+
+        public ColumnMapCollection GetColumns(Type entityType)
+        {
+            if (!Columns.ContainsKey(entityType))
+            {
+                lock (_columnsLock)
+                {
+                    if (!Columns.ContainsKey(entityType))
+                    {
+                        ColumnMapCollection columnMaps = GetMapStrategy(entityType).MapColumns(entityType);
+                        Columns.Add(entityType, columnMaps);
+                        return columnMaps;
+                    }
+                }
+            }
+
+            return Columns[entityType];
+        }
+
+        #endregion
+
+        #region - Relationships repository -
+
+        public RelationshipCollection GetRelationships(Type type)
+        {
+            if (!Relationships.ContainsKey(type))
+            {
+                lock (_relationshipsLock)
+                {
+                    if (!Relationships.ContainsKey(type))
+                    {
+                        RelationshipCollection relationships = GetMapStrategy(type).MapRelationships(type);
+                        Relationships.Add(type, relationships);
+                        return relationships;
+                    }
+                }
+            }
+
+            return Relationships[type];
+        }
+        
+        #endregion
+
+        #region - Reflection Strategy -
+
+        /// <summary>
+        /// Gets or sets the reflection strategy that the DataMapper will use to load entities.
+        /// By default the CachedReflector will be used, which provides a performance increase over the SimpleReflector.  
+        /// However, the SimpleReflector can be used in Medium Trust enviroments.
+        /// </summary>
+        public IReflectionStrategy ReflectionStrategy { get; set; }
+
+        #endregion
+
+        #region - Type Converters -
+
+        /// <summary>
+        /// Registers a converter for a given type.
+        /// </summary>
+        /// <param name="type">The CLR data type that will be converted.</param>
+        /// <param name="converter">An IConverter object that will handle the data conversion.</param>
+        public void RegisterTypeConverter(Type type, IConverter converter)
+        {
+            if (TypeConverters.ContainsKey(type))
+            {
+                TypeConverters[type] = converter;
+            }
+            else
+            {
+                TypeConverters.Add(type, converter);
+            }
+        }
+
+        /// <summary>
+        /// Checks for a type converter (if one exists).
+        /// 1) Checks for a converter registered for the current columns data type.
+        /// 2) Checks to see if a converter is registered for all enums (type of Enum) if the current column is an enum.
+        /// 3) Checks to see if a converter is registered for all objects (type of Object).
+        /// </summary>
+        /// <param name="dataMap">The current data map.</param>
+        /// <returns>Returns an IConverter object or null if one does not exist.</returns>
+        internal IConverter GetConverter(Type dataType)
+        {
+            if (TypeConverters.ContainsKey(dataType))
+            {
+                // User registered type converter
+                return TypeConverters[dataType];
+            }
+            else if (TypeConverters.ContainsKey(typeof(Enum)) && dataType.IsEnum)
+            {
+                // A converter is registered to handled enums
+                return TypeConverters[typeof(Enum)];
+            }
+            else if (TypeConverters.ContainsKey(typeof(object)))
+            {
+                // User registered default converter
+                return TypeConverters[typeof(object)];
+            }
+            else
+            {
+                // No conversion
+                return null;
+            }
+        }
+
+        #endregion
+
+        #region - DbTypeBuilder -
+
+        /// <summary>
+        /// Gets or sets the IDBTypeBuilder that is responsible for converting parameter DbTypes based on the parameter value.
+        /// Defaults to use the DbTypeBuilder.  
+        /// You can replace this with a more specific builder if you want more control over the way the parameter types are set.
+        /// </summary>
+        public IDbTypeBuilder DbTypeBuilder
+        {
+            get { return _dbTypeBuilder; }
+            set { _dbTypeBuilder = value; }
+        }
+
+        #endregion
+    }
+}

Marr.Data/Mapping/ColumnAttribute.cs

@@ -0,0 +1,122 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Data;
+using System.Data.OleDb;
+using System.Data.Common;
+
+namespace Marr.Data.Mapping
+{
+    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = false)]
+    public class ColumnAttribute : Attribute, IColumnInfo
+    {
+        private string _name;
+        private string _altName;
+        private int _size = 0;
+        private bool _isPrimaryKey;
+        private bool _isAutoIncrement;
+        private bool _returnValue;
+        private ParameterDirection _paramDirection = ParameterDirection.Input;
+
+        public ColumnAttribute()
+        {
+        }
+
+        public ColumnAttribute(string name)
+        {
+            _name = name;
+        }
+
+        /// <summary>
+        /// Gets or sets the column name.
+        /// </summary>
+        public string Name
+        {
+            get { return _name; }
+            set { _name = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets an alternate name that is used to define this column in views.
+        /// If an AltName is present, it is used in the QueryViewToObjectGraph method.
+        /// If an AltName is not present, it will return the Name property value.
+        /// </summary>
+        public string AltName
+        {
+            get { return _altName; }
+            set { _altName = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the column size.
+        /// </summary>
+        public int Size
+        {
+            get { return _size; }
+            set { _size = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets a value that determines whether the column is the Primary Key.
+        /// </summary>
+        public bool IsPrimaryKey
+        {
+            get { return _isPrimaryKey; }
+            set { _isPrimaryKey = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets a value that determines whether the column is an auto-incrementing seed column.
+        /// </summary>
+        public bool IsAutoIncrement
+        {
+            get { return _isAutoIncrement; }
+            set { _isAutoIncrement = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets a value that determines whether the column has a return value.
+        /// </summary>
+        public bool ReturnValue
+        {
+            get { return _returnValue; }
+            set { _returnValue = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the ParameterDirection.
+        /// </summary>
+        public ParameterDirection ParamDirection
+        {
+            get { return _paramDirection; }
+            set { _paramDirection = value; }
+        }
+
+        public string TryGetAltName()
+        {
+            if (!string.IsNullOrEmpty(AltName) && AltName != Name)
+            {
+                return AltName;
+            }
+            else
+            {
+                return Name;
+            }
+        }
+    }
+}

Marr.Data/Mapping/ColumnInfo.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Marr.Data.Mapping
+{
+    public class ColumnInfo : IColumnInfo
+    {
+        public ColumnInfo()
+        {
+            IsPrimaryKey = false;
+            IsAutoIncrement = false;
+            ReturnValue = false;
+            ParamDirection = System.Data.ParameterDirection.Input;
+        }
+
+        public string Name { get; set; }
+        public string AltName { get; set; }
+        public int Size { get; set; }
+        public bool IsPrimaryKey { get; set; }
+        public bool IsAutoIncrement { get; set; }
+        public bool ReturnValue { get; set; }
+        public System.Data.ParameterDirection ParamDirection { get; set; }
+
+        public string TryGetAltName()
+        {
+            if (!string.IsNullOrEmpty(AltName) && AltName != Name)
+            {
+                return AltName;
+            }
+            else
+            {
+                return Name;
+            }
+        }
+    }
+}

Marr.Data/Mapping/ColumnMap.cs

@@ -0,0 +1,69 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Data;
+using System.Reflection;
+using Marr.Data.Converters;
+
+namespace Marr.Data.Mapping
+{
+    /// <summary>
+    /// Contains information about the class fields and their associated stored proc parameters
+    /// </summary>
+    public class ColumnMap
+    {
+        /// <summary>
+        /// Creates a column map with an empty ColumnInfo object.
+        /// </summary>
+        /// <param name="member">The .net member that is being mapped.</param>
+        public ColumnMap(MemberInfo member)
+            : this(member, new ColumnInfo())
+        { }
+
+        public ColumnMap(MemberInfo member, IColumnInfo columnInfo)
+        {
+            FieldName = member.Name;
+
+            // If the column name is not specified, the field name will be used.
+            if (string.IsNullOrEmpty(columnInfo.Name))
+                columnInfo.Name = member.Name;
+
+            FieldType = ReflectionHelper.GetMemberType(member);
+
+            Type paramNetType = FieldType;
+            MapRepository repository = MapRepository.Instance;
+
+            IConverter converter = repository.GetConverter(FieldType);
+            if (converter != null)
+            {
+                // Handle conversions
+                paramNetType = converter.DbType;
+            }
+
+            // Get database specific DbType and store with column map in cache    
+            DBType = repository.DbTypeBuilder.GetDbType(paramNetType);
+
+            ColumnInfo = columnInfo;
+        }
+        
+        public string FieldName { get; set; }
+        public Type FieldType { get; set; }
+        public Enum DBType { get; set; }
+        public IColumnInfo ColumnInfo { get; set; }
+    }
+}

Marr.Data/Mapping/ColumnMapBuilder.cs

@@ -0,0 +1,240 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Linq.Expressions;
+using System.Data;
+using Marr.Data.Mapping.Strategies;
+
+namespace Marr.Data.Mapping
+{
+    /// <summary>
+    /// This class has fluent methods that are used to easily configure column mappings.
+    /// </summary>
+    /// <typeparam name="TEntity"></typeparam>
+    public class ColumnMapBuilder<TEntity>
+    {
+        private FluentMappings.MappingsFluentEntity<TEntity> _fluentEntity;
+        private string _currentPropertyName;
+
+        public ColumnMapBuilder(FluentMappings.MappingsFluentEntity<TEntity> fluentEntity, ColumnMapCollection mappedColumns)
+        {
+            _fluentEntity = fluentEntity;
+            MappedColumns = mappedColumns;
+        }
+
+        /// <summary>
+        /// Gets the list of column mappings that are being configured.
+        /// </summary>
+        public ColumnMapCollection MappedColumns { get; private set; }
+
+        #region - Fluent Methods -
+
+        /// <summary>
+        /// Initializes the configurator to configure the given property.
+        /// </summary>
+        /// <param name="property"></param>
+        /// <returns></returns>
+        public ColumnMapBuilder<TEntity> For(Expression<Func<TEntity, object>> property)
+        {
+            For(property.GetMemberName());
+            return this;
+        }
+
+        /// <summary>
+        /// Initializes the configurator to configure the given property or field.
+        /// </summary>
+        /// <param name="property"></param>
+        /// <returns></returns>
+        public ColumnMapBuilder<TEntity> For(string propertyName)
+        {
+            _currentPropertyName = propertyName;
+
+            // Try to add the column map if it doesn't exist
+            if (MappedColumns.GetByFieldName(_currentPropertyName) == null)
+            {
+                TryAddColumnMapForField(_currentPropertyName);
+            }
+
+            return this;
+        }
+
+        public ColumnMapBuilder<TEntity> SetPrimaryKey()
+        {
+            AssertCurrentPropertyIsSet();
+            return SetPrimaryKey(_currentPropertyName);
+        }
+
+        public ColumnMapBuilder<TEntity> SetPrimaryKey(string propertyName)
+        {
+            MappedColumns.GetByFieldName(propertyName).ColumnInfo.IsPrimaryKey = true;
+            return this;
+        }
+
+        public ColumnMapBuilder<TEntity> SetAutoIncrement()
+        {
+            AssertCurrentPropertyIsSet();
+            return SetAutoIncrement(_currentPropertyName);
+        }
+
+        public ColumnMapBuilder<TEntity> SetAutoIncrement(string propertyName)
+        {
+            MappedColumns.GetByFieldName(propertyName).ColumnInfo.IsAutoIncrement = true;
+            return this;
+        }
+
+        public ColumnMapBuilder<TEntity> SetColumnName(string columnName)
+        {
+            AssertCurrentPropertyIsSet();
+            return SetColumnName(_currentPropertyName, columnName);
+        }
+
+        public ColumnMapBuilder<TEntity> SetColumnName(string propertyName, string columnName)
+        {
+            MappedColumns.GetByFieldName(propertyName).ColumnInfo.Name = columnName;
+            return this;
+        }
+
+        public ColumnMapBuilder<TEntity> SetReturnValue()
+        {
+            AssertCurrentPropertyIsSet();
+            return SetReturnValue(_currentPropertyName);
+        }
+
+        public ColumnMapBuilder<TEntity> SetReturnValue(string propertyName)
+        {
+            MappedColumns.GetByFieldName(propertyName).ColumnInfo.ReturnValue = true;
+            return this;
+        }
+
+        public ColumnMapBuilder<TEntity> SetSize(int size)
+        {
+            AssertCurrentPropertyIsSet();
+            return SetSize(_currentPropertyName, size);
+        }
+
+        public ColumnMapBuilder<TEntity> SetSize(string propertyName, int size)
+        {
+            MappedColumns.GetByFieldName(propertyName).ColumnInfo.Size = size;
+            return this;
+        }
+
+        public ColumnMapBuilder<TEntity> SetAltName(string altName)
+        {
+            AssertCurrentPropertyIsSet();
+            return SetAltName(_currentPropertyName, altName);
+        }
+
+        public ColumnMapBuilder<TEntity> SetAltName(string propertyName, string altName)
+        {
+            MappedColumns.GetByFieldName(propertyName).ColumnInfo.AltName = altName;
+            return this;
+        }
+
+        public ColumnMapBuilder<TEntity> SetParamDirection(ParameterDirection direction)
+        {
+            AssertCurrentPropertyIsSet();
+            return SetParamDirection(_currentPropertyName, direction);
+        }
+
+        public ColumnMapBuilder<TEntity> SetParamDirection(string propertyName, ParameterDirection direction)
+        {
+            MappedColumns.GetByFieldName(propertyName).ColumnInfo.ParamDirection = direction;
+            return this;
+        }
+
+        public ColumnMapBuilder<TEntity> Ignore(Expression<Func<TEntity, object>> property)
+        {
+            string propertyName = property.GetMemberName();
+            return Ignore(propertyName);
+        }
+
+        public ColumnMapBuilder<TEntity> Ignore(string propertyName)
+        {
+            var columnMap = MappedColumns.GetByFieldName(propertyName);
+            MappedColumns.Remove(columnMap);
+            return this;
+        }
+
+        public ColumnMapBuilder<TEntity> PrefixAltNames(string prefix)
+        {
+            MappedColumns.PrefixAltNames(prefix);
+            return this;
+        }
+
+        public ColumnMapBuilder<TEntity> SuffixAltNames(string suffix)
+        {
+            MappedColumns.SuffixAltNames(suffix);
+            return this;
+        }
+
+        public FluentMappings.MappingsFluentTables<TEntity> Tables
+        {
+            get
+            {
+                if (_fluentEntity == null)
+                {
+                    throw new Exception("This property is not compatible with the obsolete 'MapBuilder' class.");
+                }
+
+                return _fluentEntity.Table;
+            }
+        }
+
+        public FluentMappings.MappingsFluentRelationships<TEntity> Relationships
+        {
+            get
+            {
+                if (_fluentEntity == null)
+                {
+                    throw new Exception("This property is not compatible with the obsolete 'MapBuilder' class.");
+                }
+
+                return _fluentEntity.Relationships;
+            }
+        }
+
+        public FluentMappings.MappingsFluentEntity<TNewEntity> Entity<TNewEntity>()
+        {
+            return new FluentMappings.MappingsFluentEntity<TNewEntity>(true);
+        }
+
+        /// <summary>
+        /// Tries to add a ColumnMap for the given field name.  
+        /// Throws and exception if field cannot be found.
+        /// </summary>
+        private void TryAddColumnMapForField(string fieldName)
+        {
+            // Set strategy to filter for public or private fields
+            ConventionMapStrategy strategy = new ConventionMapStrategy(false);
+
+            // Find the field that matches the given field name
+            strategy.ColumnPredicate = mi => mi.Name == fieldName;
+            ColumnMap columnMap = strategy.MapColumns(typeof(TEntity)).FirstOrDefault();
+
+            if (columnMap == null)
+            {
+                throw new DataMappingException(string.Format("Could not find the field '{0}' in '{1}'.",
+                    fieldName,
+                    typeof(TEntity).Name));
+            }
+            else
+            {
+                MappedColumns.Add(columnMap);
+            }
+        }
+
+        /// <summary>
+        /// Throws an exception if the "current" property has not been set.
+        /// </summary>
+        private void AssertCurrentPropertyIsSet()
+        {
+            if (string.IsNullOrEmpty(_currentPropertyName))
+            {
+                throw new DataMappingException("A property must first be specified using the 'For' method.");
+            }
+        }
+
+        #endregion
+    }
+}

Marr.Data/Mapping/ColumnMapCollection.cs

@@ -0,0 +1,176 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Data;
+using System.Text.RegularExpressions;
+using System.Data.Common;
+using System.Linq;
+using System.Linq.Expressions;
+
+namespace Marr.Data.Mapping
+{
+    /// <summary>
+    /// This class contains a list of column mappings.
+    /// It also provides various methods to filter the collection.
+    /// </summary>
+    public class ColumnMapCollection : List<ColumnMap>
+    {
+        #region - Filters -
+
+        public ColumnMap GetByColumnName(string columnName)
+        {
+            return this.Find(m => m.ColumnInfo.Name == columnName);
+        }
+
+        public ColumnMap GetByFieldName(string fieldName)
+        {
+            return this.Find(m => m.FieldName == fieldName);
+        }
+
+        /// <summary>
+        /// Iterates through all fields marked as return values.
+        /// </summary>
+        public IEnumerable<ColumnMap> ReturnValues
+        {
+            get
+            {
+                foreach (ColumnMap map in this)
+                    if (map.ColumnInfo.ReturnValue)
+                        yield return map;
+            }
+        }
+
+        /// <summary>
+        /// Iterates through all fields that are not return values.
+        /// </summary>
+        public ColumnMapCollection NonReturnValues
+        {
+            get
+            {
+                ColumnMapCollection collection = new ColumnMapCollection();
+
+                foreach (ColumnMap map in this)
+                    if (!map.ColumnInfo.ReturnValue)
+                        collection.Add(map);
+
+                return collection;
+            }
+        }
+
+        /// <summary>
+        /// Iterates through all fields marked as Output parameters or InputOutput.
+        /// </summary>
+        public IEnumerable<ColumnMap> OutputFields
+        {
+            get
+            {
+                foreach (ColumnMap map in this)
+                    if (map.ColumnInfo.ParamDirection == ParameterDirection.InputOutput ||
+                        map.ColumnInfo.ParamDirection == ParameterDirection.Output)
+                        yield return map;
+            }
+        }
+
+        /// <summary>
+        /// Iterates through all fields marked as primary keys.
+        /// </summary>
+        public ColumnMapCollection PrimaryKeys
+        {
+            get
+            {
+                ColumnMapCollection keys = new ColumnMapCollection();
+                foreach (ColumnMap map in this)
+                    if (map.ColumnInfo.IsPrimaryKey)
+                        keys.Add(map);
+
+                return keys;
+            }
+        }
+
+        /// <summary>
+        /// Parses and orders the parameters from the query text.  
+        /// Filters the list of mapped columns to match the parameters found in the sql query.
+        /// All parameters starting with the '@' or ':' symbol are matched and returned.
+        /// </summary>
+        /// <param name="command">The command and parameters that are being parsed.</param>
+        /// <returns>A list of mapped columns that are present in the sql statement as parameters.</returns>
+        public ColumnMapCollection OrderParameters(DbCommand command)
+        {
+            if (command.CommandType == CommandType.Text && this.Count > 0)
+            {
+                string commandTypeString = command.GetType().ToString();
+                if (commandTypeString.Contains("Oracle") || commandTypeString.Contains("OleDb"))
+                {
+                    ColumnMapCollection columns = new ColumnMapCollection();
+
+                    // Find all @Parameters contained in the sql statement
+                    string paramPrefix = commandTypeString.Contains("Oracle") ? ":" : "@";
+                    string regexString = string.Format(@"{0}[\w-]+", paramPrefix);
+                    Regex regex = new Regex(regexString);
+                    foreach (Match m in regex.Matches(command.CommandText))
+                    {
+                        ColumnMap matchingColumn = this.Find(c => string.Concat(paramPrefix, c.ColumnInfo.Name.ToLower()) == m.Value.ToLower());
+                        if (matchingColumn != null)
+                            columns.Add(matchingColumn);
+                    }
+
+                    return columns;
+                }
+            }
+
+            return this;
+        }
+
+
+        #endregion
+
+        #region - Actions -
+
+        /// <summary>
+        /// Set's each column's altname as the given prefix + the column name.
+        /// Ex: 
+        /// Original column name: "ID"
+        /// Passed in prefix: "PRODUCT_"
+        /// Generated AltName: "PRODUCT_ID"
+        /// </summary>
+        /// <param name="prefix">The given prefix.</param>
+        /// <returns></returns>
+        public ColumnMapCollection PrefixAltNames(string prefix)
+        {
+            this.ForEach(c => c.ColumnInfo.AltName = c.ColumnInfo.Name.Insert(0, prefix));
+            return this;
+        }
+
+        /// <summary>
+        /// Set's each column's altname as the column name + the given prefix.
+        /// Ex: 
+        /// Original column name: "ID"
+        /// Passed in suffix: "_PRODUCT"
+        /// Generated AltName: "ID_PRODUCT"
+        /// </summary>
+        /// <param name="suffix"></param>
+        /// <returns></returns>
+        public ColumnMapCollection SuffixAltNames(string suffix)
+        {
+            this.ForEach(c => c.ColumnInfo.AltName = c.ColumnInfo.Name + suffix);
+            return this;
+        }
+
+        #endregion
+    }
+}

Marr.Data/Mapping/EnumConversionType.cs

@@ -0,0 +1,29 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Marr.Data.Mapping
+{
+    public enum EnumConversionType
+    {
+        NA,
+        Int,
+        String
+    }
+}

Marr.Data/Mapping/FluentMappings.cs

@@ -0,0 +1,236 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Reflection;
+using Marr.Data.Mapping.Strategies;
+using System.Collections;
+
+namespace Marr.Data.Mapping
+{
+    /// <summary>
+    /// Provides a fluent interface for mapping domain entities and properties to database tables and columns.
+    /// </summary>
+    public class FluentMappings
+    {
+        private bool _publicOnly;
+
+        public FluentMappings()
+            : this(true)
+        { }
+
+        public FluentMappings(bool publicOnly)
+        {
+            _publicOnly = publicOnly;
+            
+        }
+
+        public MappingsFluentEntity<TEntity> Entity<TEntity>()
+        {
+            return new MappingsFluentEntity<TEntity>(_publicOnly);
+        }
+
+        public class MappingsFluentEntity<TEntity>
+        {
+            public MappingsFluentEntity(bool publicOnly)
+            {
+                Columns = new MappingsFluentColumns<TEntity>(this, publicOnly);
+                Table = new MappingsFluentTables<TEntity>(this);
+                Relationships = new MappingsFluentRelationships<TEntity>(this, publicOnly);
+            }
+
+            /// <summary>
+            /// Contains methods that map entity properties to database table and view column names;
+            /// </summary>
+            public MappingsFluentColumns<TEntity> Columns { get; private set; }
+
+            /// <summary>
+            /// Contains methods that map entity classes to database table names.
+            /// </summary>
+            public MappingsFluentTables<TEntity> Table { get; private set; }
+
+            /// <summary>
+            /// Contains methods that map sub-entities with database table and view column names.
+            /// </summary>
+            public MappingsFluentRelationships<TEntity> Relationships { get; private set; }
+        }
+
+        public class MappingsFluentColumns<TEntity>
+        {
+            private bool _publicOnly;
+            private FluentMappings.MappingsFluentEntity<TEntity> _fluentEntity;
+
+            public MappingsFluentColumns(FluentMappings.MappingsFluentEntity<TEntity> fluentEntity, bool publicOnly)
+            {
+                _fluentEntity = fluentEntity;
+                _publicOnly = publicOnly;
+            }
+
+            /// <summary>
+            /// Creates column mappings for the given type.
+            /// Maps all properties except ICollection properties.
+            /// </summary>
+            /// <typeparam name="T">The type that is being built.</typeparam>
+            /// <returns><see cref="ColumnMapCollection"/></returns>
+            public ColumnMapBuilder<TEntity> AutoMapAllProperties()
+            {
+                return AutoMapPropertiesWhere(m => m.MemberType == MemberTypes.Property &&
+                    !typeof(ICollection).IsAssignableFrom((m as PropertyInfo).PropertyType));
+            }
+
+            /// <summary>
+            /// Creates column mappings for the given type.
+            /// Maps all properties that are simple types (int, string, DateTime, etc).  
+            /// ICollection properties are not included.
+            /// </summary>
+            /// <typeparam name="T">The type that is being built.</typeparam>
+            /// <returns><see cref="ColumnMapCollection"/></returns>
+            public ColumnMapBuilder<TEntity> AutoMapSimpleTypeProperties()
+            {
+                return AutoMapPropertiesWhere(m => m.MemberType == MemberTypes.Property &&
+                    DataHelper.IsSimpleType((m as PropertyInfo).PropertyType) &&
+                    !typeof(ICollection).IsAssignableFrom((m as PropertyInfo).PropertyType));
+            }
+
+            /// <summary>
+            /// Creates column mappings for the given type if they match the predicate.
+            /// </summary>
+            /// <typeparam name="T">The type that is being built.</typeparam>
+            /// <param name="predicate">Determines whether a mapping should be created based on the member info.</param>
+            /// <returns><see cref="ColumnMapConfigurator"/></returns>
+            public ColumnMapBuilder<TEntity> AutoMapPropertiesWhere(Func<MemberInfo, bool> predicate)
+            {
+                Type entityType = typeof(TEntity);
+                ConventionMapStrategy strategy = new ConventionMapStrategy(_publicOnly);
+                strategy.ColumnPredicate = predicate;
+                ColumnMapCollection columns = strategy.MapColumns(entityType);
+                MapRepository.Instance.Columns[entityType] = columns;
+                return new ColumnMapBuilder<TEntity>(_fluentEntity, columns);
+            }
+
+            /// <summary>
+            /// Creates a ColumnMapBuilder that starts out with no pre-populated columns.
+            /// All columns must be added manually using the builder.
+            /// </summary>
+            /// <typeparam name="T"></typeparam>
+            /// <returns></returns>
+            public ColumnMapBuilder<TEntity> MapProperties()
+            {
+                Type entityType = typeof(TEntity);
+                ColumnMapCollection columns = new ColumnMapCollection();
+                MapRepository.Instance.Columns[entityType] = columns;
+                return new ColumnMapBuilder<TEntity>(_fluentEntity, columns);
+            }
+        }
+
+        public class MappingsFluentTables<TEntity>
+        {
+            private FluentMappings.MappingsFluentEntity<TEntity> _fluentEntity;
+
+            public MappingsFluentTables(FluentMappings.MappingsFluentEntity<TEntity> fluentEntity)
+            {
+                _fluentEntity = fluentEntity;
+            }
+
+            /// <summary>
+            /// Provides a fluent table mapping interface.
+            /// </summary>
+            /// <typeparam name="T"></typeparam>
+            /// <returns></returns>
+            public TableBuilder<TEntity> AutoMapTable<T>()
+            {
+                return new TableBuilder<TEntity>(_fluentEntity);
+            }
+
+            /// <summary>
+            /// Sets the table name for a given type.
+            /// </summary>
+            /// <typeparam name="T"></typeparam>
+            /// <param name="tableName"></param>
+            public TableBuilder<TEntity> MapTable(string tableName)
+            {
+                return new TableBuilder<TEntity>(_fluentEntity).SetTableName(tableName);
+            }
+        }
+
+        public class MappingsFluentRelationships<TEntity>
+        {
+            private FluentMappings.MappingsFluentEntity<TEntity> _fluentEntity;
+            private bool _publicOnly;
+
+            public MappingsFluentRelationships(FluentMappings.MappingsFluentEntity<TEntity> fluentEntity, bool publicOnly)
+            {
+                _fluentEntity = fluentEntity;
+                _publicOnly = publicOnly;
+            }
+
+            /// <summary>
+            /// Creates relationship mappings for the given type.
+            /// Maps all properties that implement ICollection or are not "simple types".
+            /// </summary>
+            /// <returns></returns>
+            public RelationshipBuilder<TEntity> AutoMapICollectionOrComplexProperties()
+            {
+                return AutoMapPropertiesWhere(m =>
+                    m.MemberType == MemberTypes.Property &&
+                    (
+                        typeof(ICollection).IsAssignableFrom((m as PropertyInfo).PropertyType) || !DataHelper.IsSimpleType((m as PropertyInfo).PropertyType)
+                    )
+                );
+
+            }
+
+            /// <summary>
+            /// Creates relationship mappings for the given type.
+            /// Maps all properties that implement ICollection.
+            /// </summary>
+            /// <returns><see cref="RelationshipBuilder"/></returns>
+            public RelationshipBuilder<TEntity> AutoMapICollectionProperties()
+            {
+                return AutoMapPropertiesWhere(m =>
+                    m.MemberType == MemberTypes.Property &&
+                    typeof(ICollection).IsAssignableFrom((m as PropertyInfo).PropertyType));
+            }
+
+            /// <summary>
+            /// Creates relationship mappings for the given type.
+            /// Maps all properties that are not "simple types".
+            /// </summary>
+            /// <returns></returns>
+            public RelationshipBuilder<TEntity> AutoMapComplexTypeProperties<T>()
+            {
+                return AutoMapPropertiesWhere(m =>
+                    m.MemberType == MemberTypes.Property &&
+                    !DataHelper.IsSimpleType((m as PropertyInfo).PropertyType));
+            }
+
+            /// <summary>
+            /// Creates relationship mappings for the given type if they match the predicate.
+            /// </summary>
+            /// <param name="predicate">Determines whether a mapping should be created based on the member info.</param>
+            /// <returns><see cref="RelationshipBuilder"/></returns>
+            public RelationshipBuilder<TEntity> AutoMapPropertiesWhere(Func<MemberInfo, bool> predicate)
+            {
+                Type entityType = typeof(TEntity);
+                ConventionMapStrategy strategy = new ConventionMapStrategy(_publicOnly);
+                strategy.RelationshipPredicate = predicate;
+                RelationshipCollection relationships = strategy.MapRelationships(entityType);
+                MapRepository.Instance.Relationships[entityType] = relationships;
+                return new RelationshipBuilder<TEntity>(_fluentEntity, relationships);
+            }
+
+            /// <summary>
+            /// Creates a RelationshipBuilder that starts out with no pre-populated relationships.
+            /// All relationships must be added manually using the builder.
+            /// </summary>
+            /// <returns></returns>
+            public RelationshipBuilder<TEntity> MapProperties<T>()
+            {
+                Type entityType = typeof(T);
+                RelationshipCollection relationships = new RelationshipCollection();
+                MapRepository.Instance.Relationships[entityType] = relationships;
+                return new RelationshipBuilder<TEntity>(_fluentEntity, relationships);
+            }
+        }
+    }
+}

Marr.Data/Mapping/IColumnInfo.cs

@@ -0,0 +1,37 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Data;
+using System.Data.Common;
+using System.Data.OleDb;
+
+namespace Marr.Data.Mapping
+{
+    public interface IColumnInfo
+    {
+        string Name { get; set;  }
+        string AltName { get; set; }
+        int Size { get; set;  }
+        bool IsPrimaryKey { get; set; }
+        bool IsAutoIncrement { get; set; }
+        bool ReturnValue { get; set; }
+        ParameterDirection ParamDirection { get; set; }
+        string TryGetAltName();
+    }
+   
+}

Marr.Data/Mapping/IRelationshipInfo.cs

@@ -0,0 +1,34 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Marr.Data.Mapping
+{
+    public interface IRelationshipInfo
+    {
+        RelationshipTypes RelationType { get; set; }
+        Type EntityType { get; set; }
+    }
+
+    public enum RelationshipTypes
+    {
+        AutoDetect,
+        One,
+        Many
+    }
+}

Marr.Data/Mapping/MapBuilder.cs

@@ -0,0 +1,208 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Marr.Data.Mapping.Strategies;
+using System.Reflection;
+using System.Collections;
+
+namespace Marr.Data.Mapping
+{
+    [Obsolete("This class is obsolete.  Please use the 'Mappings' class.")]
+    public class MapBuilder
+    {
+        private bool _publicOnly;
+
+        public MapBuilder()
+            : this(true)
+        { }
+
+        public MapBuilder(bool publicOnly)
+        {
+            _publicOnly = publicOnly;
+        }
+
+        #region - Columns -
+
+        /// <summary>
+        /// Creates column mappings for the given type.
+        /// Maps all properties except ICollection properties.
+        /// </summary>
+        /// <typeparam name="T">The type that is being built.</typeparam>
+        /// <returns><see cref="ColumnMapCollection"/></returns>
+        public ColumnMapBuilder<T> BuildColumns<T>()
+        {
+            return BuildColumns<T>(m => m.MemberType == MemberTypes.Property &&
+                !typeof(ICollection).IsAssignableFrom((m as PropertyInfo).PropertyType));
+        }
+
+        /// <summary>
+        /// Creates column mappings for the given type.
+        /// Maps all properties that are simple types (int, string, DateTime, etc).  
+        /// ICollection properties are not included.
+        /// </summary>
+        /// <typeparam name="T">The type that is being built.</typeparam>
+        /// <returns><see cref="ColumnMapCollection"/></returns>
+        public ColumnMapBuilder<T> BuildColumnsFromSimpleTypes<T>()
+        {
+            return BuildColumns<T>(m => m.MemberType == MemberTypes.Property &&
+                DataHelper.IsSimpleType((m as PropertyInfo).PropertyType) &&
+                !typeof(ICollection).IsAssignableFrom((m as PropertyInfo).PropertyType));
+        }
+
+        /// <summary>
+        /// Creates column mappings for the given type.  
+        /// Maps properties that are included in the include list.
+        /// </summary>
+        /// <typeparam name="T">The type that is being built.</typeparam>
+        /// <param name="propertiesToInclude"></param>
+        /// <returns><see cref="ColumnMapCollection"/></returns>
+        public ColumnMapBuilder<T> BuildColumns<T>(params string[] propertiesToInclude)
+        {
+            return BuildColumns<T>(m =>
+                m.MemberType == MemberTypes.Property &&
+                propertiesToInclude.Contains(m.Name));
+        }
+
+        /// <summary>
+        /// Creates column mappings for the given type.
+        /// Maps all properties except the ones in the exclusion list.
+        /// </summary>
+        /// <typeparam name="T">The type that is being built.</typeparam>
+        /// <param name="propertiesToExclude"></param>
+        /// <returns><see cref="ColumnMapCollection"/></returns>
+        public ColumnMapBuilder<T> BuildColumnsExcept<T>(params string[] propertiesToExclude)
+        {
+            return BuildColumns<T>(m => 
+                m.MemberType == MemberTypes.Property &&
+                !propertiesToExclude.Contains(m.Name));
+        }
+
+        /// <summary>
+        /// Creates column mappings for the given type if they match the predicate.
+        /// </summary>
+        /// <typeparam name="T">The type that is being built.</typeparam>
+        /// <param name="predicate">Determines whether a mapping should be created based on the member info.</param>
+        /// <returns><see cref="ColumnMapConfigurator"/></returns>
+        public ColumnMapBuilder<T> BuildColumns<T>(Func<MemberInfo, bool> predicate)
+        {
+            Type entityType = typeof(T);
+            ConventionMapStrategy strategy = new ConventionMapStrategy(_publicOnly);
+            strategy.ColumnPredicate = predicate;
+            ColumnMapCollection columns = strategy.MapColumns(entityType);
+            MapRepository.Instance.Columns[entityType] = columns;
+            return new ColumnMapBuilder<T>(null, columns);
+        }
+
+        /// <summary>
+        /// Creates a ColumnMapBuilder that starts out with no pre-populated columns.
+        /// All columns must be added manually using the builder.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        public ColumnMapBuilder<T> Columns<T>()
+        {
+            Type entityType = typeof(T);
+            ColumnMapCollection columns = new ColumnMapCollection();
+            MapRepository.Instance.Columns[entityType] = columns;
+            return new ColumnMapBuilder<T>(null, columns);
+        }
+        
+        #endregion
+
+        #region - Relationships -
+
+        /// <summary>
+        /// Creates relationship mappings for the given type.
+        /// Maps all properties that implement ICollection.
+        /// </summary>
+        /// <typeparam name="T">The type that is being built.</typeparam>
+        /// <returns><see cref="RelationshipBuilder"/></returns>
+        public RelationshipBuilder<T> BuildRelationships<T>()
+        {
+            return BuildRelationships<T>(m => 
+                m.MemberType == MemberTypes.Property && 
+                typeof(ICollection).IsAssignableFrom((m as PropertyInfo).PropertyType));
+        }
+
+        /// <summary>
+        /// Creates relationship mappings for the given type.
+        /// Maps all properties that are listed in the include list.
+        /// </summary>
+        /// <typeparam name="T">The type that is being built.</typeparam>
+        /// <param name="propertiesToInclude"></param>
+        /// <returns><see cref="RelationshipBuilder"/></returns>
+        public RelationshipBuilder<T> BuildRelationships<T>(params string[] propertiesToInclude)
+        {
+            Func<MemberInfo, bool> predicate = m => 
+                (
+                    // ICollection properties
+                    m.MemberType == MemberTypes.Property && 
+                    typeof(ICollection).IsAssignableFrom((m as PropertyInfo).PropertyType) &&
+                    propertiesToInclude.Contains(m.Name)
+                ) || ( // Single entity properties
+                    m.MemberType == MemberTypes.Property &&
+                    !typeof(ICollection).IsAssignableFrom((m as PropertyInfo).PropertyType) &&
+                    propertiesToInclude.Contains(m.Name)
+                );
+            
+            return BuildRelationships<T>(predicate);
+        }
+
+        /// <summary>
+        /// Creates relationship mappings for the given type if they match the predicate.
+        /// </summary>
+        /// <typeparam name="T">The type that is being built.</typeparam>
+        /// <param name="predicate">Determines whether a mapping should be created based on the member info.</param>
+        /// <returns><see cref="RelationshipBuilder"/></returns>
+        public RelationshipBuilder<T> BuildRelationships<T>(Func<MemberInfo, bool> predicate)
+        {
+            Type entityType = typeof(T);
+            ConventionMapStrategy strategy = new ConventionMapStrategy(_publicOnly);
+            strategy.RelationshipPredicate = predicate;
+            RelationshipCollection relationships = strategy.MapRelationships(entityType);
+            MapRepository.Instance.Relationships[entityType] = relationships;
+            return new RelationshipBuilder<T>(null, relationships);
+        }
+
+        /// <summary>
+        /// Creates a RelationshipBuilder that starts out with no pre-populated relationships.
+        /// All relationships must be added manually using the builder.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        public RelationshipBuilder<T> Relationships<T>()
+        {
+            Type entityType = typeof(T);
+            RelationshipCollection relationships = new RelationshipCollection();
+            MapRepository.Instance.Relationships[entityType] = relationships;
+            return new RelationshipBuilder<T>(null, relationships);
+        }
+        
+        #endregion
+
+        #region - Tables -
+
+        /// <summary>
+        /// Provides a fluent table mapping interface.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        public TableBuilder<T> BuildTable<T>()
+        {
+            return new TableBuilder<T>(null);
+        }
+
+        /// <summary>
+        /// Sets the table name for a given type.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="tableName"></param>
+        public TableBuilder<T> BuildTable<T>(string tableName)
+        {
+            return new TableBuilder<T>(null).SetTableName(tableName);
+        }
+
+        #endregion
+    }
+}

Marr.Data/Mapping/MappingHelper.cs

@@ -0,0 +1,185 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Data.Common;
+using Marr.Data.Converters;
+
+namespace Marr.Data.Mapping
+{
+    internal class MappingHelper
+    {
+        private MapRepository _repos;
+        private IDataMapper _db;
+
+        public MappingHelper(IDataMapper db)
+        {
+            _repos = MapRepository.Instance;
+            _db = db;
+        }
+
+        /// <summary>
+        /// Instantiates an entity and loads its mapped fields with the data from the reader.
+        /// </summary>
+        public object CreateAndLoadEntity<T>(ColumnMapCollection mappings, DbDataReader reader, bool useAltName)
+        {
+            return CreateAndLoadEntity(typeof(T), mappings, reader, useAltName);
+        }
+
+        /// <summary>
+        /// Instantiates an entity and loads its mapped fields with the data from the reader.
+        /// </summary>
+        /// <param name="entityType">The entity being created and loaded.</param>
+        /// <param name="mappings">The field mappings for the passed in entity.</param>
+        /// <param name="reader">The open data reader.</param>
+        /// <param name="useAltNames">Determines if the column AltName should be used.</param>
+        /// <returns>Returns an entity loaded with data.</returns>
+        public object CreateAndLoadEntity(Type entityType, ColumnMapCollection mappings, DbDataReader reader, bool useAltName)
+        {
+            // Create new entity
+            object ent = _repos.ReflectionStrategy.CreateInstance(entityType);
+            return LoadExistingEntity(mappings, reader, ent, useAltName);
+        }
+
+        public object LoadExistingEntity(ColumnMapCollection mappings, DbDataReader reader, object ent, bool useAltName)
+        {
+            // Populate entity fields from data reader
+            foreach (ColumnMap dataMap in mappings)
+            {
+                try
+                {
+                    string colName = dataMap.ColumnInfo.GetColumName(useAltName);
+                    int ordinal = reader.GetOrdinal(colName);
+                    object dbValue = reader.GetValue(ordinal);
+
+                    // Handle conversions
+                    IConverter conversion = _repos.GetConverter(dataMap.FieldType);
+                    if (conversion != null)
+                    {
+                        dbValue = conversion.FromDB(dataMap, dbValue);
+                    }
+
+                    _repos.ReflectionStrategy.SetFieldValue(ent, dataMap.FieldName, dbValue);
+                }
+                catch (Exception ex)
+                {
+                    string msg = string.Format("The DataMapper was unable to load the following field: '{0}'.",
+                        dataMap.ColumnInfo.Name);
+
+                    throw new DataMappingException(msg, ex);
+                }
+            }
+
+            PrepareLazyLoadedProperties(ent);
+
+            return ent;
+        }
+
+        private void PrepareLazyLoadedProperties(object ent)
+        {
+            // Handle lazy loaded properties
+            Type entType = ent.GetType();
+            if (_repos.Relationships.ContainsKey(entType))
+            {
+                Func<IDataMapper> dbCreate = () =>
+                {
+                    var db = new DataMapper(_db.ProviderFactory, _db.ConnectionString);
+                    db.SqlMode = SqlModes.Text;
+                    return db;
+                };
+
+                var relationships = _repos.Relationships[entType];
+                foreach (var rel in relationships.Where(r => r.IsLazyLoaded))
+                {
+                    ILazyLoaded lazyLoaded = (ILazyLoaded)rel.LazyLoaded.Clone();
+                    lazyLoaded.Prepare(dbCreate, ent);
+                    _repos.ReflectionStrategy.SetFieldValue(ent, rel.Member.Name, lazyLoaded);
+                }
+            }
+        }
+
+        public T LoadSimpleValueFromFirstColumn<T>(DbDataReader reader)
+        {
+            try
+            {
+                return (T)reader.GetValue(0);
+            }
+            catch (Exception ex)
+            {
+                string firstColumnName = reader.GetName(0);
+                string msg = string.Format("The DataMapper was unable to create a value of type '{0}' from the first column '{1}'.",
+                    typeof(T).Name, firstColumnName);
+
+                throw new DataMappingException(msg, ex);
+            }
+        }
+
+        /// <summary>
+        /// Creates all parameters for a SP based on the mappings of the entity,
+        /// and assigns them values based on the field values of the entity.
+        /// </summary>
+        public void CreateParameters<T>(T entity, ColumnMapCollection columnMapCollection, bool isAutoQuery)
+        {
+            ColumnMapCollection mappings = columnMapCollection;
+
+            if (!isAutoQuery)
+            {
+                // Order columns (applies to Oracle and OleDb only)
+                mappings = columnMapCollection.OrderParameters(_db.Command);
+            }
+
+            foreach (ColumnMap columnMap in mappings)
+            {
+                if (columnMap.ColumnInfo.IsAutoIncrement)
+                    continue;
+
+                var param = _db.Command.CreateParameter();
+                param.ParameterName = columnMap.ColumnInfo.Name;
+                param.Size = columnMap.ColumnInfo.Size;
+                param.Direction = columnMap.ColumnInfo.ParamDirection;
+
+                object val = _repos.ReflectionStrategy.GetFieldValue(entity, columnMap.FieldName);
+
+                param.Value = val == null ? DBNull.Value : val; // Convert nulls to DBNulls
+
+                var repos = MapRepository.Instance;
+
+                IConverter conversion = repos.GetConverter(columnMap.FieldType);
+                if (conversion != null)
+                {
+                    param.Value = conversion.ToDB(param.Value);
+                }
+
+                // Set the appropriate DbType property depending on the parameter type
+                // Note: the columnMap.DBType property was set when the ColumnMap was created
+                repos.DbTypeBuilder.SetDbType(param, columnMap.DBType);
+
+                _db.Command.Parameters.Add(param);
+            }
+        }
+
+        /// <summary>
+        /// Assigns the SP result columns to the passed in 'mappings' fields.
+        /// </summary>
+        public void SetOutputValues<T>(T entity, IEnumerable<ColumnMap> mappings)
+        {
+            foreach (ColumnMap dataMap in mappings)
+            {
+                object output = _db.Command.Parameters[dataMap.ColumnInfo.Name].Value;
+                _repos.ReflectionStrategy.SetFieldValue(entity, dataMap.FieldName, output);
+            }
+        }
+
+        /// <summary>
+        /// Assigns the passed in 'value' to the passed in 'mappings' fields.
+        /// </summary>
+        public void SetOutputValues<T>(T entity, IEnumerable<ColumnMap> mappings, object value)
+        {
+            foreach (ColumnMap dataMap in mappings)
+            {
+                _repos.ReflectionStrategy.SetFieldValue(entity, dataMap.FieldName, Convert.ChangeType(value, dataMap.FieldType));
+            }
+        }
+
+    }
+}

Marr.Data/Mapping/Relationship.cs

@@ -0,0 +1,120 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Reflection;
+
+namespace Marr.Data.Mapping
+{
+    public class Relationship
+    {
+        private IRelationshipInfo _relationshipInfo;
+        private MemberInfo _member;
+        private ILazyLoaded _lazyLoaded;
+
+        public Relationship(MemberInfo member)
+            : this(member, new RelationshipInfo())
+        { }
+
+        public Relationship(MemberInfo member, IRelationshipInfo relationshipInfo)
+        {
+            _member = member;
+
+            Type memberType = ReflectionHelper.GetMemberType(member);
+
+            // Try to determine the RelationshipType
+            if (relationshipInfo.RelationType == RelationshipTypes.AutoDetect)
+            {
+                if (typeof(System.Collections.ICollection).IsAssignableFrom(memberType))
+                {
+                    relationshipInfo.RelationType = RelationshipTypes.Many;
+                }
+                else
+                {
+                    relationshipInfo.RelationType = RelationshipTypes.One;
+                }
+            }
+
+            // Try to determine the EntityType
+            if (relationshipInfo.EntityType == null)
+            {
+                if (relationshipInfo.RelationType == RelationshipTypes.Many)
+                {
+                    if (memberType.IsGenericType)
+                    {
+                        // Assume a Collection<T> or List<T> and return T
+                        relationshipInfo.EntityType = memberType.GetGenericArguments()[0];
+                    }
+                    else
+                    {
+                        throw new ArgumentException(string.Format(
+                            "The DataMapper could not determine the RelationshipAttribute EntityType for {0}.",
+                            memberType.Name));
+                    }
+                }
+                else
+                {
+                    relationshipInfo.EntityType = memberType;
+                }
+            }
+
+            _relationshipInfo = relationshipInfo;
+        }
+
+        public IRelationshipInfo RelationshipInfo
+        {
+            get { return _relationshipInfo; }
+        }
+
+        public MemberInfo Member
+        {
+            get { return _member; }
+        }
+
+        public Type MemberType
+        {
+            get
+            {
+                // Assumes that a relationship can only have a member type of Field or Property
+                if (Member.MemberType == MemberTypes.Field)
+                    return (Member as FieldInfo).FieldType;
+                else
+                    return (Member as PropertyInfo).PropertyType;
+            }
+        }
+
+        public bool IsLazyLoaded
+        {
+            get
+            {
+                return _lazyLoaded != null;
+            }
+        }
+
+        public ILazyLoaded LazyLoaded
+        {
+            get
+            {
+                return _lazyLoaded;
+            }
+            set
+            {
+                _lazyLoaded = value;
+            }
+        }
+    }
+}

Marr.Data/Mapping/RelationshipAttribute.cs

@@ -0,0 +1,77 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Marr.Data.Mapping
+{
+    /// <summary>
+    /// Defines a field as a related entity that needs to be created at filled with data.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = false)]
+    public class RelationshipAttribute : Attribute, IRelationshipInfo
+    {
+        /// <summary>
+        /// Defines a data relationship.
+        /// </summary>
+        public RelationshipAttribute()
+            : this(RelationshipTypes.AutoDetect)
+        { }
+
+        /// <summary>
+        /// Defines a data relationship.
+        /// </summary>
+        /// <param name="relationType"></param>
+        public RelationshipAttribute(RelationshipTypes relationType)
+        {
+            RelationType = relationType;
+        }
+
+        /// <summary>
+        /// Defines a One-ToMany data relationship for a given type.
+        /// </summary>
+        /// <param name="entityType">The type of the child entity.</param>
+        public RelationshipAttribute(Type entityType)
+            : this(entityType, RelationshipTypes.AutoDetect)
+        { }
+
+        /// <summary>
+        /// Defines a data relationship.
+        /// </summary>
+        /// <param name="entityType">The type of the child entity.</param>
+        /// <param name="relationType">The relationship type can be "One" or "Many".</param>
+        public RelationshipAttribute(Type entityType, RelationshipTypes relationType)
+        {
+            EntityType = entityType;
+            RelationType = relationType;
+        }
+
+        #region IRelationshipInfo Members
+
+        /// <summary>
+        /// Gets or sets the relationship type can be "One" or "Many".
+        /// </summary>
+        public RelationshipTypes RelationType { get; set; }
+
+        /// <summary>
+        /// Gets or sets the type of the child entity.
+        /// </summary>
+        public Type EntityType { get; set; }
+
+        #endregion
+    }
+}

Marr.Data/Mapping/RelationshipBuilder.cs

@@ -0,0 +1,176 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Linq.Expressions;
+using Marr.Data.Mapping.Strategies;
+
+namespace Marr.Data.Mapping
+{
+    /// <summary>
+    /// This class has fluent methods that are used to easily configure relationship mappings.
+    /// </summary>
+    /// <typeparam name="TEntity"></typeparam>
+    public class RelationshipBuilder<TEntity>
+    {
+        private FluentMappings.MappingsFluentEntity<TEntity> _fluentEntity;
+        private string _currentPropertyName;
+
+        public RelationshipBuilder(FluentMappings.MappingsFluentEntity<TEntity> fluentEntity, RelationshipCollection relationships)
+        {
+            _fluentEntity = fluentEntity;
+            Relationships = relationships;
+        }
+
+        /// <summary>
+        /// Gets the list of relationship mappings that are being configured.
+        /// </summary>
+        public RelationshipCollection Relationships { get; private set; }
+
+        #region - Fluent Methods -
+
+        /// <summary>
+        /// Initializes the configurator to configure the given property.
+        /// </summary>
+        /// <param name="property"></param>
+        /// <returns></returns>
+        public RelationshipBuilder<TEntity> For(Expression<Func<TEntity, object>> property)
+        {
+            return For(property.GetMemberName());
+        }
+
+        /// <summary>
+        /// Initializes the configurator to configure the given property or field.
+        /// </summary>
+        /// <param name="propertyName"></param>
+        /// <returns></returns>
+        public RelationshipBuilder<TEntity> For(string propertyName)
+        {
+            _currentPropertyName = propertyName;
+
+            // Try to add the relationship if it doesn't exist
+            if (Relationships[_currentPropertyName] == null)
+            {
+                TryAddRelationshipForField(_currentPropertyName);
+            }
+
+            return this;
+        }
+
+        /// <summary>
+        /// Sets a property to be lazy loaded, with a given query.
+        /// </summary>
+        /// <typeparam name="TChild"></typeparam>
+        /// <param name="query"></param>
+        /// <returns></returns>
+        public RelationshipBuilder<TEntity> LazyLoad<TChild>(Func<IDataMapper, TEntity, TChild> query)
+        {
+            AssertCurrentPropertyIsSet();
+
+            Relationships[_currentPropertyName].LazyLoaded = new LazyLoaded<TEntity, TChild>(query);
+            return this;
+        }
+
+        public RelationshipBuilder<TEntity> SetOneToOne()
+        {
+            AssertCurrentPropertyIsSet();
+            SetOneToOne(_currentPropertyName);
+            return this;
+        }
+
+        public RelationshipBuilder<TEntity> SetOneToOne(string propertyName)
+        {
+            Relationships[propertyName].RelationshipInfo.RelationType = RelationshipTypes.One;
+            return this;
+        }
+
+        public RelationshipBuilder<TEntity> SetOneToMany()
+        {
+            AssertCurrentPropertyIsSet();
+            SetOneToMany(_currentPropertyName);
+            return this;
+        }
+
+        public RelationshipBuilder<TEntity> SetOneToMany(string propertyName)
+        {
+            Relationships[propertyName].RelationshipInfo.RelationType = RelationshipTypes.Many;
+            return this;
+        }
+
+        public RelationshipBuilder<TEntity> Ignore(Expression<Func<TEntity, object>> property)
+        {
+            string propertyName = property.GetMemberName();
+            Relationships.RemoveAll(r => r.Member.Name == propertyName);
+            return this;
+        }
+
+        public FluentMappings.MappingsFluentTables<TEntity> Tables
+        {
+            get
+            {
+                if (_fluentEntity == null)
+                {
+                    throw new Exception("This property is not compatible with the obsolete 'MapBuilder' class.");
+                }
+
+                return _fluentEntity.Table;
+            }
+        }
+
+        public FluentMappings.MappingsFluentColumns<TEntity> Columns
+        {
+            get
+            {
+                if (_fluentEntity == null)
+                {
+                    throw new Exception("This property is not compatible with the obsolete 'MapBuilder' class.");
+                }
+
+                return _fluentEntity.Columns;
+            }
+        }
+
+        public FluentMappings.MappingsFluentEntity<TNewEntity> Entity<TNewEntity>()
+        {
+            return new FluentMappings.MappingsFluentEntity<TNewEntity>(true);
+        }
+
+        /// <summary>
+        /// Tries to add a Relationship for the given field name.  
+        /// Throws and exception if field cannot be found.
+        /// </summary>
+        private void TryAddRelationshipForField(string fieldName)
+        {
+            // Set strategy to filter for public or private fields
+            ConventionMapStrategy strategy = new ConventionMapStrategy(false);
+
+            // Find the field that matches the given field name
+            strategy.RelationshipPredicate = mi => mi.Name == fieldName;
+            Relationship relationship = strategy.MapRelationships(typeof(TEntity)).FirstOrDefault();
+
+            if (relationship == null)
+            {
+                throw new DataMappingException(string.Format("Could not find the field '{0}' in '{1}'.",
+                    fieldName,
+                    typeof(TEntity).Name));
+            }
+            else
+            {
+                Relationships.Add(relationship);
+            }
+        }
+
+        /// <summary>
+        /// Throws an exception if the "current" property has not been set.
+        /// </summary>
+        private void AssertCurrentPropertyIsSet()
+        {
+            if (string.IsNullOrEmpty(_currentPropertyName))
+            {
+                throw new DataMappingException("A property must first be specified using the 'For' method.");
+            }
+        }
+
+        #endregion
+    }
+}

Marr.Data/Mapping/RelationshipCollection.cs

@@ -0,0 +1,37 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Marr.Data.Mapping
+{
+    public class RelationshipCollection : List<Relationship>
+    {
+        /// <summary>
+        /// Gets a ColumnMap by its field name.
+        /// </summary>
+        /// <param name="fieldName"></param>
+        /// <returns></returns>
+        public Relationship this[string fieldName]
+        {
+            get
+            {
+                return this.Find(m => m.Member.Name == fieldName);
+            }
+        }
+    }
+}

Marr.Data/Mapping/RelationshipInfo.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Marr.Data.Mapping
+{
+    public class RelationshipInfo : IRelationshipInfo
+    {
+        public RelationshipTypes RelationType { get; set; }
+
+        public Type EntityType { get; set; }
+    }
+}

Marr.Data/Mapping/Strategies/AttributeMapStrategy.cs

@@ -0,0 +1,75 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Reflection;
+using Marr.Data.Converters;
+using Marr.Data.Parameters;
+
+namespace Marr.Data.Mapping.Strategies
+{
+    /// <summary>
+    /// Maps fields or properties that are marked with the ColumnAttribute.
+    /// </summary>
+    public class AttributeMapStrategy : ReflectionMapStrategyBase
+    {
+        public AttributeMapStrategy()
+            : base()
+        { }
+
+        public AttributeMapStrategy(bool publicOnly)
+            : base(publicOnly)
+        { }
+
+        public AttributeMapStrategy(BindingFlags flags)
+            : base(flags)
+        { }
+
+        /// <summary>
+        /// Registers any member with a ColumnAttribute as a ColumnMap.
+        /// <param name="entityType">The entity that is being mapped.</param>
+        /// <param name="member">The current member that is being inspected.</param>
+        /// <param name="columnAtt">A ColumnAttribute (is null of one does not exist).</param>
+        /// <param name="columnMaps">A list of ColumnMaps.</param>
+        /// </summary>
+        protected override void CreateColumnMap(Type entityType, MemberInfo member, ColumnAttribute columnAtt, ColumnMapCollection columnMaps)
+        {
+            if (columnAtt != null)
+            {
+                ColumnMap columnMap = new ColumnMap(member, columnAtt);
+                columnMaps.Add(columnMap);
+            }
+        }
+
+        /// <summary>
+        /// Registers any member with a RelationshipAttribute as a relationship.
+        /// </summary>
+        /// <param name="entityType">The entity that is being mapped.</param>
+        /// <param name="member">The current member that is being inspected.</param>
+        /// <param name="relationshipAtt">A RelationshipAttribute (is null if one does not exist).</param>
+        /// <param name="relationships">A list of Relationships.</param>
+        protected override void CreateRelationship(Type entityType, MemberInfo member, RelationshipAttribute relationshipAtt, RelationshipCollection relationships)
+        {
+            if (relationshipAtt != null)
+            {
+                Relationship relationship = new Relationship(member, relationshipAtt);
+                relationships.Add(relationship);
+            }
+        }
+    }
+}

Marr.Data/Mapping/Strategies/ConventionMapStrategy.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Reflection;
+using System.Collections;
+
+namespace Marr.Data.Mapping.Strategies
+{
+    /// <summary>
+    /// Allows you to specify a member based filter by defining predicates that filter the members that are mapped.
+    /// </summary>
+    public class ConventionMapStrategy : ReflectionMapStrategyBase
+    {
+        public ConventionMapStrategy(bool publicOnly)
+            : base(publicOnly)
+        {
+            // Default: Only map members that are properties
+            ColumnPredicate = m => m.MemberType == MemberTypes.Property;
+
+            // Default: Only map members that are properties and that are ICollection types
+            RelationshipPredicate = m =>
+            {
+                return m.MemberType == MemberTypes.Property && typeof(ICollection).IsAssignableFrom((m as PropertyInfo).PropertyType);
+            };
+        }
+
+        public Func<MemberInfo, bool> ColumnPredicate;
+        public Func<MemberInfo, bool> RelationshipPredicate;        
+
+        
+
+        protected override void CreateColumnMap(Type entityType, System.Reflection.MemberInfo member, ColumnAttribute columnAtt, ColumnMapCollection columnMaps)
+        {
+            if (ColumnPredicate(member))
+            {
+                // Map public property to DB column
+                columnMaps.Add(new ColumnMap(member));
+            }
+        }
+
+        protected override void CreateRelationship(Type entityType, System.Reflection.MemberInfo member, RelationshipAttribute relationshipAtt, RelationshipCollection relationships)
+        {
+            if (RelationshipPredicate(member))
+            {
+                relationships.Add(new Relationship(member));
+            }
+        }
+
+    }
+}

Marr.Data/Mapping/Strategies/IMapStrategy.cs

@@ -0,0 +1,48 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Marr.Data.Mapping.Strategies
+{
+    /// <summary>
+    /// A strategy for creating mappings for a given entity.
+    /// </summary>
+    public interface IMapStrategy
+    {
+        /// <summary>
+        /// Creates a table map for a given entity type.
+        /// </summary>
+        /// <param name="entityType"></param>
+        /// <returns></returns>
+        string MapTable(Type entityType);
+
+        /// <summary>
+        /// Creates a ColumnMapCollection for a given entity type.
+        /// </summary>
+        /// <param name="entityType">The entity that is being mapped.</param>
+        ColumnMapCollection MapColumns(Type entityType);
+
+        /// <summary>
+        /// Creates a RelationshpCollection for a given entity type.
+        /// </summary>
+        /// <param name="entityType">The entity that is being mapped.</param>
+        /// <returns></returns>
+        RelationshipCollection MapRelationships(Type entityType);
+    }
+}

Marr.Data/Mapping/Strategies/PropertyMapStrategy.cs

@@ -0,0 +1,85 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Reflection;
+
+namespace Marr.Data.Mapping.Strategies
+{
+    /// <summary>
+    /// Maps all public properties to DB columns.  
+    /// </summary>
+    public class PropertyMapStrategy : AttributeMapStrategy
+    {
+        public PropertyMapStrategy(bool publicOnly)
+            : base(publicOnly)
+        { }
+
+        /// <summary>
+        /// Maps properties to DB columns if a ColumnAttribute is not present.
+        /// <param name="entityType">The entity that is being mapped.</param>
+        /// <param name="member">The current member that is being inspected.</param>
+        /// <param name="columnAtt">A ColumnAttribute (is null of one does not exist).</param>
+        /// <param name="columnMaps">A list of ColumnMaps.</param>
+        /// </summary>
+        protected override void CreateColumnMap(Type entityType, MemberInfo member, ColumnAttribute columnAtt, ColumnMapCollection columnMaps)
+        {
+            if (columnAtt != null)
+            {
+                // Add columns with ColumnAttribute
+                base.CreateColumnMap(entityType, member, columnAtt, columnMaps);
+            }
+            else
+            {
+                if (member.MemberType == MemberTypes.Property)
+                {
+                    // Map public property to DB column
+                    columnMaps.Add(new ColumnMap(member));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Maps a relationship if a RelationshipAttribute is present.
+        /// </summary>
+        /// <param name="entityType">The entity that is being mapped.</param>
+        /// <param name="member">The current member that is being inspected.</param>
+        /// <param name="relationshipAtt">A RelationshipAttribute (is null if one does not exist).</param>
+        /// <param name="relationships">A list of Relationships.</param>
+        protected override void CreateRelationship(Type entityType, MemberInfo member, RelationshipAttribute relationshipAtt, RelationshipCollection relationships)
+        {
+            if (relationshipAtt != null)
+            {
+                // Add relationships by RelationshipAttribute
+                base.CreateRelationship(entityType, member, relationshipAtt, relationships);
+            }
+            else
+            {
+                if (member.MemberType == MemberTypes.Property)
+                {
+                    PropertyInfo propertyInfo = member as PropertyInfo;
+                    if (typeof(System.Collections.ICollection).IsAssignableFrom(propertyInfo.PropertyType))
+                    {
+                        Relationship relationship = new Relationship(member);
+                        relationships.Add(relationship);
+                    }
+                }
+            }
+        }
+    }
+}

Marr.Data/Mapping/Strategies/ReflectionMapStrategyBase.cs

@@ -0,0 +1,151 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Reflection;
+
+namespace Marr.Data.Mapping.Strategies
+{
+    /// <summary>
+    /// Iterates through the members of an entity based on the BindingFlags, and provides an abstract method for adding ColumnMaps for each member.
+    /// </summary>
+    public abstract class ReflectionMapStrategyBase : IMapStrategy
+    {
+        private BindingFlags _bindingFlags;
+
+        /// <summary>
+        /// Loops through members with the following BindingFlags:
+        /// Instance | NonPublic | Public | FlattenHierarchy
+        /// </summary>
+        public ReflectionMapStrategyBase()
+        {
+            _bindingFlags = BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.FlattenHierarchy;
+        }
+
+        /// <summary>
+        /// Loops through members with the following BindingFlags:
+        /// Instance | Public | FlattenHierarchy | NonPublic (optional)
+        /// </summary>
+        /// <param name="publicOnly"></param>
+        public ReflectionMapStrategyBase(bool publicOnly)
+        {
+            if (publicOnly)
+            {
+                _bindingFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy;
+            }
+            else
+            {
+                _bindingFlags = BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.FlattenHierarchy;
+            }
+        }
+
+        /// <summary>
+        /// Loops through members based on the passed in BindingFlags.
+        /// </summary>
+        /// <param name="bindingFlags"></param>
+        public ReflectionMapStrategyBase(BindingFlags bindingFlags)
+        {
+            _bindingFlags = bindingFlags;
+        }
+
+        public string MapTable(Type entityType)
+        {
+            object[] atts = entityType.GetCustomAttributes(typeof(TableAttribute), true);
+            if (atts.Length > 0)
+            {
+                return (atts[0] as TableAttribute).Name;
+            }
+            else
+            {
+                return entityType.Name;
+            }
+        }
+
+        /// <summary>
+        /// Implements IMapStrategy.
+        /// Loops through filtered members and calls the virtual "CreateColumnMap" void for each member.
+        /// Subclasses can override CreateColumnMap to customize adding ColumnMaps.
+        /// </summary>
+        /// <param name="entityType"></param>
+        /// <returns></returns>
+        public ColumnMapCollection MapColumns(Type entityType)
+        {
+            ColumnMapCollection columnMaps = new ColumnMapCollection();
+
+            MemberInfo[] members = entityType.GetMembers(_bindingFlags);
+            foreach (var member in members)
+            {
+                ColumnAttribute columnAtt = GetColumnAttribute(member);
+                CreateColumnMap(entityType, member, columnAtt, columnMaps);
+            }
+            
+            return columnMaps;
+        }
+
+        public RelationshipCollection MapRelationships(Type entityType)
+        {
+            RelationshipCollection relationships = new RelationshipCollection();
+
+            MemberInfo[] members = entityType.GetMembers(_bindingFlags);
+            foreach (MemberInfo member in members)
+            {
+                RelationshipAttribute relationshipAtt = GetRelationshipAttribute(member);
+                CreateRelationship(entityType, member, relationshipAtt, relationships);
+            }
+
+            return relationships;
+        }
+
+        protected ColumnAttribute GetColumnAttribute(MemberInfo member)
+        {
+            if (member.IsDefined(typeof(ColumnAttribute), false))
+            {
+                return (ColumnAttribute)member.GetCustomAttributes(typeof(ColumnAttribute), false)[0];
+            }
+
+            return null;
+        }
+
+        protected RelationshipAttribute GetRelationshipAttribute(MemberInfo member)
+        {
+            if (member.IsDefined(typeof(RelationshipAttribute), false))
+            {
+                return (RelationshipAttribute)member.GetCustomAttributes(typeof(RelationshipAttribute), false)[0];
+            }
+
+            return null;
+        }
+        
+        /// <summary>
+        /// Inspect a member and optionally add a ColumnMap.
+        /// </summary>
+        /// <param name="entityType">The entity type that is being mapped.</param>
+        /// <param name="member">The member that is being mapped.</param>
+        /// <param name="columnMaps">The ColumnMapCollection that is being created.</param>
+        protected abstract void CreateColumnMap(Type entityType, MemberInfo member, ColumnAttribute columnAtt, ColumnMapCollection columnMaps);
+
+        /// <summary>
+        /// Inspect a member and optionally add a Relationship.
+        /// </summary>
+        /// <param name="entityType">The entity that is being mapped.</param>
+        /// <param name="member">The current member that is being inspected.</param>
+        /// <param name="relationshipAtt">A RelationshipAttribute (is null if one does not exist).</param>
+        /// <param name="relationships">A list of Relationships.</param>
+        protected abstract void CreateRelationship(Type entityType, MemberInfo member, RelationshipAttribute relationshipAtt, RelationshipCollection relationships);
+    }
+}

Marr.Data/Mapping/TableAttribute.cs

@@ -0,0 +1,43 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Marr.Data.Mapping
+{
+    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
+    public class TableAttribute : Attribute
+    {
+        private string _name;
+
+        public TableAttribute()
+        {
+        }
+
+        public TableAttribute(string name)
+        {
+            _name = name;
+        }
+
+        public string Name
+        {
+            get { return _name; }
+            set { _name = value; }
+        }
+    }
+}

Marr.Data/Mapping/TableBuilder.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Marr.Data.Mapping
+{
+    /// <summary>
+    /// This class has fluent methods that are used to easily configure the table mapping.
+    /// </summary>
+    public class TableBuilder<TEntity>
+    {
+        private FluentMappings.MappingsFluentEntity<TEntity> _fluentEntity;
+
+        public TableBuilder(FluentMappings.MappingsFluentEntity<TEntity> fluentEntity)
+        {
+            _fluentEntity = fluentEntity;
+        }
+
+        #region - Fluent Methods -
+
+        public TableBuilder<TEntity> SetTableName(string tableName)
+        {
+            MapRepository.Instance.Tables[typeof(TEntity)] = tableName;
+            return this;
+        }
+
+        public FluentMappings.MappingsFluentColumns<TEntity> Columns
+        {
+            get
+            {
+                if (_fluentEntity == null)
+                {
+                    throw new Exception("This property is not compatible with the obsolete 'MapBuilder' class.");
+                }
+
+                return _fluentEntity.Columns;
+            }
+        }
+
+        public FluentMappings.MappingsFluentRelationships<TEntity> Relationships
+        {
+            get
+            {
+                if (_fluentEntity == null)
+                {
+                    throw new Exception("This property is not compatible with the obsolete 'MapBuilder' class.");
+                }
+
+                return _fluentEntity.Relationships;
+            }
+        }
+
+        public FluentMappings.MappingsFluentEntity<TNewEntity> Entity<TNewEntity>()
+        {
+            return new FluentMappings.MappingsFluentEntity<TNewEntity>(true);
+        }
+
+        #endregion
+    }
+}

Marr.Data/Marr.Data.csproj

@@ -0,0 +1,164 @@
+<?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>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{F6FC6BE7-0847-4817-A1ED-223DC647C3D7}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Marr.Data</RootNamespace>
+    <AssemblyName>Marr.Data</AssemblyName>
+    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <SccProjectName>SAK</SccProjectName>
+    <SccLocalPath>SAK</SccLocalPath>
+    <SccAuxPath>SAK</SccAuxPath>
+    <SccProvider>SAK</SccProvider>
+    <FileUpgradeFlags>
+    </FileUpgradeFlags>
+    <OldToolsVersion>3.5</OldToolsVersion>
+    <UpgradeBackupLocation />
+    <TargetFrameworkProfile />
+  </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="FastReflection">
+      <HintPath>..\Libraries\FastReflection\FastReflection.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Data.DataSetExtensions">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Converters\BooleanIntConverter.cs" />
+    <Compile Include="Converters\BooleanYNConverter.cs" />
+    <Compile Include="Converters\CastConverter.cs" />
+    <Compile Include="Converters\ConversionException.cs" />
+    <Compile Include="Converters\EnumIntConverter.cs" />
+    <Compile Include="Converters\EnumStringConverter.cs" />
+    <Compile Include="Converters\IConverter.cs" />
+    <Compile Include="DataHelper.cs" />
+    <Compile Include="DataMapper.cs" />
+    <Compile Include="DataMappingException.cs" />
+    <Compile Include="EntityGraph.cs" />
+    <Compile Include="EntityMerger.cs" />
+    <Compile Include="EntityReference.cs" />
+    <Compile Include="ExtensionMethods.cs" />
+    <Compile Include="GroupingKeyCollection.cs" />
+    <Compile Include="IDataMapper.cs" />
+    <Compile Include="LazyLoaded.cs" />
+    <Compile Include="Mapping\FluentMappings.cs" />
+    <Compile Include="UnitOfWork.cs" />
+    <Compile Include="UnitOfWorkSharedContext.cs" />
+    <Compile Include="Mapping\ColumnMapBuilder.cs" />
+    <Compile Include="Mapping\MapBuilder.cs" />
+    <Compile Include="Mapping\RelationshipBuilder.cs" />
+    <Compile Include="Mapping\RelationshipInfo.cs" />
+    <Compile Include="Mapping\Strategies\AttributeMapStrategy.cs" />
+    <Compile Include="Mapping\ColumnAttribute.cs" />
+    <Compile Include="Mapping\ColumnInfo.cs" />
+    <Compile Include="Mapping\ColumnMap.cs" />
+    <Compile Include="Mapping\ColumnMapCollection.cs" />
+    <Compile Include="Mapping\Strategies\ConventionMapStrategy.cs" />
+    <Compile Include="Mapping\Strategies\PropertyMapStrategy.cs" />
+    <Compile Include="Mapping\Strategies\ReflectionMapStrategyBase.cs" />
+    <Compile Include="Mapping\EnumConversionType.cs" />
+    <Compile Include="Mapping\IColumnInfo.cs" />
+    <Compile Include="Mapping\IRelationshipInfo.cs" />
+    <Compile Include="Mapping\MappingHelper.cs" />
+    <Compile Include="Mapping\Relationship.cs" />
+    <Compile Include="Mapping\RelationshipAttribute.cs" />
+    <Compile Include="Mapping\RelationshipCollection.cs" />
+    <Compile Include="Mapping\Strategies\IMapStrategy.cs" />
+    <Compile Include="Mapping\TableAttribute.cs" />
+    <Compile Include="Mapping\TableBuilder.cs" />
+    <Compile Include="MapRepository.cs" />
+    <Compile Include="Parameters\DbTypeBuilder.cs" />
+    <Compile Include="Parameters\IDbTypeBuilder.cs" />
+    <Compile Include="Parameters\OleDbTypeBuilder.cs" />
+    <Compile Include="Parameters\ParameterChainMethods.cs" />
+    <Compile Include="Parameters\SqlDbTypeBuilder.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="QGen\DeleteQuery.cs" />
+    <Compile Include="QGen\Dialects\Dialect.cs" />
+    <Compile Include="QGen\Dialects\FirebirdDialect.cs" />
+    <Compile Include="QGen\Dialects\OracleDialect.cs" />
+    <Compile Include="QGen\Dialects\SqliteDialect.cs" />
+    <Compile Include="QGen\Dialects\SqlServerCeDialect.cs" />
+    <Compile Include="QGen\Dialects\SqlServerDialect.cs" />
+    <Compile Include="QGen\ExpressionVisitor.cs" />
+    <Compile Include="QGen\InsertQuery.cs" />
+    <Compile Include="QGen\InsertQueryBuilder.cs" />
+    <Compile Include="QGen\IQuery.cs" />
+    <Compile Include="QGen\IQueryBuilder.cs" />
+    <Compile Include="QGen\JoinBuilder.cs" />
+    <Compile Include="QGen\PagingQueryDecorator.cs" />
+    <Compile Include="QGen\QueryBuilder.cs" />
+    <Compile Include="QGen\QueryFactory.cs" />
+    <Compile Include="QGen\QueryQueueItem.cs" />
+    <Compile Include="QGen\RowCountQueryDecorator.cs" />
+    <Compile Include="QGen\SelectQuery.cs" />
+    <Compile Include="QGen\SortBuilder.cs" />
+    <Compile Include="QGen\SortColumn.cs" />
+    <Compile Include="QGen\Table.cs" />
+    <Compile Include="QGen\TableCollection.cs" />
+    <Compile Include="QGen\UpdateQuery.cs" />
+    <Compile Include="QGen\UpdateQueryBuilder.cs" />
+    <Compile Include="QGen\View.cs" />
+    <Compile Include="QGen\WhereBuilder.cs" />
+    <Compile Include="Reflection\IReflectionStrategy.cs" />
+    <Compile Include="Reflection\SimpleReflectionStrategy.cs" />
+    <Compile Include="Reflection\CachedReflectionStrategy.cs" />
+    <Compile Include="Reflection\ReflectionHelper.cs" />
+    <Compile Include="SqlModesEnum.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <Folder Include="NuGet\Tools\" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="NuGet\NuGet.exe" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="NuGet\marrdatamapper.nuspec" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PostBuildEvent>
+    </PostBuildEvent>
+  </PropertyGroup>
+  <PropertyGroup>
+    <PreBuildEvent>
+    </PreBuildEvent>
+  </PropertyGroup>
+  <!-- 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>

Marr.Data/NuGet/marrdatamapper.nuspec

@@ -0,0 +1,20 @@
+<?xml version="1.0"?>
+<package xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <metadata xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
+    <id>MarrDataMapper</id>
+    <version>
+      3.17.4747.34302
+    </version>
+    <authors>Jordan Marr</authors>
+    <requireLicenseAcceptance>true</requireLicenseAcceptance>
+    <description>Marr Data Mapper is a Linq enabled ORM that allows you to project views into complex object graphs. Contributors: Rick Schott, vitidev.</description>
+     <language>en-US</language>
+    <projectUrl>http://marrdatamapper.codeplex.com/</projectUrl>
+    <licenseUrl>http://marrdatamapper.codeplex.com/license</licenseUrl>
+    <tags>ORM data mapper fluent linq sql relational database DAL entity</tags>
+  </metadata>
+  <files>
+     <file src="bin\Release\*.dll" target="lib" />    
+  </files>
+</package>
+

Marr.Data/Parameters/DbTypeBuilder.cs

@@ -0,0 +1,74 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Data;
+using Marr.Data.Mapping;
+
+namespace Marr.Data.Parameters
+{
+    public class DbTypeBuilder : IDbTypeBuilder
+    {
+        public Enum GetDbType(Type type)
+        {
+            if (type == typeof(String))
+                return DbType.String;
+
+            else if (type == typeof(Int32))
+                return DbType.Int32;
+
+            else if (type == typeof(Decimal))
+                return DbType.Decimal;
+
+            else if (type == typeof(DateTime))
+                return DbType.DateTime;
+
+            else if (type == typeof(Boolean))
+                return DbType.Boolean;
+
+            else if (type == typeof(Int16))
+                return DbType.Int16;
+
+            else if (type == typeof(Single))
+                return DbType.Single;
+
+            else if (type == typeof(Int64))
+                return DbType.Int64;
+
+            else if (type == typeof(Double))
+                return DbType.Double;
+
+            else if (type == typeof(Byte))
+                return DbType.Byte;
+
+            else if (type == typeof(Byte[]))
+                return DbType.Binary;
+
+            else if (type == typeof(Guid))
+                return DbType.Guid;
+
+            else
+                return DbType.Object;
+        }
+
+        public void SetDbType(System.Data.IDbDataParameter param, Enum dbType)
+        {
+            param.DbType = (DbType)dbType;
+        }
+    }
+}

Marr.Data/Parameters/IDbTypeBuilder.cs

@@ -0,0 +1,34 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Data;
+using Marr.Data.Mapping;
+
+namespace Marr.Data.Parameters
+{
+    /// <summary>
+    /// Converts from a .NET datatype to the appropriate DB type enum, 
+    /// and then adds the value to the appropriate property on the parameter.
+    /// </summary>
+    public interface IDbTypeBuilder
+    {
+        Enum GetDbType(Type type);
+        void SetDbType(IDbDataParameter param, Enum dbType);
+    }
+}

Marr.Data/Parameters/OleDbTypeBuilder.cs

@@ -0,0 +1,72 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Data.OleDb;
+using Marr.Data.Mapping;
+
+namespace Marr.Data.Parameters
+{
+    public class OleDbTypeBuilder : IDbTypeBuilder
+    {
+        public Enum GetDbType(Type type)
+        {
+            if (type == typeof(String))
+                return OleDbType.VarChar;
+
+            else if (type == typeof(Int32))
+                return OleDbType.Integer;
+
+            else if (type == typeof(Decimal))
+                return OleDbType.Decimal;
+
+            else if (type == typeof(DateTime))
+                return OleDbType.DBTimeStamp;
+
+            else if (type == typeof(Boolean))
+                return OleDbType.Boolean;
+
+            else if (type == typeof(Int16))
+                return OleDbType.SmallInt;
+
+            else if (type == typeof(Int64))
+                return OleDbType.BigInt;
+
+            else if (type == typeof(Double))
+                return OleDbType.Double;
+
+            else if (type == typeof(Byte))
+                return OleDbType.Binary;
+
+            else if (type == typeof(Byte[]))
+                return OleDbType.VarBinary;
+
+            else if (type == typeof(Guid))
+                return OleDbType.Guid;
+
+            else
+                return OleDbType.Variant;
+        }
+
+        public void SetDbType(System.Data.IDbDataParameter param, Enum dbType)
+        {
+            var oleDbParam = (OleDbParameter)param;
+            oleDbParam.OleDbType = (OleDbType)dbType;
+        }
+    }
+}

Marr.Data/Parameters/ParameterChainMethods.cs

@@ -0,0 +1,124 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Data;
+using System.Data.Common;
+using Marr.Data.Converters;
+
+namespace Marr.Data.Parameters
+{
+    /// <summary>
+    /// This class allows chaining methods to be called for convenience when adding a parameter.
+    /// </summary>
+    public class ParameterChainMethods
+    {
+        /// <summary>
+        /// Creates a new parameter and adds it to the command's Parameters collection.
+        /// </summary>
+        /// <param name="command">The command that the parameter will be added to.</param>
+        /// <param name="parameterName">The parameter name.</param>
+        public ParameterChainMethods(DbCommand command, string parameterName, object value)
+        {
+            Parameter = command.CreateParameter();
+            Parameter.ParameterName = parameterName;
+
+            // Convert null to DBNull.Value
+            if (value == null) 
+                value = DBNull.Value;
+
+            Type valueType = value.GetType();
+
+            // Check for a registered IConverter
+            IConverter converter = MapRepository.Instance.GetConverter(valueType);
+            if (converter != null)
+            {
+                Parameter.Value = converter.ToDB(value);
+            }
+            else
+            {
+                Parameter.Value = value;
+            } 
+
+            //// Determine the correct DbType based on the passed in value type
+            //IDbTypeBuilder typeBuilder = MapRepository.Instance.DbTypeBuilder;
+            //Enum dbType = typeBuilder.GetDbType(valueType);
+
+            //// Set the appropriate DbType property depending on the parameter type
+            //typeBuilder.SetDbType(Parameter, dbType);
+
+            command.Parameters.Add(Parameter);
+        }
+
+        /// <summary>
+        /// Gets a reference to the parameter.
+        /// </summary>
+        public IDbDataParameter Parameter { get; private set; }
+
+        /// <summary>
+        /// Sets the direction of a parameter.
+        /// </summary>
+        /// <param name="direction">Determines the direction of a parameter.</param>
+        /// <returns>Return a ParameterChainMethods object.</returns>
+        public ParameterChainMethods Direction(ParameterDirection direction)
+        {
+            Parameter.Direction = direction;
+            return this;
+        }
+
+        /// <summary>
+        /// Sets the direction of a parameter to 'Output'.
+        /// </summary>
+        /// <returns></returns>
+        public ParameterChainMethods Output()
+        {
+            Parameter.Direction = ParameterDirection.Output;
+            return this;
+        }
+
+        public ParameterChainMethods DBType(DbType dbType)
+        {
+            Parameter.DbType = dbType;
+            return this;
+        }
+
+        public ParameterChainMethods Size(int size)
+        {
+            Parameter.Size = size;
+            return this;
+        }
+
+        public ParameterChainMethods Precision(byte precision)
+        {
+            Parameter.Precision = precision;
+            return this;
+        }
+
+        public ParameterChainMethods Scale(byte scale)
+        {
+            Parameter.Scale = scale;
+            return this;
+        }
+        
+        public ParameterChainMethods Name(string name)
+        {
+            Parameter.ParameterName = name;
+            return this;
+        }
+    }
+}

Marr.Data/Parameters/SqlDbTypeBuilder.cs

@@ -0,0 +1,76 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Data;
+using System.Data.SqlClient;
+using Marr.Data.Mapping;
+
+namespace Marr.Data.Parameters
+{
+    public class SqlDbTypeBuilder : IDbTypeBuilder
+    {
+        public Enum GetDbType(Type type)
+        {
+            if (type == typeof(String))
+                return SqlDbType.VarChar;
+
+            else if (type == typeof(Int32))
+                return SqlDbType.Int;
+
+            else if (type == typeof(Decimal))
+                return SqlDbType.Decimal;
+
+            else if (type == typeof(DateTime))
+                return SqlDbType.DateTime;
+
+            else if (type == typeof(Boolean))
+                return SqlDbType.Bit;
+
+            else if (type == typeof(Int16))
+                return SqlDbType.SmallInt;
+
+            else if (type == typeof(Int64))
+                return SqlDbType.BigInt;
+
+            else if (type == typeof(Double))
+                return SqlDbType.Float;
+
+            else if (type == typeof(Char))
+                return SqlDbType.Char;
+
+            else if (type == typeof(Byte))
+                return SqlDbType.Binary;
+
+            else if (type == typeof(Byte[]))
+                return SqlDbType.VarBinary;
+
+            else if (type == typeof(Guid))
+                return SqlDbType.UniqueIdentifier;
+
+            else
+                return SqlDbType.Variant;
+        }
+
+        public void SetDbType(System.Data.IDbDataParameter param, Enum dbType)
+        {
+            var sqlDbParam = (SqlParameter)param;
+            sqlDbParam.SqlDbType = (SqlDbType)dbType;
+        }
+    }
+}

Marr.Data/Properties/AssemblyInfo.cs

@@ -0,0 +1,41 @@
+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("Marr.Data")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Marr.Data")]
+[assembly: AssemblyCopyright("Copyright ©  2011")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Share internals
+[assembly: InternalsVisibleTo("Marr.Data.Relationships")]
+[assembly: InternalsVisibleTo("Marr.Data.Tests")]
+
+
+// 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("6864f4d2-cd0f-4720-9c15-3085f1aa8293")]
+
+// 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("3.17.*")]
+[assembly: AssemblyInformationalVersion("3.17")]

Marr.Data/QGen/DeleteQuery.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Marr.Data.Mapping;
+using System.Data.Common;
+
+namespace Marr.Data.QGen
+{
+    /// <summary>
+    /// This class creates a SQL delete query.
+    /// </summary>
+    public class DeleteQuery : IQuery
+    {
+        protected Table TargetTable { get; set; }
+        protected string WhereClause { get; set; }
+        protected Dialects.Dialect Dialect { get; set; }
+
+        public DeleteQuery(Dialects.Dialect dialect, Table targetTable, string whereClause)
+        {
+            Dialect = dialect;
+            TargetTable = targetTable;
+            WhereClause = whereClause;
+        }
+
+        public string Generate()
+        {
+            return string.Format("DELETE FROM {0} {1} ",
+                Dialect.CreateToken(TargetTable.Name), 
+                WhereClause);
+        }
+    }
+}

Marr.Data/QGen/Dialects/Dialect.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Marr.Data.QGen.Dialects
+{
+    public class Dialect
+    {
+        /// <summary>
+        /// The default token is surrounded by brackets.
+        /// </summary>
+        /// <param name="token"></param>
+        public virtual string CreateToken(string token)
+        {
+            if (string.IsNullOrEmpty(token))
+            {
+                return string.Empty;
+            }
+
+            string[] parts = token.Replace('[', new Char()).Replace(']', new Char()).Split('.');
+
+            StringBuilder sb = new StringBuilder();
+            foreach (string part in parts)
+            {
+                if (sb.Length > 0)
+                    sb.Append(".");
+
+                sb.Append("[").Append(part).Append("]");
+            }
+
+            return sb.ToString();
+        }
+
+        public virtual string IdentityQuery
+        {
+            get
+            {
+                return null;
+            }
+        }
+
+        public bool HasIdentityQuery
+        {
+            get
+            {
+                return !string.IsNullOrEmpty(IdentityQuery);
+            }
+        }
+
+        public virtual bool SupportsBatchQueries
+        {
+            get
+            {
+                return true;
+            }
+        }
+    }
+}

Marr.Data/QGen/Dialects/FirebirdDialect.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Marr.Data.QGen.Dialects
+{
+    public class FirebirdDialect : Dialect
+    {
+        public override string CreateToken(string token)
+        {
+            if (string.IsNullOrEmpty(token))
+            {
+                return string.Empty;
+            }
+
+            return token.Replace('[', new Char()).Replace(']', new Char());
+        }
+    }
+}

Marr.Data/QGen/Dialects/OracleDialect.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Marr.Data.QGen.Dialects
+{
+    public class OracleDialect : Dialect
+    {
+        public override string CreateToken(string token)
+        {
+            if (string.IsNullOrEmpty(token))
+            {
+                return string.Empty;
+            }
+
+            string[] parts = token.Replace('[', new Char()).Replace(']', new Char()).Split('.');
+
+            StringBuilder sb = new StringBuilder();
+            foreach (string part in parts)
+            {
+                if (sb.Length > 0)
+                    sb.Append(".");
+
+                bool hasSpaces = part.Contains(' ');
+
+                if (hasSpaces)
+                    sb.Append("[").Append(part).Append("]");
+                else
+                    sb.Append(part);
+            }
+
+            return sb.ToString();
+        }
+    }
+}

Marr.Data/QGen/Dialects/SqlServerCeDialect.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Marr.Data.QGen.Dialects
+{
+    public class SqlServerCeDialect : Dialect
+    {
+        public override string IdentityQuery
+        {
+            get
+            {
+                return "SELECT @@IDENTITY;";
+            }
+        }
+
+        public override bool SupportsBatchQueries
+        {
+            get
+            {
+                return false;
+            }
+        }
+    }
+}

Marr.Data/QGen/Dialects/SqlServerDialect.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Marr.Data.QGen.Dialects
+{
+    public class SqlServerDialect : Dialect
+    {
+        public override string IdentityQuery
+        {
+            get
+            {
+                return "SELECT SCOPE_IDENTITY();";
+            }
+        }
+    }
+}

Marr.Data/QGen/Dialects/SqliteDialect.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Marr.Data.QGen.Dialects
+{
+    public class SqliteDialect : Dialect
+    {
+        public override string IdentityQuery
+        {
+            get
+            {
+                return "SELECT last_insert_rowid();";
+            }
+        }
+    }
+}

Marr.Data/QGen/ExpressionVisitor.cs

@@ -0,0 +1,149 @@
+/* This class was copied from Mehfuz's LinqExtender project, which is available from github.
+ * http://mehfuzh.github.com/LinqExtender/
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Linq.Expressions;
+
+namespace Marr.Data.QGen
+{
+    ///<summary>
+    /// Expression visitor 
+    ///</summary>
+    public class ExpressionVisitor
+    {
+        /// <summary>
+        /// Visits expression and delegates call to different to branch.
+        /// </summary>
+        /// <param name="expression"></param>
+        /// <returns></returns>
+        protected virtual Expression Visit(Expression expression)
+        {
+            if (expression == null)
+                return null;
+
+            switch (expression.NodeType)
+            {
+                case ExpressionType.Lambda:
+                    return VisitLamda((LambdaExpression)expression);
+                case ExpressionType.ArrayLength:
+                case ExpressionType.Convert:
+                case ExpressionType.ConvertChecked:
+                case ExpressionType.Negate:
+                case ExpressionType.UnaryPlus:
+                case ExpressionType.NegateChecked:
+                case ExpressionType.Not:
+                case ExpressionType.Quote:
+                case ExpressionType.TypeAs:
+                    return this.VisitUnary((UnaryExpression)expression);
+                case ExpressionType.Add:
+                case ExpressionType.AddChecked:
+                case ExpressionType.And:
+                case ExpressionType.AndAlso:
+                case ExpressionType.ArrayIndex:
+                case ExpressionType.Coalesce:
+                case ExpressionType.Divide:
+                case ExpressionType.Equal:
+                case ExpressionType.ExclusiveOr:
+                case ExpressionType.GreaterThan:
+                case ExpressionType.GreaterThanOrEqual:
+                case ExpressionType.LeftShift:
+                case ExpressionType.LessThan:
+                case ExpressionType.LessThanOrEqual:
+                case ExpressionType.Modulo:
+                case ExpressionType.Multiply:
+                case ExpressionType.MultiplyChecked:
+                case ExpressionType.NotEqual:
+                case ExpressionType.Or:
+                case ExpressionType.OrElse:
+                case ExpressionType.Power:
+                case ExpressionType.RightShift:
+                case ExpressionType.Subtract:
+                case ExpressionType.SubtractChecked:
+                    return this.VisitBinary((BinaryExpression)expression);
+                case ExpressionType.Call:
+                    return this.VisitMethodCall((MethodCallExpression)expression);
+                case ExpressionType.Constant:
+                    return this.VisitConstant((ConstantExpression)expression);
+                case ExpressionType.MemberAccess:
+                    return this.VisitMemberAccess((MemberExpression)expression);
+                case ExpressionType.Parameter:
+                    return this.VisitParameter((ParameterExpression)expression);
+
+            }
+            throw new ArgumentOutOfRangeException("expression", expression.NodeType.ToString());
+        }
+
+        /// <summary>
+        /// Visits the constance expression. To be implemented by user.
+        /// </summary>
+        /// <param name="expression"></param>
+        /// <returns></returns>
+        protected virtual Expression VisitConstant(ConstantExpression expression)
+        {
+            return expression;
+        }
+
+        /// <summary>
+        /// Visits the memeber access expression. To be implemented by user.
+        /// </summary>
+        /// <param name="expression"></param>
+        /// <returns></returns>
+        protected virtual Expression VisitMemberAccess(MemberExpression expression)
+        {
+            return expression;
+        }
+
+        /// <summary>
+        /// Visits the method call expression. To be implemented by user.
+        /// </summary>
+        /// <param name="expression"></param>
+        /// <returns></returns>
+        protected virtual Expression VisitMethodCall(MethodCallExpression expression)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Visits the binary expression.
+        /// </summary>
+        /// <param name="expression"></param>
+        /// <returns></returns>
+        protected virtual Expression VisitBinary(BinaryExpression expression)
+        {
+            this.Visit(expression.Left);
+            this.Visit(expression.Right);
+            return expression;
+        }
+
+        /// <summary>
+        /// Visits the unary expression.
+        /// </summary>
+        /// <param name="expression"></param>
+        /// <returns></returns>
+        protected virtual Expression VisitUnary(UnaryExpression expression)
+        {
+            this.Visit(expression.Operand);
+            return expression;
+        }
+
+        /// <summary>
+        /// Visits the lamda expression.
+        /// </summary>
+        /// <param name="lambdaExpression"></param>
+        /// <returns></returns>
+        protected virtual Expression VisitLamda(LambdaExpression lambdaExpression)
+        {
+            this.Visit(lambdaExpression.Body);
+            return lambdaExpression;
+        }
+
+        private Expression VisitParameter(ParameterExpression expression)
+        {
+            return expression;
+        }
+    }
+}

Marr.Data/QGen/IQuery.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Marr.Data.QGen
+{
+    internal interface IQuery
+    {
+        /// <summary>
+        /// Generates a SQL query for a given entity.
+        /// </summary>
+        /// <returns></returns>
+        string Generate();
+    }
+}

Marr.Data/QGen/IQueryBuilder.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Marr.Data.QGen
+{
+    public interface IQueryBuilder
+    {
+        string BuildQuery();
+    }
+
+    public interface ISortQueryBuilder : IQueryBuilder
+    {
+        string BuildQuery(bool useAltNames);
+    }
+}

Marr.Data/QGen/InsertQuery.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Marr.Data.Mapping;
+using System.Data.Common;
+using Marr.Data.QGen.Dialects;
+
+namespace Marr.Data.QGen
+{
+    /// <summary>
+    /// This class creates an insert query.
+    /// </summary>
+    public class InsertQuery : IQuery
+    {
+        protected Dialect Dialect { get; set; }
+        protected string Target { get; set; }
+        protected ColumnMapCollection Columns { get; set; }
+        protected DbCommand Command { get; set; }
+
+        public InsertQuery(Dialect dialect, ColumnMapCollection columns, DbCommand command, string target)
+        {
+            if (string.IsNullOrEmpty(target))
+            {
+                throw new DataMappingException("A target table must be passed in or set in a TableAttribute.");
+            }
+            Dialect = dialect;
+            Target = target;
+            Columns = columns;
+            Command = command;
+        }
+
+        public virtual string Generate()
+        {
+            StringBuilder sql = new StringBuilder();
+            StringBuilder values = new StringBuilder(") VALUES (");
+
+            sql.AppendFormat("INSERT INTO {0} (", Dialect.CreateToken(Target));
+
+            int sqlStartIndex = sql.Length;
+            int valuesStartIndex = values.Length;
+
+            foreach (DbParameter p in Command.Parameters)
+            {
+                var c = Columns.GetByColumnName(p.ParameterName);
+
+                if (c == null)
+                    break; // All insert columns have been added
+
+                if (sql.Length > sqlStartIndex)
+                    sql.Append(",");
+
+                if (values.Length > valuesStartIndex)
+                    values.Append(",");
+
+                if (!c.ColumnInfo.IsAutoIncrement)
+                {
+                    sql.AppendFormat(Dialect.CreateToken(c.ColumnInfo.Name));
+                    values.AppendFormat("{0}{1}", Command.ParameterPrefix(), p.ParameterName);
+                }
+            }
+
+            values.Append(")");
+
+            sql.Append(values);
+
+            return sql.ToString();
+        }
+    }
+}

Marr.Data/QGen/InsertQueryBuilder.cs

@@ -0,0 +1,204 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Marr.Data.Mapping;
+using System.Linq.Expressions;
+
+namespace Marr.Data.QGen
+{
+    public class InsertQueryBuilder<T> : IQueryBuilder
+    {
+        private DataMapper _db;
+        private string _tableName;
+        private T _entity;
+        private MappingHelper _mappingHelper;
+        private ColumnMapCollection _mappings;
+        private SqlModes _previousSqlMode;
+        private bool _generateQuery = true;
+        private bool _getIdentityValue;
+        private Dialects.Dialect _dialect;
+        private ColumnMapCollection _columnsToInsert;
+
+        public InsertQueryBuilder()
+        {
+            // Used only for unit testing with mock frameworks
+        }
+
+        public InsertQueryBuilder(DataMapper db)
+        {
+            _db = db;
+            _tableName = MapRepository.Instance.GetTableName(typeof(T));
+            _previousSqlMode = _db.SqlMode;
+            _mappingHelper = new MappingHelper(_db);
+            _mappings = MapRepository.Instance.GetColumns(typeof(T));
+            _dialect = QueryFactory.CreateDialect(_db);
+        }
+
+        public virtual InsertQueryBuilder<T> TableName(string tableName)
+        {
+            _tableName = tableName;
+            return this;
+        }
+
+        public virtual InsertQueryBuilder<T> QueryText(string queryText)
+        {
+            _generateQuery = false;
+            _db.Command.CommandText = queryText;
+            return this;
+        }
+
+        public virtual InsertQueryBuilder<T> Entity(T entity)
+        {
+            _entity = entity;
+            return this;
+        }
+
+        /// <summary>
+        /// Runs an identity query to get the value of an autoincrement field.
+        /// </summary>
+        /// <returns></returns>
+        public virtual InsertQueryBuilder<T> GetIdentity()
+        {
+            if (!_dialect.HasIdentityQuery)
+            {
+                string err = string.Format("The current dialect '{0}' does not have an identity query implemented.", _dialect.ToString());
+                throw new DataMappingException(err);
+            }
+
+            _getIdentityValue = true;
+            return this;
+        }
+
+        public virtual InsertQueryBuilder<T> ColumnsIncluding(params Expression<Func<T, object>>[] properties)
+        {
+            List<string> columnList = new List<string>();
+
+            foreach (var column in properties)
+            {
+                columnList.Add(column.GetMemberName());
+            }
+
+            return ColumnsIncluding(columnList.ToArray());
+        }
+
+        public virtual InsertQueryBuilder<T> ColumnsIncluding(params string[] properties)
+        {
+            _columnsToInsert = new ColumnMapCollection();
+
+            foreach (string propertyName in properties)
+            {
+                _columnsToInsert.Add(_mappings.GetByFieldName(propertyName));
+            }
+
+            return this;
+        }
+
+        public virtual InsertQueryBuilder<T> ColumnsExcluding(params Expression<Func<T, object>>[] properties)
+        {
+            List<string> columnList = new List<string>();
+
+            foreach (var column in properties)
+            {
+                columnList.Add(column.GetMemberName());
+            }
+
+            return ColumnsExcluding(columnList.ToArray());
+        }
+
+        public virtual InsertQueryBuilder<T> ColumnsExcluding(params string[] properties)
+        {
+            _columnsToInsert = new ColumnMapCollection();
+
+            _columnsToInsert.AddRange(_mappings);
+
+            foreach (string propertyName in properties)
+            {
+                _columnsToInsert.RemoveAll(c => c.FieldName == propertyName);
+            }
+
+            return this;
+        }
+
+        public virtual object Execute()
+        {
+            if (_generateQuery)
+            {
+                BuildQuery();
+            }
+            else
+            {
+                TryAppendIdentityQuery();
+                _mappingHelper.CreateParameters<T>(_entity, _mappings.NonReturnValues, _generateQuery);
+            }
+
+            object scalar = null;
+
+            try
+            {
+                _db.OpenConnection();
+
+                scalar = _db.Command.ExecuteScalar();
+
+                if (_getIdentityValue && !_dialect.SupportsBatchQueries)
+                {
+                    // Run identity query as a separate query
+                    _db.Command.CommandText = _dialect.IdentityQuery;
+                    scalar = _db.Command.ExecuteScalar();
+                }
+
+                _mappingHelper.SetOutputValues<T>(_entity, _mappings.OutputFields);
+                if (scalar != null)
+                {
+                    _mappingHelper.SetOutputValues<T>(_entity, _mappings.ReturnValues, scalar);
+                }
+            }
+            finally
+            {
+                _db.CloseConnection();
+            }
+
+            
+            if (_generateQuery)
+            {
+                // Return to previous sql mode
+                _db.SqlMode = _previousSqlMode;
+            }
+
+            return scalar;
+        }
+
+        public virtual string BuildQuery()
+        {
+            if (_entity == null)
+                throw new ArgumentNullException("You must specify an entity to insert.");
+
+            // Override SqlMode since we know this will be a text query
+            _db.SqlMode = SqlModes.Text;
+
+            var columns = _columnsToInsert ?? _mappings;
+
+            _mappingHelper.CreateParameters<T>(_entity, columns, _generateQuery);
+            IQuery query = QueryFactory.CreateInsertQuery(columns, _db, _tableName);
+
+            _db.Command.CommandText = query.Generate();
+
+            TryAppendIdentityQuery();
+
+            return _db.Command.CommandText;
+        }
+
+        private void TryAppendIdentityQuery()
+        {
+            if (_getIdentityValue && _dialect.SupportsBatchQueries)
+            {
+                // Append a batched identity query
+                if (!_db.Command.CommandText.EndsWith(";"))
+                {
+                    _db.Command.CommandText += ";";
+                }
+                _db.Command.CommandText += _dialect.IdentityQuery;
+            }
+        }
+    }
+}

Marr.Data/QGen/JoinBuilder.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Data.Common;
+using Marr.Data.QGen.Dialects;
+using System.Linq.Expressions;
+
+namespace Marr.Data.QGen
+{
+    /// <summary>
+    /// This class overrides the WhereBuilder which utilizes the ExpressionVisitor base class, 
+    /// and it is responsible for translating the lambda expression into a "JOIN ON" clause.
+    /// It populates the protected string builder, which outputs the "JOIN ON" clause when the ToString method is called.
+    /// </summary>
+    /// <typeparam name="T">The entity that is on the left side of the join.</typeparam>
+    /// <typeparam name="T2">The entity that is on the right side of the join.</typeparam>
+    public class JoinBuilder<T, T2> : WhereBuilder<T>
+    {
+        public JoinBuilder(DbCommand command, Dialect dialect, Expression<Func<T, T2, bool>> filter, TableCollection tables)
+            : base(command, dialect, filter.Body, tables, false, true)
+        { }
+
+        protected override string PrefixText
+        {
+            get
+            {
+                return "ON";
+            }
+        }
+
+        protected override Expression VisitMemberAccess(MemberExpression expression)
+        {
+            string fqColumn = GetFullyQualifiedColumnName(expression.Member, expression.Expression.Type);
+            _sb.Append(fqColumn);
+            return expression;
+        }
+    }
+}

Marr.Data/QGen/PagingQueryDecorator.cs

@@ -0,0 +1,239 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Marr.Data.Mapping;
+using Marr.Data.QGen.Dialects;
+
+namespace Marr.Data.QGen
+{
+    /// <summary>
+    /// Decorates the SelectQuery by wrapping it in a paging query.
+    /// </summary>
+    public class PagingQueryDecorator : IQuery
+    {
+        private SelectQuery _innerQuery;
+        private int _firstRow;
+        private int _lastRow;
+
+        public PagingQueryDecorator(SelectQuery innerQuery, int skip, int take)
+        {
+            if (string.IsNullOrEmpty(innerQuery.OrderBy.ToString()))
+            {
+                throw new DataMappingException("A paged query must specify an order by clause.");
+            }
+
+            _innerQuery = innerQuery;
+            _firstRow = skip + 1;
+            _lastRow = skip + take;
+        }
+
+        public string Generate()
+        {
+            // Decide which type of paging query to create
+            
+            if (_innerQuery.IsView || _innerQuery.IsJoin)
+            {
+                return ComplexPaging();
+            }
+            else
+            {
+                return SimplePaging();
+            }
+        }
+
+        /// <summary>
+        /// Generates a query that pages a simple inner query.
+        /// </summary>
+        /// <returns></returns>
+        private string SimplePaging()
+        {
+            // Create paged query
+            StringBuilder sql = new StringBuilder();
+
+            sql.AppendLine("WITH RowNumCTE AS");
+            sql.AppendLine("(");
+            _innerQuery.BuildSelectClause(sql);
+            BuildRowNumberColumn(sql);
+            _innerQuery.BuildFromClause(sql);
+            _innerQuery.BuildJoinClauses(sql);
+            _innerQuery.BuildWhereClause(sql);
+            sql.AppendLine(")");
+            BuildSimpleOuterSelect(sql);
+
+            return sql.ToString();
+        }
+        
+        /// <summary>
+        /// Generates a query that pages a view or joined inner query.
+        /// </summary>
+        /// <returns></returns>
+        private string ComplexPaging()
+        {
+            // Create paged query
+            StringBuilder sql = new StringBuilder();
+
+            sql.AppendLine("WITH GroupCTE AS (");
+            BuildSelectClause(sql);
+            BuildGroupColumn(sql);
+            _innerQuery.BuildFromClause(sql);
+            _innerQuery.BuildJoinClauses(sql);
+            _innerQuery.BuildWhereClause(sql);
+            sql.AppendLine("),");
+            sql.AppendLine("RowNumCTE AS (");
+            sql.AppendLine("SELECT *");
+            BuildRowNumberColumn(sql);
+            sql.AppendLine("FROM GroupCTE");
+            sql.AppendLine("WHERE GroupRow = 1");
+            sql.AppendLine(")");
+            _innerQuery.BuildSelectClause(sql);
+            _innerQuery.BuildFromClause(sql);
+            _innerQuery.BuildJoinClauses(sql);
+            BuildJoinBackToCTE(sql);
+            sql.AppendFormat("WHERE RowNumber BETWEEN {0} AND {1}", _firstRow, _lastRow);
+
+            return sql.ToString();
+        }
+
+        private void BuildJoinBackToCTE(StringBuilder sql)
+        {
+            Table baseTable = GetBaseTable();
+            sql.AppendLine("INNER JOIN RowNumCTE cte");
+            int pksAdded = 0;
+            foreach (var pk in baseTable.Columns.PrimaryKeys)
+            {
+                if (pksAdded > 0)
+                    sql.Append(" AND ");
+
+                string cteQueryPkName = _innerQuery.NameOrAltName(pk.ColumnInfo);
+                string outerQueryPkName = _innerQuery.IsJoin ? pk.ColumnInfo.Name : _innerQuery.NameOrAltName(pk.ColumnInfo);
+                sql.AppendFormat("ON cte.{0} = {1} ", cteQueryPkName, _innerQuery.Dialect.CreateToken(string.Concat("t0", ".", outerQueryPkName)));
+                pksAdded++;
+            }
+            sql.AppendLine();
+        }
+
+        private void BuildSimpleOuterSelect(StringBuilder sql)
+        {
+            sql.Append("SELECT ");
+            int startIndex = sql.Length;
+
+            // COLUMNS
+            foreach (Table join in _innerQuery.Tables)
+            {
+                for (int i = 0; i < join.Columns.Count; i++)
+                {
+                    var c = join.Columns[i];
+
+                    if (sql.Length > startIndex)
+                        sql.Append(",");
+
+                    string token = _innerQuery.NameOrAltName(c.ColumnInfo);
+                    sql.Append(_innerQuery.Dialect.CreateToken(token));
+                }
+            }
+
+            sql.AppendLine("FROM RowNumCTE");
+            sql.AppendFormat("WHERE RowNumber BETWEEN {0} AND {1}", _firstRow, _lastRow).AppendLine();
+            sql.AppendLine("ORDER BY RowNumber ASC;");
+        }
+
+        private void BuildGroupColumn(StringBuilder sql)
+        {
+            bool isView = _innerQuery.IsView;
+            sql.AppendFormat(", ROW_NUMBER() OVER (PARTITION BY {0} {1}) As GroupRow ", BuildBaseTablePKColumns(isView), _innerQuery.OrderBy.BuildQuery(isView));
+        }
+
+        private string BuildBaseTablePKColumns(bool useAltName = true)
+        {
+            Table baseTable = GetBaseTable();
+
+            StringBuilder sb = new StringBuilder();
+            foreach (var col in baseTable.Columns.PrimaryKeys)
+            {
+                if (sb.Length > 0)
+                    sb.AppendLine(", ");
+
+                string columnName = useAltName ?
+                    _innerQuery.NameOrAltName(col.ColumnInfo) :
+                    col.ColumnInfo.Name;
+
+                sb.AppendFormat(_innerQuery.Dialect.CreateToken(string.Concat(baseTable.Alias, ".", columnName)));
+            }
+
+            return sb.ToString();
+        }
+
+        private void BuildRowNumberColumn(StringBuilder sql)
+        {
+            string orderBy = _innerQuery.OrderBy.ToString();
+            // Remove table prefixes from order columns
+            foreach (Table t in _innerQuery.Tables)
+            {
+                orderBy = orderBy.Replace(string.Format("[{0}].", t.Alias), "");
+            }
+            
+            sql.AppendFormat(", ROW_NUMBER() OVER ({0}) As RowNumber ", orderBy);
+        }
+
+        private Table GetBaseTable()
+        {
+            Table baseTable = null;
+            if (_innerQuery.Tables[0] is View)
+            {
+                baseTable = (_innerQuery.Tables[0] as View).Tables[0];
+            }
+            else
+            {
+                baseTable = _innerQuery.Tables[0];
+            }
+            return baseTable;
+        }
+
+        public void BuildSelectClause(StringBuilder sql)
+        {
+            List<string> appended = new List<string>();
+
+            sql.Append("SELECT ");
+
+            int startIndex = sql.Length;
+
+            // COLUMNS
+            foreach (Table join in _innerQuery.Tables)
+            {
+                for (int i = 0; i < join.Columns.Count; i++)
+                {
+                    var c = join.Columns[i];
+
+                    if (sql.Length > startIndex && sql[sql.Length - 1] != ',')
+                        sql.Append(",");
+
+                    if (join is View)
+                    {
+                        string token = _innerQuery.Dialect.CreateToken(string.Concat(join.Alias, ".", _innerQuery.NameOrAltName(c.ColumnInfo)));
+                        if (appended.Contains(token))
+                            continue;
+
+                        sql.Append(token);
+                        appended.Add(token);
+                    }
+                    else
+                    {
+                        string token = string.Concat(join.Alias, ".", c.ColumnInfo.Name);
+                        if (appended.Contains(token))
+                            continue;
+
+                        sql.Append(_innerQuery.Dialect.CreateToken(token));
+
+                        if (_innerQuery.UseAltName && c.ColumnInfo.AltName != null && c.ColumnInfo.AltName != c.ColumnInfo.Name)
+                        {
+                            string altName = c.ColumnInfo.AltName;
+                            sql.AppendFormat(" AS {0}", altName);
+                        }
+                    }
+                }
+            }
+        }
+
+    }
+}

Marr.Data/QGen/QueryBuilder.cs

@@ -0,0 +1,532 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Marr.Data.QGen;
+using System.Linq.Expressions;
+using System.Reflection;
+using Marr.Data.Mapping;
+using System.Data.Common;
+using System.Collections;
+
+namespace Marr.Data.QGen
+{
+    /// <summary>
+    /// This class is responsible for building a select query.
+    /// It uses chaining methods to provide a fluent interface for creating select queries.
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public class QueryBuilder<T> : ExpressionVisitor, IEnumerable<T>, IQueryBuilder
+    {
+        #region - Private Members -
+
+        private Dialects.Dialect _dialect;
+        private DataMapper _db;
+        private TableCollection _tables;
+        private WhereBuilder<T> _whereBuilder;
+        private SortBuilder<T> _sortBuilder;
+        private bool _useAltName = false;
+        private bool _isGraph = false;
+        private string _queryText;
+        private List<MemberInfo> _childrenToLoad;
+        private bool _enablePaging = false;
+        private int _skip;
+        private int _take;
+        private SortBuilder<T> SortBuilder
+        {
+            get
+            {
+                // Lazy load
+                if (_sortBuilder == null)
+                    _sortBuilder = new SortBuilder<T>(this, _db, _whereBuilder, _dialect, _tables, _useAltName);
+
+                return _sortBuilder;
+            }
+        }
+        private List<T> _results = new List<T>();
+        private EntityGraph _entityGraph;
+        private EntityGraph EntGraph
+        {
+            get
+            {
+                if (_entityGraph == null)
+                {
+                    _entityGraph = new EntityGraph(typeof(T), _results);
+                }
+
+                return _entityGraph;
+            }
+        }
+
+        #endregion
+
+        #region - Constructor -
+
+        public QueryBuilder()
+        {
+            // Used only for unit testing with mock frameworks
+        }
+
+        public QueryBuilder(DataMapper db, Dialects.Dialect dialect)
+        {
+            _db = db;
+            _dialect = dialect;
+            _tables = new TableCollection();
+            _tables.Add(new Table(typeof(T)));
+            _childrenToLoad = new List<MemberInfo>();
+        }
+
+        #endregion
+
+        #region - Fluent Methods -
+
+        /// <summary>
+        /// Overrides the base table name that will be used in the query.
+        /// </summary>
+        [Obsolete("This method is obsolete.  Use either the FromTable or FromView method instead.", true)]
+        public virtual QueryBuilder<T> From(string tableName)
+        {
+            return FromView(tableName);
+        }
+
+        /// <summary>
+        /// Overrides the base view name that will be used in the query.
+        /// Will try to use the mapped "AltName" values when loading the columns.
+        /// </summary>
+        public virtual QueryBuilder<T> FromView(string viewName)
+        {
+            if (string.IsNullOrEmpty(viewName))
+                throw new ArgumentNullException("view");
+
+            _useAltName = true;
+
+            // Replace the base table with a view with tables
+            View view = new View(viewName, _tables.ToArray());
+            _tables.ReplaceBaseTable(view);
+
+            //// Override the base table name
+            //_tables[0].Name = view;
+            return this;
+        }
+
+        /// <summary>
+        /// Overrides the base table name that will be used in the query.
+        /// Will not try to use the mapped "AltName" values when loading the  columns.
+        /// </summary>
+        public virtual QueryBuilder<T> FromTable(string table)
+        {
+            if (string.IsNullOrEmpty(table))
+                throw new ArgumentNullException("view");
+
+            _useAltName = false;
+
+            // Override the base table name
+            _tables[0].Name = table;
+            return this;
+        }
+
+        /// <summary>
+        /// Allows you to manually specify the query text.
+        /// </summary>
+        public virtual QueryBuilder<T> QueryText(string queryText)
+        {
+            _queryText = queryText;
+            return this;
+        }
+
+        /// <summary>
+        /// If no parameters are passed in, this method instructs the DataMapper to load all related entities in the graph.
+        /// If specific entities are passed in, only these relationships will be loaded.
+        /// </summary>
+        /// <param name="childrenToLoad">A list of related child entites to load (passed in as properties / lambda expressions).</param>
+        public virtual QueryBuilder<T> Graph(params Expression<Func<T, object>>[] childrenToLoad)
+        {
+            TableCollection tablesInView = new TableCollection();
+            if (childrenToLoad.Length > 0)
+            {
+                // Add base table
+                tablesInView.Add(_tables[0]);
+
+                foreach (var exp in childrenToLoad)
+                {
+                    MemberInfo child = (exp.Body as MemberExpression).Member;
+
+                    var node = EntGraph.Where(g => g.Member != null && g.Member.EqualsMember(child)).FirstOrDefault();
+                    if (node != null)
+                    {
+                        tablesInView.Add(new Table(node.EntityType, JoinType.None));
+                    }
+
+                    if (!_childrenToLoad.ContainsMember(child))
+                    {
+                        _childrenToLoad.Add(child);
+                    }
+                }
+            }
+            else
+            {
+                // Add all tables in the graph
+                foreach (var node in EntGraph)
+                {
+                    tablesInView.Add(new Table(node.EntityType, JoinType.None));
+                }
+            }
+
+            // Replace the base table with a view with tables
+            View view = new View(_tables[0].Name, tablesInView.ToArray());
+            _tables.ReplaceBaseTable(view);
+
+            _isGraph = true;
+            _useAltName = true;
+            return this;
+        }
+        
+        public virtual QueryBuilder<T> Page(int pageNumber, int pageSize)
+        {
+            _enablePaging = true;
+            _skip = (pageNumber - 1) * pageSize;
+            _take = pageSize;
+            return this;
+        }
+        
+        private string[] ParseChildrenToLoad(Expression<Func<T, object>>[] childrenToLoad)
+        {
+            List<string> entitiesToLoad = new List<string>();
+
+            // Parse relationship member names from expression array
+            foreach (var exp in childrenToLoad)
+            {
+                MemberInfo member = (exp.Body as MemberExpression).Member;
+                entitiesToLoad.Add(member.Name);
+                
+            }
+
+            return entitiesToLoad.ToArray();
+        }
+
+        /// <summary>
+        /// Allows you to interact with the DbDataReader to manually load entities.
+        /// </summary>
+        /// <param name="readerAction">An action that takes a DbDataReader.</param>
+        public virtual void DataReader(Action<DbDataReader> readerAction)
+        {
+            if (string.IsNullOrEmpty(_queryText))
+                throw new ArgumentNullException("The query text cannot be blank.");
+
+            var mappingHelper = new MappingHelper(_db);
+            _db.Command.CommandText = _queryText;
+
+            try
+            {
+                _db.OpenConnection();
+                using (DbDataReader reader = _db.Command.ExecuteReader())
+                {
+                    readerAction.Invoke(reader);
+                }
+            }
+            finally
+            {
+                _db.CloseConnection();
+            }
+        }
+
+        public virtual int GetRowCount()
+        {
+            SqlModes previousSqlMode = _db.SqlMode;
+
+            // Generate a row count query
+            string where = _whereBuilder != null ? _whereBuilder.ToString() : string.Empty;
+
+            IQuery query = QueryFactory.CreateRowCountSelectQuery(_tables, _db, where, SortBuilder, _useAltName);
+            string queryText = query.Generate();
+
+            _db.SqlMode = SqlModes.Text;
+            int count = (int)_db.ExecuteScalar(queryText);
+
+            _db.SqlMode = previousSqlMode;
+            return count;
+        }
+
+        /// <summary>
+        /// Executes the query and returns a list of results.
+        /// </summary>
+        /// <returns>A list of query results of type T.</returns>
+        public virtual List<T> ToList()
+        {
+            SqlModes previousSqlMode = _db.SqlMode;
+
+            BuildQueryOrAppendClauses();
+
+            if (_isGraph)
+            {
+                _results = (List<T>)_db.QueryToGraph<T>(_queryText, EntGraph, _childrenToLoad);
+            }
+            else
+            {
+                _results = (List<T>)_db.Query<T>(_queryText, _results, _useAltName);
+            }
+
+            // Return to previous sql mode
+            _db.SqlMode = previousSqlMode;
+
+            return _results;
+        }
+
+        private void BuildQueryOrAppendClauses()
+        {
+            if (_queryText == null)
+            {
+                // Build entire query
+                _db.SqlMode = SqlModes.Text;
+                BuildQuery();
+            }
+            else if (_whereBuilder != null || _sortBuilder != null)
+            {
+                _db.SqlMode = SqlModes.Text;
+                if (_whereBuilder != null)
+                {
+                    // Append a where clause to an existing query
+                    _queryText = string.Concat(_queryText, " ", _whereBuilder.ToString());
+                }
+
+                if (_sortBuilder != null)
+                {
+                    // Append an order clause to an existing query
+                    _queryText = string.Concat(_queryText, " ", _sortBuilder.ToString());
+                }
+            }
+        }
+
+        public virtual string BuildQuery()
+        {
+            // Generate a query
+            string where = _whereBuilder != null ? _whereBuilder.ToString() : string.Empty;
+
+            IQuery query = null;
+            if (_enablePaging)
+            {
+                query = QueryFactory.CreatePagingSelectQuery(_tables, _db, where, SortBuilder, _useAltName, _skip, _take);
+            }
+            else
+            {
+                query = QueryFactory.CreateSelectQuery(_tables, _db, where, SortBuilder, _useAltName);
+            }
+
+            _queryText = query.Generate();
+
+            return _queryText;
+        }
+
+        #endregion
+
+        #region - Helper Methods -
+
+        private ColumnMapCollection GetColumns(IEnumerable<string> entitiesToLoad)
+        {
+            // If QueryToGraph<T> and no child load entities are specified, load all children
+            bool loadAllChildren = _useAltName && entitiesToLoad == null;
+
+            // If Query<T>
+            if (!_useAltName)
+            {
+                return MapRepository.Instance.GetColumns(typeof(T));
+            }
+
+            ColumnMapCollection columns = new ColumnMapCollection();
+
+            Type baseEntityType = typeof(T);
+            EntityGraph graph = new EntityGraph(baseEntityType, null);
+
+            foreach (var lvl in graph)
+            {
+                if (loadAllChildren || lvl.IsRoot || entitiesToLoad.Contains(lvl.Member.Name))
+                {
+                    columns.AddRange(lvl.Columns);
+                }
+            }
+
+            return columns;
+        }
+
+        public static implicit operator List<T>(QueryBuilder<T> builder)
+        {
+            return builder.ToList();
+        }
+
+        #endregion
+
+        #region - Linq Support -
+
+        public virtual SortBuilder<T> Where<TObj>(Expression<Func<TObj, bool>> filterExpression)
+        {
+            _whereBuilder = new WhereBuilder<T>(_db.Command, _dialect, filterExpression, _tables, _useAltName, true);
+            return SortBuilder;
+        }
+
+        public virtual SortBuilder<T> Where(Expression<Func<T, bool>> filterExpression)
+        {
+            _whereBuilder = new WhereBuilder<T>(_db.Command, _dialect, filterExpression, _tables, false, true);
+            return SortBuilder;
+        }
+
+        public virtual SortBuilder<T> Where(string whereClause)
+        {
+            if (string.IsNullOrEmpty(whereClause))
+                throw new ArgumentNullException("whereClause");
+
+            if (!whereClause.ToUpper().Contains("WHERE "))
+            {
+                whereClause = whereClause.Insert(0, " WHERE ");
+            }
+
+            _whereBuilder = new WhereBuilder<T>(whereClause, _useAltName);
+            return SortBuilder;
+        }
+
+        public virtual SortBuilder<T> OrderBy(Expression<Func<T, object>> sortExpression)
+        {
+            SortBuilder.OrderBy(sortExpression);
+            return SortBuilder;
+        }
+
+        public virtual SortBuilder<T> ThenBy(Expression<Func<T, object>> sortExpression)
+        {
+            SortBuilder.OrderBy(sortExpression);
+            return SortBuilder;
+        }
+
+        public virtual SortBuilder<T> OrderByDescending(Expression<Func<T, object>> sortExpression)
+        {
+            SortBuilder.OrderByDescending(sortExpression);
+            return SortBuilder;
+        }
+
+        public virtual SortBuilder<T> ThenByDescending(Expression<Func<T, object>> sortExpression)
+        {
+            SortBuilder.OrderByDescending(sortExpression);
+            return SortBuilder;
+        }
+
+        public virtual SortBuilder<T> OrderBy(string orderByClause)
+        {
+            if (string.IsNullOrEmpty(orderByClause))
+                throw new ArgumentNullException("orderByClause");
+
+            if (!orderByClause.ToUpper().Contains("ORDER BY "))
+            {
+                orderByClause = orderByClause.Insert(0, " ORDER BY ");
+            }
+
+            SortBuilder.OrderBy(orderByClause);
+            return SortBuilder;
+        }
+
+        public virtual QueryBuilder<T> Take(int count)
+        {
+            _enablePaging = true;
+            _take = count;
+            return this;
+        }
+
+        public virtual QueryBuilder<T> Skip(int count)
+        {
+            _enablePaging = true;
+            _skip = count;
+            return this;
+        }
+
+        /// <summary>
+        /// Handles all.
+        /// </summary>
+        /// <param name="expression"></param>
+        /// <returns></returns>
+        protected override System.Linq.Expressions.Expression Visit(System.Linq.Expressions.Expression expression)
+        {
+            return base.Visit(expression);
+        }
+
+        /// <summary>
+        /// Handles Where.
+        /// </summary>
+        /// <param name="lambdaExpression"></param>
+        /// <returns></returns>
+        protected override System.Linq.Expressions.Expression VisitLamda(System.Linq.Expressions.LambdaExpression lambdaExpression)
+        {
+            _sortBuilder = this.Where(lambdaExpression as Expression<Func<T, bool>>);
+            return base.VisitLamda(lambdaExpression);
+        }
+
+        /// <summary>
+        /// Handles OrderBy.
+        /// </summary>
+        /// <param name="expression"></param>
+        /// <returns></returns>
+        protected override System.Linq.Expressions.Expression VisitMethodCall(MethodCallExpression expression)
+        {
+            if (expression.Method.Name == "OrderBy" || expression.Method.Name == "ThenBy")
+            {
+                var memberExp = ((expression.Arguments[1] as UnaryExpression).Operand as System.Linq.Expressions.LambdaExpression).Body as System.Linq.Expressions.MemberExpression;
+                _sortBuilder.Order(memberExp.Expression.Type, memberExp.Member.Name);
+            }
+            if (expression.Method.Name == "OrderByDescending" || expression.Method.Name == "ThenByDescending")
+            {
+                var memberExp = ((expression.Arguments[1] as UnaryExpression).Operand as System.Linq.Expressions.LambdaExpression).Body as System.Linq.Expressions.MemberExpression;
+                _sortBuilder.OrderByDescending(memberExp.Expression.Type, memberExp.Member.Name);
+            }
+
+            return base.VisitMethodCall(expression);
+        }
+
+        public virtual QueryBuilder<T> Join<TLeft, TRight>(JoinType joinType, Expression<Func<TLeft, IEnumerable<TRight>>> rightEntity, Expression<Func<TLeft, TRight, bool>> filterExpression)
+        {
+            MemberInfo rightMember = (rightEntity.Body as MemberExpression).Member;
+            return this.Join(joinType, rightMember, filterExpression);
+        }
+
+        public virtual QueryBuilder<T> Join<TLeft, TRight>(JoinType joinType, Expression<Func<TLeft, TRight>> rightEntity, Expression<Func<TLeft, TRight, bool>> filterExpression)
+        {
+            MemberInfo rightMember = (rightEntity.Body as MemberExpression).Member;
+            return this.Join(joinType, rightMember, filterExpression);
+        }
+
+        public virtual QueryBuilder<T> Join<TLeft, TRight>(JoinType joinType, MemberInfo rightMember, Expression<Func<TLeft, TRight, bool>> filterExpression)
+        {
+            _useAltName = true;
+            _isGraph = true;
+
+            if (!_childrenToLoad.ContainsMember(rightMember))
+                _childrenToLoad.Add(rightMember);
+
+            Table table = new Table(typeof(TRight), joinType);
+            _tables.Add(table);
+
+            var builder = new JoinBuilder<TLeft, TRight>(_db.Command, _dialect, filterExpression, _tables);
+
+            table.JoinClause = builder.ToString();
+            return this;
+        }
+
+
+        #endregion
+
+        #region IEnumerable<T> Members
+
+        IEnumerator<T> IEnumerable<T>.GetEnumerator()
+        {
+            var list = this.ToList();
+            return list.GetEnumerator();
+        }
+
+        #endregion
+
+        #region IEnumerable Members
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            var list = this.ToList();
+            return list.GetEnumerator();
+        }
+
+        #endregion
+    }
+}

Marr.Data/QGen/QueryFactory.cs

@@ -0,0 +1,110 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Data.Common;
+using Marr.Data.QGen.Dialects;
+
+namespace Marr.Data.QGen
+{
+    /// <summary>
+    /// This class contains the factory logic that determines which type of IQuery object should be created.
+    /// </summary>
+    internal class QueryFactory
+    {
+        private const string DB_SqlClient = "System.Data.SqlClient.SqlClientFactory";
+        private const string DB_OleDb = "System.Data.OleDb.OleDbFactory";
+        private const string DB_SqlCeClient = "System.Data.SqlServerCe.SqlCeProviderFactory";
+        private const string DB_SystemDataOracleClient = "System.Data.OracleClientFactory";
+        private const string DB_OracleDataAccessClient = "Oracle.DataAccess.Client.OracleClientFactory";
+        private const string DB_FireBirdClient = "FirebirdSql.Data.FirebirdClient.FirebirdClientFactory";
+        private const string DB_SQLiteClient = "System.Data.SQLite.SQLiteFactory";
+        
+        public static IQuery CreateUpdateQuery(Mapping.ColumnMapCollection columns, IDataMapper dataMapper, string target, string whereClause)
+        {
+            Dialect dialect = CreateDialect(dataMapper);
+            return new UpdateQuery(dialect, columns, dataMapper.Command, target, whereClause);
+        }
+
+        public static IQuery CreateInsertQuery(Mapping.ColumnMapCollection columns, IDataMapper dataMapper, string target)
+        {
+            Dialect dialect = CreateDialect(dataMapper);
+            return new InsertQuery(dialect, columns, dataMapper.Command, target);
+        }
+
+        public static IQuery CreateDeleteQuery(Dialects.Dialect dialect, Table targetTable, string whereClause)
+        {
+            return new DeleteQuery(dialect, targetTable, whereClause);
+        }
+
+        public static IQuery CreateSelectQuery(TableCollection tables, IDataMapper dataMapper, string where, ISortQueryBuilder orderBy, bool useAltName)
+        {
+            Dialect dialect = CreateDialect(dataMapper);
+            return new SelectQuery(dialect, tables, where, orderBy, useAltName);
+        }
+
+        public static IQuery CreateRowCountSelectQuery(TableCollection tables, IDataMapper dataMapper, string where, ISortQueryBuilder orderBy, bool useAltName)
+        {
+            SelectQuery innerQuery = (SelectQuery)CreateSelectQuery(tables, dataMapper, where, orderBy, useAltName);
+
+            string providerString = dataMapper.ProviderFactory.ToString();
+            switch (providerString)
+            {
+                case DB_SqlClient:
+                    return new RowCountQueryDecorator(innerQuery);
+
+                case DB_SqlCeClient:
+                    return new RowCountQueryDecorator(innerQuery);
+
+                default:
+                    throw new NotImplementedException("Row count has not yet been implemented for this provider.");
+            }
+        }
+
+        public static IQuery CreatePagingSelectQuery(TableCollection tables, IDataMapper dataMapper, string where, ISortQueryBuilder orderBy, bool useAltName, int skip, int take)
+        {
+            SelectQuery innerQuery = (SelectQuery)CreateSelectQuery(tables, dataMapper, where, orderBy, useAltName);
+
+            string providerString = dataMapper.ProviderFactory.ToString();
+            switch (providerString)
+            {
+                case DB_SqlClient:
+                    return new PagingQueryDecorator(innerQuery, skip, take);
+
+                case DB_SqlCeClient:
+                    return new PagingQueryDecorator(innerQuery, skip, take);
+
+                default:
+                    throw new NotImplementedException("Paging has not yet been implemented for this provider.");
+            }
+        }
+
+        public static Dialects.Dialect CreateDialect(IDataMapper dataMapper)
+        {
+            string providerString = dataMapper.ProviderFactory.ToString();
+            switch (providerString)
+            {
+                case DB_SqlClient:
+                    return new SqlServerDialect();
+
+                case DB_OracleDataAccessClient:
+                    return new OracleDialect();
+
+                case DB_SystemDataOracleClient:
+                    return new OracleDialect();
+
+                case DB_SqlCeClient:
+                    return new SqlServerCeDialect();
+
+                case DB_FireBirdClient:
+                    return new FirebirdDialect();
+
+                case DB_SQLiteClient:
+                    return new SqliteDialect();
+
+                default:
+                    return new Dialect();
+            }
+        }
+    }
+}

Marr.Data/QGen/QueryQueueItem.cs

@@ -0,0 +1,19 @@
+//using System;
+//using System.Collections.Generic;
+//using System.Linq;
+//using System.Text;
+
+//namespace Marr.Data.QGen
+//{
+//    public class QueryQueueItem
+//    {
+//        public QueryQueueItem(string queryText, IEnumerable<string> entitiesToLoad)
+//        {
+//            QueryText = queryText;
+//            EntitiesToLoad = entitiesToLoad;
+//        }
+
+//        public string QueryText { get; set; }
+//        public IEnumerable<string> EntitiesToLoad { get; private set; }
+//    }
+//}

Marr.Data/QGen/RowCountQueryDecorator.cs

@@ -0,0 +1,127 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Marr.Data.QGen
+{
+    public class RowCountQueryDecorator : IQuery
+    {
+        private SelectQuery _innerQuery;
+
+        public RowCountQueryDecorator(SelectQuery innerQuery)
+        {
+            _innerQuery = innerQuery;
+        }
+        
+        public string Generate()
+        {
+            // Decide which type of paging query to create
+            if (_innerQuery.IsView || _innerQuery.IsJoin)
+            {
+                return ComplexRowCount();
+            }
+            else
+            {
+                return SimpleRowCount();
+            }
+        }
+
+        /// <summary>
+        /// Generates a row count query for a multiple table joined query (groups by the parent entity).
+        /// </summary>
+        /// <returns></returns>
+        private string ComplexRowCount()
+        {
+            // Create paged query
+            StringBuilder sql = new StringBuilder();
+
+            sql.AppendLine("WITH GroupCTE AS (");
+            sql.Append("SELECT ").AppendLine(BuildBaseTablePKColumns());
+            BuildGroupColumn(sql);
+            _innerQuery.BuildFromClause(sql);
+            _innerQuery.BuildJoinClauses(sql);
+            _innerQuery.BuildWhereClause(sql);
+            sql.AppendLine(")");
+            BuildSelectCountClause(sql);
+            sql.AppendLine("FROM GroupCTE");
+            sql.AppendLine("WHERE GroupRow = 1");
+
+            return sql.ToString();
+        }
+
+        /// <summary>
+        /// Generates a row count query for a single table query (no joins).
+        /// </summary>
+        /// <returns></returns>
+        private string SimpleRowCount()
+        {
+            StringBuilder sql = new StringBuilder();
+
+            BuildSelectCountClause(sql);
+            _innerQuery.BuildFromClause(sql);
+            _innerQuery.BuildJoinClauses(sql);
+            _innerQuery.BuildWhereClause(sql);
+
+            return sql.ToString();
+        }
+
+        private void BuildGroupColumn(StringBuilder sql)
+        {
+            string baseTablePKColumns = BuildBaseTablePKColumns();
+            sql.AppendFormat(", ROW_NUMBER() OVER (PARTITION BY {0} ORDER BY {1}) As GroupRow ", baseTablePKColumns, baseTablePKColumns);
+        }
+
+        private string BuildBaseTablePKColumns()
+        {
+            Table baseTable = GetBaseTable();
+
+            StringBuilder sb = new StringBuilder();
+            foreach (var col in baseTable.Columns.PrimaryKeys)
+            {
+                if (sb.Length > 0)
+                    sb.AppendLine(", ");
+
+                string colName = _innerQuery.IsView ?
+                    _innerQuery.NameOrAltName(col.ColumnInfo) :
+                    col.ColumnInfo.Name;
+
+                sb.AppendFormat(_innerQuery.Dialect.CreateToken(string.Concat(baseTable.Alias, ".", colName)));
+            }
+
+            return sb.ToString();
+        }
+
+        private void BuildSelectCountClause(StringBuilder sql)
+        {
+            sql.AppendLine("SELECT COUNT(*)");
+        }
+
+        private Table GetBaseTable()
+        {
+            Table baseTable = null;
+            if (_innerQuery.Tables[0] is View)
+            {
+                baseTable = (_innerQuery.Tables[0] as View).Tables[0];
+            }
+            else
+            {
+                baseTable = _innerQuery.Tables[0];
+            }
+            return baseTable;
+        }
+    }
+}
+
+/*
+WITH GroupCTE AS 
+(
+	SELECT [t0].[ID],[t0].[OrderName],[t1].[ID] AS OrderItemID,[t1].[OrderID],[t1].[ItemDescription],[t1].[Price], 
+	ROW_NUMBER() OVER (PARTITION BY [t0].[ID]  ORDER BY [t0].[OrderName]) As GroupRow  
+	FROM [Order] [t0] 
+	LEFT JOIN [OrderItem] [t1] ON (([t0].[ID] = [t1].[OrderID])) 
+	--WHERE (([t0].[OrderName] = @P0))
+)
+SELECT * FROM GroupCTE
+WHERE GroupRow = 1
+*/

Marr.Data/QGen/SelectQuery.cs

@@ -0,0 +1,157 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Marr.Data;
+using Marr.Data.Mapping;
+using System.Data.Common;
+using Marr.Data.QGen.Dialects;
+
+namespace Marr.Data.QGen
+{
+    /// <summary>
+    /// This class is responsible for creating a select query.
+    /// </summary>
+    public class SelectQuery : IQuery
+    {
+        public Dialect Dialect { get; set; }
+        public string WhereClause { get; set; }
+        public ISortQueryBuilder OrderBy { get; set; }
+        public TableCollection Tables { get; set; }
+        public bool UseAltName;
+
+        public SelectQuery(Dialect dialect, TableCollection tables, string whereClause, ISortQueryBuilder orderBy, bool useAltName)
+        {
+            Dialect = dialect;
+            Tables = tables;
+            WhereClause = whereClause;
+            OrderBy = orderBy;
+            UseAltName = useAltName;
+        }
+
+        public bool IsView
+        {
+            get
+            {
+                return Tables[0] is View;
+            }
+        }
+
+        public bool IsJoin
+        {
+            get
+            {
+                return Tables.Count > 1;
+            }
+        }
+
+        public virtual string Generate()
+        {
+            StringBuilder sql = new StringBuilder();
+
+            BuildSelectClause(sql);
+            BuildFromClause(sql);
+            BuildJoinClauses(sql);
+            BuildWhereClause(sql);
+            BuildOrderClause(sql);
+
+            return sql.ToString();
+        }
+
+        public void BuildSelectClause(StringBuilder sql)
+        {
+            sql.Append("SELECT ");
+
+            int startIndex = sql.Length;
+
+            // COLUMNS
+            foreach (Table join in Tables)
+            {
+                for (int i = 0; i < join.Columns.Count; i++)
+                {
+                    var c = join.Columns[i];
+
+                    if (sql.Length > startIndex)
+                        sql.Append(",");
+
+                    if (join is View)
+                    {
+                        string token = string.Concat(join.Alias, ".", NameOrAltName(c.ColumnInfo));
+                        sql.Append(Dialect.CreateToken(token));
+                    }
+                    else
+                    {
+                        string token = string.Concat(join.Alias, ".", c.ColumnInfo.Name);
+                        sql.Append(Dialect.CreateToken(token));
+
+                        if (UseAltName && c.ColumnInfo.AltName != null && c.ColumnInfo.AltName != c.ColumnInfo.Name)
+                        {
+                            string altName = c.ColumnInfo.AltName;
+                            sql.AppendFormat(" AS {0}", altName);
+                        }
+                    }
+                }
+            }
+        }
+
+        public string NameOrAltName(IColumnInfo columnInfo)
+        {
+            if (UseAltName && columnInfo.AltName != null && columnInfo.AltName != columnInfo.Name)
+            {
+                return columnInfo.AltName;
+            }
+            else
+            {
+                return columnInfo.Name;
+            }
+        }
+
+        public void BuildFromClause(StringBuilder sql)
+        {
+            // BASE TABLE
+            Table baseTable = Tables[0];
+            sql.AppendFormat(" FROM {0} {1} ", Dialect.CreateToken(baseTable.Name), Dialect.CreateToken(baseTable.Alias));
+        }
+
+        public void BuildJoinClauses(StringBuilder sql)
+        {
+            // JOINS
+            for (int i = 1; i < Tables.Count; i++)
+            {
+                if (Tables[i].JoinType != JoinType.None)
+                {
+                    sql.AppendFormat("{0} {1} {2} {3} ",
+                        TranslateJoin(Tables[i].JoinType),
+                        Dialect.CreateToken(Tables[i].Name),
+                        Dialect.CreateToken(Tables[i].Alias),
+                        Tables[i].JoinClause);
+                }
+            }
+        }
+
+        public void BuildWhereClause(StringBuilder sql)
+        {
+            sql.Append(WhereClause);
+        }
+
+        public void BuildOrderClause(StringBuilder sql)
+        {
+            sql.Append(OrderBy.ToString());
+        }       
+
+        private string TranslateJoin(JoinType join)
+        {
+            switch (join)
+            {
+                case JoinType.Inner:
+                    return "INNER JOIN";
+                case JoinType.Left:
+                    return "LEFT JOIN";
+                case JoinType.Right:
+                    return "RIGHT JOIN";
+                default:
+                    return string.Empty;
+            }
+        }
+    }
+}

Marr.Data/QGen/SortBuilder.cs

@@ -0,0 +1,246 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Linq.Expressions;
+using System.Reflection;
+using Marr.Data.QGen.Dialects;
+
+namespace Marr.Data.QGen
+{
+    /// <summary>
+    /// This class is responsible for creating an "ORDER BY" clause.
+    /// It uses chaining methods to provide a fluent interface.
+    /// It also has some methods that coincide with Linq methods, to provide Linq compatibility.
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public class SortBuilder<T> : IEnumerable<T>, ISortQueryBuilder
+    {
+        private string _constantOrderByClause;
+        private QueryBuilder<T> _baseBuilder;
+        private Dialect _dialect;
+        private List<SortColumn<T>> _sortExpressions;
+        private bool _useAltName;
+        private TableCollection _tables;
+        private IDataMapper _db;
+        private WhereBuilder<T> _whereBuilder;
+
+        public SortBuilder()
+        {
+            // Used only for unit testing with mock frameworks
+        }
+
+        public SortBuilder(QueryBuilder<T> baseBuilder, IDataMapper db, WhereBuilder<T> whereBuilder, Dialect dialect, TableCollection tables, bool useAltName)
+        {
+            _baseBuilder = baseBuilder;
+            _db = db;
+            _whereBuilder = whereBuilder;
+            _dialect = dialect;
+            _sortExpressions = new List<SortColumn<T>>();
+            _useAltName = useAltName;
+            _tables = tables;
+        }
+
+        #region - AndWhere / OrWhere -
+
+        public virtual SortBuilder<T> OrWhere(Expression<Func<T, bool>> filterExpression)
+        {
+            var orWhere = new WhereBuilder<T>(_db.Command, _dialect, filterExpression, _tables, _useAltName, true);
+            _whereBuilder.Append(orWhere, WhereAppendType.OR);
+            return this;
+        }
+
+        public virtual SortBuilder<T> OrWhere(string whereClause)
+        {
+            var orWhere = new WhereBuilder<T>(whereClause, _useAltName);
+            _whereBuilder.Append(orWhere, WhereAppendType.OR);
+            return this;
+        }
+
+        public virtual SortBuilder<T> AndWhere(Expression<Func<T, bool>> filterExpression)
+        {
+            var andWhere = new WhereBuilder<T>(_db.Command, _dialect, filterExpression, _tables, _useAltName, true);
+            _whereBuilder.Append(andWhere, WhereAppendType.AND);
+            return this;
+        }
+
+        public virtual SortBuilder<T> AndWhere(string whereClause)
+        {
+            var andWhere = new WhereBuilder<T>(whereClause, _useAltName);
+            _whereBuilder.Append(andWhere, WhereAppendType.AND);
+            return this;
+        }
+
+        #endregion
+
+        #region - Order -
+
+        internal SortBuilder<T> Order(Type declaringType, string propertyName)
+        {
+            _sortExpressions.Add(new SortColumn<T>(declaringType, propertyName, SortDirection.Asc));
+            return this;
+        }
+
+        internal SortBuilder<T> OrderByDescending(Type declaringType, string propertyName)
+        {
+            _sortExpressions.Add(new SortColumn<T>(declaringType, propertyName, SortDirection.Desc));
+            return this;
+        }
+        
+        public virtual SortBuilder<T> OrderBy(string orderByClause)
+        {
+            if (string.IsNullOrEmpty(orderByClause))
+                throw new ArgumentNullException("orderByClause");
+
+            if (!orderByClause.ToUpper().Contains("ORDER BY "))
+            {
+                orderByClause = orderByClause.Insert(0, " ORDER BY ");
+            }
+
+            _constantOrderByClause = orderByClause;
+            return this;
+        }
+
+        public virtual SortBuilder<T> OrderBy(Expression<Func<T, object>> sortExpression)
+        {
+            _sortExpressions.Add(new SortColumn<T>(sortExpression, SortDirection.Asc));
+            return this;
+        }
+
+        public virtual SortBuilder<T> OrderByDescending(Expression<Func<T, object>> sortExpression)
+        {
+            _sortExpressions.Add(new SortColumn<T>(sortExpression, SortDirection.Desc));
+            return this;
+        }
+
+        public virtual SortBuilder<T> ThenBy(Expression<Func<T, object>> sortExpression)
+        {
+            _sortExpressions.Add(new SortColumn<T>(sortExpression, SortDirection.Asc));
+            return this;
+        }
+
+        public virtual SortBuilder<T> ThenByDescending(Expression<Func<T, object>> sortExpression)
+        {
+            _sortExpressions.Add(new SortColumn<T>(sortExpression, SortDirection.Desc));
+            return this;
+        }
+
+        #endregion
+
+        #region - Paging -
+
+        public virtual SortBuilder<T> Take(int count)
+        {
+            _baseBuilder.Take(count);
+            return this;
+        }
+
+        public virtual SortBuilder<T> Skip(int count)
+        {
+            _baseBuilder.Skip(count);
+            return this;
+        }
+
+        public virtual SortBuilder<T> Page(int pageNumber, int pageSize)
+        {
+            _baseBuilder.Page(pageNumber, pageSize);
+            return this;
+        }
+
+        #endregion
+
+        #region - GetRowCount -
+
+        public virtual int GetRowCount()
+        {
+            return _baseBuilder.GetRowCount();
+        }
+
+        #endregion
+
+        #region - ToList / ToString / BuildQuery -
+
+        public virtual List<T> ToList()
+        {
+            return _baseBuilder.ToList();
+        }
+
+        public virtual string BuildQuery()
+        {
+            return _baseBuilder.BuildQuery();
+        }
+
+        public virtual string BuildQuery(bool useAltName)
+        {
+            if (!string.IsNullOrEmpty(_constantOrderByClause))
+            {
+                return _constantOrderByClause;
+            }
+
+            StringBuilder sb = new StringBuilder();
+
+            foreach (var sort in _sortExpressions)
+            {
+                if (sb.Length > 0)
+                    sb.Append(",");
+
+                Table table = _tables.FindTable(sort.DeclaringType);
+
+                if (table == null)
+                {
+                    string msg = string.Format("The property '{0} -> {1}' you are trying to reference in the 'ORDER BY' statement belongs to an entity that has not been joined in your query.  To reference this property, you must join the '{0}' entity using the Join method.",
+                        sort.DeclaringType.Name,
+                        sort.PropertyName);
+
+                    throw new DataMappingException(msg);
+                }
+
+                string columnName = DataHelper.GetColumnName(sort.DeclaringType, sort.PropertyName, useAltName);
+                sb.Append(_dialect.CreateToken(string.Format("{0}.{1}", table.Alias, columnName)));
+
+                if (sort.Direction == SortDirection.Desc)
+                    sb.Append(" DESC");
+            }
+
+            if (sb.Length > 0)
+                sb.Insert(0, " ORDER BY ");
+
+            return sb.ToString();
+        }
+
+        public override string ToString()
+        {
+            return BuildQuery(_useAltName);
+        }
+
+        #endregion
+
+        #region - Implicit List<T> Operator -
+
+        public static implicit operator List<T>(SortBuilder<T> builder)
+        {
+            return builder.ToList();
+        }
+
+        #endregion
+
+        #region IEnumerable<T> Members
+
+        public virtual IEnumerator<T> GetEnumerator()
+        {
+            var list = this.ToList();
+            return list.GetEnumerator();
+        }
+
+        #endregion
+
+        #region IEnumerable Members
+
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+        {
+            throw new NotImplementedException();
+        }
+
+        #endregion
+    }
+}

Marr.Data/QGen/SortColumn.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Linq.Expressions;
+using System.Reflection;
+
+namespace Marr.Data.QGen
+{
+    public class SortColumn<T>
+    {
+        public SortColumn(Expression<Func<T, object>> sortExpression, SortDirection direction)
+        {
+            MemberExpression me = GetMemberExpression(sortExpression.Body);
+            DeclaringType = me.Expression.Type;
+            PropertyName = me.Member.Name;
+            Direction = direction;
+        }
+
+        public SortColumn(Type declaringType, string propertyName, SortDirection direction)
+        {
+            DeclaringType = declaringType;
+            PropertyName = propertyName;
+            Direction = direction;
+        }
+
+        public SortDirection Direction { get; private set; }
+        public Type DeclaringType { get; private set; }
+        public string PropertyName { get; private set; }
+
+        private MemberExpression GetMemberExpression(Expression exp)
+        {
+            MemberExpression me = exp as MemberExpression;
+
+            if (me == null)
+            {
+                var ue = exp as UnaryExpression;
+                me = ue.Operand as MemberExpression;
+            }
+
+            return me;
+        }
+    }
+    
+    public enum SortDirection
+    {
+        Asc,
+        Desc
+    }
+}

Marr.Data/QGen/Table.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Marr.Data.Mapping;
+
+namespace Marr.Data.QGen
+{
+    /// <summary>
+    /// This class represents a table in a query.
+    /// A table contains corresponding columns.
+    /// </summary>
+    public class Table
+    {
+        public Table(Type memberType)
+            : this(memberType, JoinType.None)
+        { }
+
+        public Table(Type memberType, JoinType joinType)
+        {
+            EntityType = memberType;
+            Name = memberType.GetTableName();
+            JoinType = joinType;
+            Columns = MapRepository.Instance.GetColumns(memberType);
+        }
+
+        public bool IsBaseTable
+        {
+            get
+            {
+                return Alias == "t0";
+            }
+        }
+
+        public Type EntityType { get; private set; }
+        public virtual string Name { get; set; }
+        public JoinType JoinType { get; private set; }
+        public virtual ColumnMapCollection Columns { get; private set; }
+        public virtual string Alias { get; set; }
+        public string JoinClause { get; set; }
+    }
+
+    public enum JoinType
+    {
+        None,
+        Inner,
+        Left,
+        Right
+    }
+}

Marr.Data/QGen/TableCollection.cs

@@ -0,0 +1,97 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Collections;
+using System.Reflection;
+
+namespace Marr.Data.QGen
+{
+    /// <summary>
+    /// This class holds a collection of Table objects.
+    /// </summary>
+    public class TableCollection : IEnumerable<Table>
+    {
+        private List<Table> _tables;
+
+        public TableCollection()
+        {
+            _tables = new List<Table>();
+        }
+
+        public void Add(Table table)
+        {
+            if (this.Any(t => t.EntityType == table.EntityType))
+            {
+                // Already exists -- don't add
+                return;
+            }
+
+            // Create an alias (ex: "t0", "t1", "t2", etc...)
+            table.Alias = string.Format("t{0}", _tables.Count);
+            _tables.Add(table);
+        }
+
+        public void ReplaceBaseTable(View view)
+        {
+            _tables.RemoveAt(0);
+            Add(view);
+        }
+
+        /// <summary>
+        /// Tries to find a table for a given member.  
+        /// </summary>
+        public Table FindTable(Type declaringType)
+        {
+            return this.EnumerateViewsAndTables().Where(t => t.EntityType == declaringType).FirstOrDefault();
+        }
+
+        public Table this[int index]
+        {
+            get
+            {
+                return _tables[index];
+            }
+        }
+
+        public int Count
+        {
+            get
+            {
+                return _tables.Count;
+            }
+        }
+
+        /// <summary>
+        /// Recursively enumerates through all tables, including tables embedded in views.
+        /// </summary>
+        /// <returns></returns>
+        public IEnumerable<Table> EnumerateViewsAndTables()
+        {
+            foreach (Table table in _tables)
+            {
+                if (table is View)
+                {
+                    foreach (Table viewTable in (table as View))
+                    {
+                        yield return viewTable;
+                    }
+                }
+                else
+                {
+                    yield return table;
+                }
+            }
+        }
+
+        public IEnumerator<Table> GetEnumerator()
+        {
+            return _tables.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return _tables.GetEnumerator();
+        }
+    }
+}

Marr.Data/QGen/UpdateQuery.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Data.Common;
+using Marr.Data.Mapping;
+using Marr.Data.QGen.Dialects;
+
+namespace Marr.Data.QGen
+{
+    public class UpdateQuery : IQuery
+    {
+        protected Dialect Dialect { get; set; }
+        protected string Target { get; set; }
+        protected ColumnMapCollection Columns { get; set; }
+        protected DbCommand Command { get; set; }
+        protected string WhereClause { get; set; }
+
+        public UpdateQuery(Dialect dialect, ColumnMapCollection columns, DbCommand command, string target, string whereClause)
+        {
+            Dialect = dialect;
+            Target = target;
+            Columns = columns;
+            Command = command;
+            WhereClause = whereClause;
+        }
+
+        public string Generate()
+        {
+            StringBuilder sql = new StringBuilder();
+
+            sql.AppendFormat("UPDATE {0} SET ", Dialect.CreateToken(Target));
+
+            int startIndex = sql.Length;
+
+            foreach (DbParameter p in Command.Parameters)
+            {
+                var c = Columns.GetByColumnName(p.ParameterName);
+
+                if (c == null)
+                    break; // All SET columns have been added
+
+                if (sql.Length > startIndex)
+                    sql.Append(",");
+
+                if (!c.ColumnInfo.IsAutoIncrement)
+                {
+                    sql.AppendFormat("{0}={1}{2}", Dialect.CreateToken(c.ColumnInfo.Name), Command.ParameterPrefix(), p.ParameterName);
+                }
+            }
+
+            sql.AppendFormat(" {0}", WhereClause);
+
+            return sql.ToString();
+        }
+
+
+    }
+}

Marr.Data/QGen/UpdateQueryBuilder.cs

@@ -0,0 +1,176 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Marr.Data.Mapping;
+using System.Linq.Expressions;
+
+namespace Marr.Data.QGen
+{
+    public class UpdateQueryBuilder<T>
+    {
+        private DataMapper _db;
+        private string _tableName;
+        private T _entity;
+        private MappingHelper _mappingHelper;
+        private ColumnMapCollection _mappings;
+        private SqlModes _previousSqlMode;
+        private bool _generateQuery = true;
+        private TableCollection _tables;
+        private Expression<Func<T, bool>> _filterExpression;
+        private Dialects.Dialect _dialect;
+        private ColumnMapCollection _columnsToUpdate;
+
+        public UpdateQueryBuilder()
+        {
+            // Used only for unit testing with mock frameworks
+        }
+
+        public UpdateQueryBuilder(DataMapper db)
+        {
+            _db = db;
+            _tableName = MapRepository.Instance.GetTableName(typeof(T));
+            _tables = new TableCollection();
+            _tables.Add(new Table(typeof(T)));
+            _previousSqlMode = _db.SqlMode;
+            _mappingHelper = new MappingHelper(_db);
+            _mappings = MapRepository.Instance.GetColumns(typeof(T));
+            _dialect = QueryFactory.CreateDialect(_db);
+        }
+
+        public virtual UpdateQueryBuilder<T> TableName(string tableName)
+        {
+            _tableName = tableName;
+            return this;
+        }
+
+        public virtual UpdateQueryBuilder<T> QueryText(string queryText)
+        {
+            _generateQuery = false;
+            _db.Command.CommandText = queryText;
+            return this;
+        }
+
+        public virtual UpdateQueryBuilder<T> Entity(T entity)
+        {
+            _entity = entity;
+            return this;
+        }
+
+        public virtual UpdateQueryBuilder<T> Where(Expression<Func<T, bool>> filterExpression)
+        {
+            _filterExpression = filterExpression;
+            return this;
+        }
+
+        public virtual UpdateQueryBuilder<T> ColumnsIncluding(params Expression<Func<T, object>>[] properties)
+        {
+            List<string> columnList = new List<string>();
+
+            foreach (var column in properties)
+            {
+                columnList.Add(column.GetMemberName());
+            }
+
+            return ColumnsIncluding(columnList.ToArray());
+        }
+
+        public virtual UpdateQueryBuilder<T> ColumnsIncluding(params string[] properties)
+        {
+            _columnsToUpdate = new ColumnMapCollection();
+
+            foreach (string propertyName in properties)
+            {
+                _columnsToUpdate.Add(_mappings.GetByFieldName(propertyName));
+            }
+
+            return this;
+        }
+
+        public virtual UpdateQueryBuilder<T> ColumnsExcluding(params Expression<Func<T, object>>[] properties)
+        {
+            List<string> columnList = new List<string>();
+
+            foreach (var column in properties)
+            {
+                columnList.Add(column.GetMemberName());
+            }
+
+            return ColumnsExcluding(columnList.ToArray());
+        }
+
+        public virtual UpdateQueryBuilder<T> ColumnsExcluding(params string[] properties)
+        {
+            _columnsToUpdate = new ColumnMapCollection();
+
+            _columnsToUpdate.AddRange(_mappings);
+
+            foreach (string propertyName in properties)
+            {
+                _columnsToUpdate.RemoveAll(c => c.FieldName == propertyName);
+            }
+
+            return this;
+        }
+
+        public virtual string BuildQuery()
+        {
+            if (_entity == null)
+                throw new ArgumentNullException("You must specify an entity to update.");
+
+            // Override SqlMode since we know this will be a text query
+            _db.SqlMode = SqlModes.Text;
+
+            var columnsToUpdate = _columnsToUpdate ?? _mappings;
+
+            _mappingHelper.CreateParameters<T>(_entity, columnsToUpdate, _generateQuery);
+
+            string where = string.Empty;
+            if (_filterExpression != null)
+            {
+                var whereBuilder = new WhereBuilder<T>(_db.Command, _dialect, _filterExpression, _tables, false, false);
+                where = whereBuilder.ToString();
+            }
+
+            IQuery query = QueryFactory.CreateUpdateQuery(columnsToUpdate, _db, _tableName, where);
+
+            _db.Command.CommandText = query.Generate();
+
+            return _db.Command.CommandText;
+        }
+
+        public virtual int Execute()
+        {
+            if (_generateQuery)
+            {
+                BuildQuery();
+            }
+            else
+            {
+                _mappingHelper.CreateParameters<T>(_entity, _mappings, _generateQuery);
+            }
+
+            int rowsAffected = 0;
+
+            try
+            {
+                _db.OpenConnection();
+                rowsAffected = _db.Command.ExecuteNonQuery();
+                _mappingHelper.SetOutputValues<T>(_entity, _mappings.OutputFields);                
+            }
+            finally
+            {
+                _db.CloseConnection();
+            }
+
+
+            if (_generateQuery)
+            {
+                // Return to previous sql mode
+                _db.SqlMode = _previousSqlMode;
+            }
+
+            return rowsAffected;
+        }
+    }
+}

Marr.Data/QGen/View.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Marr.Data.Mapping;
+
+namespace Marr.Data.QGen
+{
+    /// <summary>
+    /// This class represents a View.  A view can hold multiple tables (and their columns).
+    /// </summary>
+    public class View : Table, IEnumerable<Table>
+    {
+        private string _viewName;
+        private Table[] _tables;
+        private Mapping.ColumnMapCollection _columns;
+
+        public View(string viewName, Table[] tables)
+            : base(tables[0].EntityType, JoinType.None)
+        {
+            _viewName = viewName;
+            _tables = tables;
+        }
+
+        public Table[] Tables
+        {
+            get { return _tables; }
+        }
+        
+        public override string Name
+        {
+            get
+            {
+                return _viewName;
+            }
+            set
+            {
+                _viewName = value;
+            }
+        }
+
+        public override string Alias
+        {
+            get
+            {
+                return base.Alias;
+            }
+            set
+            {
+                base.Alias = value;
+
+                // Sync view tables
+                foreach (Table table in _tables)
+                {
+                    table.Alias = value;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets all the columns from all the tables included in the view.
+        /// </summary>
+        public override Mapping.ColumnMapCollection Columns
+        {
+            get
+            {
+                if (_columns == null)
+                {
+                    var allColumns = _tables.SelectMany(t => t.Columns);
+                    _columns = new ColumnMapCollection();
+                    _columns.AddRange(allColumns);
+                }
+
+                return _columns;
+            }
+        }
+
+        public IEnumerator<Table> GetEnumerator()
+        {
+            foreach (Table table in _tables)
+            {
+                yield return table;
+            }
+        }
+
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+        {
+            return this.GetEnumerator();
+        }
+    }
+}

Marr.Data/QGen/WhereBuilder.cs

@@ -0,0 +1,279 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Linq.Expressions;
+using Marr.Data;
+using Marr.Data.Mapping;
+using System.Data.Common;
+using Marr.Data.Parameters;
+using System.Reflection;
+using Marr.Data.QGen.Dialects;
+
+namespace Marr.Data.QGen
+{
+    /// <summary>
+    /// This class utilizes the ExpressionVisitor base class, and it is responsible for creating the "WHERE" clause.
+    /// It builds a protected StringBuilder class whose output is created when the ToString method is called.
+    /// It also has some methods that coincide with Linq methods, to provide Linq compatibility.
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public class WhereBuilder<T> : ExpressionVisitor
+    {
+        private string _constantWhereClause;
+        private MapRepository _repos;
+        private DbCommand _command;
+        private string _paramPrefix;
+        private bool isLeftSide = true;
+        protected bool _useAltName;
+        protected Dialect _dialect;
+        protected StringBuilder _sb;
+        protected TableCollection _tables;
+        protected bool _tablePrefix;
+
+        public WhereBuilder(string whereClause, bool useAltName)
+        {
+            _constantWhereClause = whereClause;
+            _useAltName = useAltName;
+        }
+
+        public WhereBuilder(DbCommand command, Dialect dialect, Expression filter, TableCollection tables, bool useAltName, bool tablePrefix)
+        {
+            _repos = MapRepository.Instance;
+            _command = command;
+            _dialect = dialect;
+            _paramPrefix = command.ParameterPrefix();
+            _sb = new StringBuilder();
+            _useAltName = useAltName;
+            _tables = tables;
+            _tablePrefix = tablePrefix;
+
+            if (filter != null)
+            {
+                _sb.AppendFormat("{0} ", PrefixText);
+                base.Visit(filter);
+            }            
+        }
+
+        protected virtual string PrefixText
+        {
+            get
+            {
+                return "WHERE";
+            }
+        }
+
+        protected override Expression VisitBinary(BinaryExpression expression)
+        {
+            _sb.Append("(");
+
+            isLeftSide = true;
+            Visit(expression.Left);
+
+            _sb.AppendFormat(" {0} ", Decode(expression.NodeType));
+
+            isLeftSide = false;
+            Visit(expression.Right);
+
+            _sb.Append(")");
+
+            return expression;
+        }
+
+        protected override Expression VisitMethodCall(MethodCallExpression expression)
+        {
+            string method = (expression as System.Linq.Expressions.MethodCallExpression).Method.Name;
+            switch (method)
+            {
+                case "Contains":
+                    Write_Contains(expression);
+                    break;
+
+                case "StartsWith":
+                    Write_StartsWith(expression);
+                    break;
+
+                case "EndsWith":
+                    Write_EndsWith(expression);
+                    break;
+
+                default:
+                    string msg = string.Format("'{0}' expressions are not yet implemented in the where clause expression tree parser.", method);
+                    throw new NotImplementedException(msg);
+            }
+
+            return expression;
+        }
+
+        protected override Expression VisitMemberAccess(MemberExpression expression)
+        {
+            if (isLeftSide)
+            {
+                string fqColumn = GetFullyQualifiedColumnName(expression.Member, expression.Expression.Type);
+                _sb.Append(fqColumn);
+            }
+            else
+            {
+                // Add parameter to Command.Parameters
+                string paramName = string.Concat(_paramPrefix, "P", _command.Parameters.Count.ToString());
+                _sb.Append(paramName);
+
+                object value = GetRightValue(expression);
+                new ParameterChainMethods(_command, paramName, value);
+            }
+
+            return expression;
+        }
+
+        protected override Expression VisitConstant(ConstantExpression expression)
+        {
+            // Add parameter to Command.Parameters
+            string paramName = string.Concat(_paramPrefix, "P", _command.Parameters.Count.ToString());
+
+            _sb.Append(paramName);
+
+            var parameter = new ParameterChainMethods(_command, paramName, expression.Value).Parameter;
+            return expression;
+        }
+
+        private object GetRightValue(Expression rightExpression)
+        {
+            object rightValue = null;
+
+            var right = rightExpression as ConstantExpression;
+            if (right == null) // Value is not directly passed in as a constant
+            {
+                var rightMemberExp = (rightExpression as MemberExpression);
+                var parentMemberExpression = rightMemberExp.Expression as MemberExpression;
+                if (parentMemberExpression != null) // Value is passed in as a property on a parent entity
+                {
+                    string entityName = (rightMemberExp.Expression as MemberExpression).Member.Name;
+                    var container = ((rightMemberExp.Expression as MemberExpression).Expression as ConstantExpression).Value;
+                    var entity = _repos.ReflectionStrategy.GetFieldValue(container, entityName);
+                    rightValue = _repos.ReflectionStrategy.GetFieldValue(entity, rightMemberExp.Member.Name);
+                }
+                else // Value is passed in as a variable
+                {
+                    var parent = (rightMemberExp.Expression as ConstantExpression).Value;
+                    rightValue = _repos.ReflectionStrategy.GetFieldValue(parent, rightMemberExp.Member.Name);
+                }
+            }
+            else // Value is passed in directly as a constant
+            {
+                rightValue = right.Value;
+            }
+
+            return rightValue;
+        }
+
+        protected string GetFullyQualifiedColumnName(MemberInfo member, Type declaringType)
+        {
+            if (_tablePrefix)
+            {
+                Table table = _tables.FindTable(declaringType);
+
+                if (table == null)
+                {
+                    string msg = string.Format("The property '{0} -> {1}' you are trying to reference in the 'WHERE' statement belongs to an entity that has not been joined in your query.  To reference this property, you must join the '{0}' entity using the Join method.",
+                        declaringType,
+                        member.Name);
+
+                    throw new DataMappingException(msg);
+                }
+
+                string columnName = DataHelper.GetColumnName(declaringType, member.Name, _useAltName);
+                return _dialect.CreateToken(string.Format("{0}.{1}", table.Alias, columnName));
+            }
+            else
+            {
+                string columnName = DataHelper.GetColumnName(declaringType, member.Name, _useAltName);
+                return _dialect.CreateToken(columnName);
+            }
+        }
+
+        private string Decode(ExpressionType expType)
+        {
+            switch (expType)
+            {
+                case ExpressionType.AndAlso: return "AND";
+                case ExpressionType.And: return "AND";
+                case ExpressionType.Equal: return "=";
+                case ExpressionType.GreaterThan: return ">";
+                case ExpressionType.GreaterThanOrEqual: return ">=";
+                case ExpressionType.LessThan: return "<";
+                case ExpressionType.LessThanOrEqual: return "<=";
+                case ExpressionType.NotEqual: return "<>";
+                case ExpressionType.OrElse: return "OR";
+                case ExpressionType.Or: return "OR";
+                default: throw new NotSupportedException(string.Format("{0} statement is not supported", expType.ToString()));
+            }
+        }
+
+        private void Write_Contains(MethodCallExpression body)
+        {
+            // Add parameter to Command.Parameters
+            object value = GetRightValue(body.Arguments[0]);
+            string paramName = string.Concat(_paramPrefix, "P", _command.Parameters.Count.ToString());
+            var parameter = new ParameterChainMethods(_command, paramName, value).Parameter;
+
+            MemberExpression memberExp = (body.Object as MemberExpression);
+            string fqColumn = GetFullyQualifiedColumnName(memberExp.Member, memberExp.Expression.Type);
+            _sb.AppendFormat("({0} LIKE '%' + {1} + '%')", fqColumn, paramName);
+        }
+
+        private void Write_StartsWith(MethodCallExpression body)
+        {
+            // Add parameter to Command.Parameters
+            object value = GetRightValue(body.Arguments[0]);
+            string paramName = string.Concat(_paramPrefix, "P", _command.Parameters.Count.ToString());
+            var parameter = new ParameterChainMethods(_command, paramName, value).Parameter;
+
+            MemberExpression memberExp = (body.Object as MemberExpression);
+            string fqColumn = GetFullyQualifiedColumnName(memberExp.Member, memberExp.Expression.Type);
+            _sb.AppendFormat("({0} LIKE {1} + '%')", fqColumn, paramName);
+        }
+
+        private void Write_EndsWith(MethodCallExpression body)
+        {
+            // Add parameter to Command.Parameters
+            object value = GetRightValue(body.Arguments[0]);
+            string paramName = string.Concat(_paramPrefix, "P", _command.Parameters.Count.ToString());
+            var parameter = new ParameterChainMethods(_command, paramName, value).Parameter;
+
+            MemberExpression memberExp = (body.Object as MemberExpression);
+            string fqColumn = GetFullyQualifiedColumnName(memberExp.Member, memberExp.Expression.Type);
+            _sb.AppendFormat("({0} LIKE '%' + {1})", fqColumn, paramName);
+        }
+
+        /// <summary>
+        /// Appends the current where clause with another where clause.
+        /// </summary>
+        /// <param name="where">The second where clause that is being appended.</param>
+        /// <param name="appendType">AND / OR</param>
+        internal void Append(WhereBuilder<T> where, WhereAppendType appendType)
+        {
+            _constantWhereClause = string.Format("{0} {1} {2}",
+                this.ToString(),
+                appendType.ToString(),
+                where.ToString().Replace("WHERE ", string.Empty));
+        }
+
+        public override string ToString()
+        {
+            if (string.IsNullOrEmpty(_constantWhereClause))
+            {
+                return _sb.ToString();
+            }
+            else
+            {
+                return _constantWhereClause;
+            }
+        }
+    } 
+
+    internal enum WhereAppendType
+    {
+        AND,
+        OR
+    }
+}

Marr.Data/Reflection/CachedReflectionStrategy.cs

@@ -0,0 +1,90 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Reflection;
+using FastReflection;
+
+namespace Marr.Data.Reflection
+{
+    public class CachedReflectionStrategy : IReflectionStrategy
+    {
+        private FastReflection.CachedReflector _reflector;
+
+        public CachedReflectionStrategy()
+        {
+            _reflector = new CachedReflector();
+        }
+
+        /// <summary>
+        /// Sets an entity field value by name to the passed in 'val'.
+        /// </summary>
+        public void SetFieldValue<T>(T entity, string fieldName, object val)
+        {
+            MemberInfo member = entity.GetType().GetMember(fieldName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)[0];
+
+            try
+            {
+                // Handle DB null values
+                if (val == DBNull.Value)
+                {
+                    if (member.MemberType == MemberTypes.Field)
+                        _reflector.SetValue(member, entity, ReflectionHelper.GetDefaultValue((member as FieldInfo).FieldType));
+
+                    else if (member.MemberType == MemberTypes.Property)
+                    {
+                        var pi = (member as PropertyInfo);
+                        if (pi.CanWrite)
+                            _reflector.SetValue(member, entity, ReflectionHelper.GetDefaultValue((member as PropertyInfo).PropertyType));
+                    }
+                }
+                else
+                {
+                    if (member.MemberType == MemberTypes.Field)
+                        _reflector.SetValue(member, entity, val);
+                    else if (member.MemberType == MemberTypes.Property)
+                    {
+                        var pi = (member as PropertyInfo);
+                        if (pi.CanWrite)
+                            _reflector.SetValue(member, entity, val);
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                string msg = string.Format("The DataMapper was unable to load the following field: {0}.  \nDetails: {1}", fieldName, ex.Message);
+                throw new DataMappingException(msg, ex);
+            }
+        }
+
+        /// <summary>
+        /// Gets an entity field value by name.
+        /// </summary>
+        public object GetFieldValue(object entity, string fieldName)
+        {
+            MemberInfo member = entity.GetType().GetMember(fieldName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)[0];
+
+            if (member.MemberType == MemberTypes.Field)
+            {
+                return _reflector.GetValue(member, entity);
+            }
+            else if (member.MemberType == MemberTypes.Property)
+            {
+                if ((member as PropertyInfo).CanRead)
+                    return _reflector.GetValue(member, entity);
+            }
+
+            throw new DataMappingException(string.Format("The DataMapper could not get the value for {0}.{1}.", entity.GetType().Name, fieldName));
+        }
+
+        /// <summary>
+        /// Instantiantes a type using the FastReflector library for increased speed.
+        /// </summary>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        public object CreateInstance(Type type)
+        {
+            return _reflector.Instantiate(type);
+        }
+    }
+}

Marr.Data/Reflection/IReflectionStrategy.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Marr.Data.Reflection
+{
+    public interface IReflectionStrategy
+    {
+        void SetFieldValue<T>(T entity, string fieldName, object val);
+        object GetFieldValue(object entity, string fieldName);
+        object CreateInstance(Type type);
+    }
+}

Marr.Data/Reflection/ReflectionHelper.cs

@@ -0,0 +1,80 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Reflection;
+/* * 
+ * The FastReflection library was written by Renaud Bédard (renaud.bedard@gmail.com)
+ * http://theinstructionlimit.com/?p=76
+ * */
+using FastReflection;
+
+// ReSharper disable CheckNamespace
+namespace Marr.Data
+// ReSharper restore CheckNamespace
+{
+    public class ReflectionHelper
+    {
+        /// <summary>
+        /// Converts a DBNull.Value to a null for a reference field,
+        /// or the default value of a value field.
+        /// </summary>
+        /// <param name="fieldType"></param>
+        /// <returns></returns>
+        public static object GetDefaultValue(Type fieldType)
+        {
+            if (fieldType.IsGenericType)
+            {
+                return null;
+            }
+            else if (fieldType.IsValueType)
+            {
+                return Activator.CreateInstance(fieldType);
+            }
+            else
+            {
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Gets the CLR data type of a MemberInfo.  
+        /// If the type is nullable, returns the underlying type.
+        /// </summary>
+        /// <param name="member"></param>
+        /// <returns></returns>
+        public static Type GetMemberType(MemberInfo member)
+        {
+            Type memberType = null;
+            if (member.MemberType == MemberTypes.Property)
+                memberType = (member as PropertyInfo).PropertyType;
+            else if (member.MemberType == MemberTypes.Field)
+                memberType = (member as FieldInfo).FieldType;
+            else
+                memberType = typeof(object);
+
+            // Handle nullable types - get underlying type
+            if (memberType.IsGenericType && memberType.GetGenericTypeDefinition() == typeof(Nullable<>))
+            {
+                memberType = memberType.GetGenericArguments()[0];
+            }
+
+            return memberType;
+        }
+    }
+}

Marr.Data/Reflection/SimpleReflectionStrategy.cs

@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Reflection;
+using Marr.Data;
+
+namespace Marr.Data.Reflection
+{
+    public class SimpleReflectionStrategy : IReflectionStrategy
+    {
+        /// <summary>
+        /// Sets an entity field value by name to the passed in 'val'.
+        /// </summary>
+        public void SetFieldValue<T>(T entity, string fieldName, object val)
+        {
+            MemberInfo member = entity.GetType().GetMember(fieldName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)[0];
+
+            try
+            {
+                // Handle DB null values
+                if (val == DBNull.Value)
+                {
+                    if (member.MemberType == MemberTypes.Field)
+                        (member as FieldInfo).SetValue(entity, ReflectionHelper.GetDefaultValue((member as FieldInfo).FieldType));
+
+                    else if (member.MemberType == MemberTypes.Property)
+                    {
+                        var pi = (member as PropertyInfo);
+                        if (pi.CanWrite)
+                            (member as PropertyInfo).SetValue(entity, ReflectionHelper.GetDefaultValue((member as PropertyInfo).PropertyType), null);
+
+                    }
+                }
+                else
+                {
+                    if (member.MemberType == MemberTypes.Field)
+                        (member as FieldInfo).SetValue(entity, val);
+
+                    else if (member.MemberType == MemberTypes.Property)
+                    {
+                        var pi = (member as PropertyInfo);
+                        if (pi.CanWrite)
+                            (member as PropertyInfo).SetValue(entity, val, null);
+
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                string msg = string.Format("The DataMapper was unable to load the following field: {0}.  \nDetails: {1}", fieldName, ex.Message);
+                throw new DataMappingException(msg, ex);
+            }
+        }
+
+        /// <summary>
+        /// Gets an entity field value by name.
+        /// </summary>
+        public object GetFieldValue(object entity, string fieldName)
+        {
+            MemberInfo member = entity.GetType().GetMember(fieldName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)[0];
+
+            if (member.MemberType == MemberTypes.Field)
+            {
+                return (member as FieldInfo).GetValue(entity);
+            }
+            else if (member.MemberType == MemberTypes.Property)
+            {
+                if ((member as PropertyInfo).CanRead)
+                    return (member as PropertyInfo).GetValue(entity, null);
+            }
+            throw new DataMappingException(string.Format("The DataMapper could not get the value for {0}.{1}.", entity.GetType().Name, fieldName));
+        }
+
+        /// <summary>
+        /// Instantiantes a type using the FastReflector library for increased speed.
+        /// </summary>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        public object CreateInstance(Type type)
+        {
+            return Activator.CreateInstance(type);
+        }
+    }
+}

Marr.Data/SqlModesEnum.cs

@@ -0,0 +1,27 @@
+/*  Copyright (C) 2008 - 2011 Jordan Marr
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library. If not, see <http://www.gnu.org/licenses/>. */
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Marr.Data
+{
+    public enum SqlModes
+    {
+        StoredProcedure,
+        Text
+    }
+}

Marr.Data/UnitOfWork.cs

@@ -0,0 +1,128 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Marr.Data
+{
+    /// <summary>
+    /// The UnitOfWork class can be used to manage the lifetime of an IDataMapper, from creation to disposal.
+    /// When used in a "using" statement, the UnitOfWork will create and dispose an IDataMapper.
+    /// When the SharedContext property is used in a "using" statement, 
+    /// it will create a parent unit of work that will share a single IDataMapper with other units of work,
+    /// and the IDataMapper will not be disposed until the shared context is disposed.
+    /// If more than one shared context is created, the IDataMapper will be disposed when the outer most
+    /// shared context is disposed.
+    /// </summary>
+    /// <remarks>
+    /// It should be noted that the Dispose method on the UnitOfWork class only affects the managed IDataMapper.
+    /// The UnitOfWork instance itself is not affected by the Dispose method.
+    /// </remarks>
+    public class UnitOfWork : IDisposable
+    {
+        private Func<IDataMapper> _dbConstructor;
+        private IDataMapper _lazyLoadedDB;
+        private short _transactionCount;
+
+        public UnitOfWork(Func<IDataMapper> dbConstructor)
+        {
+            _dbConstructor = dbConstructor;
+        }
+
+        /// <summary>
+        /// Gets an IDataMapper object whose lifetime is managed by the UnitOfWork class.
+        /// </summary>
+        public IDataMapper DB
+        {
+            get
+            {
+                if (_lazyLoadedDB == null)
+                {
+                    _lazyLoadedDB = _dbConstructor.Invoke();
+                }
+
+                return _lazyLoadedDB;
+            }
+        }
+
+        /// <summary>
+        /// Instructs the UnitOfWork to share a single IDataMapper instance.
+        /// </summary>
+        public UnitOfWorkSharedContext SharedContext
+        {
+            get
+            {
+                return new UnitOfWorkSharedContext(this);
+            }
+        }
+
+        public void BeginTransaction()
+        {
+            // Only allow one transaction to begin
+            if (_transactionCount < 1)
+            {
+                DB.BeginTransaction();
+            }
+
+            _transactionCount++;
+        }
+
+        public void Commit()
+        {
+            // Only allow the outermost transaction to commit (all nested transactions must succeed)
+            if (_transactionCount == 1)
+            {
+                DB.Commit();
+            }
+
+            _transactionCount--;
+        }
+
+        public void RollBack()
+        {
+            // Any level transaction should be allowed to rollback
+            DB.RollBack();
+
+            // Throw an exception if a nested ShareContext transaction rolls back
+            if (_transactionCount > 1)
+            {
+                throw new NestedSharedContextRollBackException();
+            }
+
+            _transactionCount--;
+        }
+
+        public void Dispose()
+        {
+            if (!IsShared)
+            {
+                ForceDispose();
+            }
+        }
+
+        internal bool IsShared { get; set; }
+
+        private void ForceDispose()
+        {
+            _transactionCount = 0;
+
+            if (_lazyLoadedDB != null)
+            {
+                _lazyLoadedDB.Dispose();
+                _lazyLoadedDB = null;
+            }
+        }
+    }
+
+    [Serializable]
+    public class NestedSharedContextRollBackException : Exception
+    {
+        public NestedSharedContextRollBackException() { }
+        public NestedSharedContextRollBackException(string message) : base(message) { }
+        public NestedSharedContextRollBackException(string message, Exception inner) : base(message, inner) { }
+        protected NestedSharedContextRollBackException(
+          System.Runtime.Serialization.SerializationInfo info,
+          System.Runtime.Serialization.StreamingContext context)
+            : base(info, context) { }
+    }
+}

Marr.Data/UnitOfWorkSharedContext.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Marr.Data
+{
+    /// <summary>
+    /// Works in conjunction with the UnitOfWork to create a new 
+    /// shared context that will preserve a single IDataMapper.
+    /// </summary>
+    public class UnitOfWorkSharedContext : IDisposable
+    {
+        private UnitOfWork _mgr;
+        private bool _isParentContext;
+
+        public UnitOfWorkSharedContext(UnitOfWork mgr)
+        {
+            _mgr = mgr;
+
+            if (_mgr.IsShared)
+            {
+                _isParentContext = false;
+            }
+            else
+            {
+                _isParentContext = true;
+                _mgr.IsShared = true;
+            }
+        }
+
+        public void Dispose()
+        {
+            if (_isParentContext)
+            {
+                _mgr.IsShared = false;
+                _mgr.Dispose();
+            }
+        }
+    }
+}

NzbDrone.Api.Test/NzbDrone.Api.Test.csproj

@@ -11,6 +11,8 @@
     <AssemblyName>NzbDrone.Api.Test</AssemblyName>
     <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
+    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\</SolutionDir>
+    <RestorePackages>true</RestorePackages>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -81,6 +83,7 @@
     <None Include="packages.config" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <Import Project="$(SolutionDir)\.nuget\nuget.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">

NzbDrone.Api/Series/SeriesModule.cs

@@ -61,7 +61,6 @@ private Response AddSeries()
             //We also need to remove any special characters from the filename before attempting to create it           
 
             _seriesService.AddSeries(request.Title, request.Path, request.TvDbId, request.QualityProfileId, null);
-            _jobProvider.Enqueue(typeof(ImportNewSeriesJob));
 
             return new Response { StatusCode = HttpStatusCode.Created };
         }

NzbDrone.Core.Test/JobTests/ImportNewSeriesJobTest.cs

@@ -1,218 +0,0 @@
-
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using FizzWare.NBuilder;
-using Moq;
-using NUnit.Framework;
-using NzbDrone.Core.Jobs.Implementations;
-using NzbDrone.Core.MediaFiles;
-using NzbDrone.Core.Tv;
-using NzbDrone.Core.Jobs;
-using NzbDrone.Core.Model.Notification;
-using NzbDrone.Core.Providers;
-
-using NzbDrone.Core.Test.Framework;
-using NzbDrone.Test.Common;
-using NzbDrone.Test.Common.AutoMoq;
-
-namespace NzbDrone.Core.Test.JobTests
-{ 
-    [TestFixture]
-    
-    public class ImportNewSeriesJobTest : CoreTest
-    {
-        [Test]
-        public void import_new_series_succesful()
-        {
-            var series = Builder<Series>.CreateListOfSize(2)
-                     .All().With(s => s.LastInfoSync = null)
-                     .TheFirst(1).With(s => s.Id = 12)
-                     .TheNext(1).With(s => s.Id = 15)
-                        .Build();
-
-            var notification = new ProgressNotification("Test");
-
-            WithStrictMocker();
-
-            Mocker.GetMock<ISeriesRepository>()
-                .Setup(p => p.All())
-                .Returns(series);
-
-
-            Mocker.GetMock<DiskScanJob>()
-                .Setup(j => j.Start(notification, It.Is<object>(d => d.GetPropertyValue<int>("SeriesId") == series[0].Id)))
-                .Callback(() => series[0].LastDiskSync = DateTime.Now);
-
-            Mocker.GetMock<DiskScanJob>()
-                .Setup(j => j.Start(notification, It.Is<object>(d => d.GetPropertyValue<int>("SeriesId") == series[1].Id)))
-                .Callback(() => series[1].LastDiskSync = DateTime.Now);
-
-            Mocker.GetMock<XemUpdateJob>()
-                .Setup(j => j.Start(notification, It.Is<object>(d => d.GetPropertyValue<int>("SeriesId") > 0)));
-
-            Mocker.GetMock<UpdateInfoJob>()
-                .Setup(j => j.Start(notification, It.Is<object>(d => d.GetPropertyValue<int>("SeriesId") == series[0].Id)))
-                .Callback(() => series[0].LastInfoSync = DateTime.Now);
-
-            Mocker.GetMock<UpdateInfoJob>()
-                .Setup(j => j.Start(notification, It.Is<object>(d => d.GetPropertyValue<int>("SeriesId") == series[1].Id)))
-                .Callback(() => series[1].LastInfoSync = DateTime.Now);
-
-            Mocker.GetMock<ISeriesRepository>()
-                .Setup(s => s.Get(series[0].Id)).Returns(series[0]);
-
-            Mocker.GetMock<ISeriesRepository>()
-                .Setup(s => s.Get(series[1].Id)).Returns(series[1]);
-
-            Mocker.GetMock<IMediaFileService>()
-                .Setup(s => s.GetFilesBySeries(It.IsAny<int>())).Returns(new List<EpisodeFile>());
-
-            
-            Mocker.Resolve<ImportNewSeriesJob>().Start(notification, null);
-
-            
-            Mocker.GetMock<DiskScanJob>().Verify(j => j.Start(notification, It.Is<object>(d => d.GetPropertyValue<int>("SeriesId") == series[0].Id)), Times.Once());
-            Mocker.GetMock<DiskScanJob>().Verify(j => j.Start(notification, It.Is<object>(d => d.GetPropertyValue<int>("SeriesId") == series[1].Id)), Times.Once());
-
-            Mocker.GetMock<UpdateInfoJob>().Verify(j => j.Start(notification, It.Is<object>(d => d.GetPropertyValue<int>("SeriesId") == series[0].Id)), Times.Once());
-            Mocker.GetMock<UpdateInfoJob>().Verify(j => j.Start(notification, It.Is<object>(d => d.GetPropertyValue<int>("SeriesId") == series[1].Id)), Times.Once());
-
-        }
-
-
-
-
-        [Test]
-        [Timeout(3000)]
-        public void failed_import_should_not_be_stuck_in_loop()
-        {
-            var series = Builder<Series>.CreateListOfSize(2)
-                     .All().With(s => s.LastInfoSync = null)
-                     .TheFirst(1).With(s => s.Id = 12)
-                     .TheNext(1).With(s => s.Id = 15)
-                        .Build();
-
-            var notification = new ProgressNotification("Test");
-
-            WithStrictMocker();
-
-            Mocker.GetMock<ISeriesRepository>()
-                .Setup(p => p.All())
-                .Returns(series);
-
-            Mocker.GetMock<UpdateInfoJob>()
-                .Setup(j => j.Start(notification, It.Is<object>(d => d.GetPropertyValue<int>("SeriesId") == series[0].Id)))
-                .Callback(() => series[0].LastInfoSync = DateTime.Now);
-
-            Mocker.GetMock<UpdateInfoJob>()
-                .Setup(j => j.Start(notification, It.Is<object>(d => d.GetPropertyValue<int>("SeriesId") == series[1].Id)))
-                .Throws(new InvalidOperationException());
-
-            Mocker.GetMock<DiskScanJob>()
-                .Setup(j => j.Start(notification, It.Is<object>(d => d.GetPropertyValue<int>("SeriesId") == series[0].Id)))
-                .Callback(() => series[0].LastDiskSync = DateTime.Now);
-
-            Mocker.GetMock<ISeriesRepository>()
-                .Setup(s => s.Get(series[0].Id)).Returns(series[0]);
-
-            Mocker.GetMock<IMediaFileService>()
-                .Setup(s => s.GetFilesBySeries(It.IsAny<int>())).Returns(new List<EpisodeFile>());
-
-            Mocker.GetMock<XemUpdateJob>()
-                .Setup(j => j.Start(notification, It.Is<object>(d => d.GetPropertyValue<int>("SeriesId") == series[0].Id)));
-
-            
-            Mocker.Resolve<ImportNewSeriesJob>().Start(notification, null);
-
-            
-            Mocker.GetMock<UpdateInfoJob>().Verify(j => j.Start(notification, It.Is<object>(d => d.GetPropertyValue<int>("SeriesId") == series[0].Id)), Times.Once());
-            Mocker.GetMock<UpdateInfoJob>().Verify(j => j.Start(notification, It.Is<object>(d => d.GetPropertyValue<int>("SeriesId") == series[1].Id)), Times.Once());
-
-            Mocker.GetMock<DiskScanJob>().Verify(j => j.Start(notification, It.Is<object>(d => d.GetPropertyValue<int>("SeriesId") == series[0].Id)), Times.Once());
-
-            ExceptionVerification.ExpectedErrors(1);
-
-        }
-
-
-
-        [Test]
-        public void AutoIgnoreSeason_new_series_should_not_ignore_any()
-        {
-            int seriesId = 12;
-
-            WithStrictMocker();
-            Mocker.GetMock<IMediaFileService>()
-                .Setup(p => p.GetFilesBySeries(seriesId))
-                .Returns(new List<EpisodeFile>());
-
-            Mocker.GetMock<ISeasonRepository>()
-                .Setup(p => p.GetSeasonNumbers(seriesId))
-                .Returns(new List<int> { 0, 1, 2, 3, 4 });
-
-            Mocker.Resolve<ImportNewSeriesJob>().AutoIgnoreSeasons(seriesId);
-
-
-            Mocker.GetMock<ISeasonService>().Verify(p => p.SetIgnore(seriesId, It.IsAny<int>(), It.IsAny<Boolean>()), Times.Never());
-        }
-
-        [Test]
-        public void AutoIgnoreSeason_existing_should_not_ignore_currentseason()
-        {
-            int seriesId = 12;
-
-            var episodesFiles = Builder<EpisodeFile>.CreateListOfSize(2)
-            .All().With(e => e.SeriesId = seriesId)
-            .Build();
-
-            episodesFiles[0].SeasonNumber = 0;
-            episodesFiles[1].SeasonNumber = 1;
-
-            WithStrictMocker();
-
-            Mocker.GetMock<IMediaFileService>()
-                .Setup(p => p.GetFilesBySeries(seriesId))
-                .Returns(episodesFiles.ToList());
-
-            Mocker.GetMock<ISeasonRepository>()
-                .Setup(p => p.GetSeasonNumbers(seriesId))
-                .Returns(new List<int> { 0, 1, 2 });
-
-            Mocker.Resolve<ImportNewSeriesJob>().AutoIgnoreSeasons(seriesId);
-
-            Mocker.GetMock<ISeasonService>().Verify(p => p.SetIgnore(seriesId, 2, It.IsAny<Boolean>()), Times.Never());
-        }
-
-        [Test]
-        public void AutoIgnoreSeason_existing_should_ignore_seasons_with_no_file()
-        {
-            int seriesId = 12;
-
-            var episodesFiles = Builder<EpisodeFile>.CreateListOfSize(2)
-            .All().With(e => e.SeriesId = seriesId)
-            .Build();
-
-            episodesFiles[0].SeasonNumber = 1;
-
-            
-
-            Mocker.GetMock<IMediaFileService>()
-                .Setup(p => p.GetFilesBySeries(seriesId))
-                .Returns(episodesFiles.ToList());
-
-            Mocker.GetMock<ISeasonRepository>()
-                .Setup(p => p.GetSeasonNumbers(seriesId))
-                .Returns(new List<int> { 0, 1, 2 });
-
-            Mocker.Resolve<ImportNewSeriesJob>().AutoIgnoreSeasons(seriesId);
-
-            Mocker.GetMock<ISeasonService>().Verify(p => p.SetIgnore(seriesId, 0, true), Times.Once());
-            Mocker.GetMock<ISeasonService>().Verify(p => p.SetIgnore(seriesId, 1, true), Times.Never());
-            Mocker.GetMock<ISeasonService>().Verify(p => p.SetIgnore(seriesId, 2, It.IsAny<Boolean>()), Times.Never());
-        }
-    }
-
-
-}

NzbDrone.Core.Test/NzbDrone.Core.Test.csproj

@@ -67,10 +67,6 @@
     <Reference Include="AutoMoq">
       <HintPath>..\packages\AutoMoq.1.6.1\lib\AutoMoq.dll</HintPath>
     </Reference>
-    <Reference Include="FastReflection, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\packages\MarrDataMapper.3.17.4747.34302\lib\FastReflection.dll</HintPath>
-    </Reference>
     <Reference Include="FizzWare.NBuilder, Version=3.0.1.0, Culture=neutral, PublicKeyToken=5651b03e12e42c12, processorArchitecture=MSIL">
       <HintPath>..\packages\NBuilder.3.0.1.1\lib\FizzWare.NBuilder.dll</HintPath>
     </Reference>
@@ -84,10 +80,6 @@
     <Reference Include="FluentMigrator.Runner">
       <HintPath>..\packages\FluentMigrator.1.0.6.0\tools\FluentMigrator.Runner.dll</HintPath>
     </Reference>
-    <Reference Include="Marr.Data, Version=3.17.4747.34302, Culture=neutral, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\packages\MarrDataMapper.3.17.4747.34302\lib\Marr.Data.dll</HintPath>
-    </Reference>
     <Reference Include="Microsoft.CSharp" />
     <Reference Include="Microsoft.Practices.ServiceLocation, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
@@ -235,7 +227,6 @@
     <Compile Include="DecisionEngineTests\MonitoredEpisodeSpecificationFixture.cs" />
     <Compile Include="ProviderTests\DownloadProviderTests\DownloadProviderFixture.cs" />
     <Compile Include="EpisodeStatusTest.cs" />
-    <Compile Include="JobTests\ImportNewSeriesJobTest.cs" />
     <Compile Include="JobTests\DiskScanJobTest.cs" />
     <Compile Include="IndexerTests\IndexerFixture.cs" />
     <Compile Include="DecisionEngineTests\AllowedDownloadSpecificationFixture.cs" />
@@ -258,6 +249,10 @@
     <Compile Include="XbmcVersionTests.cs" />
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\Marr.Data\Marr.Data.csproj">
+      <Project>{f6fc6be7-0847-4817-a1ed-223dc647c3d7}</Project>
+      <Name>Marr.Data</Name>
+    </ProjectReference>
     <ProjectReference Include="..\NzbDrone.Common\NzbDrone.Common.csproj">
       <Project>{F2BE0FDF-6E47-4827-A420-DD4EF82407F8}</Project>
       <Name>NzbDrone.Common</Name>

NzbDrone.Core.Test/packages.config

@@ -5,7 +5,6 @@
   <package id="CommonServiceLocator" version="1.0" targetFramework="net40" />
   <package id="FluentAssertions" version="2.0.1" targetFramework="net40" />
   <package id="FluentMigrator" version="1.0.6.0" targetFramework="net40" />
-  <package id="MarrDataMapper" version="3.17.4747.34302" targetFramework="net40" />
   <package id="Moq" version="4.0.10827" />
   <package id="NBuilder" version="3.0.1.1" />
   <package id="NCrunch.Framework" version="1.43.0.23" targetFramework="net40" />

NzbDrone.Core/Jobs/Implementations/ImportNewSeriesJob.cs

@@ -1,118 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using NLog;
-using NzbDrone.Core.Datastore;
-using NzbDrone.Core.MediaFiles;
-using NzbDrone.Core.Model.Notification;
-using NzbDrone.Core.Tv;
-
-namespace NzbDrone.Core.Jobs.Implementations
-{
-    /// <summary>
-    /// This job processes newly added jobs by downloading their info
-    /// from TheTVDB.org and doing a disk scan. this job should only 
-    /// </summary>
-    public class ImportNewSeriesJob : IJob
-    {
-        private readonly IMediaFileService _mediaFileService;
-        private readonly UpdateInfoJob _updateInfoJob;
-        private readonly DiskScanJob _diskScanJob;
-        private readonly ISeasonRepository _seasonRepository;
-        private readonly XemUpdateJob _xemUpdateJob;
-        private readonly ISeriesRepository _seriesRepository;
-        private readonly ISeasonService _seasonService;
-
-        private static readonly Logger Logger = LogManager.GetCurrentClassLogger();
-
-        private List<int> _attemptedSeries;
-
-        public ImportNewSeriesJob(IMediaFileService mediaFileService, UpdateInfoJob updateInfoJob,
-                                    DiskScanJob diskScanJob,
-                                    ISeasonRepository seasonRepository, XemUpdateJob xemUpdateJob, ISeriesRepository seriesRepository, ISeasonService seasonService)
-        {
-            _mediaFileService = mediaFileService;
-            _updateInfoJob = updateInfoJob;
-            _diskScanJob = diskScanJob;
-            _seasonRepository = seasonRepository;
-            _xemUpdateJob = xemUpdateJob;
-            _seriesRepository = seriesRepository;
-            _seasonService = seasonService;
-        }
-
-        public string Name
-        {
-            get { return "Import New Series"; }
-        }
-
-        public TimeSpan DefaultInterval
-        {
-            get { return TimeSpan.FromHours(6); }
-        }
-
-        public void Start(ProgressNotification notification, dynamic options)
-        {
-            _attemptedSeries = new List<int>();
-            ScanSeries(notification);
-        }
-
-        private void ScanSeries(ProgressNotification notification)
-        {
-            var syncList = _seriesRepository.All().Where(s => s.LastInfoSync == null && !_attemptedSeries.Contains(s.Id)).ToList();
-            if (syncList.Count == 0)
-            {
-                return;
-            }
-
-            foreach (var currentSeries in syncList)
-            {
-                try
-                {
-                    _attemptedSeries.Add(((ModelBase)currentSeries).Id);
-                    notification.CurrentMessage = String.Format("Searching for '{0}'", new DirectoryInfo(currentSeries.Path).Name);
-
-                    _updateInfoJob.Start(notification, new { SeriesId = ((ModelBase)currentSeries).Id });
-                    _diskScanJob.Start(notification, new { SeriesId = ((ModelBase)currentSeries).Id });
-
-                    var updatedSeries = _seriesRepository.Get(((ModelBase)currentSeries).Id);
-                    AutoIgnoreSeasons(((ModelBase)updatedSeries).Id);
-
-                    //Get Scene Numbering if applicable
-                    _xemUpdateJob.Start(notification, new { SeriesId = ((ModelBase)updatedSeries).Id });
-
-                    notification.CurrentMessage = String.Format("{0} was successfully imported", updatedSeries.Title);
-                }
-
-                catch (Exception e)
-                {
-                    Logger.ErrorException(e.Message, e);
-                }
-            }
-
-            //Keep scanning until there no more shows left.
-            ScanSeries(notification);
-        }
-
-        public void AutoIgnoreSeasons(int seriesId)
-        {
-            //Todo: Need to convert this over to ObjectDb
-            return;
-            var episodeFiles = _mediaFileService.GetFilesBySeries(seriesId);
-
-            if (episodeFiles.Count() != 0)
-            {
-                var seasons = _seasonRepository.GetSeasonNumbers(seriesId);
-                var currentSeasons = seasons.Max();
-
-                foreach (var season in seasons)
-                {
-                    if (season != currentSeasons && !episodeFiles.Any(e => e.SeasonNumber == season))
-                    {
-                        _seasonService.SetIgnore(seriesId, season, true);
-                    }
-                }
-            }
-        }
-    }
-}

NzbDrone.Core/Jobs/Implementations/UpdateInfoJob.cs

@@ -46,18 +46,21 @@ public TimeSpan DefaultInterval
 
         public virtual void Start(ProgressNotification notification, dynamic options)
         {
-            IList<Series> ListOfSeriesToUpdate;
+            IList<Series> listOfSeriesToUpdate;
             if (options == null || options.SeriesId == 0)
             {
                 if (_configService.IgnoreArticlesWhenSortingSeries)
-                    ListOfSeriesToUpdate = _seriesRepository.All().OrderBy(o => o.Title.IgnoreArticles()).ToList();
-
-                else
-                    ListOfSeriesToUpdate = _seriesRepository.All().OrderBy(o => o.Title).ToList();
+                {
+                    listOfSeriesToUpdate = _seriesRepository.All().OrderBy(o => o.Title.IgnoreArticles()).ToList();
                 }
                 else
                 {
-                ListOfSeriesToUpdate = new List<Series>
+                    listOfSeriesToUpdate = _seriesRepository.All().OrderBy(o => o.Title).ToList();
+                }
+            }
+            else
+            {
+                listOfSeriesToUpdate = new List<Series>
                     {
                         _seriesRepository.Get((int) options.SeriesId)
                     };
@@ -66,7 +69,7 @@ public virtual void Start(ProgressNotification notification, dynamic options)
             //Update any Daily Series in the DB with the IsDaily flag
             _dailySeriesService.UpdateDailySeries();
 
-            foreach (var seriesToUpdate in ListOfSeriesToUpdate)
+            foreach (var seriesToUpdate in listOfSeriesToUpdate)
             {
                 var series = seriesToUpdate;
 

NzbDrone.Core/NzbDrone.Core.csproj

@@ -133,9 +133,6 @@
     <Reference Include="FluentMigrator.Runner">
       <HintPath>..\packages\FluentMigrator.1.0.6.0\tools\FluentMigrator.Runner.dll</HintPath>
     </Reference>
-    <Reference Include="FastReflection">
-      <HintPath>..\packages\MarrDataMapper.3.17.4747.34302\lib\FastReflection.dll</HintPath>
-    </Reference>
     <Reference Include="Growl.Connector">
       <HintPath>..\packages\Growl.0.6\lib\Growl.Connector.dll</HintPath>
     </Reference>
@@ -145,9 +142,6 @@
     <Reference Include="Ionic.Zip">
       <HintPath>..\packages\DotNetZip.1.9.1.8\lib\net20\Ionic.Zip.dll</HintPath>
     </Reference>
-    <Reference Include="Marr.Data">
-      <HintPath>..\packages\MarrDataMapper.3.17.4747.34302\lib\Marr.Data.dll</HintPath>
-    </Reference>
     <Reference Include="MediaInfoDotNet">
       <HintPath>..\packages\MediaInfoNet.0.3\lib\MediaInfoDotNet.dll</HintPath>
     </Reference>
@@ -255,7 +249,6 @@
     <Compile Include="Jobs\Implementations\DiskScanJob.cs" />
     <Compile Include="Jobs\Implementations\EmptyRecycleBinJob.cs" />
     <Compile Include="Jobs\Implementations\EpisodeSearchJob.cs" />
-    <Compile Include="Jobs\Implementations\ImportNewSeriesJob.cs" />
     <Compile Include="Jobs\Implementations\PastWeekBacklogSearchJob.cs" />
     <Compile Include="Jobs\Implementations\PostDownloadScanJob.cs" />
     <Compile Include="Jobs\Implementations\RecentBacklogSearchJob.cs" />
@@ -577,6 +570,10 @@
     <EmbeddedResource Include="NzbDrone.jpg" />
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\Marr.Data\Marr.Data.csproj">
+      <Project>{F6FC6BE7-0847-4817-A1ED-223DC647C3D7}</Project>
+      <Name>Marr.Data</Name>
+    </ProjectReference>
     <ProjectReference Include="..\NzbDrone.Common\NzbDrone.Common.csproj">
       <Project>{F2BE0FDF-6E47-4827-A420-DD4EF82407F8}</Project>
       <Name>NzbDrone.Common</Name>

NzbDrone.Core/Tv/SeriesService.cs

@@ -26,7 +26,7 @@ public interface ISeriesService
         void DeleteSeries(int seriesId, bool deleteFiles);
     }
 
-    public class SeriesService : ISeriesService
+    public class SeriesService : ISeriesService, IHandleAsync<SeriesAddedEvent>
     {
         private readonly ISeriesRepository _seriesRepository;
         private readonly IConfigService _configService;
@@ -178,5 +178,10 @@ public void DeleteSeries(int seriesId, bool deleteFiles)
             _seriesRepository.Delete(seriesId);
             _eventAggregator.Publish(new SeriesDeletedEvent(series, deleteFiles));
         }
+
+        public void HandleAsync(SeriesAddedEvent message)
+        {
+            UpdateSeriesInfo(message.Series.Id);
+        }
     }
 }

NzbDrone.Core/packages.config

@@ -4,7 +4,6 @@
   <package id="DotNetZip" version="1.9.1.8" />
   <package id="FluentMigrator" version="1.0.6.0" targetFramework="net40" />
   <package id="Growl" version="0.6" />
-  <package id="MarrDataMapper" version="3.17.4747.34302" targetFramework="net40" />
   <package id="MediaInfoNet" version="0.3" targetFramework="net40" />
   <package id="Newtonsoft.Json" version="4.5.11" targetFramework="net40" />
   <package id="NLog" version="2.0.0.2000" />

NzbDrone.sln

@@ -44,72 +44,208 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NzbDrone.Console", "NzbDron
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NzbDrone.Api.Test", "NzbDrone.Api.Test\NzbDrone.Api.Test.csproj", "{D18A5DEB-5102-4775-A1AF-B75DAAA8907B}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Marr.Data", "Marr.Data\Marr.Data.csproj", "{F6FC6BE7-0847-4817-A1ED-223DC647C3D7}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Debug|Mixed Platforms = Debug|Mixed Platforms
 		Debug|x86 = Debug|x86
+		Release|Any CPU = Release|Any CPU
+		Release|Mixed Platforms = Release|Mixed Platforms
 		Release|x86 = Release|x86
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{D12F7F2F-8A3C-415F-88FA-6DD061A84869}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{D12F7F2F-8A3C-415F-88FA-6DD061A84869}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{D12F7F2F-8A3C-415F-88FA-6DD061A84869}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
+		{D12F7F2F-8A3C-415F-88FA-6DD061A84869}.Debug|Mixed Platforms.Build.0 = Debug|x86
 		{D12F7F2F-8A3C-415F-88FA-6DD061A84869}.Debug|x86.ActiveCfg = Debug|x86
 		{D12F7F2F-8A3C-415F-88FA-6DD061A84869}.Debug|x86.Build.0 = Debug|x86
+		{D12F7F2F-8A3C-415F-88FA-6DD061A84869}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{D12F7F2F-8A3C-415F-88FA-6DD061A84869}.Release|Any CPU.Build.0 = Release|Any CPU
+		{D12F7F2F-8A3C-415F-88FA-6DD061A84869}.Release|Mixed Platforms.ActiveCfg = Release|x86
+		{D12F7F2F-8A3C-415F-88FA-6DD061A84869}.Release|Mixed Platforms.Build.0 = Release|x86
 		{D12F7F2F-8A3C-415F-88FA-6DD061A84869}.Release|x86.ActiveCfg = Release|x86
 		{D12F7F2F-8A3C-415F-88FA-6DD061A84869}.Release|x86.Build.0 = Release|x86
+		{FF5EE3B6-913B-47CE-9CEB-11C51B4E1205}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{FF5EE3B6-913B-47CE-9CEB-11C51B4E1205}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{FF5EE3B6-913B-47CE-9CEB-11C51B4E1205}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
+		{FF5EE3B6-913B-47CE-9CEB-11C51B4E1205}.Debug|Mixed Platforms.Build.0 = Debug|x86
 		{FF5EE3B6-913B-47CE-9CEB-11C51B4E1205}.Debug|x86.ActiveCfg = Debug|x86
 		{FF5EE3B6-913B-47CE-9CEB-11C51B4E1205}.Debug|x86.Build.0 = Debug|x86
+		{FF5EE3B6-913B-47CE-9CEB-11C51B4E1205}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{FF5EE3B6-913B-47CE-9CEB-11C51B4E1205}.Release|Any CPU.Build.0 = Release|Any CPU
+		{FF5EE3B6-913B-47CE-9CEB-11C51B4E1205}.Release|Mixed Platforms.ActiveCfg = Release|x86
+		{FF5EE3B6-913B-47CE-9CEB-11C51B4E1205}.Release|Mixed Platforms.Build.0 = Release|x86
 		{FF5EE3B6-913B-47CE-9CEB-11C51B4E1205}.Release|x86.ActiveCfg = Release|x86
 		{FF5EE3B6-913B-47CE-9CEB-11C51B4E1205}.Release|x86.Build.0 = Release|x86
+		{193ADD3B-792B-4173-8E4C-5A3F8F0237F0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{193ADD3B-792B-4173-8E4C-5A3F8F0237F0}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{193ADD3B-792B-4173-8E4C-5A3F8F0237F0}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
+		{193ADD3B-792B-4173-8E4C-5A3F8F0237F0}.Debug|Mixed Platforms.Build.0 = Debug|x86
 		{193ADD3B-792B-4173-8E4C-5A3F8F0237F0}.Debug|x86.ActiveCfg = Debug|x86
 		{193ADD3B-792B-4173-8E4C-5A3F8F0237F0}.Debug|x86.Build.0 = Debug|x86
+		{193ADD3B-792B-4173-8E4C-5A3F8F0237F0}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{193ADD3B-792B-4173-8E4C-5A3F8F0237F0}.Release|Any CPU.Build.0 = Release|Any CPU
+		{193ADD3B-792B-4173-8E4C-5A3F8F0237F0}.Release|Mixed Platforms.ActiveCfg = Release|x86
+		{193ADD3B-792B-4173-8E4C-5A3F8F0237F0}.Release|Mixed Platforms.Build.0 = Release|x86
 		{193ADD3B-792B-4173-8E4C-5A3F8F0237F0}.Release|x86.ActiveCfg = Release|x86
 		{193ADD3B-792B-4173-8E4C-5A3F8F0237F0}.Release|x86.Build.0 = Release|x86
+		{C0EA1A40-91AD-4EEB-BD16-2DDDEBD20AE5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{C0EA1A40-91AD-4EEB-BD16-2DDDEBD20AE5}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{C0EA1A40-91AD-4EEB-BD16-2DDDEBD20AE5}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
+		{C0EA1A40-91AD-4EEB-BD16-2DDDEBD20AE5}.Debug|Mixed Platforms.Build.0 = Debug|x86
 		{C0EA1A40-91AD-4EEB-BD16-2DDDEBD20AE5}.Debug|x86.ActiveCfg = Debug|x86
 		{C0EA1A40-91AD-4EEB-BD16-2DDDEBD20AE5}.Debug|x86.Build.0 = Debug|x86
+		{C0EA1A40-91AD-4EEB-BD16-2DDDEBD20AE5}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{C0EA1A40-91AD-4EEB-BD16-2DDDEBD20AE5}.Release|Any CPU.Build.0 = Release|Any CPU
+		{C0EA1A40-91AD-4EEB-BD16-2DDDEBD20AE5}.Release|Mixed Platforms.ActiveCfg = Release|x86
+		{C0EA1A40-91AD-4EEB-BD16-2DDDEBD20AE5}.Release|Mixed Platforms.Build.0 = Release|x86
 		{C0EA1A40-91AD-4EEB-BD16-2DDDEBD20AE5}.Release|x86.ActiveCfg = Release|x86
 		{C0EA1A40-91AD-4EEB-BD16-2DDDEBD20AE5}.Release|x86.Build.0 = Release|x86
+		{FAFB5948-A222-4CF6-AD14-026BE7564802}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{FAFB5948-A222-4CF6-AD14-026BE7564802}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{FAFB5948-A222-4CF6-AD14-026BE7564802}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
+		{FAFB5948-A222-4CF6-AD14-026BE7564802}.Debug|Mixed Platforms.Build.0 = Debug|x86
 		{FAFB5948-A222-4CF6-AD14-026BE7564802}.Debug|x86.ActiveCfg = Debug|x86
 		{FAFB5948-A222-4CF6-AD14-026BE7564802}.Debug|x86.Build.0 = Debug|x86
+		{FAFB5948-A222-4CF6-AD14-026BE7564802}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{FAFB5948-A222-4CF6-AD14-026BE7564802}.Release|Any CPU.Build.0 = Release|Any CPU
+		{FAFB5948-A222-4CF6-AD14-026BE7564802}.Release|Mixed Platforms.ActiveCfg = Release|x86
+		{FAFB5948-A222-4CF6-AD14-026BE7564802}.Release|Mixed Platforms.Build.0 = Release|x86
 		{FAFB5948-A222-4CF6-AD14-026BE7564802}.Release|x86.ActiveCfg = Release|x86
 		{FAFB5948-A222-4CF6-AD14-026BE7564802}.Release|x86.Build.0 = Release|x86
+		{4CCC53CD-8D5E-4CC4-97D2-5C9312AC2BD7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{4CCC53CD-8D5E-4CC4-97D2-5C9312AC2BD7}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{4CCC53CD-8D5E-4CC4-97D2-5C9312AC2BD7}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
+		{4CCC53CD-8D5E-4CC4-97D2-5C9312AC2BD7}.Debug|Mixed Platforms.Build.0 = Debug|x86
 		{4CCC53CD-8D5E-4CC4-97D2-5C9312AC2BD7}.Debug|x86.ActiveCfg = Debug|x86
 		{4CCC53CD-8D5E-4CC4-97D2-5C9312AC2BD7}.Debug|x86.Build.0 = Debug|x86
+		{4CCC53CD-8D5E-4CC4-97D2-5C9312AC2BD7}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{4CCC53CD-8D5E-4CC4-97D2-5C9312AC2BD7}.Release|Any CPU.Build.0 = Release|Any CPU
+		{4CCC53CD-8D5E-4CC4-97D2-5C9312AC2BD7}.Release|Mixed Platforms.ActiveCfg = Release|x86
+		{4CCC53CD-8D5E-4CC4-97D2-5C9312AC2BD7}.Release|Mixed Platforms.Build.0 = Release|x86
 		{4CCC53CD-8D5E-4CC4-97D2-5C9312AC2BD7}.Release|x86.ActiveCfg = Release|x86
 		{4CCC53CD-8D5E-4CC4-97D2-5C9312AC2BD7}.Release|x86.Build.0 = Release|x86
+		{35388E8E-0CDB-4A84-AD16-E4B6EFDA5D97}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{35388E8E-0CDB-4A84-AD16-E4B6EFDA5D97}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{35388E8E-0CDB-4A84-AD16-E4B6EFDA5D97}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
+		{35388E8E-0CDB-4A84-AD16-E4B6EFDA5D97}.Debug|Mixed Platforms.Build.0 = Debug|x86
 		{35388E8E-0CDB-4A84-AD16-E4B6EFDA5D97}.Debug|x86.ActiveCfg = Debug|x86
 		{35388E8E-0CDB-4A84-AD16-E4B6EFDA5D97}.Debug|x86.Build.0 = Debug|x86
+		{35388E8E-0CDB-4A84-AD16-E4B6EFDA5D97}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{35388E8E-0CDB-4A84-AD16-E4B6EFDA5D97}.Release|Any CPU.Build.0 = Release|Any CPU
+		{35388E8E-0CDB-4A84-AD16-E4B6EFDA5D97}.Release|Mixed Platforms.ActiveCfg = Release|x86
+		{35388E8E-0CDB-4A84-AD16-E4B6EFDA5D97}.Release|Mixed Platforms.Build.0 = Release|x86
 		{35388E8E-0CDB-4A84-AD16-E4B6EFDA5D97}.Release|x86.ActiveCfg = Release|x86
 		{35388E8E-0CDB-4A84-AD16-E4B6EFDA5D97}.Release|x86.Build.0 = Release|x86
+		{F2BE0FDF-6E47-4827-A420-DD4EF82407F8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F2BE0FDF-6E47-4827-A420-DD4EF82407F8}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F2BE0FDF-6E47-4827-A420-DD4EF82407F8}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
+		{F2BE0FDF-6E47-4827-A420-DD4EF82407F8}.Debug|Mixed Platforms.Build.0 = Debug|x86
 		{F2BE0FDF-6E47-4827-A420-DD4EF82407F8}.Debug|x86.ActiveCfg = Debug|x86
 		{F2BE0FDF-6E47-4827-A420-DD4EF82407F8}.Debug|x86.Build.0 = Debug|x86
+		{F2BE0FDF-6E47-4827-A420-DD4EF82407F8}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F2BE0FDF-6E47-4827-A420-DD4EF82407F8}.Release|Any CPU.Build.0 = Release|Any CPU
+		{F2BE0FDF-6E47-4827-A420-DD4EF82407F8}.Release|Mixed Platforms.ActiveCfg = Release|x86
+		{F2BE0FDF-6E47-4827-A420-DD4EF82407F8}.Release|Mixed Platforms.Build.0 = Release|x86
 		{F2BE0FDF-6E47-4827-A420-DD4EF82407F8}.Release|x86.ActiveCfg = Release|x86
 		{F2BE0FDF-6E47-4827-A420-DD4EF82407F8}.Release|x86.Build.0 = Release|x86
+		{BEC74619-DDBB-4FBA-B517-D3E20AFC9997}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{BEC74619-DDBB-4FBA-B517-D3E20AFC9997}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{BEC74619-DDBB-4FBA-B517-D3E20AFC9997}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
+		{BEC74619-DDBB-4FBA-B517-D3E20AFC9997}.Debug|Mixed Platforms.Build.0 = Debug|x86
 		{BEC74619-DDBB-4FBA-B517-D3E20AFC9997}.Debug|x86.ActiveCfg = Debug|x86
 		{BEC74619-DDBB-4FBA-B517-D3E20AFC9997}.Debug|x86.Build.0 = Debug|x86
+		{BEC74619-DDBB-4FBA-B517-D3E20AFC9997}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{BEC74619-DDBB-4FBA-B517-D3E20AFC9997}.Release|Any CPU.Build.0 = Release|Any CPU
+		{BEC74619-DDBB-4FBA-B517-D3E20AFC9997}.Release|Mixed Platforms.ActiveCfg = Release|x86
+		{BEC74619-DDBB-4FBA-B517-D3E20AFC9997}.Release|Mixed Platforms.Build.0 = Release|x86
 		{BEC74619-DDBB-4FBA-B517-D3E20AFC9997}.Release|x86.ActiveCfg = Release|x86
 		{BEC74619-DDBB-4FBA-B517-D3E20AFC9997}.Release|x86.Build.0 = Release|x86
+		{CADDFCE0-7509-4430-8364-2074E1EEFCA2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{CADDFCE0-7509-4430-8364-2074E1EEFCA2}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{CADDFCE0-7509-4430-8364-2074E1EEFCA2}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
+		{CADDFCE0-7509-4430-8364-2074E1EEFCA2}.Debug|Mixed Platforms.Build.0 = Debug|x86
 		{CADDFCE0-7509-4430-8364-2074E1EEFCA2}.Debug|x86.ActiveCfg = Debug|x86
 		{CADDFCE0-7509-4430-8364-2074E1EEFCA2}.Debug|x86.Build.0 = Debug|x86
+		{CADDFCE0-7509-4430-8364-2074E1EEFCA2}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{CADDFCE0-7509-4430-8364-2074E1EEFCA2}.Release|Any CPU.Build.0 = Release|Any CPU
+		{CADDFCE0-7509-4430-8364-2074E1EEFCA2}.Release|Mixed Platforms.ActiveCfg = Release|x86
+		{CADDFCE0-7509-4430-8364-2074E1EEFCA2}.Release|Mixed Platforms.Build.0 = Release|x86
 		{CADDFCE0-7509-4430-8364-2074E1EEFCA2}.Release|x86.ActiveCfg = Release|x86
 		{CADDFCE0-7509-4430-8364-2074E1EEFCA2}.Release|x86.Build.0 = Release|x86
+		{6BCE712F-846D-4846-9D1B-A66B858DA755}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{6BCE712F-846D-4846-9D1B-A66B858DA755}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{6BCE712F-846D-4846-9D1B-A66B858DA755}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
+		{6BCE712F-846D-4846-9D1B-A66B858DA755}.Debug|Mixed Platforms.Build.0 = Debug|x86
 		{6BCE712F-846D-4846-9D1B-A66B858DA755}.Debug|x86.ActiveCfg = Debug|x86
 		{6BCE712F-846D-4846-9D1B-A66B858DA755}.Debug|x86.Build.0 = Debug|x86
+		{6BCE712F-846D-4846-9D1B-A66B858DA755}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{6BCE712F-846D-4846-9D1B-A66B858DA755}.Release|Any CPU.Build.0 = Release|Any CPU
+		{6BCE712F-846D-4846-9D1B-A66B858DA755}.Release|Mixed Platforms.ActiveCfg = Release|x86
+		{6BCE712F-846D-4846-9D1B-A66B858DA755}.Release|Mixed Platforms.Build.0 = Release|x86
 		{6BCE712F-846D-4846-9D1B-A66B858DA755}.Release|x86.ActiveCfg = Release|x86
 		{6BCE712F-846D-4846-9D1B-A66B858DA755}.Release|x86.Build.0 = Release|x86
+		{700D0B95-95CD-43F3-B6C9-FAA0FC1358D4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{700D0B95-95CD-43F3-B6C9-FAA0FC1358D4}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{700D0B95-95CD-43F3-B6C9-FAA0FC1358D4}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
+		{700D0B95-95CD-43F3-B6C9-FAA0FC1358D4}.Debug|Mixed Platforms.Build.0 = Debug|x86
 		{700D0B95-95CD-43F3-B6C9-FAA0FC1358D4}.Debug|x86.ActiveCfg = Debug|x86
 		{700D0B95-95CD-43F3-B6C9-FAA0FC1358D4}.Debug|x86.Build.0 = Debug|x86
+		{700D0B95-95CD-43F3-B6C9-FAA0FC1358D4}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{700D0B95-95CD-43F3-B6C9-FAA0FC1358D4}.Release|Any CPU.Build.0 = Release|Any CPU
+		{700D0B95-95CD-43F3-B6C9-FAA0FC1358D4}.Release|Mixed Platforms.ActiveCfg = Release|x86
+		{700D0B95-95CD-43F3-B6C9-FAA0FC1358D4}.Release|Mixed Platforms.Build.0 = Release|x86
 		{700D0B95-95CD-43F3-B6C9-FAA0FC1358D4}.Release|x86.ActiveCfg = Release|x86
 		{700D0B95-95CD-43F3-B6C9-FAA0FC1358D4}.Release|x86.Build.0 = Release|x86
+		{FD286DF8-2D3A-4394-8AD5-443FADE55FB2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{FD286DF8-2D3A-4394-8AD5-443FADE55FB2}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{FD286DF8-2D3A-4394-8AD5-443FADE55FB2}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
+		{FD286DF8-2D3A-4394-8AD5-443FADE55FB2}.Debug|Mixed Platforms.Build.0 = Debug|x86
 		{FD286DF8-2D3A-4394-8AD5-443FADE55FB2}.Debug|x86.ActiveCfg = Debug|x86
 		{FD286DF8-2D3A-4394-8AD5-443FADE55FB2}.Debug|x86.Build.0 = Debug|x86
+		{FD286DF8-2D3A-4394-8AD5-443FADE55FB2}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{FD286DF8-2D3A-4394-8AD5-443FADE55FB2}.Release|Any CPU.Build.0 = Release|Any CPU
+		{FD286DF8-2D3A-4394-8AD5-443FADE55FB2}.Release|Mixed Platforms.ActiveCfg = Release|x86
+		{FD286DF8-2D3A-4394-8AD5-443FADE55FB2}.Release|Mixed Platforms.Build.0 = Release|x86
 		{FD286DF8-2D3A-4394-8AD5-443FADE55FB2}.Release|x86.ActiveCfg = Release|x86
 		{FD286DF8-2D3A-4394-8AD5-443FADE55FB2}.Release|x86.Build.0 = Release|x86
+		{3DCA7B58-B8B3-49AC-9D9E-56F4A0460976}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{3DCA7B58-B8B3-49AC-9D9E-56F4A0460976}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{3DCA7B58-B8B3-49AC-9D9E-56F4A0460976}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
+		{3DCA7B58-B8B3-49AC-9D9E-56F4A0460976}.Debug|Mixed Platforms.Build.0 = Debug|x86
 		{3DCA7B58-B8B3-49AC-9D9E-56F4A0460976}.Debug|x86.ActiveCfg = Debug|x86
 		{3DCA7B58-B8B3-49AC-9D9E-56F4A0460976}.Debug|x86.Build.0 = Debug|x86
+		{3DCA7B58-B8B3-49AC-9D9E-56F4A0460976}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{3DCA7B58-B8B3-49AC-9D9E-56F4A0460976}.Release|Any CPU.Build.0 = Release|Any CPU
+		{3DCA7B58-B8B3-49AC-9D9E-56F4A0460976}.Release|Mixed Platforms.ActiveCfg = Release|x86
+		{3DCA7B58-B8B3-49AC-9D9E-56F4A0460976}.Release|Mixed Platforms.Build.0 = Release|x86
 		{3DCA7B58-B8B3-49AC-9D9E-56F4A0460976}.Release|x86.ActiveCfg = Release|x86
 		{3DCA7B58-B8B3-49AC-9D9E-56F4A0460976}.Release|x86.Build.0 = Release|x86
+		{D18A5DEB-5102-4775-A1AF-B75DAAA8907B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{D18A5DEB-5102-4775-A1AF-B75DAAA8907B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{D18A5DEB-5102-4775-A1AF-B75DAAA8907B}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
+		{D18A5DEB-5102-4775-A1AF-B75DAAA8907B}.Debug|Mixed Platforms.Build.0 = Debug|x86
 		{D18A5DEB-5102-4775-A1AF-B75DAAA8907B}.Debug|x86.ActiveCfg = Debug|Any CPU
 		{D18A5DEB-5102-4775-A1AF-B75DAAA8907B}.Debug|x86.Build.0 = Debug|Any CPU
+		{D18A5DEB-5102-4775-A1AF-B75DAAA8907B}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{D18A5DEB-5102-4775-A1AF-B75DAAA8907B}.Release|Any CPU.Build.0 = Release|Any CPU
+		{D18A5DEB-5102-4775-A1AF-B75DAAA8907B}.Release|Mixed Platforms.ActiveCfg = Release|x86
+		{D18A5DEB-5102-4775-A1AF-B75DAAA8907B}.Release|Mixed Platforms.Build.0 = Release|x86
 		{D18A5DEB-5102-4775-A1AF-B75DAAA8907B}.Release|x86.ActiveCfg = Release|x86
 		{D18A5DEB-5102-4775-A1AF-B75DAAA8907B}.Release|x86.Build.0 = Release|x86
+		{F6FC6BE7-0847-4817-A1ED-223DC647C3D7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F6FC6BE7-0847-4817-A1ED-223DC647C3D7}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F6FC6BE7-0847-4817-A1ED-223DC647C3D7}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
+		{F6FC6BE7-0847-4817-A1ED-223DC647C3D7}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
+		{F6FC6BE7-0847-4817-A1ED-223DC647C3D7}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{F6FC6BE7-0847-4817-A1ED-223DC647C3D7}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F6FC6BE7-0847-4817-A1ED-223DC647C3D7}.Release|Any CPU.Build.0 = Release|Any CPU
+		{F6FC6BE7-0847-4817-A1ED-223DC647C3D7}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
+		{F6FC6BE7-0847-4817-A1ED-223DC647C3D7}.Release|Mixed Platforms.Build.0 = Release|Any CPU
+		{F6FC6BE7-0847-4817-A1ED-223DC647C3D7}.Release|x86.ActiveCfg = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE