/examples/EFTester/Acme.TestModel/Business/Objects/ManyTypesCollection.Generated.cs

Large files files are truncated, but you can click here to view the full file

using System;

using System.Data;

using System.Xml;

using System.Collections;

using System.Runtime.Serialization;

using System.ComponentModel;

using Acme.TestModel.Business.Rules;

using Acme.TestModel.Business.SelectCommands;

using Acme.TestModel.Domain.Objects;

using Widgetsphere.Core.DataAccess;

using Widgetsphere.Core.Util;

using Widgetsphere.Core.Logging;

using Widgetsphere.Core.Exceptions;

using Acme.TestModel.Business.LINQ;

using System.IO;

using System.Collections.Generic;

using System.Linq.Expressions;

using System.Data.Linq;

using System.Linq;

using System.Text;

using Widgetsphere.Core.EventArgs;

using System.Text.RegularExpressions;



namespace Acme.TestModel.Business.Objects

{

	/// <summary>

	/// The collection to hold 'ManyTypes' entities

	/// </summary>

	[Serializable()]

	public partial class ManyTypesCollection : Widgetsphere.Core.DataAccess.BusinessCollectionPersistableBase, Widgetsphere.Core.DataAccess.IPersistableBusinessCollection, System.IDisposable, System.ComponentModel.IListSource, System.Collections.IList, System.Collections.IEnumerator, System.Collections.Generic.IEnumerable<Acme.TestModel.Business.Objects.ManyTypes>, Widgetsphere.Core.DataAccess.IWrappingClass

	{

		#region Member Variables



		internal DomainManyTypesCollection wrappedClass;



		/// <summary>

		/// The parent subdomain object

		/// </summary>

		protected SubDomain _subDomain = null;



		#endregion



		#region Constructor / Initialize



		internal ManyTypesCollection(DomainManyTypesCollection classToWrap)

		{

			_subDomain = classToWrap.SubDomain;

			wrappedClass = classToWrap;

		}



		/// <summary>

		/// Constructor that enables you to specify a modifier

		/// </summary>

		/// <param name="modifier">Used in audit operations to track changes</param>

		public ManyTypesCollection(string modifier)

		{

			_subDomain = new SubDomain(modifier);

			ResetWrappedClass((DomainManyTypesCollection)_subDomain.GetDomainCollection(Collections.ManyTypesCollection));

		}



		/// <summary>

		/// The default constructor

		/// </summary>

		public ManyTypesCollection() 

		{

			_subDomain = new SubDomain(ConfigurationValues.GetInstance().Modifier);

			ResetWrappedClass((DomainManyTypesCollection)_subDomain.GetDomainCollection(Collections.ManyTypesCollection));

		}



		#endregion



		#region Property Implementations



		/// <summary>

		/// Returns the internal object that this object wraps

		/// </summary>

		[System.ComponentModel.Browsable(false)]

		internal virtual object WrappedClass

		{

			get { return wrappedClass ; }

			set { wrappedClass = (DomainManyTypesCollection)value ; }

		}



		//WrappingClass Interface

		object Widgetsphere.Core.DataAccess.IWrappingClass.WrappedClass

		{

			get { return this.WrappedClass; }

			set { this.WrappedClass = value; }

		}



		/// <summary>

		/// Specifies a modifier string to be used in the audit functionality

		/// </summary>

		public string Modifier

		{

			get

			{

				try

				{

					return wrappedClass.Modifier;

				}

				catch (System.Data.DBConcurrencyException dbcex) { throw new Widgetsphere.Core.Exceptions.ConcurrencyException(GlobalValues.ERROR_CONCURRENCY_FAILURE, dbcex); }

				catch (System.Data.SqlClient.SqlException sqlexp) { if (sqlexp.Number == 547 || sqlexp.Number == 2627) throw new Widgetsphere.Core.Exceptions.UniqueConstraintViolatedException(GlobalValues.ERROR_CONSTRAINT_FAILURE, sqlexp); else throw; }

				catch (System.Exception ex) { System.Diagnostics.Debug.WriteLine(ex.ToString()); throw; }

			}

			internal set { wrappedClass.Modifier = value; }

		}



		/// <summary>

		/// A reference to the SubDomain that holds this collection

		/// </summary>

		public SubDomain SubDomain

		{

			get

			{

				try

				{

					return wrappedClass.SubDomain;

				}

				catch (System.Data.DBConcurrencyException dbcex) { throw new Widgetsphere.Core.Exceptions.ConcurrencyException(GlobalValues.ERROR_CONCURRENCY_FAILURE, dbcex); }

				catch (System.Data.SqlClient.SqlException sqlexp) { if (sqlexp.Number == 547 || sqlexp.Number == 2627) throw new Widgetsphere.Core.Exceptions.UniqueConstraintViolatedException(GlobalValues.ERROR_CONSTRAINT_FAILURE, sqlexp); else throw; }

				catch (System.Exception ex) { System.Diagnostics.Debug.WriteLine(ex.ToString()); throw; }

			}

		}



		/// <summary>

		/// Returns the number of items in this collection

		/// </summary>

		public override int Count

		{

			get

			{

				try

				{

					lock (wrappedClass.SubDomain)

					{

						DataTable dt = wrappedClass.GetChanges(DataRowState.Deleted);

						if (dt == null) return wrappedClass.Count;

						else return wrappedClass.Count - dt.Rows.Count;

					}

				}

				catch (System.Data.DBConcurrencyException dbcex) { throw new Widgetsphere.Core.Exceptions.ConcurrencyException(GlobalValues.ERROR_CONCURRENCY_FAILURE, dbcex); }

				catch (System.Data.SqlClient.SqlException sqlexp) { if (sqlexp.Number == 547 || sqlexp.Number == 2627) throw new Widgetsphere.Core.Exceptions.UniqueConstraintViolatedException(GlobalValues.ERROR_CONSTRAINT_FAILURE, sqlexp); else throw; }

				catch (System.Exception ex) { System.Diagnostics.Debug.WriteLine(ex.ToString()); throw; }

			}

		}



