WinForms controls to develop with the Pfz.Databasing framework

using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using Pfz.Databasing.Filtering;
using Pfz.Databasing.Internal;
using Pfz.Databasing.Managers;

namespace Pfz.Databasing
{
	/// <summary>
	/// Provides methods for creating and reading Records easily.
	/// </summary>
	public static class Record
	{
		#region CreateThreadConnection
			/// <summary>
			/// Creates a new default thread connection.
			/// </summary>
			public static ThreadConnection CreateThreadConnection()
			{
				return CreateThreadConnection("Default");
			}
			
			/// <summary>
			/// Creates a new thread connection using the given connection name.
			/// </summary>
			public static ThreadConnection CreateThreadConnection(string name)
			{
				var manager = DatabaseManager.Get();
				var connection = manager.CreateConnection(name);
				return new ThreadConnection(connection, true);
			}
		#endregion
	
		#region Create
			/// <summary>
			/// Creates a database record for insert of the given type.
			/// </summary>
			/// <typeparam name="T">The type of the record.</typeparam>
			/// <returns>A new created record, for insert.</returns>
			public static T Create<T>()
			where
				T: class, IRecord
			{
				return DatabaseManager.Get().Create<T>(ThreadConnection.Value);
			}
		#endregion
		
		#region LoadByPrimaryKey
			/// <summary>
			/// Loads a record by it's primary key values.
			/// </summary>
			public static T LoadByPrimaryKey<T>(params object[] primaryKeyValues)
			where
				T: class, IRecord
			{
				T result = TryLoadByPrimaryKey<T>(primaryKeyValues);
				
				if (result == null)
					throw new DatabaseException("Record of type " + typeof(T).FullName + "not found by it's primary key values.");
				
				return result;
			}
		#endregion
		#region TryLoadByPrimaryKey
			/// <summary>
			/// Tries to load a record by it's primary key values.
			/// </summary>
			public static T TryLoadByPrimaryKey<T>(params object[] primaryKeyValues)
			where
				T: class, IRecord
			{
				return DatabaseManager.Get().TryLoadByPrimaryKey<T>(ThreadConnection.Get(), primaryKeyValues);
			}
		#endregion
		
		#region FastLoadByPartialSql
			/// <summary>
			/// Returns a fast-enumerator to read all records from the given partial sql.
			/// </summary>
			public static IFastEnumerator<T> FastLoadByPartialSql<T>(string partialSql, params object[] parameterValues)
			where
				T: class, IRecord
			{
				return DatabaseManager.Get().FastLoadByPartialSql<T>(ThreadConnection.Get(), partialSql, parameterValues);
			}
		#endregion
		#region LoadByPartialSql
			/// <summary>
			/// Returns a custom enumerable collection to read all records from the given
			/// partial sql. Consider using FastLoadByPartialSql if possible.
			/// </summary>
			public static IEnumerable<T> LoadByPartialSql<T>(string partialSql, params object[] parameterValues)
			where
				T: class, IRecord
			{
				using(var fastEnumerator = FastLoadByPartialSql<T>(partialSql, parameterValues))
				{
					while(true)
					{
						T result = fastEnumerator.GetNext();
						if (result == null)
							yield break;
						
						yield return result;
					}
				}
			}
		#endregion
		
		#region FastLoadByLinqFilter
			/// <summary>
			/// Loads records using a linq filter.
			/// Returns a FastEnumerator.
			/// </summary>
			public static IFastEnumerator<T> FastLoadByLinqFilter<T>(Expression<Func<T, bool>> filterExpression)
			where
				T: class, IRecord
			{
				var manager = DatabaseManager.Get();
				
				FilterGroup filterGroup = null;
				if (filterExpression != null)
				{
					var filterLinqWhere = new FilterLinqWhere(filterExpression.Body);
					filterGroup = filterLinqWhere.fGroup;
				}
				
				return FastLoadByFilterGroup<T>(filterGroup);
			}
		#endregion
		#region LoadByLinqFilter
			/// <summary>
			/// Loads records by a linq filter.
			/// </summary>
			public static IEnumerable<T> LoadByLinqFilter<T>(Expression<Func<T, bool>> filterExpression)
			where
				T: class, IRecord
			{
				using(var enumerator = FastLoadByLinqFilter<T>(filterExpression))
				{
					while(true)
					{
						T result = enumerator.GetNext();
						
						if (result == null)
							yield break;
						
						yield return result;
					}
				}
			}
		#endregion
		
		#region FastLoadByFilterGroup
			/// <summary>
			/// Gets a fast enumerator to read all records from the given filterGroup.
			/// </summary>
			public static IFastEnumerator<T> FastLoadByFilterGroup<T>(FilterGroup filterGroup)
			where
				T: class, IRecord
			{
				var manager = DatabaseManager.Get();
				return manager.FastLoadByFilterGroup<T>(ThreadConnection.Get(), filterGroup);
			}
		#endregion
		#region LoadByFilterGroup
			/// <summary>
			/// Gets an enumerator to read all the records from the given filter group.
			/// </summary>
			public static IEnumerable<T> LoadByFilterGroup<T>(FilterGroup filterGroup)
			where
				T: class, IRecord
			{
				using(var fastEnumerator = FastLoadByFilterGroup<T>(filterGroup))
				{
					T result = fastEnumerator.GetNext();
					
					if (result == null)
						yield break;
					
					yield return result;
				}
			}
		#endregion
		
		#region GetQuery
			/// <summary>
			/// Gets a new query for the specific record type.
			/// </summary>
			/// <typeparam name="T">The type of the record to create a query for.</typeparam>
			public static RecordQuery<T> GetQuery<T>()
			where
				T: class, IRecord
			{
				return new RecordQuery<T>();
			}
		#endregion
		#region CreateFilterGroupFromLinqFilter
			/// <summary>
			/// Creates a filtergroup from a linq expression.
			/// </summary>
			public static FilterGroup CreateFilterGroupFromLinqFilter<T>(Expression<Func<T, bool>> filterExpression)
			where
				T: class, IRecord
			{
				if (filterExpression == null)
					return null;
			
				var filterLinqWhere = new FilterLinqWhere(filterExpression.Body);
				return filterLinqWhere.fGroup;
			}
		#endregion
	}
}