		/// <summary>

		/// Determines the type of object contained by this collection.

		/// </summary>

		public virtual Type ContainedType

		{

			get { return typeof(ManyTypes); }

		}



		/// <summary>

		/// Determines the type of collection for this object.

		/// </summary>

		public virtual Collections Collection

		{

			get { return Collections.ManyTypesCollection; }

		}



		#endregion



		#region Enumerator



		/// <summary>

		/// Gets or sets the element at the specified index.

		/// </summary>

		/// <param name="index">The zero-based index of the element to get or set. </param>

		/// <returns>The element at the specified index.</returns>

		public virtual ManyTypes this[int index]

		{

			get

			{

				try

				{

					var internalEnumerator = this.GetEnumerator();

					internalEnumerator.Reset();

					int ii = -1;

					while(ii < index)

					{

						internalEnumerator.MoveNext();

						ii++;

					}

					var retval = (ManyTypes)internalEnumerator.Current;

					if (retval.wrappedClass == null)

					{

						if (!((0 <= index) && (index < this.Count)))

							throw new IndexOutOfRangeException();

						else

							throw new Exception("The item is null. This is not a valid state.");

					}

					else return (ManyTypes)internalEnumerator.Current;

				}

				catch (System.Data.DBConcurrencyException dbcex) { throw new Widgetsphere.Core.Exceptions.ConcurrencyException(GlobalValues.ERROR_CONCURRENCY_FAILURE, dbcex); }

				catch (System.Data.SqlClient.SqlException sqlexp) { if (sqlexp.Number == 547 || sqlexp.Number == 2627) throw new Widgetsphere.Core.Exceptions.UniqueConstraintViolatedException(GlobalValues.ERROR_CONSTRAINT_FAILURE, sqlexp); else throw; }

				catch (System.Exception ex) { System.Diagnostics.Debug.WriteLine(ex.ToString()); throw; }

			}

		}



		#endregion



		#region Methods



		/// <summary>

		/// Create a new object to later add to this collection

		/// </summary>

		public virtual ManyTypes NewItem(Guid key) 

		{

			try

			{

				lock (wrappedClass.SubDomain)

				{

					return new ManyTypes(wrappedClass.NewItem(key));

				}

			}

			catch (System.Data.DBConcurrencyException dbcex) { throw new Widgetsphere.Core.Exceptions.ConcurrencyException(GlobalValues.ERROR_CONCURRENCY_FAILURE, dbcex); }

			catch (System.Data.SqlClient.SqlException sqlexp) { if (sqlexp.Number == 547 || sqlexp.Number == 2627) throw new Widgetsphere.Core.Exceptions.UniqueConstraintViolatedException(GlobalValues.ERROR_CONSTRAINT_FAILURE, sqlexp); else throw; }

			catch (System.Exception ex) { System.Diagnostics.Debug.WriteLine(ex.ToString()); throw; }

		}



		/// <summary>

		/// Create a new object to later add to this collection

		/// </summary>

		public virtual ManyTypes NewItem() 

		{

			try

			{

				lock (wrappedClass.SubDomain)

				{

					return new ManyTypes(wrappedClass.NewItem());

				}

			}

			catch (System.Data.DBConcurrencyException dbcex) { throw new Widgetsphere.Core.Exceptions.ConcurrencyException(GlobalValues.ERROR_CONCURRENCY_FAILURE, dbcex); }

			catch (System.Data.SqlClient.SqlException sqlexp) { if (sqlexp.Number == 547 || sqlexp.Number == 2627) throw new Widgetsphere.Core.Exceptions.UniqueConstraintViolatedException(GlobalValues.ERROR_CONSTRAINT_FAILURE, sqlexp); else throw; }

			catch (System.Exception ex) { System.Diagnostics.Debug.WriteLine(ex.ToString()); throw; }

		}



		/// <summary>

		/// Add a newly created entity to this collection.

		/// </summary>

		public virtual void AddItem(ManyTypes item) 

		{

			try

			{

				lock (wrappedClass.SubDomain)

				{

					wrappedClass.AddItem((DomainManyTypes)item.WrappedClass);

				}

			}

			catch (System.Data.DBConcurrencyException dbcex) { throw new Widgetsphere.Core.Exceptions.ConcurrencyException(GlobalValues.ERROR_CONCURRENCY_FAILURE, dbcex); }

			catch (System.Data.SqlClient.SqlException sqlexp) { if (sqlexp.Number == 547 || sqlexp.Number == 2627) throw new Widgetsphere.Core.Exceptions.UniqueConstraintViolatedException(GlobalValues.ERROR_CONSTRAINT_FAILURE, sqlexp); else throw; }

			catch (System.Exception ex) { System.Diagnostics.Debug.WriteLine(ex.ToString()); throw; }

		}



		/// <summary>

		/// Determines if the specified item exists in this list

		/// </summary>

		/// <param name="item"></param>

		/// <returns></returns>

		public virtual bool Contains(Acme.TestModel.Business.Objects.ManyTypes item)

		{

			foreach (var o in this)

			{

				if (o == item) return true;

			}

			return false;

		}



		/// <summary>

		/// Determines the position in the list of the specified item, if it exists

		/// </summary>

		/// <param name="item"></param>

		/// <returns></returns>

		public virtual int IndexOf(Acme.TestModel.Business.Objects.ManyTypes item)

		{

			int index = 0;

			foreach (var o in this)

			{

				if (o == item) return index;

				index++;

			}

			return -1;

		}



		#region IListSource Members



		bool System.ComponentModel.IListSource.ContainsListCollection

		{

			get { return true; }

		}



		System.Collections.IList System.ComponentModel.IListSource.GetList()

		{

			var list = new System.Collections.Generic.List<Acme.TestModel.Business.Objects.ManyTypes>();

			list.AddRange(this);

			return list;

		}



		#endregion



		#region IList Members



		int System.Collections.IList.Add(object value)

		{

			if (!(value is Acme.TestModel.Business.Objects.ManyTypes))

				throw new System.Exception("The specified type is not valid!");

			var item = value as Acme.TestModel.Business.Objects.ManyTypes;

			this.AddItem(item);

			return this.Count;

		}



		void System.Collections.IList.Clear()

		{

			throw new System.NotImplementedException();

		}



		bool System.Collections.IList.Contains(object value)

		{

			if (!(value is Acme.TestModel.Business.Objects.ManyTypes))

				throw new System.Exception("The specified type is not valid!");

			var item = value as Acme.TestModel.Business.Objects.ManyTypes;

			return this.Contains(item);

		}



		int System.Collections.IList.IndexOf(object value)

		{

			if (!(value is Acme.TestModel.Business.Objects.ManyTypes))

				throw new System.Exception("The specified type is not valid!");

			var item = value as Acme.TestModel.Business.Objects.ManyTypes;

			return this.IndexOf(item);

		}



		void System.Collections.IList.Insert(int index, object value)

		{

			throw new System.NotImplementedException();

		}



		bool System.Collections.IList.IsFixedSize

		{

			get { return false; }

		}



		bool System.Collections.IList.IsReadOnly

		{

			get { return false; }

		}



		void System.Collections.IList.Remove(object value)

		{

			if (!(value is Acme.TestModel.Business.Objects.ManyTypes))

				throw new System.Exception("The specified type is not valid!");

			var item = value as Acme.TestModel.Business.Objects.ManyTypes;

			if (this.Contains(item))

				item.Delete();

		}



		void System.Collections.IList.RemoveAt(int index)

		{

			if ((0 <= index) && (index < this.Count))

				this[index].Delete();

		}



		object System.Collections.IList.this[int index]

		{

			get { return this[index]; }

			set { throw new System.NotImplementedException(); }

		}



		#endregion



		/// <summary>

		/// Takes an IVisitor object and iterates through each item in this collection

		/// </summary>

		/// <param name="visitor">The object that processes each collection item</param>

		public virtual void ProcessVisitor(IVisitor visitor)

		{

			if (visitor == null) throw new Exception("This object cannot be null.");

			lock(this)

			{

				foreach (IBusinessObject item in this)

				{

					visitor.Visit(item);

				}

			}

		}



		#region Static SQL Methods



		internal static string GetFieldAliasFromFieldNameSqlMapping(string alias)

		{

			alias = alias.Replace("[", string.Empty).Replace("]", string.Empty);

			switch (alias.ToLower())

			{

				case "guid_id": return "guidid";

				case "test_bigint": return "testbigint";

				case "test_binary": return "testbinary";

				case "test_bit": return "testbit";

				case "test_char": return "testchar";

				case "test_date": return "testdate";

				case "test_datetime": return "testdatetime";

				case "test_datetime2": return "testdatetime2";

				case "test_datetimeoffset": return "testdatetimeoffset";

				case "test_decimal": return "testdecimal";

				case "test_float": return "testfloat";

				case "test_image": return "testimage";

				case "test_int": return "testint";

				case "test_money": return "testmoney";

				case "test_nchar": return "testnchar";

				case "test_ntext": return "testntext";

				case "test_nvarchar": return "testnvarchar";

				case "test_real": return "testreal";

				case "test_smalldatetime": return "testsmalldatetime";

				case "test_smallint": return "testsmallint";

				case "test_smallmoney": return "testsmallmoney";

				case "test_text": return "testtext";

				case "test_time": return "testtime";

				case "test_tinyint": return "testtinyint";

				case "test_uniqueidentifier": return "testuniqueidentifier";

				case "test_varbinary": return "testvarbinary";

				case "test_varchar": return "testvarchar";

				case "test_xml": return "testxml";

				case "testcalculated": return "testcalculated";

				case "varcharmax": return "varcharmax";

				case "created_date": return "createddate";

				case "created_by": return "createdby";

				case "modified_date": return "modifieddate";

				case "modified_by": return "modifiedby";

				case "time_stamp": return "timestamp";

				default: throw new Exception("The select clause is not valid.");

			}

		}



		internal static string GetTableFromFieldAliasSqlMapping(string alias)

		{

			switch (alias.ToLower())

			{

				case "guidid": return "MANY_TYPES";

				case "testbigint": return "MANY_TYPES";

				case "testbinary": return "MANY_TYPES";

				case "testbit": return "MANY_TYPES";

				case "testchar": return "MANY_TYPES";

				case "testdate": return "MANY_TYPES";

				case "testdatetime": return "MANY_TYPES";

				case "testdatetime2": return "MANY_TYPES";

				case "testdatetimeoffset": return "MANY_TYPES";

				case "testdecimal": return "MANY_TYPES";

				case "testfloat": return "MANY_TYPES";

				case "testimage": return "MANY_TYPES";

				case "testint": return "MANY_TYPES";

				case "testmoney": return "MANY_TYPES";

				case "testnchar": return "MANY_TYPES";

				case "testntext": return "MANY_TYPES";

				case "testnvarchar": return "MANY_TYPES";

				case "testreal": return "MANY_TYPES";

				case "testsmalldatetime": return "MANY_TYPES";

				case "testsmallint": return "MANY_TYPES";

				case "testsmallmoney": return "MANY_TYPES";

				case "testtext": return "MANY_TYPES";

				case "testtime": return "MANY_TYPES";

				case "testtinyint": return "MANY_TYPES";

				case "testuniqueidentifier": return "MANY_TYPES";

				case "testvarbinary": return "MANY_TYPES";

				case "testvarchar": return "MANY_TYPES";

				case "testxml": return "MANY_TYPES";

				case "testcalculated": return "MANY_TYPES";

				case "varcharmax": return "MANY_TYPES";

				case "createdby": return "MANY_TYPES";

				case "createddate": return "MANY_TYPES";

				case "modifiedby": return "MANY_TYPES";

				case "modifieddate": return "MANY_TYPES";

				case "timestamp": return "MANY_TYPES";

				default: throw new Exception("The select clause is not valid.");

			}

		}



		internal static string GetTableFromFieldNameSqlMapping(string field)

		{

			switch (field.ToLower())

			{

				case "guid_id": return "MANY_TYPES";

				case "test_bigint": return "MANY_TYPES";

				case "test_binary": return "MANY_TYPES";

				case "test_bit": return "MANY_TYPES";

				case "test_char": return "MANY_TYPES";

				case "test_date": return "MANY_TYPES";

				case "test_datetime": return "MANY_TYPES";

				case "test_datetime2": return "MANY_TYPES";

				case "test_datetimeoffset": return "MANY_TYPES";

				case "test_decimal": return "MANY_TYPES";

				case "test_float": return "MANY_TYPES";

				case "test_image": return "MANY_TYPES";

				case "test_int": return "MANY_TYPES";

				case "test_money": return "MANY_TYPES";

				case "test_nchar": return "MANY_TYPES";

				case "test_ntext": return "MANY_TYPES";

				case "test_nvarchar": return "MANY_TYPES";

				case "test_real": return "MANY_TYPES";

				case "test_smalldatetime": return "MANY_TYPES";

				case "test_smallint": return "MANY_TYPES";

				case "test_smallmoney": return "MANY_TYPES";

				case "test_text": return "MANY_TYPES";

				case "test_time": return "MANY_TYPES";

				case "test_tinyint": return "MANY_TYPES";

				case "test_uniqueidentifier": return "MANY_TYPES";

				case "test_varbinary": return "MANY_TYPES";

				case "test_varchar": return "MANY_TYPES";

				case "test_xml": return "MANY_TYPES";

				case "testcalculated": return "MANY_TYPES";

				case "varcharmax": return "MANY_TYPES";

				case "created_by": return "MANY_TYPES";

				case "created_date": return "MANY_TYPES";

				case "modified_by": return "MANY_TYPES";

				case "modified_date": return "MANY_TYPES";

				case "time_stamp": return "MANY_TYPES";

				default: throw new Exception("The select clause is not valid.");

			}

		}



		internal static string GetRemappedLinqSql(string sql, string parentAlias, LinqSQLFromClauseCollection childTables)

		{

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[guid_id\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[guid_id]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[test_bigint\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[test_bigint]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[test_binary\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[test_binary]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[test_bit\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[test_bit]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[test_char\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[test_char]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[test_date\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[test_date]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[test_datetime\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[test_datetime]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[test_datetime2\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[test_datetime2]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[test_datetimeoffset\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[test_datetimeoffset]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[test_decimal\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[test_decimal]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[test_float\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[test_float]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[test_image\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[test_image]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[test_int\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[test_int]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[test_money\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[test_money]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[test_nchar\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[test_nchar]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[test_ntext\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[test_ntext]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[test_nvarchar\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[test_nvarchar]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[test_real\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[test_real]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[test_smalldatetime\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[test_smalldatetime]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[test_smallint\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[test_smallint]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[test_smallmoney\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[test_smallmoney]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[test_text\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[test_text]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[test_time\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[test_time]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[test_tinyint\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[test_tinyint]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[test_uniqueidentifier\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[test_uniqueidentifier]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[test_varbinary\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[test_varbinary]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[test_varchar\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[test_varchar]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[test_xml\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[test_xml]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[testcalculated\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[testcalculated]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[varcharmax\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[varcharmax]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[createdby\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[createdby]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[createddate\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[createddate]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[modifiedby\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[modifiedby]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[modifieddate\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[modifieddate]", RegexOptions.IgnoreCase);

			sql = System.Text.RegularExpressions.Regex.Replace(sql, "\\[" + parentAlias + "\\]\\.\\[timestamp\\]", "[" + childTables.GetBaseAliasTable(parentAlias, "MANY_TYPES") + "].[timestamp]", RegexOptions.IgnoreCase);

			return sql;

		}



		internal static string GetPagedSQL(List<LinqSQLField> fieldList, LinqSQLFromClauseCollection fromLinkList, string whereClause, object paging, Widgetsphere.Core.DataAccess.QueryOptimizer optimizer)

		{

			var sb = new StringBuilder();

			var paging2 = (ManyTypesPaging)paging;



			//Calculate the SELECT clause

			sb.Append("SELECT ");

			int index = 0;

			foreach (LinqSQLField field in fieldList)

			{

				sb.Append("[t0].[" + field.Name + "]");

				if (index < fieldList.Count - 1) sb.Append(", ");

				index++;

			}

			sb.AppendLine();

			sb.AppendLine("FROM (");



			//Calculate the Inner SELECT clause

			sb.Append("SELECT ");

			index = 0;

			foreach (var field in fieldList)

			{

				sb.Append(field.GetSQL(false));

				if (index < fieldList.Count - 1) sb.Append(", ");

				index++;

			}

			sb.AppendLine();



			//If there is no sort then add primary key

			if (paging2.OrderByList.Count == 0)

			{

				paging2.OrderByList.Add(new ManyTypesPagingFieldItem(ManyTypes.FieldNameConstants.GuidId));

			}



			//Determine the paging sort

			var isPrimary = false;

			var orderByClause = string.Empty;

			foreach (var fieldItem in paging2.OrderByList)

			{

				if (!string.IsNullOrEmpty(orderByClause)) orderByClause += ", ";

				switch (fieldItem.Field.ToString().ToLower())

				{

					case "guidid": orderByClause += "[" + (from x in fieldList where x.Alias.ToLower() == fieldItem.Field.ToString().ToLower() select x).FirstOrDefault().Table + "].[guid_id]" + (fieldItem.Ascending ? string.Empty : " DESC"); isPrimary = true;break;

					case "testbigint": orderByClause += "[" + (from x in fieldList where x.Alias.ToLower() == fieldItem.Field.ToString().ToLower() select x).FirstOrDefault().Table + "].[test_bigint]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "testbinary": orderByClause += "[" + (from x in fieldList where x.Alias.ToLower() == fieldItem.Field.ToString().ToLower() select x).FirstOrDefault().Table + "].[test_binary]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "testbit": orderByClause += "[" + (from x in fieldList where x.Alias.ToLower() == fieldItem.Field.ToString().ToLower() select x).FirstOrDefault().Table + "].[test_bit]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "testchar": orderByClause += "[" + (from x in fieldList where x.Alias.ToLower() == fieldItem.Field.ToString().ToLower() select x).FirstOrDefault().Table + "].[test_char]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "testdate": orderByClause += "[" + (from x in fieldList where x.Alias.ToLower() == fieldItem.Field.ToString().ToLower() select x).FirstOrDefault().Table + "].[test_date]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "testdatetime": orderByClause += "[" + (from x in fieldList where x.Alias.ToLower() == fieldItem.Field.ToString().ToLower() select x).FirstOrDefault().Table + "].[test_datetime]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "testdatetime2": orderByClause += "[" + (from x in fieldList where x.Alias.ToLower() == fieldItem.Field.ToString().ToLower() select x).FirstOrDefault().Table + "].[test_datetime2]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "testdatetimeoffset": orderByClause += "[" + (from x in fieldList where x.Alias.ToLower() == fieldItem.Field.ToString().ToLower() select x).FirstOrDefault().Table + "].[test_datetimeoffset]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "testdecimal": orderByClause += "[" + (from x in fieldList where x.Alias.ToLower() == fieldItem.Field.ToString().ToLower() select x).FirstOrDefault().Table + "].[test_decimal]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "testfloat": orderByClause += "[" + (from x in fieldList where x.Alias.ToLower() == fieldItem.Field.ToString().ToLower() select x).FirstOrDefault().Table + "].[test_float]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "testimage": orderByClause += "[" + (from x in fieldList where x.Alias.ToLower() == fieldItem.Field.ToString().ToLower() select x).FirstOrDefault().Table + "].[test_image]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "testint": orderByClause += "[" + (from x in fieldList where x.Alias.ToLower() == fieldItem.Field.ToString().ToLower() select x).FirstOrDefault().Table + "].[test_int]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "testmoney": orderByClause += "[" + (from x in fieldList where x.Alias.ToLower() == fieldItem.Field.ToString().ToLower() select x).FirstOrDefault().Table + "].[test_money]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "testnchar": orderByClause += "[" + (from x in fieldList where x.Alias.ToLower() == fieldItem.Field.ToString().ToLower() select x).FirstOrDefault().Table + "].[test_nchar]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "testntext": orderByClause += "[" + (from x in fieldList where x.Alias.ToLower() == fieldItem.Field.ToString().ToLower() select x).FirstOrDefault().Table + "].[test_ntext]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "testnvarchar": orderByClause += "[" + (from x in fieldList where x.Alias.ToLower() == fieldItem.Field.ToString().ToLower() select x).FirstOrDefault().Table + "].[test_nvarchar]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "testreal": orderByClause += "[" + (from x in fieldList where x.Alias.ToLower() == fieldItem.Field.ToString().ToLower() select x).FirstOrDefault().Table + "].[test_real]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "testsmalldatetime": orderByClause += "[" + (from x in fieldList where x.Alias.ToLower() == fieldItem.Field.ToString().ToLower() select x).FirstOrDefault().Table + "].[test_smalldatetime]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "testsmallint": orderByClause += "[" + (from x in fieldList where x.Alias.ToLower() == fieldItem.Field.ToString().ToLower() select x).FirstOrDefault().Table + "].[test_smallint]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "testsmallmoney": orderByClause += "[" + (from x in fieldList where x.Alias.ToLower() == fieldItem.Field.ToString().ToLower() select x).FirstOrDefault().Table + "].[test_smallmoney]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "testtext": orderByClause += "[" + (from x in fieldList where x.Alias.ToLower() == fieldItem.Field.ToString().ToLower() select x).FirstOrDefault().Table + "].[test_text]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "testtime": orderByClause += "[" + (from x in fieldList where x.Alias.ToLower() == fieldItem.Field.ToString().ToLower() select x).FirstOrDefault().Table + "].[test_time]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "testtinyint": orderByClause += "[" + (from x in fieldList where x.Alias.ToLower() == fieldItem.Field.ToString().ToLower() select x).FirstOrDefault().Table + "].[test_tinyint]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "testuniqueidentifier": orderByClause += "[" + (from x in fieldList where x.Alias.ToLower() == fieldItem.Field.ToString().ToLower() select x).FirstOrDefault().Table + "].[test_uniqueidentifier]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "testvarbinary": orderByClause += "[" + (from x in fieldList where x.Alias.ToLower() == fieldItem.Field.ToString().ToLower() select x).FirstOrDefault().Table + "].[test_varbinary]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "testvarchar": orderByClause += "[" + (from x in fieldList where x.Alias.ToLower() == fieldItem.Field.ToString().ToLower() select x).FirstOrDefault().Table + "].[test_varchar]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "testxml": orderByClause += "[" + (from x in fieldList where x.Alias.ToLower() == fieldItem.Field.ToString().ToLower() select x).FirstOrDefault().Table + "].[test_xml]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "testcalculated": orderByClause += "[" + (from x in fieldList where x.Alias.ToLower() == fieldItem.Field.ToString().ToLower() select x).FirstOrDefault().Table + "].[TestCalculated]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "varcharmax": orderByClause += "[" + (from x in fieldList where x.Alias.ToLower() == fieldItem.Field.ToString().ToLower() select x).FirstOrDefault().Table + "].[varcharmax]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "createddate": orderByClause += "[t0].[created_date]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "createdby": orderByClause += "[t0].[created_by]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "modifieddate": orderByClause += "[t0].[modified_date]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "modifiedby": orderByClause += "[t0].[modified_by]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					case "timestamp": orderByClause += "[t0].[time_stamp]" + (fieldItem.Ascending ? string.Empty : " DESC"); break;

					default: throw new Exception("The order by clause is not valid.");

				}

			}



			//Get the primary key for predictable sorts

			string primarySortKey = string.Empty;

			primarySortKey = "[t0].[guid_id]";



			sb.AppendLine(", ROW_NUMBER() OVER (ORDER BY " + orderByClause + ((primarySortKey == string.Empty) || ((isPrimary && (!string.IsNullOrEmpty(primarySortKey)))) ? string.Empty : ", " + primarySortKey) + ") AS Row");

			//Calculate the FROM clause

			index = 0;

			sb.Append("FROM ");

			foreach (LinqSQLFromClause fromClause in fromLinkList)

			{

				sb.Append("[" + fromClause.Schema + "].[" + fromClause.TableName + "] AS [" + fromClause.Alias + "] ");

				if (optimizer.NoLocking) sb.Append("WITH (NOLOCK)");

				if (!string.IsNullOrEmpty(fromClause.LinkClause)) sb.Append(fromClause.LinkClause + " ");



				if (index < fromLinkList.Count - 1)

				{

					sb.AppendLine();

					sb.Append("LEFT OUTER JOIN ");

				}



				index++;

			}

			sb.AppendLine();



			//Calculate the WHERE clause

			if (!string.IsNullOrEmpty(whereClause))

			{

				foreach (LinqSQLFromClause fromClause in fromLinkList)

				{

					//Only process table that were original and not inserted above

					if (fromClause.AnchorAlias == string.Empty)

					{

						whereClause = LinqSQLParser.GetRemappedLinqSql(fromClause, whereClause, fromLinkList, LinqSQLParser.ObjectTypeConstants.Table);

					}

				}

				sb.Append("WHERE " + whereClause);

			}



			sb.AppendLine(") AS [t0]");

			sb.AppendLine("WHERE (Row >= " + (((paging2.PageIndex - 1) * paging2.RecordsperPage) + 1) + ") AND (Row <= " + (paging2.PageIndex * paging2.RecordsperPage) + ")");



			return sb.ToString();

		}



		#endregion



		/// <summary>

		/// Persists this collection to store.

		/// </summary>

		public override void Persist()

		{

			try

			{

				foreach (ManyTypes item in this)

				{

					if (item.wrappedClass.RowState != DataRowState.Unchanged)

						item.OnValidate(new BusinessObjectEventArgs(item));

				}



				lock (wrappedClass.SubDomain)

				{

					wrappedClass.Persist();

				}

			}

			catch (System.Data.DBConcurrencyException dbcex) { throw new Widgetsphere.Core.Exceptions.ConcurrencyException(GlobalValues.ERROR_CONCURRENCY_FAILURE, dbcex); }

			catch (System.Data.SqlClient.SqlException sqlexp) { if (sqlexp.Number == 547 || sqlexp.Number == 2627) throw new Widgetsphere.Core.Exceptions.UniqueConstraintViolatedException(GlobalValues.ERROR_CONSTRAINT_FAILURE, sqlexp); else throw; }

			catch (System.Exception ex) { System.Diagnostics.Debug.WriteLine(ex.ToString()); throw; }

		}



		/// <summary>

		/// Select all objects from store.

		/// </summary>

		public static ManyTypesCollection RunSelect()

		{

			return RunSelect(ConfigurationValues.GetInstance().Modifier);

		}



		/// <summary>

		/// Select all objects from store.

		/// </summary>

		public static ManyTypesCollection RunSelect(string modifier)

		{

			try

			{

				var returnVal = new ManyTypesCollection(DomainManyTypesCollection.RunSelect(modifier));

				return returnVal;

			}

			catch (System.Data.DBConcurrencyException dbcex) { throw new Widgetsphere.Core.Exceptions.ConcurrencyException(GlobalValues.ERROR_CONCURRENCY_FAILURE, dbcex); }

			catch (System.Data.SqlClient.SqlException sqlexp) { if (sqlexp.Number == 547 || sqlexp.Number == 2627) throw new Widgetsphere.Core.Exceptions.UniqueConstraintViolatedException(GlobalValues.ERROR_CONSTRAINT_FAILURE, sqlexp); else throw; }

			catch (System.Exception ex) { System.Diagnostics.Debug.WriteLine(ex.ToString()); throw; }

		}



		/// <summary>

		/// Using the specified Where expression, execute a query against the database to return a result set

		/// </summary>

		/// <param name="where">The expression that determines the records selected</param>

		public static ManyTypesCollection RunSelect(Expression<Func<Acme.TestModel.Business.LINQ.ManyTypesQuery, bool>> where)

		{

			return RunSelect(where, ConfigurationValues.GetInstance().Modifier);

		}



		/// <summary>

		/// Using the specified Where expression, execute a query against the database to return a result set

		/// </summary>

		/// <param name="where">The expression that determines the records selected</param>

		/// <param name="modifier">The modified audit trail</param>

		public static ManyTypesCollection RunSelect(Expression<Func<Acme.TestModel.Business.LINQ.ManyTypesQuery, bool>> where, string modifier)

		{

			return RunSelect(where, new QueryOptimizer(), modifier);

		}



		/// <summary>

		/// Using the specified Where expression, execute a query against the database to return a result set

		/// </summary>

		/// <param name="where">The expression that determines the records selected</param>

		/// <param name="optimizer">An object to specify querying parameters and return profiling information</param>

		/// <param name="modifier">The modified audit trail</param>

		public static ManyTypesCollection RunSelect(Expression<Func<Acme.TestModel.Business.LINQ.ManyTypesQuery, bool>> where, Widgetsphere.Core.DataAccess.QueryOptimizer optimizer, string modifier)

		{

			var subDomain = new SubDomain(modifier);

			var dc = new DataContext(ConfigurationValues.GetInstance().ConnectionString);

			var template = dc.GetTable<ManyTypesQuery>();

			var cmd = BusinessCollectionPersistableBase.GetCommand<ManyTypesQuery>(dc, template, where);

			cmd.CommandTimeout = ConfigurationValues.GetInstance().DefaultTimeOut;

			var parser = LinqSQLParser.Create(cmd.CommandText, LinqSQLParser.ObjectTypeConstants.Table);

			cmd.CommandText = parser.GetSQL(optimizer);

			dc.Connection.Open();

			var startTime = DateTime.Now;

			var result = dc.Translate<ManyTypesQuery>(cmd.ExecuteReader());

			var endTime = DateTime.Now;

			optimizer.TotalMilliseconds = (long)endTime.Subtract(startTime).TotalMilliseconds;

			var retval = subDomain.GetCollection<ManyTypesCollection>();

			var pkList = new HashSet<string>();

			foreach (var item in result)

			{

				var pk = item.SinglePrimaryKeyValue();

				if (!pkList.Contains(pk))

				{

					pkList.Add(pk);

					var newItem = retval.NewItem(item.GuidId);

					LoadDataRow(item, newItem);

					retval.AddItem(newItem);

				}

			}

			retval.wrappedClass.AcceptChanges();

			retval.wrappedClass.EndLoadData();

			dc.Connection.Close();

			return retval;

		}



		/// <summary>

		/// Using the specified Where expression, execute a query against the database to return a result set

		/// </summary>

		/// <param name="where">The expression that determines the records selected</param>

		/// <param name="paging">The paging object to determine how the results are paged.</param>

		public static ManyTypesCollection RunSelect(Expression<Func<Acme.TestModel.Business.LINQ.ManyTypesQuery, bool>> where, Acme.TestModel.Business.Objects.ManyTypesPaging paging)

		{

			return RunSelect(where, paging, ConfigurationValues.GetInstance().Modifier);

		}



		/// <summary>

		/// Using the specified Where expression, execute a query against the database to return a result set

		/// </summary>

		/// <param name="where">The expression that determines the records selected</param>

		/// <param name="paging">The paging object to determine how the results are paged.</param>

		/// <param name="modifier">The modified audit trail</param>

		public static ManyTypesCollection RunSelect(Expression<Func<Acme.TestModel.Business.LINQ.ManyTypesQuery, bool>> where, Acme.TestModel.Business.Objects.ManyTypesPaging paging, string modifier)

		{

			return RunSelect(where, paging, new QueryOptimizer(), modifier);

		}



		/// <summary>

		/// Using the specified Where expression, execute a query against the database to return a result set

		/// </summary>

		/// <param name="where">The expression that determines the records selected</param>

		/// <param name="paging">The paging object to determine how the results are paged.</param>

		/// <param name="optimizer">An object to specify querying parameters and return profiling information</param>

		/// <param name="modifier">The modified audit trail</param>

		public static ManyTypesCollection RunSelect(Expression<Func<Acme.TestModel.Business.LINQ.ManyTypesQuery, bool>> where, Acme.TestModel.Business.Objects.ManyTypesPaging paging, Widgetsphere.Core.DataAccess.QueryOptimizer optimizer, string modifier)

		{

			if (paging == null) throw new Exception("The paging object cannot be null.");

			var subDomain = new SubDomain(modifier);



			var dc = new DataContext(ConfigurationValues.GetInstance().ConnectionString);

			var template = dc.GetTable<ManyTypesQuery>();

			var cmd = BusinessCollectionPersistableBase.GetCommand<ManyTypesQuery>(dc, template, where);

			cmd.CommandTimeout = ConfigurationValues.GetInstance().DefaultTimeOut;

			var parser = LinqSQLParser.Create(cmd.CommandText, paging, LinqSQLParser.ObjectTypeConstants.Table);

			cmd.CommandText = parser.GetSQL(optimizer);

			dc.Connection.Open();

			var startTime = DateTime.Now;

			var result = dc.Translate<ManyTypesQuery>(cmd.ExecuteReader());

			var endTime = DateTime.Now;

			optimizer.TotalMilliseconds = (long)endTime.Subtract(startTime).TotalMilliseconds;

			var retval = subDomain.GetCollection<ManyTypesCollection>();

			var pkList = new HashSet<string>();

			foreach (var item in result)

			{

				var pk = item.SinglePrimaryKeyValue();

				if (!pkList.Contains(pk))

				{

					pkList.Add(pk);

					var newItem = retval.NewItem(item.GuidId);

					LoadDataRow(item, newItem);

					retval.AddItem(newItem);

				}

			}

			retval.wrappedClass.AcceptChanges();

			retval.wrappedClass.EndLoadData();

			dc.Connection.Close();

			paging.RecordCount = GetCount(where);

			return retval;

		}



		private static void LoadDataRow(ManyTypesQuery item, ManyTypes newItem)

		{

			newItem.wrappedClass["varcharmax"] = item.Varcharmax;

			newItem.wrappedClass["TestCalculated"] = StringHelper.ConvertToDatabase(item.Testcalculated);

			newItem.wrappedClass["test_xml"] = item.TestXml;

			newItem.wrappedClass["test_datetimeoffset"] = item.TestDatetimeoffset;

			newItem.wrappedClass["test_datetime2"] = item.TestDatetime2;

			newItem.wrappedClass["test_time"] = item.TestTime;

			newItem.wrappedClass["test_date"] = item.TestDate;

			newItem.wrappedClass["test_varbinary"] = item.TestVarbinary;

			newItem.wrappedClass["test_tinyint"] = item.TestTinyint;

			newItem.wrappedClass["test_text"] = item.TestText;

			newItem.wrappedClass["test_smallmoney"] = item.TestSmallmoney;

			newItem.wrappedClass["test_smallint"] = item.TestSmallint;

			newItem.wrappedClass["test_smalldatetime"] = item.TestSmalldatetime;

			newItem.wrappedClass["test_uniqueidentifier"] = item.TestUniqueidentifier;

			newItem.wrappedClass["test_real"] = item.TestReal;

			newItem.wrappedClass["test_nvarchar"] = item.TestNvarchar;

			newItem.wrappedClass["test_ntext"] = item.TestNtext;

			newItem.wrappedClass["test_nchar"] = item.TestNchar;

			newItem.wrappedClass["test_money"] = item.TestMoney;

			newItem.wrappedClass["test_int"] = item.TestInt;

			newItem.wrappedClass["test_image"] = item.TestImage;

			newItem.wrappedClass["test_float"] = item.TestFloat;

			newItem.wrappedClass["test_decimal"] = item.TestDecimal;

			newItem.wrappedClass["test_datetime"] = item.TestDatetime;

			newItem.wrappedClass["test_char"] = item.TestChar;

			newItem.wrappedClass["test_bit"] = item.TestBit;

			newItem.wrappedClass["test_binary"] = item.TestBinary;

			newItem.wrappedClass["test_bigint"] = item.TestBigint;

			newItem.wrappedClass["test_varchar"] = item.TestVarchar;

			newItem.wrappedClass["guid_id"] = item.GuidId;

			newItem.wrappedClass["CreatedDate"] = StringHelper.ConvertToDatabase(item.CreatedDate);

			newItem.wrappedClass["CreatedBy"] = StringHelper.ConvertToDatabase(item.CreatedBy);

			newItem.wrappedClass["ModifiedDate"] = StringHelper.ConvertToDatabase(item.ModifiedDate);

			newItem.wrappedClass["ModifiedBy"] = StringHelper.ConvertToDatabase(item.ModifiedBy);

			newItem.wrappedClass["TimeStamp"] = item.TimeStamp;

		}



		/// <summary>

		/// Get the maximum value of the field for all objects

		/// </summary>

		/// <param name="select">The field to aggregate</param>

		public static int? GetMax(Expression<Func<Acme.TestModel.Business.LINQ.ManyTypesQuery, int>> select)

		{

			return GetMax(select, x => true);

		}



		/// <summary>

		/// Get the maximum value of the field in the set of records that match the Where condition

		/// </summary>

		/// <param name="select">The field to aggregate</param>

		/// <param name="where">The expression that determines the records selected</param>

		public static int? GetMax(Expression<Func<Acme.TestModel.Business.LINQ.ManyTypesQuery, int>> select, Expression<Func<Acme.TestModel.Business.LINQ.ManyTypesQuery, bool>> where)

		{

			return GetMax(select, where, new QueryOptimizer());

		}



		/// <summary>

		/// Get the maximum value of the field in the set of records that match the Where condition

		/// </summary>

		/// <param name="select">The field to aggregate</param>

		/// <param name="where">The expression that determines the records selected</param>

		/// <param name="optimizer">An object to specify querying parameters and return profiling information</param>

		public static int? GetMax(Expression<Func<Acme.TestModel.Business.LINQ.ManyTypesQuery, int>> select, Expression<Func<Acme.TestModel.Business.LINQ.ManyTypesQuery, bool>> where, Widgetsphere.Core.DataAccess.QueryOptimizer optimizer)

		{

			return BusinessObjectQuery<ManyTypes, ManyTypesQuery, int>.GetMax(select, where, optimizer, "MANY_TYPES", GetDatabaseFieldName, LinqSQLParser.ObjectTypeConstants.Table);

		}



		/// <summary>

		/// Get the maximum value of the field for all objects

		/// </summary>

		/// <param name="select">The field to aggregate</param>

		public static int? GetMax(Expression<Func<Acme.TestModel.Business.LINQ.ManyTypesQuery, int?>> select)

		{

			return GetMax(select, x => true);

		}



		/// <summary>

		/// Get the maximum value of the field in the set of records that match the Where condition

		/// </summary>

		/// <param name="select">The field to aggregate</param>

		/// <param name="where">The expression that determines the records selected</param>

		public st…