v1.0.5.0

Activity Index. User Account country. Internals regions.

SaxoniteStandardDbas/Dbas/App/SaxDbDfnGenerator.cs

@@ -18,17 +18,21 @@ namespace Saxonite.Net.Standard.Dbas.App
 		//-------------------------------------------------------------------
 		// Data members.
 		public static readonly string messageTitle = "Saxonite database definition generator";
+		public enum DatabaseInstance
+		{
+			Core
+		}
 
 		//-------------------------------------------------------------------
 		/// <summary>
 		/// Generate database definitions.
 		/// </summary>
-		public static bool Generate(String connectionString)
+		public static bool Generate(DatabaseInstance dbInstance, String connectionString)
 		{
 			String fn = nameof(SaxDbDfnGenerator) + ".Generate";
 
 			// Locate output folder:
-			String directory = GetOutputFolder();
+			String directory = GetOutputFolder(dbInstance);
 			if (String.IsNullOrEmpty(directory) || !FileUtil.IsDirectory(directory)) return false;
 
 			// Open database.
@@ -40,7 +44,7 @@ namespace Saxonite.Net.Standard.Dbas.App
 			// Generate database definition.
 			try
 			{
-				return GenerateDatabaseDefinition(database, directory);
+				return GenerateDatabaseDefinition(dbInstance, database, directory);
 			}
 			catch (Exception exc)
 			{
@@ -50,7 +54,7 @@ namespace Saxonite.Net.Standard.Dbas.App
 		}
 
 		//-------------------------------------------------------------------
-		private static bool GenerateDatabaseDefinition(SacsDatabase database, String directory)
+		private static bool GenerateDatabaseDefinition(DatabaseInstance dbInstance, SacsDatabase database, String directory)
 		{
 			DatabaseDefinitionGenerator.Config config = new DatabaseDefinitionGenerator.Config()
 			{
@@ -70,7 +74,7 @@ namespace Saxonite.Net.Standard.Dbas.App
 			config.DefinitionClass.Usings.Add("Sarand.Net.Standard.Base.Utils");
 			config.DefinitionClass.Usings.Add("Sarand.Net.Standard.Base.Dbas");
 			config.DefinitionClass.Namespace = "Saxonite.Base.App";
-			config.DefinitionClass.Classname = "SaxDbDfn";
+			config.DefinitionClass.Classname = "SaxDbDfn_" + dbInstance.ToString();
 			// Table class.
 			config.TableClass.Usings.Clear();
 			config.TableClass.Usings.Add("Sarand.Net.Standard.Base.Core");
@@ -88,7 +92,7 @@ namespace Saxonite.Net.Standard.Dbas.App
 		}
 
 		//-------------------------------------------------------------------
-		private static String GetOutputFolder()
+		private static String GetOutputFolder(DatabaseInstance dbInstance)
 		{
 			String fn = nameof(SaxDbDfnGenerator) + ".GetOutputFolder";
 			var assembly = Assembly.GetAssembly(typeof(DatabaseDefinitionGenerator));
@@ -111,8 +115,8 @@ namespace Saxonite.Net.Standard.Dbas.App
 				SaLogger.Error(fn + " Failed to find '" + projectFolder + "' solution root folder in assembly path:\n\t" + assemblyDirectory);
 				return String.Empty;
 			}
-			// Code files are generated to '..\Dbas\Generated\LogisticsMgr\' folder.
-			directory += Path.DirectorySeparatorChar + "Database" + Path.DirectorySeparatorChar + "Generated" + Path.DirectorySeparatorChar + "Saxonite";
+			// Code files are generated to '..\Dbas\Generated\Saxonite-[Instance]\' folder.
+			directory += Path.DirectorySeparatorChar + "Database" + Path.DirectorySeparatorChar + "Generated" + Path.DirectorySeparatorChar + "Saxonite-" + dbInstance.ToString();
 			SaLogger.Debug(fn + " Output folder: " + directory);
 			if (!FileUtil.ValidateDirectory(directory, true))
 			{

SaxoniteStandardDbas/Dbas/App/SaxSystem_Dbas.cs

@@ -19,21 +19,21 @@ namespace Saxonite.Net.Standard.Dbas.App
 		//-------------------------------------------------------------------
 		// Business components.
 		//-------------------------------------------------------------------
-		public override SaxReferenceMgr CreateReferenceMgr(SaxSessionContext sessionContext)
+		public override SaxReferenceMgr CreateReferenceMgr(SaxSessionContext sessionContext, SaxInternals internals)
 		{
-			return new SaxReferenceMgr_Dbas(sessionContext);
+			return new SaxReferenceMgr_Dbas(sessionContext, internals);
 		}
-		public override SaxAccountMgr CreateAccountMgr(SaxSessionContext sessionContext)
+		public override SaxAccountMgr CreateAccountMgr(SaxSessionContext sessionContext, SaxInternals internals)
 		{
-			return new SaxAccountMgr_Dbas(sessionContext);
+			return new SaxAccountMgr_Dbas(sessionContext, internals);
 		}
-		public override SaxActivityMgr CreateActivityMgr(SaxSessionContext sessionContext)
+		public override SaxActivityMgr CreateActivityMgr(SaxSessionContext sessionContext, SaxInternals internals)
 		{
-			return new SaxActivityMgr_Dbas(sessionContext);
+			return new SaxActivityMgr_Dbas(sessionContext, internals);
 		}
-		public override SaxItemDataMgr CreateItemDataMgr(SaxSessionContext sessionContext)
+		public override SaxItemDataMgr CreateItemDataMgr(SaxSessionContext sessionContext, SaxInternals internals)
 		{
-			return new SaxItemDataMgr_Dbas(sessionContext);
+			return new SaxItemDataMgr_Dbas(sessionContext, internals);
 		}
 
 		//-------------------------------------------------------------------

SaxoniteStandardDbas/Dbas/Bus/SaxActivityIndex_Dbas.cs

@@ -0,0 +1,32 @@
+using Sarand.Net.Standard.Base.Bus;
+using Sarand.Net.Standard.Base.Dbas;
+using Saxonite.Net.Standard.Base.Bus;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Saxonite.Net.Standard.Dbas.Bus
+{
+	//=======================================================================
+	public class SaxActivityIndex_Dbas : SaxActivityIndex
+	{
+		//-------------------------------------------------------------------
+		// Data members.
+		private ISacsDatabase database;
+
+		//-------------------------------------------------------------------
+		// Construction.
+		public SaxActivityIndex_Dbas(ISacsDatabase database, ItemId itemId, SysId sportId, SysId regionId, DateTime effectiveOn, UInt16 flags) :
+			base(itemId, sportId, regionId, effectiveOn)
+		{
+			this.database = database;
+			Flags = flags;
+		}
+
+		//-------------------------------------------------------------------
+		// Associated data.
+
+		//-------------------------------------------------------------------
+	}
+	//=======================================================================
+}

SaxoniteStandardDbas/Dbas/Internal/ActivityIndex_Db.cs

@@ -0,0 +1,221 @@
+using Microsoft.Data.SqlClient;
+using Sarand.Net.Standard.Base.Core;
+using Sarand.Net.Standard.Base.Dbas;
+using Sarand.Net.Standard.Base.Utils;
+using Saxonite.Net.Standard.Dbas.Data;
+using System;
+using System.Collections.Generic;
+using System.Data.Common;
+using System.Linq;
+
+//---------------------------------------------------------------------------
+// Code generated by Sarand Database Utilities Tue 25-May-2021 19:36:10
+//---------------------------------------------------------------------------
+namespace Saxonite.Net.Standard.Dbas.Internal
+{
+	internal class ActivityIndex_Db : SaxDbDataItem
+	{
+		//-------------------------------------------------------------------
+		// Column definitions.
+		public class ColumnsData
+		{
+			public ColumnDataInt16 _ItemType { get; } = new ColumnDataInt16("ItemType");
+			public ColumnDataInt64 _ItemId { get; } = new ColumnDataInt64("ItemId");
+			public ColumnDataInt32 _SportId { get; } = new ColumnDataInt32("SportId");
+			public ColumnDataInt32 _RegionId { get; } = new ColumnDataInt32("RegionId");
+			public ColumnDataDateTime _EffectiveOn { get; } = new ColumnDataDateTime("EffectiveOn");
+			public ColumnDataString _Notes { get; } = new ColumnDataString("Notes");
+			public ColumnDataInt16 _Flags { get; } = new ColumnDataInt16("Flags");
+			public ColumnDataString _Status { get; } = new ColumnDataString("Status");
+			public ColumnDataDateTime _CreateOn { get; } = new ColumnDataDateTime("CreateOn");
+			public ColumnDataInt32 _CreateBy { get; } = new ColumnDataInt32("CreateBy");
+			public ColumnDataString _CreateHost { get; } = new ColumnDataString("CreateHost");
+			public ColumnDataDateTime _UpdateOn { get; } = new ColumnDataDateTime("UpdateOn");
+			public ColumnDataInt32 _UpdateBy { get; } = new ColumnDataInt32("UpdateBy");
+			public ColumnDataString _UpdateHost { get; } = new ColumnDataString("UpdateHost");
+		}
+
+		//-------------------------------------------------------------------
+		// Data members.
+		protected static List<String> fields { get; } = new List<String>()
+		{
+			"ItemType",
+			"ItemId",
+			"SportId",
+			"RegionId",
+			"EffectiveOn",
+			"Notes",
+			"Flags",
+			"Status",
+			"CreateOn",
+			"CreateBy",
+			"CreateHost",
+			"UpdateOn",
+			"UpdateBy",
+			"UpdateHost",
+		};
+		protected static List<String> fieldsId { get; } = new List<String>()
+		{
+		};
+		protected static List<String> fieldsPrimary { get; } = new List<String>()
+		{
+			"ItemType",
+			"ItemId",
+			"SportId",
+			"RegionId",
+			"EffectiveOn",
+		};
+		protected static List<String> fieldsIgnoreOnUpdate { get; } = new List<String>()
+		{
+			"CreateOn",
+			"CreateBy",
+			"CreateHost",
+		};
+
+		//-------------------------------------------------------------------
+		// Construction.
+		internal ActivityIndex_Db (IDatabaseInfo dbInfo) : base(dbInfo)
+		{
+		}
+
+		//-------------------------------------------------------------------
+		// Properties.
+		public override String SchemaName { get; } = "dbo";
+		public override String TableName { get; } = "ActivityIndex";
+		public String TableNameFmt { get { return (!String.IsNullOrEmpty(SchemaName) ? "[" + SchemaName + "]." : "") + "[" + TableName + "]"; } }
+		public static List<String> Fields { get { return new List<String>(fields); } }
+		public static List<String> FieldsId { get { return new List<String>(fieldsId); } }
+		public static List<String> FieldsNonId { get { return fields.FindAll(item => !fieldsId.ContainsCI(item)); } }
+		// Columns.
+		public ColumnsData Cols { get; } = new ColumnsData();
+		public Int16 _ItemType { get { return Cols._ItemType.Value; } set { Cols._ItemType.Value = value; } }
+		public Int64 _ItemId { get { return Cols._ItemId.Value; } set { Cols._ItemId.Value = value; } }
+		public Int32 _SportId { get { return Cols._SportId.Value; } set { Cols._SportId.Value = value; } }
+		public Int32 _RegionId { get { return Cols._RegionId.Value; } set { Cols._RegionId.Value = value; } }
+		public DateTime _EffectiveOn { get { return Cols._EffectiveOn.Value; } set { Cols._EffectiveOn.Value = value; } }
+		public String _Notes { get { return Cols._Notes.Value; } set { Cols._Notes.Value = value; } }
+		public Int16 _Flags { get { return Cols._Flags.Value; } set { Cols._Flags.Value = value; } }
+		public String _Status { get { return Cols._Status.Value; } set { Cols._Status.Value = value; } }
+		public DateTime _CreateOn { get { return Cols._CreateOn.Value; } set { Cols._CreateOn.Value = value; } }
+		public Int32 _CreateBy { get { return Cols._CreateBy.Value; } set { Cols._CreateBy.Value = value; } }
+		public String _CreateHost { get { return Cols._CreateHost.Value; } set { Cols._CreateHost.Value = value; } }
+		public DateTime _UpdateOn { get { return Cols._UpdateOn.Value; } set { Cols._UpdateOn.Value = value; } }
+		public Int32 _UpdateBy { get { return Cols._UpdateBy.Value; } set { Cols._UpdateBy.Value = value; } }
+		public String _UpdateHost { get { return Cols._UpdateHost.Value; } set { Cols._UpdateHost.Value = value; } }
+		// Existing columns - confirmed on database if table exists.
+		public List<String> ExistingColumnNames { get { return GetExistingColumnNames(Fields); } }
+		public List<String> ExistingColumnNamesNonId { get { return GetExistingColumnNames(FieldsNonId); } }
+
+		//-------------------------------------------------------------------
+		// Population.
+		public override void PopulateFrom (DbCommand dbCommand, String tableAlias, String filter)
+		{
+			dbCommand.CommandText =
+				"SELECT " + ExistingColumnNames.Concat(", ", (!String.IsNullOrEmpty(tableAlias) ? tableAlias + "." : "") + "[", "]") + " " +
+				"FROM " + TableNameFmt + (!String.IsNullOrEmpty(tableAlias) ? " " + tableAlias : "") + " " + 
+				(!String.IsNullOrEmpty(filter) ? "WHERE " + filter : "");
+			Log(GetType().Name + ".PopulateFrom", dbCommand.CommandText);
+			using (DbDataReader dbDataReader = dbCommand.ExecuteReader())
+			{
+				dbDataReader.Read();
+				PopulateFrom(dbDataReader);
+			}
+		}
+		public override void PopulateFrom (DbDataReader dbDataReader)
+		{
+			_ItemType = GetFieldInt16(dbDataReader, "ItemType", _ItemType);
+			_ItemId = GetFieldInt64(dbDataReader, "ItemId", _ItemId);
+			_SportId = GetFieldInt32(dbDataReader, "SportId", _SportId);
+			_RegionId = GetFieldInt32(dbDataReader, "RegionId", _RegionId);
+			_EffectiveOn = GetFieldDateTime(dbDataReader, "EffectiveOn", _EffectiveOn);
+			_Notes = GetFieldString(dbDataReader, "Notes", _Notes);
+			_Flags = GetFieldInt16(dbDataReader, "Flags", _Flags);
+			_Status = GetFieldString(dbDataReader, "Status", _Status);
+			_CreateOn = GetFieldDateTime(dbDataReader, "CreateOn", _CreateOn);
+			_CreateBy = GetFieldInt32(dbDataReader, "CreateBy", _CreateBy);
+			_CreateHost = GetFieldString(dbDataReader, "CreateHost", _CreateHost);
+			_UpdateOn = GetFieldDateTime(dbDataReader, "UpdateOn", _UpdateOn);
+			_UpdateBy = GetFieldInt32(dbDataReader, "UpdateBy", _UpdateBy);
+			_UpdateHost = GetFieldString(dbDataReader, "UpdateHost", _UpdateHost);
+		}
+
+		//-------------------------------------------------------------------
+		// Insert command.
+		public override bool ExecuteInsertCommand (DbCommand dbCommand)
+		{
+			List<String> columnNames = ExistingColumnNamesNonId;
+			// Construct query.
+			String query =
+				"INSERT INTO " + TableNameFmt + " " +
+				"("+columnNames.Concat(",","[","]")+") ";
+			if (dbCommand is SqlCommand)
+				query += "VALUES (" + columnNames.Concat(",", "@", "") + ") ";
+			else query += "VALUES (" + StringListUtil.CreateList("?", columnNames.Count).Concat(",") + ") ";
+			dbCommand.CommandText = query;
+			Log(GetType().Name + ".ExecuteInsertCommand", dbCommand.CommandText);
+			// Populate parameters.
+			dbCommand.Parameters.Clear();
+			if (columnNames.ContainsCI("ItemType")) AddCommandParameter(dbCommand, "@ItemType", _ItemType);
+			if (columnNames.ContainsCI("ItemId")) AddCommandParameter(dbCommand, "@ItemId", _ItemId);
+			if (columnNames.ContainsCI("SportId")) AddCommandParameter(dbCommand, "@SportId", _SportId);
+			if (columnNames.ContainsCI("RegionId")) AddCommandParameter(dbCommand, "@RegionId", _RegionId);
+			if (columnNames.ContainsCI("EffectiveOn")) AddCommandParameter(dbCommand, "@EffectiveOn", _EffectiveOn);
+			if (columnNames.ContainsCI("Notes")) AddCommandParameter(dbCommand, "@Notes", _Notes);
+			if (columnNames.ContainsCI("Flags")) AddCommandParameter(dbCommand, "@Flags", _Flags);
+			if (columnNames.ContainsCI("Status")) AddCommandParameter(dbCommand, "@Status", _Status);
+			if (columnNames.ContainsCI("CreateOn")) AddCommandParameter(dbCommand, "@CreateOn", _CreateOn);
+			if (columnNames.ContainsCI("CreateBy")) AddCommandParameter(dbCommand, "@CreateBy", _CreateBy);
+			if (columnNames.ContainsCI("CreateHost")) AddCommandParameter(dbCommand, "@CreateHost", _CreateHost);
+			if (columnNames.ContainsCI("UpdateOn")) AddCommandParameter(dbCommand, "@UpdateOn", _UpdateOn);
+			if (columnNames.ContainsCI("UpdateBy")) AddCommandParameter(dbCommand, "@UpdateBy", _UpdateBy);
+			if (columnNames.ContainsCI("UpdateHost")) AddCommandParameter(dbCommand, "@UpdateHost", _UpdateHost);
+			// Execute insert command.
+			bool commandSuccess = false;
+			int executeNonQuery = dbCommand.ExecuteNonQuery();
+			if (executeNonQuery == 1)
+			{
+				commandSuccess = true;
+			}
+			return commandSuccess;
+		}
+
+		//-------------------------------------------------------------------
+		// Update command.
+		public override bool ExecuteUpdateCommand (DbCommand dbCommand)
+		{
+			// Columns to update.
+			List<String> columnNames = ExistingColumnNamesNonId.Where(item => !fieldsPrimary.ContainsCI(item) && !fieldsIgnoreOnUpdate.ContainsCI(item)).ToList();
+			// Construct query.
+			String query = "UPDATE " + TableNameFmt + " SET ";
+			if (dbCommand is SqlCommand)
+			{
+				query += StringPairList.CreateFrom(columnNames.Bracket("[","]"),columnNames).Concat("=@").Concat(", ") + " ";
+				query += "WHERE ItemType=@ItemType AND ItemId=@ItemId AND SportId=@SportId AND RegionId=@RegionId AND EffectiveOn=@EffectiveOn;";
+			}
+			else
+			{
+				query += columnNames.Concat(", ", "", "=?") + " ";
+				query += "WHERE ItemType=? AND ItemId=? AND SportId=? AND RegionId=? AND EffectiveOn=?;";
+			}
+			dbCommand.CommandText = query;
+			Log(GetType().Name + ".ExecuteUpdateCommand", dbCommand.CommandText);
+			// Populate parameters.
+			dbCommand.Parameters.Clear();
+			if (columnNames.ContainsCI("Notes")) AddCommandParameter(dbCommand, "@Notes", _Notes);
+			if (columnNames.ContainsCI("Flags")) AddCommandParameter(dbCommand, "@Flags", _Flags);
+			if (columnNames.ContainsCI("Status")) AddCommandParameter(dbCommand, "@Status", _Status);
+			if (columnNames.ContainsCI("UpdateOn")) AddCommandParameter(dbCommand, "@UpdateOn", _UpdateOn);
+			if (columnNames.ContainsCI("UpdateBy")) AddCommandParameter(dbCommand, "@UpdateBy", _UpdateBy);
+			if (columnNames.ContainsCI("UpdateHost")) AddCommandParameter(dbCommand, "@UpdateHost", _UpdateHost);
+			AddCommandParameter(dbCommand, "@ItemType", _ItemType);
+			AddCommandParameter(dbCommand, "@ItemId", _ItemId);
+			AddCommandParameter(dbCommand, "@SportId", _SportId);
+			AddCommandParameter(dbCommand, "@RegionId", _RegionId);
+			AddCommandParameter(dbCommand, "@EffectiveOn", _EffectiveOn);
+			int executeNonQueryResult = dbCommand.ExecuteNonQuery();
+			return (executeNonQueryResult == 1);
+		}
+
+		//-------------------------------------------------------------------
+	}
+}

SaxoniteStandardDbas/Dbas/Internal/ItemSport_Db.cs

@@ -9,7 +9,7 @@ using System.Data.Common;
 using System.Linq;
 
 //---------------------------------------------------------------------------
-// Code generated by Sarand Database Utilities Thu 20-May-2021 17:19:55
+// Code generated by Sarand Database Utilities Tue 25-May-2021 19:36:10
 //---------------------------------------------------------------------------
 namespace Saxonite.Net.Standard.Dbas.Internal
 {

SaxoniteStandardDbas/Dbas/Internal/JournalistArticle_Db.cs

@@ -9,7 +9,7 @@ using System.Data.Common;
 using System.Linq;
 
 //---------------------------------------------------------------------------
-// Code generated by Sarand Database Utilities Thu 20-May-2021 17:19:55
+// Code generated by Sarand Database Utilities Tue 25-May-2021 19:36:10
 //---------------------------------------------------------------------------
 namespace Saxonite.Net.Standard.Dbas.Internal
 {
@@ -21,8 +21,8 @@ namespace Saxonite.Net.Standard.Dbas.Internal
 		{
 			public ColumnDataInt32 _Id { get; } = new ColumnDataInt32("Id", true);
 			public ColumnDataInt32 _UserAccountIdJournalist { get; } = new ColumnDataInt32("UserAccountIdJournalist");
-			public ColumnDataInt32 _RegionIdPrimary { get; } = new ColumnDataInt32("RegionIdPrimary");
 			public ColumnDataInt32 _SportIdPrimary { get; } = new ColumnDataInt32("SportIdPrimary");
+			public ColumnDataInt32 _RegionIdPrimary { get; } = new ColumnDataInt32("RegionIdPrimary");
 			public ColumnDataString _Headline { get; } = new ColumnDataString("Headline");
 			public ColumnDataString _Summary { get; } = new ColumnDataString("Summary");
 			public ColumnDataString _BodyData { get; } = new ColumnDataString("BodyData");
@@ -44,8 +44,8 @@ namespace Saxonite.Net.Standard.Dbas.Internal
 		{
 			"Id",
 			"UserAccountIdJournalist",
-			"RegionIdPrimary",
 			"SportIdPrimary",
+			"RegionIdPrimary",
 			"Headline",
 			"Summary",
 			"BodyData",
@@ -93,8 +93,8 @@ namespace Saxonite.Net.Standard.Dbas.Internal
 		public ColumnsData Cols { get; } = new ColumnsData();
 		public Int32 _Id { get { return Cols._Id.Value; } set { Cols._Id.Value = value; } }
 		public Int32 _UserAccountIdJournalist { get { return Cols._UserAccountIdJournalist.Value; } set { Cols._UserAccountIdJournalist.Value = value; } }
-		public Int32 _RegionIdPrimary { get { return Cols._RegionIdPrimary.Value; } set { Cols._RegionIdPrimary.Value = value; } }
 		public Int32 _SportIdPrimary { get { return Cols._SportIdPrimary.Value; } set { Cols._SportIdPrimary.Value = value; } }
+		public Int32 _RegionIdPrimary { get { return Cols._RegionIdPrimary.Value; } set { Cols._RegionIdPrimary.Value = value; } }
 		public String _Headline { get { return Cols._Headline.Value; } set { Cols._Headline.Value = value; } }
 		public String _Summary { get { return Cols._Summary.Value; } set { Cols._Summary.Value = value; } }
 		public String _BodyData { get { return Cols._BodyData.Value; } set { Cols._BodyData.Value = value; } }
@@ -131,8 +131,8 @@ namespace Saxonite.Net.Standard.Dbas.Internal
 		{
 			_Id = GetFieldInt32(dbDataReader, "Id", _Id);
 			_UserAccountIdJournalist = GetFieldInt32(dbDataReader, "UserAccountIdJournalist", _UserAccountIdJournalist);
-			_RegionIdPrimary = GetFieldInt32(dbDataReader, "RegionIdPrimary", _RegionIdPrimary);
 			_SportIdPrimary = GetFieldInt32(dbDataReader, "SportIdPrimary", _SportIdPrimary);
+			_RegionIdPrimary = GetFieldInt32(dbDataReader, "RegionIdPrimary", _RegionIdPrimary);
 			_Headline = GetFieldString(dbDataReader, "Headline", _Headline);
 			_Summary = GetFieldString(dbDataReader, "Summary", _Summary);
 			_BodyData = GetFieldString(dbDataReader, "BodyData", _BodyData);
@@ -168,8 +168,8 @@ namespace Saxonite.Net.Standard.Dbas.Internal
 			// Populate parameters.
 			dbCommand.Parameters.Clear();
 			if (columnNames.ContainsCI("UserAccountIdJournalist")) AddCommandParameter(dbCommand, "@UserAccountIdJournalist", _UserAccountIdJournalist);
-			if (columnNames.ContainsCI("RegionIdPrimary")) AddCommandParameter(dbCommand, "@RegionIdPrimary", _RegionIdPrimary);
 			if (columnNames.ContainsCI("SportIdPrimary")) AddCommandParameter(dbCommand, "@SportIdPrimary", _SportIdPrimary);
+			if (columnNames.ContainsCI("RegionIdPrimary")) AddCommandParameter(dbCommand, "@RegionIdPrimary", _RegionIdPrimary);
 			if (columnNames.ContainsCI("Headline")) AddCommandParameter(dbCommand, "@Headline", _Headline);
 			if (columnNames.ContainsCI("Summary")) AddCommandParameter(dbCommand, "@Summary", _Summary);
 			if (columnNames.ContainsCI("BodyData")) AddCommandParameter(dbCommand, "@BodyData", _BodyData);
@@ -220,8 +220,8 @@ namespace Saxonite.Net.Standard.Dbas.Internal
 			// Populate parameters.
 			dbCommand.Parameters.Clear();
 			if (columnNames.ContainsCI("UserAccountIdJournalist")) AddCommandParameter(dbCommand, "@UserAccountIdJournalist", _UserAccountIdJournalist);
-			if (columnNames.ContainsCI("RegionIdPrimary")) AddCommandParameter(dbCommand, "@RegionIdPrimary", _RegionIdPrimary);
 			if (columnNames.ContainsCI("SportIdPrimary")) AddCommandParameter(dbCommand, "@SportIdPrimary", _SportIdPrimary);
+			if (columnNames.ContainsCI("RegionIdPrimary")) AddCommandParameter(dbCommand, "@RegionIdPrimary", _RegionIdPrimary);
 			if (columnNames.ContainsCI("Headline")) AddCommandParameter(dbCommand, "@Headline", _Headline);
 			if (columnNames.ContainsCI("Summary")) AddCommandParameter(dbCommand, "@Summary", _Summary);
 			if (columnNames.ContainsCI("BodyData")) AddCommandParameter(dbCommand, "@BodyData", _BodyData);

SaxoniteStandardDbas/Dbas/Internal/OrganisationOpportunity_Db.cs

@@ -9,7 +9,7 @@ using System.Data.Common;
 using System.Linq;
 
 //---------------------------------------------------------------------------
-// Code generated by Sarand Database Utilities Thu 20-May-2021 17:19:55
+// Code generated by Sarand Database Utilities Tue 25-May-2021 19:36:10
 //---------------------------------------------------------------------------
 namespace Saxonite.Net.Standard.Dbas.Internal
 {
@@ -21,8 +21,8 @@ namespace Saxonite.Net.Standard.Dbas.Internal
 		{
 			public ColumnDataInt32 _Id { get; } = new ColumnDataInt32("Id", true);
 			public ColumnDataInt32 _OrganisationId { get; } = new ColumnDataInt32("OrganisationId");
-			public ColumnDataInt32 _RegionIdPrimary { get; } = new ColumnDataInt32("RegionIdPrimary");
 			public ColumnDataInt32 _SportIdPrimary { get; } = new ColumnDataInt32("SportIdPrimary");
+			public ColumnDataInt32 _RegionIdPrimary { get; } = new ColumnDataInt32("RegionIdPrimary");
 			public ColumnDataString _OpportunityTypeCode { get; } = new ColumnDataString("OpportunityTypeCode");
 			public ColumnDataString _Position { get; } = new ColumnDataString("Position");
 			public ColumnDataString _Outline { get; } = new ColumnDataString("Outline");
@@ -46,8 +46,8 @@ namespace Saxonite.Net.Standard.Dbas.Internal
 		{
 			"Id",
 			"OrganisationId",
-			"RegionIdPrimary",
 			"SportIdPrimary",
+			"RegionIdPrimary",
 			"OpportunityTypeCode",
 			"Position",
 			"Outline",
@@ -97,8 +97,8 @@ namespace Saxonite.Net.Standard.Dbas.Internal
 		public ColumnsData Cols { get; } = new ColumnsData();
 		public Int32 _Id { get { return Cols._Id.Value; } set { Cols._Id.Value = value; } }
 		public Int32 _OrganisationId { get { return Cols._OrganisationId.Value; } set { Cols._OrganisationId.Value = value; } }
-		public Int32 _RegionIdPrimary { get { return Cols._RegionIdPrimary.Value; } set { Cols._RegionIdPrimary.Value = value; } }
 		public Int32 _SportIdPrimary { get { return Cols._SportIdPrimary.Value; } set { Cols._SportIdPrimary.Value = value; } }
+		public Int32 _RegionIdPrimary { get { return Cols._RegionIdPrimary.Value; } set { Cols._RegionIdPrimary.Value = value; } }
 		public String _OpportunityTypeCode { get { return Cols._OpportunityTypeCode.Value; } set { Cols._OpportunityTypeCode.Value = value; } }
 		public String _Position { get { return Cols._Position.Value; } set { Cols._Position.Value = value; } }
 		public String _Outline { get { return Cols._Outline.Value; } set { Cols._Outline.Value = value; } }
@@ -137,8 +137,8 @@ namespace Saxonite.Net.Standard.Dbas.Internal
 		{
 			_Id = GetFieldInt32(dbDataReader, "Id", _Id);
 			_OrganisationId = GetFieldInt32(dbDataReader, "OrganisationId", _OrganisationId);
-			_RegionIdPrimary = GetFieldInt32(dbDataReader, "RegionIdPrimary", _RegionIdPrimary);
 			_SportIdPrimary = GetFieldInt32(dbDataReader, "SportIdPrimary", _SportIdPrimary);
+			_RegionIdPrimary = GetFieldInt32(dbDataReader, "RegionIdPrimary", _RegionIdPrimary);
 			_OpportunityTypeCode = GetFieldString(dbDataReader, "OpportunityTypeCode", _OpportunityTypeCode);
 			_Position = GetFieldString(dbDataReader, "Position", _Position);
 			_Outline = GetFieldString(dbDataReader, "Outline", _Outline);
@@ -176,8 +176,8 @@ namespace Saxonite.Net.Standard.Dbas.Internal
 			// Populate parameters.
 			dbCommand.Parameters.Clear();
 			if (columnNames.ContainsCI("OrganisationId")) AddCommandParameter(dbCommand, "@OrganisationId", _OrganisationId);
-			if (columnNames.ContainsCI("RegionIdPrimary")) AddCommandParameter(dbCommand, "@RegionIdPrimary", _RegionIdPrimary);
 			if (columnNames.ContainsCI("SportIdPrimary")) AddCommandParameter(dbCommand, "@SportIdPrimary", _SportIdPrimary);
+			if (columnNames.ContainsCI("RegionIdPrimary")) AddCommandParameter(dbCommand, "@RegionIdPrimary", _RegionIdPrimary);
 			if (columnNames.ContainsCI("OpportunityTypeCode")) AddCommandParameter(dbCommand, "@OpportunityTypeCode", _OpportunityTypeCode);
 			if (columnNames.ContainsCI("Position")) AddCommandParameter(dbCommand, "@Position", _Position);
 			if (columnNames.ContainsCI("Outline")) AddCommandParameter(dbCommand, "@Outline", _Outline);
@@ -230,8 +230,8 @@ namespace Saxonite.Net.Standard.Dbas.Internal
 			// Populate parameters.
 			dbCommand.Parameters.Clear();
 			if (columnNames.ContainsCI("OrganisationId")) AddCommandParameter(dbCommand, "@OrganisationId", _OrganisationId);
-			if (columnNames.ContainsCI("RegionIdPrimary")) AddCommandParameter(dbCommand, "@RegionIdPrimary", _RegionIdPrimary);
 			if (columnNames.ContainsCI("SportIdPrimary")) AddCommandParameter(dbCommand, "@SportIdPrimary", _SportIdPrimary);
+			if (columnNames.ContainsCI("RegionIdPrimary")) AddCommandParameter(dbCommand, "@RegionIdPrimary", _RegionIdPrimary);
 			if (columnNames.ContainsCI("OpportunityTypeCode")) AddCommandParameter(dbCommand, "@OpportunityTypeCode", _OpportunityTypeCode);
 			if (columnNames.ContainsCI("Position")) AddCommandParameter(dbCommand, "@Position", _Position);
 			if (columnNames.ContainsCI("Outline")) AddCommandParameter(dbCommand, "@Outline", _Outline);

SaxoniteStandardDbas/Dbas/Internal/Organisation_Db.cs

@@ -9,7 +9,7 @@ using System.Data.Common;
 using System.Linq;
 
 //---------------------------------------------------------------------------
-// Code generated by Sarand Database Utilities Thu 20-May-2021 17:19:55
+// Code generated by Sarand Database Utilities Tue 25-May-2021 19:36:10
 //---------------------------------------------------------------------------
 namespace Saxonite.Net.Standard.Dbas.Internal
 {
@@ -23,8 +23,8 @@ namespace Saxonite.Net.Standard.Dbas.Internal
 			public ColumnDataString _Name { get; } = new ColumnDataString("Name");
 			public ColumnDataString _OrganisationType { get; } = new ColumnDataString("OrganisationType");
 			public ColumnDataString _OrganisationCategory { get; } = new ColumnDataString("OrganisationCategory");
-			public ColumnDataInt32 _RegionIdPrimary { get; } = new ColumnDataInt32("RegionIdPrimary");
 			public ColumnDataInt32 _SportIdPrimary { get; } = new ColumnDataInt32("SportIdPrimary");
+			public ColumnDataInt32 _RegionIdPrimary { get; } = new ColumnDataInt32("RegionIdPrimary");
 			public ColumnDataString _CountryIso2Code { get; } = new ColumnDataString("CountryIso2Code");
 			public ColumnDataString _PhoneMain { get; } = new ColumnDataString("PhoneMain");
 			public ColumnDataString _PhoneAlt { get; } = new ColumnDataString("PhoneAlt");
@@ -47,8 +47,8 @@ namespace Saxonite.Net.Standard.Dbas.Internal
 			"Name",
 			"OrganisationType",
 			"OrganisationCategory",
-			"RegionIdPrimary",
 			"SportIdPrimary",
+			"RegionIdPrimary",
 			"CountryIso2Code",
 			"PhoneMain",
 			"PhoneAlt",
@@ -97,8 +97,8 @@ namespace Saxonite.Net.Standard.Dbas.Internal
 		public String _Name { get { return Cols._Name.Value; } set { Cols._Name.Value = value; } }
 		public String _OrganisationType { get { return Cols._OrganisationType.Value; } set { Cols._OrganisationType.Value = value; } }
 		public String _OrganisationCategory { get { return Cols._OrganisationCategory.Value; } set { Cols._OrganisationCategory.Value = value; } }
-		public Int32 _RegionIdPrimary { get { return Cols._RegionIdPrimary.Value; } set { Cols._RegionIdPrimary.Value = value; } }
 		public Int32 _SportIdPrimary { get { return Cols._SportIdPrimary.Value; } set { Cols._SportIdPrimary.Value = value; } }
+		public Int32 _RegionIdPrimary { get { return Cols._RegionIdPrimary.Value; } set { Cols._RegionIdPrimary.Value = value; } }
 		public String _CountryIso2Code { get { return Cols._CountryIso2Code.Value; } set { Cols._CountryIso2Code.Value = value; } }
 		public String _PhoneMain { get { return Cols._PhoneMain.Value; } set { Cols._PhoneMain.Value = value; } }
 		public String _PhoneAlt { get { return Cols._PhoneAlt.Value; } set { Cols._PhoneAlt.Value = value; } }
@@ -136,8 +136,8 @@ namespace Saxonite.Net.Standard.Dbas.Internal
 			_Name = GetFieldString(dbDataReader, "Name", _Name);
 			_OrganisationType = GetFieldString(dbDataReader, "OrganisationType", _OrganisationType);
 			_OrganisationCategory = GetFieldString(dbDataReader, "OrganisationCategory", _OrganisationCategory);
-			_RegionIdPrimary = GetFieldInt32(dbDataReader, "RegionIdPrimary", _RegionIdPrimary);
 			_SportIdPrimary = GetFieldInt32(dbDataReader, "SportIdPrimary", _SportIdPrimary);
+			_RegionIdPrimary = GetFieldInt32(dbDataReader, "RegionIdPrimary", _RegionIdPrimary);
 			_CountryIso2Code = GetFieldString(dbDataReader, "CountryIso2Code", _CountryIso2Code);
 			_PhoneMain = GetFieldString(dbDataReader, "PhoneMain", _PhoneMain);
 			_PhoneAlt = GetFieldString(dbDataReader, "PhoneAlt", _PhoneAlt);
@@ -174,8 +174,8 @@ namespace Saxonite.Net.Standard.Dbas.Internal
 			if (columnNames.ContainsCI("Name")) AddCommandParameter(dbCommand, "@Name", _Name);
 			if (columnNames.ContainsCI("OrganisationType")) AddCommandParameter(dbCommand, "@OrganisationType", _OrganisationType);
 			if (columnNames.ContainsCI("OrganisationCategory")) AddCommandParameter(dbCommand, "@OrganisationCategory", _OrganisationCategory);
-			if (columnNames.ContainsCI("RegionIdPrimary")) AddCommandParameter(dbCommand, "@RegionIdPrimary", _RegionIdPrimary);
 			if (columnNames.ContainsCI("SportIdPrimary")) AddCommandParameter(dbCommand, "@SportIdPrimary", _SportIdPrimary);
+			if (columnNames.ContainsCI("RegionIdPrimary")) AddCommandParameter(dbCommand, "@RegionIdPrimary", _RegionIdPrimary);
 			if (columnNames.ContainsCI("CountryIso2Code")) AddCommandParameter(dbCommand, "@CountryIso2Code", _CountryIso2Code);
 			if (columnNames.ContainsCI("PhoneMain")) AddCommandParameter(dbCommand, "@PhoneMain", _PhoneMain);
 			if (columnNames.ContainsCI("PhoneAlt")) AddCommandParameter(dbCommand, "@PhoneAlt", _PhoneAlt);
@@ -227,8 +227,8 @@ namespace Saxonite.Net.Standard.Dbas.Internal
 			if (columnNames.ContainsCI("Name")) AddCommandParameter(dbCommand, "@Name", _Name);
 			if (columnNames.ContainsCI("OrganisationType")) AddCommandParameter(dbCommand, "@OrganisationType", _OrganisationType);
 			if (columnNames.ContainsCI("OrganisationCategory")) AddCommandParameter(dbCommand, "@OrganisationCategory", _OrganisationCategory);
-			if (columnNames.ContainsCI("RegionIdPrimary")) AddCommandParameter(dbCommand, "@RegionIdPrimary", _RegionIdPrimary);
 			if (columnNames.ContainsCI("SportIdPrimary")) AddCommandParameter(dbCommand, "@SportIdPrimary", _SportIdPrimary);
+			if (columnNames.ContainsCI("RegionIdPrimary")) AddCommandParameter(dbCommand, "@RegionIdPrimary", _RegionIdPrimary);
 			if (columnNames.ContainsCI("CountryIso2Code")) AddCommandParameter(dbCommand, "@CountryIso2Code", _CountryIso2Code);
 			if (columnNames.ContainsCI("PhoneMain")) AddCommandParameter(dbCommand, "@PhoneMain", _PhoneMain);
 			if (columnNames.ContainsCI("PhoneAlt")) AddCommandParameter(dbCommand, "@PhoneAlt", _PhoneAlt);

SaxoniteStandardDbas/Dbas/Internal/Region_Db.cs

@@ -9,7 +9,7 @@ using System.Data.Common;
 using System.Linq;
 
 //---------------------------------------------------------------------------
-// Code generated by Sarand Database Utilities Thu 20-May-2021 17:19:55
+// Code generated by Sarand Database Utilities Tue 25-May-2021 19:36:10
 //---------------------------------------------------------------------------
 namespace Saxonite.Net.Standard.Dbas.Internal
 {

SaxoniteStandardDbas/Dbas/Internal/Sport_Db.cs

@@ -9,7 +9,7 @@ using System.Data.Common;
 using System.Linq;
 
 //---------------------------------------------------------------------------
-// Code generated by Sarand Database Utilities Thu 20-May-2021 17:19:55
+// Code generated by Sarand Database Utilities Tue 25-May-2021 19:36:10
 //---------------------------------------------------------------------------
 namespace Saxonite.Net.Standard.Dbas.Internal
 {

SaxoniteStandardDbas/Dbas/Internal/UserAccount_Db.cs

@@ -9,7 +9,7 @@ using System.Data.Common;
 using System.Linq;
 
 //---------------------------------------------------------------------------
-// Code generated by Sarand Database Utilities Thu 20-May-2021 17:19:55
+// Code generated by Sarand Database Utilities Tue 25-May-2021 19:36:10
 //---------------------------------------------------------------------------
 namespace Saxonite.Net.Standard.Dbas.Internal
 {
@@ -29,6 +29,8 @@ namespace Saxonite.Net.Standard.Dbas.Internal
 			public ColumnDataString _PhoneMobile { get; } = new ColumnDataString("PhoneMobile");
 			public ColumnDataString _PhoneAlt { get; } = new ColumnDataString("PhoneAlt");
 			public ColumnDataDateTime _DateOfBirth { get; } = new ColumnDataDateTime("DateOfBirth");
+			public ColumnDataInt32 _RegionIdCountry { get; } = new ColumnDataInt32("RegionIdCountry");
+			public ColumnDataInt32 _RegionIdProvince { get; } = new ColumnDataInt32("RegionIdProvince");
 			public ColumnDataString _PasswordToken { get; } = new ColumnDataString("PasswordToken");
 			public ColumnDataString _PasswordHashed { get; } = new ColumnDataString("PasswordHashed");
 			public ColumnDataString _PasswordHistory { get; } = new ColumnDataString("PasswordHistory");
@@ -61,6 +63,8 @@ namespace Saxonite.Net.Standard.Dbas.Internal
 			"PhoneMobile",
 			"PhoneAlt",
 			"DateOfBirth",
+			"RegionIdCountry",
+			"RegionIdProvince",
 			"PasswordToken",
 			"PasswordHashed",
 			"PasswordHistory",
@@ -119,6 +123,8 @@ namespace Saxonite.Net.Standard.Dbas.Internal
 		public String _PhoneMobile { get { return Cols._PhoneMobile.Value; } set { Cols._PhoneMobile.Value = value; } }
 		public String _PhoneAlt { get { return Cols._PhoneAlt.Value; } set { Cols._PhoneAlt.Value = value; } }
 		public DateTime _DateOfBirth { get { return Cols._DateOfBirth.Value; } set { Cols._DateOfBirth.Value = value; } }
+		public Int32 _RegionIdCountry { get { return Cols._RegionIdCountry.Value; } set { Cols._RegionIdCountry.Value = value; } }
+		public Int32 _RegionIdProvince { get { return Cols._RegionIdProvince.Value; } set { Cols._RegionIdProvince.Value = value; } }
 		public String _PasswordToken { get { return Cols._PasswordToken.Value; } set { Cols._PasswordToken.Value = value; } }
 		public String _PasswordHashed { get { return Cols._PasswordHashed.Value; } set { Cols._PasswordHashed.Value = value; } }
 		public String _PasswordHistory { get { return Cols._PasswordHistory.Value; } set { Cols._PasswordHistory.Value = value; } }
@@ -166,6 +172,8 @@ namespace Saxonite.Net.Standard.Dbas.Internal
 			_PhoneMobile = GetFieldString(dbDataReader, "PhoneMobile", _PhoneMobile);
 			_PhoneAlt = GetFieldString(dbDataReader, "PhoneAlt", _PhoneAlt);
 			_DateOfBirth = GetFieldDateTime(dbDataReader, "DateOfBirth", _DateOfBirth);
+			_RegionIdCountry = GetFieldInt32(dbDataReader, "RegionIdCountry", _RegionIdCountry);
+			_RegionIdProvince = GetFieldInt32(dbDataReader, "RegionIdProvince", _RegionIdProvince);
 			_PasswordToken = GetFieldString(dbDataReader, "PasswordToken", _PasswordToken);
 			_PasswordHashed = GetFieldString(dbDataReader, "PasswordHashed", _PasswordHashed);
 			_PasswordHistory = GetFieldString(dbDataReader, "PasswordHistory", _PasswordHistory);
@@ -212,6 +220,8 @@ namespace Saxonite.Net.Standard.Dbas.Internal
 			if (columnNames.ContainsCI("PhoneMobile")) AddCommandParameter(dbCommand, "@PhoneMobile", _PhoneMobile);
 			if (columnNames.ContainsCI("PhoneAlt")) AddCommandParameter(dbCommand, "@PhoneAlt", _PhoneAlt);
 			if (columnNames.ContainsCI("DateOfBirth")) AddCommandParameter(dbCommand, "@DateOfBirth", _DateOfBirth);
+			if (columnNames.ContainsCI("RegionIdCountry")) AddCommandParameter(dbCommand, "@RegionIdCountry", _RegionIdCountry);
+			if (columnNames.ContainsCI("RegionIdProvince")) AddCommandParameter(dbCommand, "@RegionIdProvince", _RegionIdProvince);
 			if (columnNames.ContainsCI("PasswordToken")) AddCommandParameter(dbCommand, "@PasswordToken", _PasswordToken);
 			if (columnNames.ContainsCI("PasswordHashed")) AddCommandParameter(dbCommand, "@PasswordHashed", _PasswordHashed);
 			if (columnNames.ContainsCI("PasswordHistory")) AddCommandParameter(dbCommand, "@PasswordHistory", _PasswordHistory);
@@ -273,6 +283,8 @@ namespace Saxonite.Net.Standard.Dbas.Internal
 			if (columnNames.ContainsCI("PhoneMobile")) AddCommandParameter(dbCommand, "@PhoneMobile", _PhoneMobile);
 			if (columnNames.ContainsCI("PhoneAlt")) AddCommandParameter(dbCommand, "@PhoneAlt", _PhoneAlt);
 			if (columnNames.ContainsCI("DateOfBirth")) AddCommandParameter(dbCommand, "@DateOfBirth", _DateOfBirth);
+			if (columnNames.ContainsCI("RegionIdCountry")) AddCommandParameter(dbCommand, "@RegionIdCountry", _RegionIdCountry);
+			if (columnNames.ContainsCI("RegionIdProvince")) AddCommandParameter(dbCommand, "@RegionIdProvince", _RegionIdProvince);
 			if (columnNames.ContainsCI("PasswordToken")) AddCommandParameter(dbCommand, "@PasswordToken", _PasswordToken);
 			if (columnNames.ContainsCI("PasswordHashed")) AddCommandParameter(dbCommand, "@PasswordHashed", _PasswordHashed);
 			if (columnNames.ContainsCI("PasswordHistory")) AddCommandParameter(dbCommand, "@PasswordHistory", _PasswordHistory);

SaxoniteStandardDbas/Dbas/Internal/UserOrganisation_Db.cs

@@ -9,7 +9,7 @@ using System.Data.Common;
 using System.Linq;
 
 //---------------------------------------------------------------------------
-// Code generated by Sarand Database Utilities Thu 20-May-2021 17:19:55
+// Code generated by Sarand Database Utilities Tue 25-May-2021 19:36:10
 //---------------------------------------------------------------------------
 namespace Saxonite.Net.Standard.Dbas.Internal
 {

SaxoniteStandardDbas/Dbas/Internal/UserRole_Db.cs

@@ -9,7 +9,7 @@ using System.Data.Common;
 using System.Linq;
 
 //---------------------------------------------------------------------------
-// Code generated by Sarand Database Utilities Thu 20-May-2021 17:19:55
+// Code generated by Sarand Database Utilities Tue 25-May-2021 19:36:10
 //---------------------------------------------------------------------------
 namespace Saxonite.Net.Standard.Dbas.Internal
 {

SaxoniteStandardDbas/Dbas/Internal/UserSport_Db.cs

@@ -9,7 +9,7 @@ using System.Data.Common;
 using System.Linq;
 
 //---------------------------------------------------------------------------
-// Code generated by Sarand Database Utilities Thu 20-May-2021 17:19:55
+// Code generated by Sarand Database Utilities Tue 25-May-2021 19:36:10
 //---------------------------------------------------------------------------
 namespace Saxonite.Net.Standard.Dbas.Internal
 {

SaxoniteStandardDbas/Dbas/Mgr/SaxAccountMgr_Dbas-Organisation.cs

@@ -81,7 +81,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				catch (Exception exc)
 				{
 					SetErrorState("Database query exception");
-					SaLogger.Warn(GetType().Name + ".GetOrganisation\n\tQuery: " + dbCommand.CommandText + "\n\t" + exc.GetType().Name + ": " + exc.Message);
+					SaLogger.Warn(GetType().Name + ".GetOrganisation\n\tQuery: " + dbCommand.CommandText + "\n\t" + ExceptionUtil.GetLogMessage(exc));
 				}
 			}
 			return organisation;
@@ -188,7 +188,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 					dbOrganisation.PopulateFrom(dbCommand, aliasOrganisation, "Id=" + organisation.Id.ToString());
 					// Delete organisation.
 					dbCommand.CommandType = System.Data.CommandType.Text;
-					dbCommand.CommandText = "DELETE FROM " + SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.Organisation) + " WHERE Id=" + SysId.ToString(organisation.Id) + ";";
+					dbCommand.CommandText = "DELETE FROM " + SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Organisation) + " WHERE Id=" + SysId.ToString(organisation.Id) + ";";
 					dbCommand.ExecuteNonQuery();
 					organisation.Changed = false;
 					if (DebugMode) SaLogger.Debug(fn + " Deleted. " + GetLogProperties(organisation).Concat(": ").Concat("", "\n\t"));
@@ -210,8 +210,8 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			dbOrganisation._OrganisationCategory = OrganisationCategories.GetCodeForType(organisation.OrganisationCategory);
 			dbOrganisation._PhoneMain = organisation.PhoneMain;
 			dbOrganisation._PhoneAlt = organisation.PhoneAlt;
-			dbOrganisation._RegionIdPrimary = SysId.ToInt(organisation.RegionIdPrimary);
 			dbOrganisation._SportIdPrimary = SysId.ToInt(organisation.SportIdPrimary);
+			dbOrganisation._RegionIdPrimary = SysId.ToInt(organisation.RegionIdPrimary);
 			dbOrganisation._Notes = organisation.Notes;
 			dbOrganisation._Status = SacsSystem.GetStatusCode(organisation.Status);
 			dbOrganisation._Flags = (short)organisation.Flags;
@@ -236,8 +236,8 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			organisation.OrganisationCategory = (Sax.OrganisationCategory)OrganisationCategories.GetTypeForCode(dbOrganisation._OrganisationCategory);
 			organisation.PhoneMain = dbOrganisation._PhoneMain;
 			organisation.PhoneAlt = dbOrganisation._PhoneAlt;
-			organisation.RegionIdPrimary = new SysId(dbOrganisation._RegionIdPrimary);
 			organisation.SportIdPrimary = new SysId(dbOrganisation._SportIdPrimary);
+			organisation.RegionIdPrimary = new SysId(dbOrganisation._RegionIdPrimary);
 			organisation.Notes = dbOrganisation._Notes;
 			organisation.Status = SacsSystem.GetStatusForCode(dbOrganisation._Status);
 			organisation.SetCreateStamp(dbOrganisation._CreateOn, new SysId(dbOrganisation._CreateBy), dbOrganisation._CreateHost);
@@ -248,22 +248,22 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		//-------------------------------------------------------------------
 		// Item column definitions.
 		private static readonly String aliasOrganisation = "Org";
-		private static readonly String aliasOrganisation_Region = "Org_Rgn";
-		private static readonly String prefixOrganisation_Region = "Org_Rgn_";
 		private static readonly String aliasOrganisation_Sport = "Org_Spt";
 		private static readonly String prefixOrganisation_Sport = "Org_Spt_";
+		private static readonly String aliasOrganisation_Region = "Org_Rgn";
+		private static readonly String prefixOrganisation_Region = "Org_Rgn_";
 		private static readonly String colOrganisation_User_Count = "Org_Usr_Count";
 		private static readonly String colOrganisation_Member_Count = "Org_Mbr_Count";
 		private void SetOrganisationColDfn
-			(ColumnDfn col, String caption, int width, SaxDbDfn.ColumnIdx dbCol,
+			(ColumnDfn col, String caption, int width, SaxDbDfn_Core.ColumnIdx dbCol,
 			ColumnAlignment align = ColumnAlignment.Default, DataValue.DataType dataType = DataValue.DataType.String,
 			String alias = "", String prefix = "")
 		{
-			if (String.IsNullOrEmpty(alias) && SaxDbDfn.GetTableForColumn(dbCol) == SaxDbDfn.TableIdx.Organisation)
+			if (String.IsNullOrEmpty(alias) && SaxDbDfn_Core.GetTableForColumn(dbCol) == SaxDbDfn_Core.TableIdx.Organisation)
 				alias = aliasOrganisation;
-			col.Set(caption, width, (int)dbCol, prefix + SaxDbDfn.GetColumnName(dbCol, false), SaxDbDfn.GetColumnNameQual(dbCol, alias), dataType, align);
-			if (dataType == DataValue.DataType.String && dbCol != SaxDbDfn.ColumnIdx.Unknown)
-				col.MaxLength = (int)SaxDbDfn.GetColTextLen(dbCol);
+			col.Set(caption, width, (int)dbCol, prefix + SaxDbDfn_Core.GetColumnName(dbCol, false), SaxDbDfn_Core.GetColumnNameQual(dbCol, alias), dataType, align);
+			if (dataType == DataValue.DataType.String && dbCol != SaxDbDfn_Core.ColumnIdx.Unknown)
+				col.MaxLength = (int)SaxDbDfn_Core.GetColTextLen(dbCol);
 		}
 		public override ColumnDfn GetOrganisationColumnDfn(SaxOrganisation.Column columnId, string caption = "", int width = 0)
 		{
@@ -272,92 +272,92 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			{
 				//-----------------------------------------------------------
 				case SaxOrganisation.Column.Pos:
-					SetOrganisationColDfn(columnDfn, "Pos", 60, SaxDbDfn.ColumnIdx.Unknown, ColumnAlignment.Right);
+					SetOrganisationColDfn(columnDfn, "Pos", 60, SaxDbDfn_Core.ColumnIdx.Unknown, ColumnAlignment.Right);
 					columnDfn.SortMode = ColumnDfn.ColumnSortMode.Off;
 					columnDfn.ReadOnly = true;
 					columnDfn.Resizable = false;
 					break;
 				case SaxOrganisation.Column.Id:
-					SetOrganisationColDfn(columnDfn, "Id", 80, SaxDbDfn.ColumnIdx.Organisation_Id, ColumnAlignment.Right, DataValue.DataType.Long);
+					SetOrganisationColDfn(columnDfn, "Id", 80, SaxDbDfn_Core.ColumnIdx.Organisation_Id, ColumnAlignment.Right, DataValue.DataType.Long);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxOrganisation.Column.Name:
-					SetOrganisationColDfn(columnDfn, "Name", 120, SaxDbDfn.ColumnIdx.Organisation_Name);
+					SetOrganisationColDfn(columnDfn, "Name", 120, SaxDbDfn_Core.ColumnIdx.Organisation_Name);
 					break;
 				case SaxOrganisation.Column.OrganisationType:
-					SetOrganisationColDfn(columnDfn, "Type", 80, SaxDbDfn.ColumnIdx.Organisation_OrganisationType, ColumnAlignment.Center, DataValue.DataType.String);
+					SetOrganisationColDfn(columnDfn, "Type", 80, SaxDbDfn_Core.ColumnIdx.Organisation_OrganisationType, ColumnAlignment.Center, DataValue.DataType.String);
 					break;
 				case SaxOrganisation.Column.OrganisationType_Desc:
-					SetOrganisationColDfn(columnDfn, "Type", 80, SaxDbDfn.ColumnIdx.Organisation_OrganisationType, ColumnAlignment.Center, DataValue.DataType.String);
+					SetOrganisationColDfn(columnDfn, "Type", 80, SaxDbDfn_Core.ColumnIdx.Organisation_OrganisationType, ColumnAlignment.Center, DataValue.DataType.String);
 					break;
 				case SaxOrganisation.Column.OrganisationCategory:
-					SetOrganisationColDfn(columnDfn, "Category", 80, SaxDbDfn.ColumnIdx.Organisation_OrganisationCategory, ColumnAlignment.Center, DataValue.DataType.String);
+					SetOrganisationColDfn(columnDfn, "Category", 80, SaxDbDfn_Core.ColumnIdx.Organisation_OrganisationCategory, ColumnAlignment.Center, DataValue.DataType.String);
 					break;
 				case SaxOrganisation.Column.OrganisationCategory_Desc:
-					SetOrganisationColDfn(columnDfn, "Category", 80, SaxDbDfn.ColumnIdx.Organisation_OrganisationCategory, ColumnAlignment.Center, DataValue.DataType.String);
+					SetOrganisationColDfn(columnDfn, "Category", 80, SaxDbDfn_Core.ColumnIdx.Organisation_OrganisationCategory, ColumnAlignment.Center, DataValue.DataType.String);
 					break;
 				case SaxOrganisation.Column.PhoneMain:
-					SetOrganisationColDfn(columnDfn, "Phone", 100, SaxDbDfn.ColumnIdx.Organisation_PhoneMain);
+					SetOrganisationColDfn(columnDfn, "Phone", 100, SaxDbDfn_Core.ColumnIdx.Organisation_PhoneMain);
 					break;
 				case SaxOrganisation.Column.PhoneAlt:
-					SetOrganisationColDfn(columnDfn, "Alt. phone", 100, SaxDbDfn.ColumnIdx.Organisation_PhoneAlt);
-					break;
-
-				//-----------------------------------------------------------
-				// Region.
-				case SaxOrganisation.Column.RegionId:
-					SetOrganisationColDfn(columnDfn, "Region Id", 80, SaxDbDfn.ColumnIdx.Region_Id, ColumnAlignment.Right, DataValue.DataType.Long, aliasOrganisation_Region, prefixOrganisation_Region);
-					columnDfn.ReadOnly = true;
-					break;
-				case SaxOrganisation.Column.Region_Name:
-					SetOrganisationColDfn(columnDfn, "Region", 120, SaxDbDfn.ColumnIdx.Organisation_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasOrganisation_Region, prefixOrganisation_Region);
+					SetOrganisationColDfn(columnDfn, "Alt. phone", 100, SaxDbDfn_Core.ColumnIdx.Organisation_PhoneAlt);
 					break;
 
 				//-----------------------------------------------------------
 				// Sport.
 				case SaxOrganisation.Column.SportId:
-					SetOrganisationColDfn(columnDfn, "Sport Id", 80, SaxDbDfn.ColumnIdx.Sport_Id, ColumnAlignment.Right, DataValue.DataType.Long, aliasOrganisation_Sport, prefixOrganisation_Sport);
+					SetOrganisationColDfn(columnDfn, "Sport Id", 80, SaxDbDfn_Core.ColumnIdx.Sport_Id, ColumnAlignment.Right, DataValue.DataType.Long, aliasOrganisation_Sport, prefixOrganisation_Sport);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxOrganisation.Column.Sport_Name:
-					SetOrganisationColDfn(columnDfn, "Sport", 120, SaxDbDfn.ColumnIdx.Organisation_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasOrganisation_Sport, prefixOrganisation_Sport);
+					SetOrganisationColDfn(columnDfn, "Sport", 120, SaxDbDfn_Core.ColumnIdx.Organisation_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasOrganisation_Sport, prefixOrganisation_Sport);
+					break;
+
+				//-----------------------------------------------------------
+				// Region.
+				case SaxOrganisation.Column.RegionId:
+					SetOrganisationColDfn(columnDfn, "Region Id", 80, SaxDbDfn_Core.ColumnIdx.Region_Id, ColumnAlignment.Right, DataValue.DataType.Long, aliasOrganisation_Region, prefixOrganisation_Region);
+					columnDfn.ReadOnly = true;
+					break;
+				case SaxOrganisation.Column.Region_Name:
+					SetOrganisationColDfn(columnDfn, "Region", 120, SaxDbDfn_Core.ColumnIdx.Organisation_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasOrganisation_Region, prefixOrganisation_Region);
 					break;
 
 				//-----------------------------------------------------------
 				// Derived properties.
 				case SaxOrganisation.Column.User_Count:
-					SetOrganisationColDfn(columnDfn, "Users", 80, SaxDbDfn.ColumnIdx.Unknown, ColumnAlignment.Center, DataValue.DataType.Long);
+					SetOrganisationColDfn(columnDfn, "Users", 80, SaxDbDfn_Core.ColumnIdx.Unknown, ColumnAlignment.Center, DataValue.DataType.Long);
 					columnDfn.DataName = colOrganisation_User_Count;
 					break;
 				case SaxOrganisation.Column.Member_Count:
-					SetOrganisationColDfn(columnDfn, "Members", 80, SaxDbDfn.ColumnIdx.Unknown, ColumnAlignment.Center, DataValue.DataType.Long);
+					SetOrganisationColDfn(columnDfn, "Members", 80, SaxDbDfn_Core.ColumnIdx.Unknown, ColumnAlignment.Center, DataValue.DataType.Long);
 					columnDfn.DataName = colOrganisation_Member_Count;
 					break;
 
 				//-----------------------------------------------------------
 				// Common properties.
 				case SaxOrganisation.Column.Notes:
-					SetOrganisationColDfn(columnDfn, "Notes", 240, SaxDbDfn.ColumnIdx.Organisation_Notes);
+					SetOrganisationColDfn(columnDfn, "Notes", 240, SaxDbDfn_Core.ColumnIdx.Organisation_Notes);
 					break;
 				case SaxOrganisation.Column.Flags:
-					SetOrganisationColDfn(columnDfn, "Flags", 60, SaxDbDfn.ColumnIdx.Organisation_Flags, ColumnAlignment.Center, DataValue.DataType.Long);
+					SetOrganisationColDfn(columnDfn, "Flags", 60, SaxDbDfn_Core.ColumnIdx.Organisation_Flags, ColumnAlignment.Center, DataValue.DataType.Long);
 					break;
 				case SaxOrganisation.Column.Status:
-					SetOrganisationColDfn(columnDfn, "Status", 80, SaxDbDfn.ColumnIdx.Organisation_Status, ColumnAlignment.Center);
+					SetOrganisationColDfn(columnDfn, "Status", 80, SaxDbDfn_Core.ColumnIdx.Organisation_Status, ColumnAlignment.Center);
 					break;
 				case SaxOrganisation.Column.Status_Desc:
-					SetOrganisationColDfn(columnDfn, "Status", 90, SaxDbDfn.ColumnIdx.Organisation_Status, ColumnAlignment.Center);
+					SetOrganisationColDfn(columnDfn, "Status", 90, SaxDbDfn_Core.ColumnIdx.Organisation_Status, ColumnAlignment.Center);
 					break;
 				case SaxOrganisation.Column.Status_Ind:
-					SetOrganisationColDfn(columnDfn, "Status", 80, SaxDbDfn.ColumnIdx.Organisation_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
+					SetOrganisationColDfn(columnDfn, "Status", 80, SaxDbDfn_Core.ColumnIdx.Organisation_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
 					columnDfn.TriStateFormat = ColumnTriStateFormat.Lights;
 					break;
 				case SaxOrganisation.Column.CreateOn_Date:
-					SetOrganisationColDfn(columnDfn, "Created", 80, SaxDbDfn.ColumnIdx.Organisation_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
+					SetOrganisationColDfn(columnDfn, "Created", 80, SaxDbDfn_Core.ColumnIdx.Organisation_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxOrganisation.Column.UpdateOn_Date:
-					SetOrganisationColDfn(columnDfn, "Updated", 80, SaxDbDfn.ColumnIdx.Organisation_UpdateOn, ColumnAlignment.Center, DataValue.DataType.Date);
+					SetOrganisationColDfn(columnDfn, "Updated", 80, SaxDbDfn_Core.ColumnIdx.Organisation_UpdateOn, ColumnAlignment.Center, DataValue.DataType.Date);
 					columnDfn.ReadOnly = true;
 					break;
 
@@ -379,16 +379,16 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			// Item Ids.
 			String idsIncluded = prm.IdsIncluded.Concat(",");
 			if (!idsIncluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_Id, aliasOrganisation) + " IN (" + idsIncluded + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_Id, aliasOrganisation) + " IN (" + idsIncluded + ")");
 			String idsExcluded = prm.IdsExcluded.Concat(",");
 			if (!idsExcluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_Id, aliasOrganisation) + " NOT IN (" + idsExcluded + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_Id, aliasOrganisation) + " NOT IN (" + idsExcluded + ")");
 
 			// Name.
 			if (!StringUtil.IsEmpty(prm.NameFull))
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_Name, aliasOrganisation) + "='" + DbQuery.FormatForCondition(prm.NameFull) + "'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_Name, aliasOrganisation) + "='" + DbQuery.FormatForCondition(prm.NameFull) + "'");
 			if (!StringUtil.IsEmpty(prm.NamePartial))
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_Name, aliasOrganisation) + " Like '%" + DbQuery.FormatForLike(prm.NamePartial, true) + "%'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_Name, aliasOrganisation) + " Like '%" + DbQuery.FormatForLike(prm.NamePartial, true) + "%'");
 
 			// Organisation filter.
 			if (!StringUtil.IsEmpty(prm.OrganisationFilter))
@@ -400,30 +400,30 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				foreach (String filterWord in filterWords)
 				{
 					List<String> organisationFilter = new List<String>();
-					organisationFilter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_Name, aliasOrganisation) + " Like '%" + DbQuery.FormatForLike(filterWord, true) + "%'");
+					organisationFilter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_Name, aliasOrganisation) + " Like '%" + DbQuery.FormatForLike(filterWord, true) + "%'");
 					filter.Add(organisationFilter.Concat(" OR ", "(", ")"));
 				}
 			}
 
-			// Region Ids.
-			String regionIdsIncluded = prm.RegionIdsIncluded.Concat(",");
-			if (!regionIdsIncluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_RegionIdPrimary, aliasOrganisation) + " IN (" + regionIdsIncluded + ")");
-
 			// Sport Ids.
 			String sportIdsIncluded = prm.SportIdsIncluded.Concat(",");
 			if (!sportIdsIncluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_SportIdPrimary, aliasOrganisation) + " IN (" + sportIdsIncluded + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_SportIdPrimary, aliasOrganisation) + " IN (" + sportIdsIncluded + ")");
+
+			// Region Ids.
+			String regionIdsIncluded = prm.RegionIdsIncluded.Concat(",");
+			if (!regionIdsIncluded.IsEmpty())
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_RegionIdPrimary, aliasOrganisation) + " IN (" + regionIdsIncluded + ")");
 
 			// Notes.
 			if (!StringUtil.IsEmpty(prm.NotesPartial))
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_Notes, aliasOrganisation) + " LIKE '%" + DbQuery.FormatForLike(prm.NotesPartial) + "%'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_Notes, aliasOrganisation) + " LIKE '%" + DbQuery.FormatForLike(prm.NotesPartial) + "%'");
 
 			// Status.
 			if (prm.StatusCat == SaxOrganisation.StatusCat.ActiveOnly)
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_Status, aliasOrganisation) + "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_Status, aliasOrganisation) + "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'");
 			else if (prm.StatusCat == SaxOrganisation.StatusCat.NotDeleted)
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_Status, aliasOrganisation) + "!='" + SacsSystem.GetStatusCode(SaStatus.Deleted) + "'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_Status, aliasOrganisation) + "!='" + SacsSystem.GetStatusCode(SaStatus.Deleted) + "'");
 
 			if (filter.Count < 1) filter.Add("1=1");
 			return filter;
@@ -437,9 +437,9 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			{
 				// Need to ensure correct alias used for Organisation columns in case of conflict.
 				String sortCol = String.Empty;
-				if (SaxDbDfn.GetTableForColumn((SaxDbDfn.ColumnIdx)columnDfn.DbColumn) == SaxDbDfn.TableIdx.Organisation)
+				if (SaxDbDfn_Core.GetTableForColumn((SaxDbDfn_Core.ColumnIdx)columnDfn.DbColumn) == SaxDbDfn_Core.TableIdx.Organisation)
 				{
-					sortCol = SaxDbDfn.GetColumnNameQual((SaxDbDfn.ColumnIdx)columnDfn.DbColumn, aliasOrganisation);
+					sortCol = SaxDbDfn_Core.GetColumnNameQual((SaxDbDfn_Core.ColumnIdx)columnDfn.DbColumn, aliasOrganisation);
 				}
 				else
 				{
@@ -457,7 +457,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			if (sortColumnNames.IsEmpty())
 			{
 				// Default sort columns.
-				sortColumnNames.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_Id, aliasOrganisation) + " ASC");
+				sortColumnNames.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_Id, aliasOrganisation) + " ASC");
 			}
 			return sortColumnNames;
 		}
@@ -467,7 +467,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		private long GetOrganisationCount(String filter)
 		{
 			ClearErrorState();
-			return CoreDatabase.GetRowCount(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.Organisation) + " As " + aliasOrganisation, filter);
+			return CoreDatabase.GetRowCount(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Organisation) + " As " + aliasOrganisation, filter);
 		}
 		public override long GetOrganisationCount(SaxOrganisation.Params prm)
 		{
@@ -481,7 +481,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		{
 			List<SaxOrganisation> userAccounts = new List<SaxOrganisation>();
 			DbQuery qry = new DbQuery(CoreDatabase.DbmsType);
-			qry.Tables.Add(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.Organisation), aliasOrganisation);
+			qry.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Organisation), aliasOrganisation);
 			Organisation_Db dbOrganisation = new Organisation_Db(CoreDbInfo);
 			qry.Columns.AddRange(dbOrganisation.ExistingColumnNames);
 			qry.Filters.AddRange(GetOrganisationQueryFilter(prm));
@@ -506,7 +506,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				}
 				catch (Exception exc)
 				{
-					SaLogger.Warn(GetType().Name + ".GetOrganisationList\n\tQuery: " + dbCommand.CommandText + "\n\t" + exc.GetType().Name + ": " + exc.Message);
+					SaLogger.Warn(GetType().Name + ".GetOrganisationList\n\tQuery: " + dbCommand.CommandText + "\n\t" + ExceptionUtil.GetLogMessage(exc));
 				}
 			}
 			return userAccounts;
@@ -521,67 +521,67 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			//---------------------------------------------------------------------
 			// Construct query.
 			DbQuery query = new DbQuery(CoreDatabase.DbmsType);
-			query.Tables.Add(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.Organisation), aliasOrganisation);
+			query.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Organisation), aliasOrganisation);
 
 			// Add columns as defined in query list.
 			if (columns.HasId(SaxOrganisation.Column.Id))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_Id, aliasOrganisation));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_Id, aliasOrganisation));
 			if (columns.HasId(SaxOrganisation.Column.Name))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_Name, aliasOrganisation));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_Name, aliasOrganisation));
 			if (columns.HasId(SaxOrganisation.Column.PhoneMain))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_PhoneMain, aliasOrganisation));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_PhoneMain, aliasOrganisation));
 			if (columns.HasId(SaxOrganisation.Column.PhoneAlt))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_PhoneAlt, aliasOrganisation));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_PhoneAlt, aliasOrganisation));
 			if (columns.HasId(SaxOrganisation.Column.OrganisationType) || columns.HasId(SaxOrganisation.Column.OrganisationType_Desc))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_OrganisationType, aliasOrganisation));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_OrganisationType, aliasOrganisation));
 			if (columns.HasId(SaxOrganisation.Column.OrganisationCategory) || columns.HasId(SaxOrganisation.Column.OrganisationCategory_Desc))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_OrganisationCategory, aliasOrganisation));
-			// Region.
-			bool hasRegionCols = columns.HasId(SaxOrganisation.Column.Region_Name);
-			if (columns.HasId(SaxOrganisation.Column.RegionId) || hasRegionCols)
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_RegionIdPrimary, aliasOrganisation));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_OrganisationCategory, aliasOrganisation));
 			// Sport.
 			bool hasSportCols = columns.HasId(SaxOrganisation.Column.Sport_Name);
 			if (columns.HasId(SaxOrganisation.Column.SportId) || hasSportCols)
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_SportIdPrimary, aliasOrganisation));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_SportIdPrimary, aliasOrganisation));
+			// Region.
+			bool hasRegionCols = columns.HasId(SaxOrganisation.Column.Region_Name);
+			if (columns.HasId(SaxOrganisation.Column.RegionId) || hasRegionCols)
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_RegionIdPrimary, aliasOrganisation));
 			// Common properties.
 			if (columns.HasId(SaxOrganisation.Column.Notes))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_Notes, aliasOrganisation));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_Notes, aliasOrganisation));
 			if (columns.HasId(SaxOrganisation.Column.Flags))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_Flags, aliasOrganisation));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_Flags, aliasOrganisation));
 			if (columns.HasId(SaxOrganisation.Column.Status) || columns.HasId(SaxOrganisation.Column.Status_Desc) || columns.HasId(SaxOrganisation.Column.Status_Ind))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_Status, aliasOrganisation));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_Status, aliasOrganisation));
 			if (columns.HasId(SaxOrganisation.Column.CreateOn_Date))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_CreateOn, aliasOrganisation));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_CreateOn, aliasOrganisation));
 			if (columns.HasId(SaxOrganisation.Column.UpdateOn_Date))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_UpdateOn, aliasOrganisation));
-
-			//---------------------------------------------------------------------
-			// Region.
-			if (hasRegionCols)
-			{
-				DbQueryJoin joinRegion = new DbQueryJoin(DbJoinType.LeftOuter);
-				joinRegion.Table = new StringPair(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.Region), aliasOrganisation_Region);
-				joinRegion.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_Id, aliasOrganisation_Region) + "=" + SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_RegionIdPrimary, aliasOrganisation));
-				query.Joins.Add(joinRegion);
-				List<SaxDbDfn.ColumnIdx> cols = new List<SaxDbDfn.ColumnIdx>();
-				cols.Add(SaxDbDfn.ColumnIdx.Region_Name);
-				foreach (var col in cols)
-					query.Columns.Add(SaxDbDfn.GetColumnNameQual(col, aliasOrganisation_Region), prefixOrganisation_Region + SaxDbDfn.GetColumnName(col, false));
-			}
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_UpdateOn, aliasOrganisation));
 
 			//---------------------------------------------------------------------
 			// Sport.
 			if (hasSportCols)
 			{
 				DbQueryJoin joinSport = new DbQueryJoin(DbJoinType.LeftOuter);
-				joinSport.Table = new StringPair(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.Sport), aliasOrganisation_Sport);
-				joinSport.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Sport_Id, aliasOrganisation_Sport) + "=" + SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_SportIdPrimary, aliasOrganisation));
+				joinSport.Table = new StringPair(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Sport), aliasOrganisation_Sport);
+				joinSport.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Sport_Id, aliasOrganisation_Sport) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_SportIdPrimary, aliasOrganisation));
 				query.Joins.Add(joinSport);
-				List<SaxDbDfn.ColumnIdx> cols = new List<SaxDbDfn.ColumnIdx>();
-				cols.Add(SaxDbDfn.ColumnIdx.Sport_Name);
+				List<SaxDbDfn_Core.ColumnIdx> cols = new List<SaxDbDfn_Core.ColumnIdx>();
+				cols.Add(SaxDbDfn_Core.ColumnIdx.Sport_Name);
 				foreach (var col in cols)
-					query.Columns.Add(SaxDbDfn.GetColumnNameQual(col, aliasOrganisation_Sport), prefixOrganisation_Sport + SaxDbDfn.GetColumnName(col, false));
+					query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(col, aliasOrganisation_Sport), prefixOrganisation_Sport + SaxDbDfn_Core.GetColumnName(col, false));
+			}
+
+			//---------------------------------------------------------------------
+			// Region.
+			if (hasRegionCols)
+			{
+				DbQueryJoin joinRegion = new DbQueryJoin(DbJoinType.LeftOuter);
+				joinRegion.Table = new StringPair(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Region), aliasOrganisation_Region);
+				joinRegion.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_Id, aliasOrganisation_Region) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_RegionIdPrimary, aliasOrganisation));
+				query.Joins.Add(joinRegion);
+				List<SaxDbDfn_Core.ColumnIdx> cols = new List<SaxDbDfn_Core.ColumnIdx>();
+				cols.Add(SaxDbDfn_Core.ColumnIdx.Region_Name);
+				foreach (var col in cols)
+					query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(col, aliasOrganisation_Region), prefixOrganisation_Region + SaxDbDfn_Core.GetColumnName(col, false));
 			}
 
 			//---------------------------------------------------------------------
@@ -590,10 +590,10 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			{
 				String aliasUserCount = "aUsrOrg_Count";
 				DbQuery queryUserCount = new DbQuery(CoreDatabase.DbmsType);
-				queryUserCount.Tables.Add(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.UserOrganisation), aliasUserCount);
+				queryUserCount.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.UserOrganisation), aliasUserCount);
 				queryUserCount.Columns.Add("Count(*)");
-				queryUserCount.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserOrganisation_OrganisationId, aliasUserCount) + "=" + SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_Id, aliasOrganisation));
-				queryUserCount.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserOrganisation_Status, aliasUserCount) + "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'");
+				queryUserCount.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserOrganisation_OrganisationId, aliasUserCount) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_Id, aliasOrganisation));
+				queryUserCount.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserOrganisation_Status, aliasUserCount) + "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'");
 				query.Columns.Add("(" + queryUserCount.BuildQuery() + ")", colOrganisation_Member_Count);
 			}
 
@@ -603,11 +603,11 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			{
 				String aliasMemberCount = "aUsrOrg_Count";
 				DbQuery queryMemberCount = new DbQuery(CoreDatabase.DbmsType);
-				queryMemberCount.Tables.Add(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.UserOrganisation), aliasMemberCount);
+				queryMemberCount.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.UserOrganisation), aliasMemberCount);
 				queryMemberCount.Columns.Add("Count(*)");
-				queryMemberCount.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserOrganisation_OrganisationId, aliasMemberCount) + "=" + SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_Id, aliasOrganisation));
-				queryMemberCount.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserOrganisation_OrganisationRoleCount, aliasMemberCount) + ">0");
-				queryMemberCount.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserOrganisation_Status, aliasMemberCount) + "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'");
+				queryMemberCount.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserOrganisation_OrganisationId, aliasMemberCount) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_Id, aliasOrganisation));
+				queryMemberCount.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserOrganisation_OrganisationRoleCount, aliasMemberCount) + ">0");
+				queryMemberCount.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserOrganisation_Status, aliasMemberCount) + "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'");
 				query.Columns.Add("(" + queryMemberCount.BuildQuery() + ")", colOrganisation_Member_Count);
 			}
 

SaxoniteStandardDbas/Dbas/Mgr/SaxAccountMgr_Dbas-UserAccount.cs

@@ -188,7 +188,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 					dbUserAccount.PopulateFrom(dbCommand, aliasUserAccount, "Id=" + userAccount.Id.ToString());
 					// Delete userAccount.
 					dbCommand.CommandType = System.Data.CommandType.Text;
-					dbCommand.CommandText = "DELETE FROM " + SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.UserAccount) + " WHERE Id=" + SysId.ToString(userAccount.Id) + ";";
+					dbCommand.CommandText = "DELETE FROM " + SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.UserAccount) + " WHERE Id=" + SysId.ToString(userAccount.Id) + ";";
 					dbCommand.ExecuteNonQuery();
 					userAccount.Changed = false;
 					if (DebugMode) SaLogger.Debug(fn + " Deleted. " + GetLogProperties(userAccount).Concat(": ").Concat("", "\n\t"));
@@ -211,6 +211,8 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			dbUserAccount._PhoneMain = userAccount.PhoneMain;
 			dbUserAccount._PhoneMobile = userAccount.PhoneMobile;
 			dbUserAccount._DateOfBirth = userAccount.DateOfBirth;
+			dbUserAccount._RegionIdCountry = SysId.ToInt(userAccount.RegionIdCountry);
+			dbUserAccount._RegionIdProvince = SysId.ToInt(userAccount.RegionIdProvince);
 			// Security
 			dbUserAccount._PasswordHashed = userAccount.PasswordHashed;
 			dbUserAccount._PasswordToken = userAccount.PasswordToken;
@@ -245,6 +247,8 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			userAccount.PhoneMain = dbUserAccount._PhoneMain;
 			userAccount.PhoneMobile = dbUserAccount._PhoneMobile;
 			userAccount.DateOfBirth = dbUserAccount._DateOfBirth;
+			userAccount.RegionIdCountry = new SysId(dbUserAccount._RegionIdCountry);
+			userAccount.RegionIdProvince = new SysId(dbUserAccount._RegionIdProvince);
 			// Security.
 			userAccount.PasswordHashed = dbUserAccount._PasswordHashed;
 			userAccount.PasswordToken = dbUserAccount._PasswordToken;
@@ -265,18 +269,22 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		//-------------------------------------------------------------------
 		// Item column definitions.
 		private static readonly String aliasUserAccount = "UsrAct";
+		private static readonly String aliasUserAccount_Region_Country = "UsrAct_Ctr";
+		private static readonly String prefixUserAccount_Region_Country = "UsrAct_Ctr_";
+		private static readonly String aliasUserAccount_Region_Province = "UsrAct_Prv";
+		private static readonly String prefixUserAccount_Region_Province = "UsrAct_Prv_";
 		private static readonly String colUserAccount_UserRoleCount = "UsrAct_RoleCount";
 		private static readonly String colUserAccount_SystemAdminRole = "UsrAct_SystemAdminRole";
 		private void SetUserAccountColDfn
-			(ColumnDfn col, String caption, int width, SaxDbDfn.ColumnIdx dbCol,
+			(ColumnDfn col, String caption, int width, SaxDbDfn_Core.ColumnIdx dbCol,
 			ColumnAlignment align = ColumnAlignment.Default, DataValue.DataType dataType = DataValue.DataType.String,
 			String alias = "", String prefix = "")
 		{
-			if (String.IsNullOrEmpty(alias) && SaxDbDfn.GetTableForColumn(dbCol) == SaxDbDfn.TableIdx.UserAccount)
+			if (String.IsNullOrEmpty(alias) && SaxDbDfn_Core.GetTableForColumn(dbCol) == SaxDbDfn_Core.TableIdx.UserAccount)
 				alias = aliasUserAccount;
-			col.Set(caption, width, (int)dbCol, prefix + SaxDbDfn.GetColumnName(dbCol, false), SaxDbDfn.GetColumnNameQual(dbCol, alias), dataType, align);
-			if (dataType == DataValue.DataType.String && dbCol != SaxDbDfn.ColumnIdx.Unknown)
-				col.MaxLength = (int)SaxDbDfn.GetColTextLen(dbCol);
+			col.Set(caption, width, (int)dbCol, prefix + SaxDbDfn_Core.GetColumnName(dbCol, false), SaxDbDfn_Core.GetColumnNameQual(dbCol, alias), dataType, align);
+			if (dataType == DataValue.DataType.String && dbCol != SaxDbDfn_Core.ColumnIdx.Unknown)
+				col.MaxLength = (int)SaxDbDfn_Core.GetColTextLen(dbCol);
 		}
 		public override ColumnDfn GetUserAccountColumnDfn(SaxUserAccount.Column columnId, string caption = "", int width = 0)
 		{
@@ -285,73 +293,90 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			{
 				//-----------------------------------------------------------
 				case SaxUserAccount.Column.Pos:
-					SetUserAccountColDfn(columnDfn, "Pos", 60, SaxDbDfn.ColumnIdx.Unknown, ColumnAlignment.Right);
+					SetUserAccountColDfn(columnDfn, "Pos", 60, SaxDbDfn_Core.ColumnIdx.Unknown, ColumnAlignment.Right);
 					columnDfn.SortMode = ColumnDfn.ColumnSortMode.Off;
 					columnDfn.ReadOnly = true;
 					columnDfn.Resizable = false;
 					break;
 				case SaxUserAccount.Column.Id:
-					SetUserAccountColDfn(columnDfn, "Id", 80, SaxDbDfn.ColumnIdx.UserAccount_Id, ColumnAlignment.Right, DataValue.DataType.Long);
+					SetUserAccountColDfn(columnDfn, "Id", 80, SaxDbDfn_Core.ColumnIdx.UserAccount_Id, ColumnAlignment.Right, DataValue.DataType.Long);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserAccount.Column.EmailAddress:
-					SetUserAccountColDfn(columnDfn, "Email", 120, SaxDbDfn.ColumnIdx.UserAccount_EmailAddress);
+					SetUserAccountColDfn(columnDfn, "Email", 120, SaxDbDfn_Core.ColumnIdx.UserAccount_EmailAddress);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserAccount.Column.Title:
-					SetUserAccountColDfn(columnDfn, "Title", 80, SaxDbDfn.ColumnIdx.UserAccount_Title);
+					SetUserAccountColDfn(columnDfn, "Title", 80, SaxDbDfn_Core.ColumnIdx.UserAccount_Title);
 					break;
 				case SaxUserAccount.Column.FirstName:
-					SetUserAccountColDfn(columnDfn, "FirstName", 100, SaxDbDfn.ColumnIdx.UserAccount_FirstName);
+					SetUserAccountColDfn(columnDfn, "FirstName", 100, SaxDbDfn_Core.ColumnIdx.UserAccount_FirstName);
 					break;
 				case SaxUserAccount.Column.Initials:
-					SetUserAccountColDfn(columnDfn, "Initials", 60, SaxDbDfn.ColumnIdx.UserAccount_Initials);
+					SetUserAccountColDfn(columnDfn, "Initials", 60, SaxDbDfn_Core.ColumnIdx.UserAccount_Initials);
 					break;
 				case SaxUserAccount.Column.LastName:
-					SetUserAccountColDfn(columnDfn, "LastName", 100, SaxDbDfn.ColumnIdx.UserAccount_LastName);
+					SetUserAccountColDfn(columnDfn, "LastName", 100, SaxDbDfn_Core.ColumnIdx.UserAccount_LastName);
 					break;
 				case SaxUserAccount.Column.PhoneMain:
-					SetUserAccountColDfn(columnDfn, "PhoneMain", 100, SaxDbDfn.ColumnIdx.UserAccount_PhoneMain);
+					SetUserAccountColDfn(columnDfn, "PhoneMain", 100, SaxDbDfn_Core.ColumnIdx.UserAccount_PhoneMain);
 					break;
 				case SaxUserAccount.Column.PhoneMobile:
-					SetUserAccountColDfn(columnDfn, "PhoneMobile", 100, SaxDbDfn.ColumnIdx.UserAccount_PhoneMobile);
+					SetUserAccountColDfn(columnDfn, "PhoneMobile", 100, SaxDbDfn_Core.ColumnIdx.UserAccount_PhoneMobile);
 					break;
 				case SaxUserAccount.Column.DateOfBirth:
-					SetUserAccountColDfn(columnDfn, "DOB", 80, SaxDbDfn.ColumnIdx.UserAccount_DateOfBirth, ColumnAlignment.Center, DataValue.DataType.Date);
+					SetUserAccountColDfn(columnDfn, "DOB", 80, SaxDbDfn_Core.ColumnIdx.UserAccount_DateOfBirth, ColumnAlignment.Center, DataValue.DataType.Date);
+					break;
+
+				//-------------------------------------------------------
+				// Regions.
+				case SaxUserAccount.Column.RegionIdCountry:
+					SetUserAccountColDfn(columnDfn, "Country #", 80, SaxDbDfn_Core.ColumnIdx.UserAccount_RegionIdCountry, ColumnAlignment.Right, DataValue.DataType.Long);
+					break;
+				case SaxUserAccount.Column.RegionCountry_Name:
+					SetUserAccountColDfn(columnDfn, "Country", 120, SaxDbDfn_Core.ColumnIdx.Region_Name, ColumnAlignment.Center, DataValue.DataType.String, aliasUserAccount_Region_Country, prefixUserAccount_Region_Country);
+					columnDfn.ReadOnly = true;
+					break;
+				case SaxUserAccount.Column.RegionIdProvince:
+					SetUserAccountColDfn(columnDfn, "Province #", 80, SaxDbDfn_Core.ColumnIdx.UserAccount_RegionIdProvince, ColumnAlignment.Right, DataValue.DataType.Long);
+					break;
+				case SaxUserAccount.Column.RegionProvince_Name:
+					SetUserAccountColDfn(columnDfn, "Province", 120, SaxDbDfn_Core.ColumnIdx.Region_Name, ColumnAlignment.Center, DataValue.DataType.String, aliasUserAccount_Region_Province, prefixUserAccount_Region_Province);
+					columnDfn.ReadOnly = true;
 					break;
 
 				//-------------------------------------------------------
 				// Security.
 				case SaxUserAccount.Column.LastLoginOn:
-					SetUserAccountColDfn(columnDfn, "Last login", 100, SaxDbDfn.ColumnIdx.UserAccount_LastLoginAt, ColumnAlignment.Center, DataValue.DataType.Date);
+					SetUserAccountColDfn(columnDfn, "Last login", 100, SaxDbDfn_Core.ColumnIdx.UserAccount_LastLoginAt, ColumnAlignment.Center, DataValue.DataType.Date);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserAccount.Column.LastLoginAt:
-					SetUserAccountColDfn(columnDfn, "Last login", 120, SaxDbDfn.ColumnIdx.UserAccount_LastLoginAt, ColumnAlignment.Center, DataValue.DataType.DateTime);
+					SetUserAccountColDfn(columnDfn, "Last login", 120, SaxDbDfn_Core.ColumnIdx.UserAccount_LastLoginAt, ColumnAlignment.Center, DataValue.DataType.DateTime);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserAccount.Column.LastInvalidLoginOn:
-					SetUserAccountColDfn(columnDfn, "Last invalid login", 100, SaxDbDfn.ColumnIdx.UserAccount_LastInvalidLoginAt, ColumnAlignment.Center, DataValue.DataType.Date);
+					SetUserAccountColDfn(columnDfn, "Last invalid login", 100, SaxDbDfn_Core.ColumnIdx.UserAccount_LastInvalidLoginAt, ColumnAlignment.Center, DataValue.DataType.Date);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserAccount.Column.LastInvalidLoginAt:
-					SetUserAccountColDfn(columnDfn, "Last invalid login", 100, SaxDbDfn.ColumnIdx.UserAccount_LastInvalidLoginAt, ColumnAlignment.Center, DataValue.DataType.DateTime);
+					SetUserAccountColDfn(columnDfn, "Last invalid login", 100, SaxDbDfn_Core.ColumnIdx.UserAccount_LastInvalidLoginAt, ColumnAlignment.Center, DataValue.DataType.DateTime);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserAccount.Column.InvalidLoginCount:
-					SetUserAccountColDfn(columnDfn, "Invalid logins", 80, SaxDbDfn.ColumnIdx.UserAccount_InvalidLoginCount, ColumnAlignment.Center, DataValue.DataType.Long);
+					SetUserAccountColDfn(columnDfn, "Invalid logins", 80, SaxDbDfn_Core.ColumnIdx.UserAccount_InvalidLoginCount, ColumnAlignment.Center, DataValue.DataType.Long);
 					columnDfn.ReadOnly = true;
 					break;
 
 				//-----------------------------------------------------------
 				// Derived properties.
 				case SaxUserAccount.Column.UserRoleCount:
-					SetUserAccountColDfn(columnDfn, "Roles", 80, SaxDbDfn.ColumnIdx.Unknown, ColumnAlignment.Center, DataValue.DataType.Long);
+					SetUserAccountColDfn(columnDfn, "Roles", 80, SaxDbDfn_Core.ColumnIdx.Unknown, ColumnAlignment.Center, DataValue.DataType.Long);
 					columnDfn.DataName = colUserAccount_UserRoleCount;
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserAccount.Column.SystemAdminUser:
-					SetUserAccountColDfn(columnDfn, "System Admin", 80, SaxDbDfn.ColumnIdx.Unknown, ColumnAlignment.Center, DataValue.DataType.Bool);
+					SetUserAccountColDfn(columnDfn, "System Admin", 80, SaxDbDfn_Core.ColumnIdx.Unknown, ColumnAlignment.Center, DataValue.DataType.Bool);
 					columnDfn.DataName = colUserAccount_SystemAdminRole;
 					columnDfn.ReadOnly = true;
 					break;
@@ -359,27 +384,27 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				//-----------------------------------------------------------
 				// Common properties.
 				case SaxUserAccount.Column.Notes:
-					SetUserAccountColDfn(columnDfn, "Notes", 240, SaxDbDfn.ColumnIdx.UserAccount_Notes);
+					SetUserAccountColDfn(columnDfn, "Notes", 240, SaxDbDfn_Core.ColumnIdx.UserAccount_Notes);
 					break;
 				case SaxUserAccount.Column.Flags:
-					SetUserAccountColDfn(columnDfn, "Flags", 60, SaxDbDfn.ColumnIdx.UserAccount_Flags, ColumnAlignment.Center, DataValue.DataType.Long);
+					SetUserAccountColDfn(columnDfn, "Flags", 60, SaxDbDfn_Core.ColumnIdx.UserAccount_Flags, ColumnAlignment.Center, DataValue.DataType.Long);
 					break;
 				case SaxUserAccount.Column.Status:
-					SetUserAccountColDfn(columnDfn, "Status", 80, SaxDbDfn.ColumnIdx.UserAccount_Status, ColumnAlignment.Center);
+					SetUserAccountColDfn(columnDfn, "Status", 80, SaxDbDfn_Core.ColumnIdx.UserAccount_Status, ColumnAlignment.Center);
 					break;
 				case SaxUserAccount.Column.Status_Desc:
-					SetUserAccountColDfn(columnDfn, "Status", 90, SaxDbDfn.ColumnIdx.UserAccount_Status, ColumnAlignment.Center);
+					SetUserAccountColDfn(columnDfn, "Status", 90, SaxDbDfn_Core.ColumnIdx.UserAccount_Status, ColumnAlignment.Center);
 					break;
 				case SaxUserAccount.Column.Status_Ind:
-					SetUserAccountColDfn(columnDfn, "Status", 80, SaxDbDfn.ColumnIdx.UserAccount_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
+					SetUserAccountColDfn(columnDfn, "Status", 80, SaxDbDfn_Core.ColumnIdx.UserAccount_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
 					columnDfn.TriStateFormat = ColumnTriStateFormat.Lights;
 					break;
 				case SaxUserAccount.Column.CreateOn_Date:
-					SetUserAccountColDfn(columnDfn, "Created", 80, SaxDbDfn.ColumnIdx.UserAccount_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
+					SetUserAccountColDfn(columnDfn, "Created", 80, SaxDbDfn_Core.ColumnIdx.UserAccount_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserAccount.Column.UpdateOn_Date:
-					SetUserAccountColDfn(columnDfn, "Updated", 80, SaxDbDfn.ColumnIdx.UserAccount_UpdateOn, ColumnAlignment.Center, DataValue.DataType.Date);
+					SetUserAccountColDfn(columnDfn, "Updated", 80, SaxDbDfn_Core.ColumnIdx.UserAccount_UpdateOn, ColumnAlignment.Center, DataValue.DataType.Date);
 					columnDfn.ReadOnly = true;
 					break;
 					//-----------------------------------------------------------
@@ -400,22 +425,22 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			// Item Ids.
 			String includedIds = prm.IdsIncluded.Concat(",");
 			if (!includedIds.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_Id, aliasUserAccount) + " IN (" + includedIds + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_Id, aliasUserAccount) + " IN (" + includedIds + ")");
 			String excludedIds = prm.IdsExcluded.Concat(",");
 			if (!excludedIds.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_Id, aliasUserAccount) + " NOT IN (" + excludedIds + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_Id, aliasUserAccount) + " NOT IN (" + excludedIds + ")");
 
 			// Email address.
 			if (!StringUtil.IsEmpty(prm.EmailAddress))
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_EmailAddress, aliasUserAccount) + " = '" + DbQuery.FormatForCondition(prm.EmailAddress) + "'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_EmailAddress, aliasUserAccount) + " = '" + DbQuery.FormatForCondition(prm.EmailAddress) + "'");
 
 			// Name.
 			if (!StringUtil.IsEmpty(prm.NamePartial))
 			{
 				List<String> nameFilter = new List<string>();
-				nameFilter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_Title, aliasUserAccount) + "Like'%" + DbQuery.FormatForLike(prm.NamePartial) + "%'");
-				nameFilter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_FirstName, aliasUserAccount) + "Like'%" + DbQuery.FormatForLike(prm.NamePartial) + "%'");
-				nameFilter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_LastName, aliasUserAccount) + "Like'%" + DbQuery.FormatForLike(prm.NamePartial) + "%'");
+				nameFilter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_Title, aliasUserAccount) + "Like'%" + DbQuery.FormatForLike(prm.NamePartial) + "%'");
+				nameFilter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_FirstName, aliasUserAccount) + "Like'%" + DbQuery.FormatForLike(prm.NamePartial) + "%'");
+				nameFilter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_LastName, aliasUserAccount) + "Like'%" + DbQuery.FormatForLike(prm.NamePartial) + "%'");
 				filter.Add(nameFilter.Concat(" OR ", "(", ")"));
 			}
 
@@ -429,10 +454,10 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				foreach (String filterWord in filterWords)
 				{
 					List<String> userAccountFilter = new List<string>();
-					userAccountFilter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_EmailAddress, aliasUserAccount) + " Like '%" + DbQuery.FormatForLike(filterWord) + "%'");
-					userAccountFilter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_Title, aliasUserAccount) + " Like '%" + DbQuery.FormatForLike(filterWord) + "%'");
-					userAccountFilter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_FirstName, aliasUserAccount) + " Like '%" + DbQuery.FormatForLike(filterWord) + "%'");
-					userAccountFilter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_LastName, aliasUserAccount) + " Like '%" + DbQuery.FormatForLike(filterWord) + "%'");
+					userAccountFilter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_EmailAddress, aliasUserAccount) + " Like '%" + DbQuery.FormatForLike(filterWord) + "%'");
+					userAccountFilter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_Title, aliasUserAccount) + " Like '%" + DbQuery.FormatForLike(filterWord) + "%'");
+					userAccountFilter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_FirstName, aliasUserAccount) + " Like '%" + DbQuery.FormatForLike(filterWord) + "%'");
+					userAccountFilter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_LastName, aliasUserAccount) + " Like '%" + DbQuery.FormatForLike(filterWord) + "%'");
 					filter.Add(userAccountFilter.Concat(" OR ", "(", ")"));
 				}
 			}
@@ -442,28 +467,28 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			{
 				String aliasUserRole = "UsrRol";
 				DbQuery roleQuery = new DbQuery(CoreDatabase.DbmsType);
-				roleQuery.Tables.Add(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.UserRole), aliasUserRole);
+				roleQuery.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.UserRole), aliasUserRole);
 				roleQuery.Columns.Add("1");
-				roleQuery.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserRole_UserAccountId, aliasUserRole) + "=" + SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_Id, aliasUserAccount));
+				roleQuery.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserRole_UserAccountId, aliasUserRole) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_Id, aliasUserAccount));
 
 				foreach (Sax.UserRole userRole in prm.ActiveRoles)
 				{
 					roleQuery.Filters.Clear();
-					roleQuery.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserRole_UserAccountId, aliasUserRole) + "=" + SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_Id, aliasUserAccount));
-					roleQuery.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserRole_UserRoleCode, aliasUserRole) + "='" + UserRoles.GetCodeForType(userRole) + "'");
+					roleQuery.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserRole_UserAccountId, aliasUserRole) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_Id, aliasUserAccount));
+					roleQuery.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserRole_UserRoleCode, aliasUserRole) + "='" + UserRoles.GetCodeForType(userRole) + "'");
 					filter.Add("Exists(" + roleQuery.BuildQuery() + ")");
 				}
 			}
 
 			// Notes.
 			if (!StringUtil.IsEmpty(prm.NotesPartial))
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_Notes, aliasUserAccount) + " LIKE '%" + DbQuery.FormatForLike(prm.NotesPartial) + "%'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_Notes, aliasUserAccount) + " LIKE '%" + DbQuery.FormatForLike(prm.NotesPartial) + "%'");
 
 			// Status.
 			if (prm.StatusCat == SaxUserAccount.StatusCat.ActiveOnly)
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_Status, aliasUserAccount) + "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_Status, aliasUserAccount) + "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'");
 			else if (prm.StatusCat == SaxUserAccount.StatusCat.NotDeleted)
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_Status, aliasUserAccount) + "!='" + SacsSystem.GetStatusCode(SaStatus.Deleted) + "'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_Status, aliasUserAccount) + "!='" + SacsSystem.GetStatusCode(SaStatus.Deleted) + "'");
 
 			if (filter.Count < 1) filter.Add("1=1");
 			return filter;
@@ -477,9 +502,9 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			{
 				// Need to ensure correct alias used for UserAccount columns in case of conflict.
 				String sortCol = String.Empty;
-				if (SaxDbDfn.GetTableForColumn((SaxDbDfn.ColumnIdx)columnDfn.DbColumn) == SaxDbDfn.TableIdx.UserAccount)
+				if (SaxDbDfn_Core.GetTableForColumn((SaxDbDfn_Core.ColumnIdx)columnDfn.DbColumn) == SaxDbDfn_Core.TableIdx.UserAccount)
 				{
-					sortCol = SaxDbDfn.GetColumnNameQual((SaxDbDfn.ColumnIdx)columnDfn.DbColumn, aliasUserAccount);
+					sortCol = SaxDbDfn_Core.GetColumnNameQual((SaxDbDfn_Core.ColumnIdx)columnDfn.DbColumn, aliasUserAccount);
 				}
 				else
 				{
@@ -497,7 +522,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			if (sortColumnNames.IsEmpty())
 			{
 				// Default sort columns.
-				sortColumnNames.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_Id, aliasUserAccount) + " ASC");
+				sortColumnNames.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_Id, aliasUserAccount) + " ASC");
 			}
 			return sortColumnNames;
 		}
@@ -507,7 +532,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		private long GetUserAccountCount(String filter)
 		{
 			ClearErrorState();
-			return CoreDatabase.GetRowCount(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.UserAccount) + " As " + aliasUserAccount, filter);
+			return CoreDatabase.GetRowCount(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.UserAccount) + " As " + aliasUserAccount, filter);
 		}
 		public override long GetUserAccountCount(SaxUserAccount.Params prm)
 		{
@@ -521,7 +546,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		{
 			List<SaxUserAccount> userAccounts = new List<SaxUserAccount>();
 			DbQuery qry = new DbQuery(CoreDatabase.DbmsType);
-			qry.Tables.Add(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.UserAccount), aliasUserAccount);
+			qry.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.UserAccount), aliasUserAccount);
 			UserAccount_Db dbUserAccount = new UserAccount_Db(CoreDbInfo);
 			qry.Columns.AddRange(dbUserAccount.ExistingColumnNames);
 			qry.Filters.AddRange(GetUserAccountQueryFilter(prm));
@@ -546,7 +571,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				}
 				catch (Exception exc)
 				{
-					SaLogger.Warn(GetType().Name + ".GetUserAccountList\n\tQuery: " + dbCommand.CommandText + "\n\t" + exc.GetType().Name + ": " + exc.Message);
+					SaLogger.Warn(GetType().Name + ".GetUserAccountList\n\tQuery: " + dbCommand.CommandText + "\n\t" + ExceptionUtil.GetLogMessage(exc));
 				}
 			}
 			return userAccounts;
@@ -561,41 +586,76 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			//---------------------------------------------------------------------
 			// Construct query.
 			DbQuery query = new DbQuery(CoreDatabase.DbmsType);
-			query.Tables.Add(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.UserAccount), aliasUserAccount);
+			query.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.UserAccount), aliasUserAccount);
 
 			// Add columns as defined in query list.
 			if (columns.HasId(SaxUserAccount.Column.Id))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_Id, aliasUserAccount));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_Id, aliasUserAccount));
 			if (columns.HasId(SaxUserAccount.Column.EmailAddress))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_EmailAddress, aliasUserAccount));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_EmailAddress, aliasUserAccount));
 			if (columns.HasId(SaxUserAccount.Column.Title))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_Title, aliasUserAccount));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_Title, aliasUserAccount));
 			if (columns.HasId(SaxUserAccount.Column.FirstName))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_FirstName, aliasUserAccount));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_FirstName, aliasUserAccount));
 			if (columns.HasId(SaxUserAccount.Column.Initials))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_Initials, aliasUserAccount));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_Initials, aliasUserAccount));
 			if (columns.HasId(SaxUserAccount.Column.LastName))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_LastName, aliasUserAccount));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_LastName, aliasUserAccount));
 			if (columns.HasId(SaxUserAccount.Column.PhoneMain))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_PhoneMain, aliasUserAccount));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_PhoneMain, aliasUserAccount));
 			if (columns.HasId(SaxUserAccount.Column.PhoneMobile))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_PhoneMobile, aliasUserAccount));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_PhoneMobile, aliasUserAccount));
 			if (columns.HasId(SaxUserAccount.Column.DateOfBirth))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_DateOfBirth, aliasUserAccount));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_DateOfBirth, aliasUserAccount));
+			// Regions.
+			bool hasCountryRegionCols = columns.HasId(SaxUserAccount.Column.RegionCountry_Name);
+			if (columns.HasId(SaxUserAccount.Column.RegionIdCountry) || hasCountryRegionCols)
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_RegionIdCountry, aliasUserAccount));
+			bool hasProvinceRegionCols = columns.HasId(SaxUserAccount.Column.RegionProvince_Name);
+			if (columns.HasId(SaxUserAccount.Column.RegionIdProvince) || hasProvinceRegionCols)
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_RegionIdProvince, aliasUserAccount));
 			// Security.
 			if (columns.HasId(SaxUserAccount.Column.LastLoginOn) || columns.HasId(SaxUserAccount.Column.LastLoginAt))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_LastLoginAt, aliasUserAccount));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_LastLoginAt, aliasUserAccount));
 			// Common properties.
 			if (columns.HasId(SaxUserAccount.Column.Notes))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_Notes, aliasUserAccount));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_Notes, aliasUserAccount));
 			if (columns.HasId(SaxUserAccount.Column.Flags))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_Flags, aliasUserAccount));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_Flags, aliasUserAccount));
 			if (columns.HasId(SaxUserAccount.Column.Status) || columns.HasId(SaxUserAccount.Column.Status_Desc) || columns.HasId(SaxUserAccount.Column.Status_Ind))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_Status, aliasUserAccount));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_Status, aliasUserAccount));
 			if (columns.HasId(SaxUserAccount.Column.CreateOn_Date))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_CreateOn, aliasUserAccount));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_CreateOn, aliasUserAccount));
 			if (columns.HasId(SaxUserAccount.Column.UpdateOn_Date))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_UpdateOn, aliasUserAccount));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_UpdateOn, aliasUserAccount));
+
+			//---------------------------------------------------------------------
+			// Country Region.
+			if (hasCountryRegionCols)
+			{
+				DbQueryJoin joinRegionCountry = new DbQueryJoin(DbJoinType.LeftOuter);
+				joinRegionCountry.Table = new StringPair(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Region), aliasUserAccount_Region_Country);
+				joinRegionCountry.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_Id, aliasUserAccount_Region_Country) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_RegionIdCountry, aliasUserAccount));
+				query.Joins.Add(joinRegionCountry);
+				List<SaxDbDfn_Core.ColumnIdx> cols = new List<SaxDbDfn_Core.ColumnIdx>();
+				cols.Add(SaxDbDfn_Core.ColumnIdx.Region_Name);
+				foreach (var col in cols)
+					query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(col, aliasUserAccount_Region_Country), prefixUserAccount_Region_Country + SaxDbDfn_Core.GetColumnName(col, false));
+			}
+
+			//---------------------------------------------------------------------
+			// Province Region.
+			if (hasProvinceRegionCols)
+			{
+				DbQueryJoin joinRegionProvince = new DbQueryJoin(DbJoinType.LeftOuter);
+				joinRegionProvince.Table = new StringPair(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Region), aliasUserAccount_Region_Province);
+				joinRegionProvince.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_Id, aliasUserAccount_Region_Province) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_RegionIdProvince, aliasUserAccount));
+				query.Joins.Add(joinRegionProvince);
+				List<SaxDbDfn_Core.ColumnIdx> cols = new List<SaxDbDfn_Core.ColumnIdx>();
+				cols.Add(SaxDbDfn_Core.ColumnIdx.Region_Name);
+				foreach (var col in cols)
+					query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(col, aliasUserAccount_Region_Province), prefixUserAccount_Region_Province + SaxDbDfn_Core.GetColumnName(col, false));
+			}
 
 			//---------------------------------------------------------------------
 			// User Role count.
@@ -603,10 +663,10 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			{
 				String aliasUserRole = "aUsrRol";
 				DbQuery queryUserRole = new DbQuery(CoreDatabase.DbmsType);
-				queryUserRole.Tables.Add(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.UserRole), aliasUserRole);
+				queryUserRole.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.UserRole), aliasUserRole);
 				queryUserRole.Columns.Add("Count(*)");
-				queryUserRole.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserRole_UserAccountId, aliasUserRole) + "=" + SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_Id, aliasUserAccount));
-				queryUserRole.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserRole_Status, aliasUserRole) + "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'");
+				queryUserRole.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserRole_UserAccountId, aliasUserRole) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_Id, aliasUserAccount));
+				queryUserRole.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserRole_Status, aliasUserRole) + "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'");
 				query.Columns.Add("(" + queryUserRole.BuildQuery() + ")", colUserAccount_UserRoleCount);
 			}
 
@@ -616,11 +676,11 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			{
 				String aliasUserRole = "aUsrRol";
 				DbQuery queryUserRole = new DbQuery(CoreDatabase.DbmsType);
-				queryUserRole.Tables.Add(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.UserRole), aliasUserRole);
+				queryUserRole.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.UserRole), aliasUserRole);
 				queryUserRole.Columns.Add("Count(*)");
-				queryUserRole.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserRole_UserAccountId, aliasUserRole) + "=" + SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_Id, aliasUserAccount));
-				queryUserRole.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserRole_UserRoleCode, aliasUserRole) + "='" + UserRoles.GetCodeForType(Sax.UserRole.SystemAdmin) + "'");
-				queryUserRole.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserRole_Status, aliasUserRole) + "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'");
+				queryUserRole.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserRole_UserAccountId, aliasUserRole) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_Id, aliasUserAccount));
+				queryUserRole.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserRole_UserRoleCode, aliasUserRole) + "='" + UserRoles.GetCodeForType(Sax.UserRole.SystemAdmin) + "'");
+				queryUserRole.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserRole_Status, aliasUserRole) + "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'");
 				query.Columns.Add("(" + queryUserRole.BuildQuery() + ")", colUserAccount_SystemAdminRole);
 			}
 

SaxoniteStandardDbas/Dbas/Mgr/SaxAccountMgr_Dbas-UserOrganisation.cs

@@ -83,7 +83,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				catch (Exception exc)
 				{
 					SetErrorState("Database query exception");
-					SaLogger.Warn(GetType().Name + ".GetUserOrganisation\n\tQuery: " + dbCommand.CommandText + "\n\t" + exc.GetType().Name + ": " + exc.Message);
+					SaLogger.Warn(GetType().Name + ".GetUserOrganisation\n\tQuery: " + dbCommand.CommandText + "\n\t" + ExceptionUtil.GetLogMessage(exc));
 				}
 			}
 			return userOrganisation;
@@ -190,7 +190,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 					dbUserOrganisation.PopulateFrom(dbCommand, aliasUserOrganisation, "Id=" + userOrganisation.Id.ToString());
 					// Delete userOrganisation.
 					dbCommand.CommandType = System.Data.CommandType.Text;
-					dbCommand.CommandText = "DELETE FROM " + SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.UserOrganisation) + " WHERE Id=" + SysId.ToString(userOrganisation.Id) + ";";
+					dbCommand.CommandText = "DELETE FROM " + SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.UserOrganisation) + " WHERE Id=" + SysId.ToString(userOrganisation.Id) + ";";
 					dbCommand.ExecuteNonQuery();
 					userOrganisation.Changed = false;
 					if (DebugMode) SaLogger.Debug(fn + " Deleted. " + GetLogProperties(userOrganisation).Concat(": ").Concat("", "\n\t"));
@@ -249,15 +249,15 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		private static readonly String aliasUserOrganisation_Organisation_Sport = "UsrOrg_Org_Spt";
 		private static readonly String prefixUserOrganisation_Organisation_Sport = "UsrOrg_Org_Spt_";
 		private void SetUserOrganisationColDfn
-			(ColumnDfn col, String caption, int width, SaxDbDfn.ColumnIdx dbCol,
+			(ColumnDfn col, String caption, int width, SaxDbDfn_Core.ColumnIdx dbCol,
 			ColumnAlignment align = ColumnAlignment.Default, DataValue.DataType dataType = DataValue.DataType.String,
 			String alias = "", String prefix = "")
 		{
-			if (String.IsNullOrEmpty(alias) && SaxDbDfn.GetTableForColumn(dbCol) == SaxDbDfn.TableIdx.UserOrganisation)
+			if (String.IsNullOrEmpty(alias) && SaxDbDfn_Core.GetTableForColumn(dbCol) == SaxDbDfn_Core.TableIdx.UserOrganisation)
 				alias = aliasUserOrganisation;
-			col.Set(caption, width, (int)dbCol, prefix + SaxDbDfn.GetColumnName(dbCol, false), SaxDbDfn.GetColumnNameQual(dbCol, alias), dataType, align);
-			if (dataType == DataValue.DataType.String && dbCol != SaxDbDfn.ColumnIdx.Unknown)
-				col.MaxLength = (int)SaxDbDfn.GetColTextLen(dbCol);
+			col.Set(caption, width, (int)dbCol, prefix + SaxDbDfn_Core.GetColumnName(dbCol, false), SaxDbDfn_Core.GetColumnNameQual(dbCol, alias), dataType, align);
+			if (dataType == DataValue.DataType.String && dbCol != SaxDbDfn_Core.ColumnIdx.Unknown)
+				col.MaxLength = (int)SaxDbDfn_Core.GetColTextLen(dbCol);
 		}
 		public override ColumnDfn GetUserOrganisationColumnDfn(SaxUserOrganisation.Column columnId, string caption = "", int width = 0)
 		{
@@ -266,82 +266,82 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			{
 				//-----------------------------------------------------------
 				case SaxUserOrganisation.Column.Pos:
-					SetUserOrganisationColDfn(columnDfn, "Pos", 60, SaxDbDfn.ColumnIdx.Unknown, ColumnAlignment.Right);
+					SetUserOrganisationColDfn(columnDfn, "Pos", 60, SaxDbDfn_Core.ColumnIdx.Unknown, ColumnAlignment.Right);
 					columnDfn.SortMode = ColumnDfn.ColumnSortMode.Off;
 					columnDfn.ReadOnly = true;
 					columnDfn.Resizable = false;
 					break;
 				case SaxUserOrganisation.Column.Id:
-					SetUserOrganisationColDfn(columnDfn, "Id", 80, SaxDbDfn.ColumnIdx.UserOrganisation_Id, ColumnAlignment.Right, DataValue.DataType.Long);
+					SetUserOrganisationColDfn(columnDfn, "Id", 80, SaxDbDfn_Core.ColumnIdx.UserOrganisation_Id, ColumnAlignment.Right, DataValue.DataType.Long);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserOrganisation.Column.UserAccountId:
-					SetUserOrganisationColDfn(columnDfn, "User Id", 80, SaxDbDfn.ColumnIdx.UserOrganisation_UserAccountId, ColumnAlignment.Right, DataValue.DataType.Long);
+					SetUserOrganisationColDfn(columnDfn, "User Id", 80, SaxDbDfn_Core.ColumnIdx.UserOrganisation_UserAccountId, ColumnAlignment.Right, DataValue.DataType.Long);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserOrganisation.Column.OrganisationId:
-					SetUserOrganisationColDfn(columnDfn, "Organisation Id", 80, SaxDbDfn.ColumnIdx.UserOrganisation_OrganisationId, ColumnAlignment.Right, DataValue.DataType.Long);
+					SetUserOrganisationColDfn(columnDfn, "Organisation Id", 80, SaxDbDfn_Core.ColumnIdx.UserOrganisation_OrganisationId, ColumnAlignment.Right, DataValue.DataType.Long);
 					columnDfn.ReadOnly = true;
 					break;
 
 				//-------------------------------------------------------
 				// Organisation roles.
 				case SaxUserOrganisation.Column.OrganisationRoleCount:
-					SetUserOrganisationColDfn(columnDfn, "Role count", 80, SaxDbDfn.ColumnIdx.UserOrganisation_OrganisationRoleCount, ColumnAlignment.Center, DataValue.DataType.Long);
+					SetUserOrganisationColDfn(columnDfn, "Role count", 80, SaxDbDfn_Core.ColumnIdx.UserOrganisation_OrganisationRoleCount, ColumnAlignment.Center, DataValue.DataType.Long);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserOrganisation.Column.OrganisationRoleCodes:
-					SetUserOrganisationColDfn(columnDfn, "Roles", 100, SaxDbDfn.ColumnIdx.UserOrganisation_OrganisationRoleCodes, ColumnAlignment.Left);
+					SetUserOrganisationColDfn(columnDfn, "Roles", 100, SaxDbDfn_Core.ColumnIdx.UserOrganisation_OrganisationRoleCodes, ColumnAlignment.Left);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserOrganisation.Column.OrganisationRoleDescs:
-					SetUserOrganisationColDfn(columnDfn, "Roles", 100, SaxDbDfn.ColumnIdx.UserOrganisation_OrganisationRoleCodes, ColumnAlignment.Left);
+					SetUserOrganisationColDfn(columnDfn, "Roles", 100, SaxDbDfn_Core.ColumnIdx.UserOrganisation_OrganisationRoleCodes, ColumnAlignment.Left);
 					columnDfn.ReadOnly = true;
 					break;
 
 				//-------------------------------------------------------
 				// User.
 				case SaxUserOrganisation.Column.User_EmailAddress:
-					SetUserOrganisationColDfn(columnDfn, "Email address", 160, SaxDbDfn.ColumnIdx.UserAccount_EmailAddress, ColumnAlignment.Left, DataValue.DataType.String, aliasUserOrganisation_UserAccount, prefixUserOrganisation_UserAccount);
+					SetUserOrganisationColDfn(columnDfn, "Email address", 160, SaxDbDfn_Core.ColumnIdx.UserAccount_EmailAddress, ColumnAlignment.Left, DataValue.DataType.String, aliasUserOrganisation_UserAccount, prefixUserOrganisation_UserAccount);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserOrganisation.Column.User_DisplayName:
-					SetUserOrganisationColDfn(columnDfn, "User", 160, SaxDbDfn.ColumnIdx.Unknown, ColumnAlignment.Left, DataValue.DataType.String);
+					SetUserOrganisationColDfn(columnDfn, "User", 160, SaxDbDfn_Core.ColumnIdx.Unknown, ColumnAlignment.Left, DataValue.DataType.String);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserOrganisation.Column.User_Title:
-					SetUserOrganisationColDfn(columnDfn, "TItle", 80, SaxDbDfn.ColumnIdx.UserAccount_Title, ColumnAlignment.Left, DataValue.DataType.String, aliasUserOrganisation_UserAccount, prefixUserOrganisation_UserAccount);
+					SetUserOrganisationColDfn(columnDfn, "TItle", 80, SaxDbDfn_Core.ColumnIdx.UserAccount_Title, ColumnAlignment.Left, DataValue.DataType.String, aliasUserOrganisation_UserAccount, prefixUserOrganisation_UserAccount);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserOrganisation.Column.User_FirstName:
-					SetUserOrganisationColDfn(columnDfn, "First name", 120, SaxDbDfn.ColumnIdx.UserAccount_FirstName, ColumnAlignment.Left, DataValue.DataType.String, aliasUserOrganisation_UserAccount, prefixUserOrganisation_UserAccount);
+					SetUserOrganisationColDfn(columnDfn, "First name", 120, SaxDbDfn_Core.ColumnIdx.UserAccount_FirstName, ColumnAlignment.Left, DataValue.DataType.String, aliasUserOrganisation_UserAccount, prefixUserOrganisation_UserAccount);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserOrganisation.Column.User_LastName:
-					SetUserOrganisationColDfn(columnDfn, "Last name", 120, SaxDbDfn.ColumnIdx.UserAccount_LastName, ColumnAlignment.Left, DataValue.DataType.String, aliasUserOrganisation_UserAccount, prefixUserOrganisation_UserAccount);
+					SetUserOrganisationColDfn(columnDfn, "Last name", 120, SaxDbDfn_Core.ColumnIdx.UserAccount_LastName, ColumnAlignment.Left, DataValue.DataType.String, aliasUserOrganisation_UserAccount, prefixUserOrganisation_UserAccount);
 					columnDfn.ReadOnly = true;
 					break;
 
 				//-------------------------------------------------------
 				// Organisation.
 				case SaxUserOrganisation.Column.Organisation_Name:
-					SetUserOrganisationColDfn(columnDfn, "Organisation", 160, SaxDbDfn.ColumnIdx.Organisation_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasUserOrganisation_Organisation, prefixUserOrganisation_Organisation);
+					SetUserOrganisationColDfn(columnDfn, "Organisation", 160, SaxDbDfn_Core.ColumnIdx.Organisation_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasUserOrganisation_Organisation, prefixUserOrganisation_Organisation);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserOrganisation.Column.Organisation_RegionId:
-					SetUserOrganisationColDfn(columnDfn, "Organisation region Id", 80, SaxDbDfn.ColumnIdx.Organisation_RegionIdPrimary, ColumnAlignment.Right, DataValue.DataType.Long, aliasUserOrganisation_Organisation, prefixUserOrganisation_Organisation);
+					SetUserOrganisationColDfn(columnDfn, "Organisation region Id", 80, SaxDbDfn_Core.ColumnIdx.Organisation_RegionIdPrimary, ColumnAlignment.Right, DataValue.DataType.Long, aliasUserOrganisation_Organisation, prefixUserOrganisation_Organisation);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserOrganisation.Column.Organisation_Region_Name:
-					SetUserOrganisationColDfn(columnDfn, "Organisation region", 160, SaxDbDfn.ColumnIdx.Region_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasUserOrganisation_Organisation_Region, prefixUserOrganisation_Organisation_Region);
+					SetUserOrganisationColDfn(columnDfn, "Organisation region", 160, SaxDbDfn_Core.ColumnIdx.Region_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasUserOrganisation_Organisation_Region, prefixUserOrganisation_Organisation_Region);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserOrganisation.Column.Organisation_SportId:
-					SetUserOrganisationColDfn(columnDfn, "Organisation sport Id", 80, SaxDbDfn.ColumnIdx.Organisation_SportIdPrimary, ColumnAlignment.Right, DataValue.DataType.Long, aliasUserOrganisation_Organisation, prefixUserOrganisation_Organisation);
+					SetUserOrganisationColDfn(columnDfn, "Organisation sport Id", 80, SaxDbDfn_Core.ColumnIdx.Organisation_SportIdPrimary, ColumnAlignment.Right, DataValue.DataType.Long, aliasUserOrganisation_Organisation, prefixUserOrganisation_Organisation);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserOrganisation.Column.Organisation_Sport_Name:
-					SetUserOrganisationColDfn(columnDfn, "Organisation sport", 160, SaxDbDfn.ColumnIdx.Sport_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasUserOrganisation_Organisation_Sport, prefixUserOrganisation_Organisation_Sport);
+					SetUserOrganisationColDfn(columnDfn, "Organisation sport", 160, SaxDbDfn_Core.ColumnIdx.Sport_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasUserOrganisation_Organisation_Sport, prefixUserOrganisation_Organisation_Sport);
 					columnDfn.ReadOnly = true;
 					break;
 
@@ -351,27 +351,27 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				//-----------------------------------------------------------
 				// Common properties.
 				case SaxUserOrganisation.Column.Notes:
-					SetUserOrganisationColDfn(columnDfn, "Notes", 240, SaxDbDfn.ColumnIdx.UserOrganisation_Notes);
+					SetUserOrganisationColDfn(columnDfn, "Notes", 240, SaxDbDfn_Core.ColumnIdx.UserOrganisation_Notes);
 					break;
 				case SaxUserOrganisation.Column.Flags:
-					SetUserOrganisationColDfn(columnDfn, "Flags", 60, SaxDbDfn.ColumnIdx.UserOrganisation_Flags, ColumnAlignment.Center, DataValue.DataType.Long);
+					SetUserOrganisationColDfn(columnDfn, "Flags", 60, SaxDbDfn_Core.ColumnIdx.UserOrganisation_Flags, ColumnAlignment.Center, DataValue.DataType.Long);
 					break;
 				case SaxUserOrganisation.Column.Status:
-					SetUserOrganisationColDfn(columnDfn, "Status", 80, SaxDbDfn.ColumnIdx.UserOrganisation_Status, ColumnAlignment.Center);
+					SetUserOrganisationColDfn(columnDfn, "Status", 80, SaxDbDfn_Core.ColumnIdx.UserOrganisation_Status, ColumnAlignment.Center);
 					break;
 				case SaxUserOrganisation.Column.Status_Desc:
-					SetUserOrganisationColDfn(columnDfn, "Status", 90, SaxDbDfn.ColumnIdx.UserOrganisation_Status, ColumnAlignment.Center);
+					SetUserOrganisationColDfn(columnDfn, "Status", 90, SaxDbDfn_Core.ColumnIdx.UserOrganisation_Status, ColumnAlignment.Center);
 					break;
 				case SaxUserOrganisation.Column.Status_Ind:
-					SetUserOrganisationColDfn(columnDfn, "Status", 80, SaxDbDfn.ColumnIdx.UserOrganisation_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
+					SetUserOrganisationColDfn(columnDfn, "Status", 80, SaxDbDfn_Core.ColumnIdx.UserOrganisation_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
 					columnDfn.TriStateFormat = ColumnTriStateFormat.Lights;
 					break;
 				case SaxUserOrganisation.Column.CreateOn_Date:
-					SetUserOrganisationColDfn(columnDfn, "Created", 80, SaxDbDfn.ColumnIdx.UserOrganisation_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
+					SetUserOrganisationColDfn(columnDfn, "Created", 80, SaxDbDfn_Core.ColumnIdx.UserOrganisation_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserOrganisation.Column.UpdateOn_Date:
-					SetUserOrganisationColDfn(columnDfn, "Updated", 80, SaxDbDfn.ColumnIdx.UserOrganisation_UpdateOn, ColumnAlignment.Center, DataValue.DataType.Date);
+					SetUserOrganisationColDfn(columnDfn, "Updated", 80, SaxDbDfn_Core.ColumnIdx.UserOrganisation_UpdateOn, ColumnAlignment.Center, DataValue.DataType.Date);
 					columnDfn.ReadOnly = true;
 					break;
 					//-----------------------------------------------------------
@@ -392,24 +392,24 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			// Item Ids.
 			String idsIncluded = prm.IdsIncluded.Concat(",");
 			if (!idsIncluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserOrganisation_Id, aliasUserOrganisation) + " IN (" + idsIncluded + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserOrganisation_Id, aliasUserOrganisation) + " IN (" + idsIncluded + ")");
 			String idsxcluded = prm.IdsExcluded.Concat(",");
 			if (!idsxcluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserOrganisation_Id, aliasUserOrganisation) + " NOT IN (" + idsxcluded + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserOrganisation_Id, aliasUserOrganisation) + " NOT IN (" + idsxcluded + ")");
 
 			// User accounts.
 			String userAccountIdsIncluded = prm.UserAccountIdsIncluded.Concat(",");
 			if (!userAccountIdsIncluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserOrganisation_UserAccountId, aliasUserOrganisation) + " IN (" + userAccountIdsIncluded + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserOrganisation_UserAccountId, aliasUserOrganisation) + " IN (" + userAccountIdsIncluded + ")");
 
 			// Organisations.
 			String organisationIdsIncluded = prm.OrganisationIdsIncluded.Concat(",");
 			if (!organisationIdsIncluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserOrganisation_OrganisationId, aliasUserOrganisation) + " IN (" + organisationIdsIncluded + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserOrganisation_OrganisationId, aliasUserOrganisation) + " IN (" + organisationIdsIncluded + ")");
 
 			// Organisation roles.
 			if (prm.OrganisationMembersOnly)
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserOrganisation_OrganisationRoleCount, aliasUserOrganisation) + ">0");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserOrganisation_OrganisationRoleCount, aliasUserOrganisation) + ">0");
 			if (!prm.OrganisationRoles.IsEmpty())
 			{
 				List<String> organisationRoleCodes = new List<string>();
@@ -417,19 +417,19 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				{
 					String organisationRoleCode = OrganisationRoles.GetCodeForType(organisationRole).TrimAll();
 					if (!StringUtil.IsEmpty(organisationRoleCode))
-						filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserOrganisation_OrganisationRoleCodes, aliasUserOrganisation) + " LIKE '%" + DbQuery.FormatForLike(organisationRoleCode) + "%'");
+						filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserOrganisation_OrganisationRoleCodes, aliasUserOrganisation) + " LIKE '%" + DbQuery.FormatForLike(organisationRoleCode) + "%'");
 				}
 			}
 
 			// Notes.
 			if (!StringUtil.IsEmpty(prm.NotesPartial))
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserOrganisation_Notes, aliasUserOrganisation) + " LIKE '%" + DbQuery.FormatForLike(prm.NotesPartial) + "%'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserOrganisation_Notes, aliasUserOrganisation) + " LIKE '%" + DbQuery.FormatForLike(prm.NotesPartial) + "%'");
 
 			// Status.
 			if (prm.StatusCat == SaxUserOrganisation.StatusCat.ActiveOnly)
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserOrganisation_Status, aliasUserOrganisation) + "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserOrganisation_Status, aliasUserOrganisation) + "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'");
 			else if (prm.StatusCat == SaxUserOrganisation.StatusCat.NotDeleted)
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserOrganisation_Status, aliasUserOrganisation) + "!='" + SacsSystem.GetStatusCode(SaStatus.Deleted) + "'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserOrganisation_Status, aliasUserOrganisation) + "!='" + SacsSystem.GetStatusCode(SaStatus.Deleted) + "'");
 
 			if (filter.Count < 1) filter.Add("1=1");
 			return filter;
@@ -443,9 +443,9 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			{
 				// Need to ensure correct alias used for UserOrganisation columns in case of conflict.
 				String sortCol = String.Empty;
-				if (SaxDbDfn.GetTableForColumn((SaxDbDfn.ColumnIdx)columnDfn.DbColumn) == SaxDbDfn.TableIdx.UserOrganisation)
+				if (SaxDbDfn_Core.GetTableForColumn((SaxDbDfn_Core.ColumnIdx)columnDfn.DbColumn) == SaxDbDfn_Core.TableIdx.UserOrganisation)
 				{
-					sortCol = SaxDbDfn.GetColumnNameQual((SaxDbDfn.ColumnIdx)columnDfn.DbColumn, aliasUserOrganisation);
+					sortCol = SaxDbDfn_Core.GetColumnNameQual((SaxDbDfn_Core.ColumnIdx)columnDfn.DbColumn, aliasUserOrganisation);
 				}
 				else
 				{
@@ -463,7 +463,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			if (sortColumnNames.IsEmpty())
 			{
 				// Default sort columns.
-				sortColumnNames.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserOrganisation_Id, aliasUserOrganisation) + " ASC");
+				sortColumnNames.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserOrganisation_Id, aliasUserOrganisation) + " ASC");
 			}
 			return sortColumnNames;
 		}
@@ -473,7 +473,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		private long GetUserOrganisationCount(String filter)
 		{
 			ClearErrorState();
-			return CoreDatabase.GetRowCount(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.UserOrganisation) + " As " + aliasUserOrganisation, filter);
+			return CoreDatabase.GetRowCount(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.UserOrganisation) + " As " + aliasUserOrganisation, filter);
 		}
 		public override long GetUserOrganisationCount(SaxUserOrganisation.Params prm)
 		{
@@ -487,7 +487,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		{
 			List<SaxUserOrganisation> userOrganisations = new List<SaxUserOrganisation>();
 			DbQuery qry = new DbQuery(CoreDatabase.DbmsType);
-			qry.Tables.Add(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.UserOrganisation), aliasUserOrganisation);
+			qry.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.UserOrganisation), aliasUserOrganisation);
 			UserOrganisation_Db dbUserOrganisation = new UserOrganisation_Db(CoreDbInfo);
 			qry.Columns.AddRange(dbUserOrganisation.ExistingColumnNames);
 			qry.Filters.AddRange(GetUserOrganisationQueryFilter(prm));
@@ -512,7 +512,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				}
 				catch (Exception exc)
 				{
-					SaLogger.Warn(GetType().Name + ".GetUserOrganisationList\n\tQuery: " + dbCommand.CommandText + "\n\t" + exc.GetType().Name + ": " + exc.Message);
+					SaLogger.Warn(GetType().Name + ".GetUserOrganisationList\n\tQuery: " + dbCommand.CommandText + "\n\t" + ExceptionUtil.GetLogMessage(exc));
 				}
 			}
 			return userOrganisations;
@@ -527,50 +527,50 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			//---------------------------------------------------------------------
 			// Construct query.
 			DbQuery query = new DbQuery(CoreDatabase.DbmsType);
-			query.Tables.Add(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.UserOrganisation), aliasUserOrganisation);
+			query.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.UserOrganisation), aliasUserOrganisation);
 
 			// Add columns as defined in query list.
 			if (columns.HasId(SaxUserOrganisation.Column.Id))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserOrganisation_Id, aliasUserOrganisation));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserOrganisation_Id, aliasUserOrganisation));
 			bool hasUserAccountCols = (columns.HasId(SaxUserOrganisation.Column.User_EmailAddress) || columns.HasId(SaxUserOrganisation.Column.User_DisplayName) || columns.HasId(SaxUserOrganisation.Column.User_Title) || columns.HasId(SaxUserOrganisation.Column.User_FirstName) || columns.HasId(SaxUserOrganisation.Column.User_LastName));
 			if (columns.HasId(SaxUserOrganisation.Column.UserAccountId) || hasUserAccountCols)
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserOrganisation_UserAccountId, aliasUserOrganisation));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserOrganisation_UserAccountId, aliasUserOrganisation));
 			bool hasOrganisationCols = (columns.HasId(SaxUserOrganisation.Column.Organisation_Name) || columns.HasId(SaxUserOrganisation.Column.Organisation_RegionId) || columns.HasId(SaxUserOrganisation.Column.Organisation_SportId));
 			bool hasOrganisationRegionCols = (columns.HasId(SaxUserOrganisation.Column.Organisation_Region_Name));
 			bool hasOrganisationSportCols = (columns.HasId(SaxUserOrganisation.Column.Organisation_Sport_Name));
 			if (columns.HasId(SaxUserOrganisation.Column.OrganisationId) || hasOrganisationCols || hasOrganisationRegionCols || hasOrganisationSportCols)
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserOrganisation_OrganisationId, aliasUserOrganisation));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserOrganisation_OrganisationId, aliasUserOrganisation));
 			if (columns.HasId(SaxUserOrganisation.Column.OrganisationRoleCodes) || columns.HasId(SaxUserOrganisation.Column.OrganisationRoleDescs))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserOrganisation_OrganisationRoleCodes, aliasUserOrganisation));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserOrganisation_OrganisationRoleCodes, aliasUserOrganisation));
 			if (columns.HasId(SaxUserOrganisation.Column.OrganisationRoleCount))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserOrganisation_OrganisationRoleCount, aliasUserOrganisation));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserOrganisation_OrganisationRoleCount, aliasUserOrganisation));
 			// Common properties.
 			if (columns.HasId(SaxUserOrganisation.Column.Notes))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserOrganisation_Notes, aliasUserOrganisation));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserOrganisation_Notes, aliasUserOrganisation));
 			if (columns.HasId(SaxUserOrganisation.Column.Flags))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserOrganisation_Flags, aliasUserOrganisation));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserOrganisation_Flags, aliasUserOrganisation));
 			if (columns.HasId(SaxUserOrganisation.Column.Status) || columns.HasId(SaxUserOrganisation.Column.Status_Desc) || columns.HasId(SaxUserOrganisation.Column.Status_Ind))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserOrganisation_Status, aliasUserOrganisation));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserOrganisation_Status, aliasUserOrganisation));
 			if (columns.HasId(SaxUserOrganisation.Column.CreateOn_Date))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserOrganisation_CreateOn, aliasUserOrganisation));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserOrganisation_CreateOn, aliasUserOrganisation));
 			if (columns.HasId(SaxUserOrganisation.Column.UpdateOn_Date))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserOrganisation_UpdateOn, aliasUserOrganisation));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserOrganisation_UpdateOn, aliasUserOrganisation));
 
 			//---------------------------------------------------------------------
 			// User Account.
 			if (hasUserAccountCols)
 			{
 				DbQueryJoin joinUserAccount = new DbQueryJoin(DbJoinType.LeftOuter);
-				joinUserAccount.Table = new StringPair(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.UserAccount), aliasUserOrganisation_UserAccount);
-				joinUserAccount.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_Id, aliasUserOrganisation_UserAccount) + "=" + SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserOrganisation_UserAccountId, aliasUserOrganisation));
+				joinUserAccount.Table = new StringPair(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.UserAccount), aliasUserOrganisation_UserAccount);
+				joinUserAccount.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_Id, aliasUserOrganisation_UserAccount) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserOrganisation_UserAccountId, aliasUserOrganisation));
 				query.Joins.Add(joinUserAccount);
-				List<SaxDbDfn.ColumnIdx> cols = new List<SaxDbDfn.ColumnIdx>();
-				cols.Add(SaxDbDfn.ColumnIdx.UserAccount_EmailAddress);
-				cols.Add(SaxDbDfn.ColumnIdx.UserAccount_Title);
-				cols.Add(SaxDbDfn.ColumnIdx.UserAccount_FirstName);
-				cols.Add(SaxDbDfn.ColumnIdx.UserAccount_LastName);
+				List<SaxDbDfn_Core.ColumnIdx> cols = new List<SaxDbDfn_Core.ColumnIdx>();
+				cols.Add(SaxDbDfn_Core.ColumnIdx.UserAccount_EmailAddress);
+				cols.Add(SaxDbDfn_Core.ColumnIdx.UserAccount_Title);
+				cols.Add(SaxDbDfn_Core.ColumnIdx.UserAccount_FirstName);
+				cols.Add(SaxDbDfn_Core.ColumnIdx.UserAccount_LastName);
 				foreach (var col in cols)
-					query.Columns.Add(SaxDbDfn.GetColumnNameQual(col, aliasUserOrganisation_UserAccount), prefixUserOrganisation_UserAccount + SaxDbDfn.GetColumnName(col, false));
+					query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(col, aliasUserOrganisation_UserAccount), prefixUserOrganisation_UserAccount + SaxDbDfn_Core.GetColumnName(col, false));
 			}
 
 			//---------------------------------------------------------------------
@@ -578,38 +578,38 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			if (hasOrganisationCols || hasOrganisationRegionCols || hasOrganisationSportCols)
 			{
 				DbQueryJoin joinOrganisation = new DbQueryJoin(DbJoinType.LeftOuter);
-				joinOrganisation.Table = new StringPair(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.Organisation), aliasUserOrganisation_Organisation);
-				joinOrganisation.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_Id, aliasUserOrganisation_Organisation) + "=" + SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserOrganisation_OrganisationId, aliasUserOrganisation));
+				joinOrganisation.Table = new StringPair(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Organisation), aliasUserOrganisation_Organisation);
+				joinOrganisation.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_Id, aliasUserOrganisation_Organisation) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserOrganisation_OrganisationId, aliasUserOrganisation));
 				query.Joins.Add(joinOrganisation);
-				List<SaxDbDfn.ColumnIdx> OrganisationCols = new List<SaxDbDfn.ColumnIdx>();
-				OrganisationCols.Add(SaxDbDfn.ColumnIdx.Organisation_Name);
-				OrganisationCols.Add(SaxDbDfn.ColumnIdx.Organisation_RegionIdPrimary);
-				OrganisationCols.Add(SaxDbDfn.ColumnIdx.Organisation_SportIdPrimary);
+				List<SaxDbDfn_Core.ColumnIdx> OrganisationCols = new List<SaxDbDfn_Core.ColumnIdx>();
+				OrganisationCols.Add(SaxDbDfn_Core.ColumnIdx.Organisation_Name);
+				OrganisationCols.Add(SaxDbDfn_Core.ColumnIdx.Organisation_RegionIdPrimary);
+				OrganisationCols.Add(SaxDbDfn_Core.ColumnIdx.Organisation_SportIdPrimary);
 				foreach (var col in OrganisationCols)
-					query.Columns.Add(SaxDbDfn.GetColumnNameQual(col, aliasUserOrganisation_Organisation), prefixUserOrganisation_Organisation + SaxDbDfn.GetColumnName(col, false));
+					query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(col, aliasUserOrganisation_Organisation), prefixUserOrganisation_Organisation + SaxDbDfn_Core.GetColumnName(col, false));
 
 				if (hasOrganisationRegionCols)
 				{
 					DbQueryJoin joinOrganisationRegion = new DbQueryJoin(DbJoinType.LeftOuter);
-					joinOrganisationRegion.Table = new StringPair(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.Region), aliasUserOrganisation_Organisation_Region);
-					joinOrganisationRegion.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_Id, aliasUserOrganisation_Organisation_Region) + "=" + SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_RegionIdPrimary, aliasUserOrganisation_Organisation));
+					joinOrganisationRegion.Table = new StringPair(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Region), aliasUserOrganisation_Organisation_Region);
+					joinOrganisationRegion.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_Id, aliasUserOrganisation_Organisation_Region) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_RegionIdPrimary, aliasUserOrganisation_Organisation));
 					query.Joins.Add(joinOrganisationRegion);
-					List<SaxDbDfn.ColumnIdx> regionCols = new List<SaxDbDfn.ColumnIdx>();
-					regionCols.Add(SaxDbDfn.ColumnIdx.Region_Name);
+					List<SaxDbDfn_Core.ColumnIdx> regionCols = new List<SaxDbDfn_Core.ColumnIdx>();
+					regionCols.Add(SaxDbDfn_Core.ColumnIdx.Region_Name);
 					foreach (var col in regionCols)
-						query.Columns.Add(SaxDbDfn.GetColumnNameQual(col, aliasUserOrganisation_Organisation_Region), prefixUserOrganisation_Organisation_Region + SaxDbDfn.GetColumnName(col, false));
+						query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(col, aliasUserOrganisation_Organisation_Region), prefixUserOrganisation_Organisation_Region + SaxDbDfn_Core.GetColumnName(col, false));
 				}
 
 				if (hasOrganisationSportCols)
 				{
 					DbQueryJoin joinOrganisationSport = new DbQueryJoin(DbJoinType.LeftOuter);
-					joinOrganisationSport.Table = new StringPair(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.Sport), aliasUserOrganisation_Organisation_Sport);
-					joinOrganisationSport.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Sport_Id, aliasUserOrganisation_Organisation_Sport) + "=" + SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_SportIdPrimary, aliasUserOrganisation_Organisation));
+					joinOrganisationSport.Table = new StringPair(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Sport), aliasUserOrganisation_Organisation_Sport);
+					joinOrganisationSport.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Sport_Id, aliasUserOrganisation_Organisation_Sport) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_SportIdPrimary, aliasUserOrganisation_Organisation));
 					query.Joins.Add(joinOrganisationSport);
-					List<SaxDbDfn.ColumnIdx> regionCols = new List<SaxDbDfn.ColumnIdx>();
-					regionCols.Add(SaxDbDfn.ColumnIdx.Sport_Name);
+					List<SaxDbDfn_Core.ColumnIdx> regionCols = new List<SaxDbDfn_Core.ColumnIdx>();
+					regionCols.Add(SaxDbDfn_Core.ColumnIdx.Sport_Name);
 					foreach (var col in regionCols)
-						query.Columns.Add(SaxDbDfn.GetColumnNameQual(col, aliasUserOrganisation_Organisation_Sport), prefixUserOrganisation_Organisation_Sport + SaxDbDfn.GetColumnName(col, false));
+						query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(col, aliasUserOrganisation_Organisation_Sport), prefixUserOrganisation_Organisation_Sport + SaxDbDfn_Core.GetColumnName(col, false));
 				}
 			}
 

SaxoniteStandardDbas/Dbas/Mgr/SaxAccountMgr_Dbas-UserRole.cs

@@ -82,7 +82,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				catch (Exception exc)
 				{
 					SetErrorState("Database query exception");
-					SaLogger.Warn(GetType().Name + ".GetUserRole\n\tQuery: " + dbCommand.CommandText + "\n\t" + exc.GetType().Name + ": " + exc.Message);
+					SaLogger.Warn(GetType().Name + ".GetUserRole\n\tQuery: " + dbCommand.CommandText + "\n\t" + ExceptionUtil.GetLogMessage(exc));
 				}
 			}
 			return userRole;
@@ -189,7 +189,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 					dbUserRole.PopulateFrom(dbCommand, aliasUserRole, "Id=" + userRole.Id.ToString());
 					// Delete userRole.
 					dbCommand.CommandType = System.Data.CommandType.Text;
-					dbCommand.CommandText = "DELETE FROM " + SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.UserRole) + " WHERE Id=" + SysId.ToString(userRole.Id) + ";";
+					dbCommand.CommandText = "DELETE FROM " + SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.UserRole) + " WHERE Id=" + SysId.ToString(userRole.Id) + ";";
 					dbCommand.ExecuteNonQuery();
 					userRole.Changed = false;
 					if (DebugMode) SaLogger.Debug(fn + " Deleted. " + GetLogProperties(userRole).Concat(": ").Concat("", "\n\t"));
@@ -239,15 +239,15 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		private static readonly String aliasUserRole_UserAccount = "UsrRol_Usr";
 		private static readonly String prefixUserRole_UserAccount = "UsrRol_Usr_";
 		private void SetUserRoleColDfn
-			(ColumnDfn col, String caption, int width, SaxDbDfn.ColumnIdx dbCol,
+			(ColumnDfn col, String caption, int width, SaxDbDfn_Core.ColumnIdx dbCol,
 			ColumnAlignment align = ColumnAlignment.Default, DataValue.DataType dataType = DataValue.DataType.String,
 			String alias = "", String prefix = "")
 		{
-			if (String.IsNullOrEmpty(alias) && SaxDbDfn.GetTableForColumn(dbCol) == SaxDbDfn.TableIdx.UserRole)
+			if (String.IsNullOrEmpty(alias) && SaxDbDfn_Core.GetTableForColumn(dbCol) == SaxDbDfn_Core.TableIdx.UserRole)
 				alias = aliasUserRole;
-			col.Set(caption, width, (int)dbCol, prefix + SaxDbDfn.GetColumnName(dbCol, false), SaxDbDfn.GetColumnNameQual(dbCol, alias), dataType, align);
-			if (dataType == DataValue.DataType.String && dbCol != SaxDbDfn.ColumnIdx.Unknown)
-				col.MaxLength = (int)SaxDbDfn.GetColTextLen(dbCol);
+			col.Set(caption, width, (int)dbCol, prefix + SaxDbDfn_Core.GetColumnName(dbCol, false), SaxDbDfn_Core.GetColumnNameQual(dbCol, alias), dataType, align);
+			if (dataType == DataValue.DataType.String && dbCol != SaxDbDfn_Core.ColumnIdx.Unknown)
+				col.MaxLength = (int)SaxDbDfn_Core.GetColTextLen(dbCol);
 		}
 		public override ColumnDfn GetUserRoleColumnDfn(SaxUserRole.Column columnId, string caption = "", int width = 0)
 		{
@@ -256,44 +256,44 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			{
 				//-----------------------------------------------------------
 				case SaxUserRole.Column.Pos:
-					SetUserRoleColDfn(columnDfn, "Pos", 60, SaxDbDfn.ColumnIdx.Unknown, ColumnAlignment.Right);
+					SetUserRoleColDfn(columnDfn, "Pos", 60, SaxDbDfn_Core.ColumnIdx.Unknown, ColumnAlignment.Right);
 					columnDfn.SortMode = ColumnDfn.ColumnSortMode.Off;
 					columnDfn.ReadOnly = true;
 					columnDfn.Resizable = false;
 					break;
 				case SaxUserRole.Column.UserAccountId:
-					SetUserRoleColDfn(columnDfn, "User Id", 80, SaxDbDfn.ColumnIdx.UserRole_UserAccountId, ColumnAlignment.Right, DataValue.DataType.Long);
+					SetUserRoleColDfn(columnDfn, "User Id", 80, SaxDbDfn_Core.ColumnIdx.UserRole_UserAccountId, ColumnAlignment.Right, DataValue.DataType.Long);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserRole.Column.Id:
-					SetUserRoleColDfn(columnDfn, "Id", 80, SaxDbDfn.ColumnIdx.UserRole_Id, ColumnAlignment.Right, DataValue.DataType.Long);
+					SetUserRoleColDfn(columnDfn, "Id", 80, SaxDbDfn_Core.ColumnIdx.UserRole_Id, ColumnAlignment.Right, DataValue.DataType.Long);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserRole.Column.UserRole:
-					SetUserRoleColDfn(columnDfn, "Role", 120, SaxDbDfn.ColumnIdx.UserRole_UserRoleCode, ColumnAlignment.Center);
+					SetUserRoleColDfn(columnDfn, "Role", 120, SaxDbDfn_Core.ColumnIdx.UserRole_UserRoleCode, ColumnAlignment.Center);
 					columnDfn.ReadOnly = true;
 					break;
 
 				//-------------------------------------------------------
 				// User.
 				case SaxUserRole.Column.User_EmailAddress:
-					SetUserRoleColDfn(columnDfn, "Email address", 160, SaxDbDfn.ColumnIdx.UserAccount_EmailAddress, ColumnAlignment.Left, DataValue.DataType.String, aliasUserRole_UserAccount, prefixUserRole_UserAccount);
+					SetUserRoleColDfn(columnDfn, "Email address", 160, SaxDbDfn_Core.ColumnIdx.UserAccount_EmailAddress, ColumnAlignment.Left, DataValue.DataType.String, aliasUserRole_UserAccount, prefixUserRole_UserAccount);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserRole.Column.User_DisplayName:
-					SetUserRoleColDfn(columnDfn, "User", 160, SaxDbDfn.ColumnIdx.Unknown, ColumnAlignment.Left, DataValue.DataType.String);
+					SetUserRoleColDfn(columnDfn, "User", 160, SaxDbDfn_Core.ColumnIdx.Unknown, ColumnAlignment.Left, DataValue.DataType.String);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserRole.Column.User_Title:
-					SetUserRoleColDfn(columnDfn, "TItle", 80, SaxDbDfn.ColumnIdx.UserAccount_Title, ColumnAlignment.Left, DataValue.DataType.String, aliasUserRole_UserAccount, prefixUserRole_UserAccount);
+					SetUserRoleColDfn(columnDfn, "TItle", 80, SaxDbDfn_Core.ColumnIdx.UserAccount_Title, ColumnAlignment.Left, DataValue.DataType.String, aliasUserRole_UserAccount, prefixUserRole_UserAccount);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserRole.Column.User_FirstName:
-					SetUserRoleColDfn(columnDfn, "First name", 120, SaxDbDfn.ColumnIdx.UserAccount_FirstName, ColumnAlignment.Left, DataValue.DataType.String, aliasUserRole_UserAccount, prefixUserRole_UserAccount);
+					SetUserRoleColDfn(columnDfn, "First name", 120, SaxDbDfn_Core.ColumnIdx.UserAccount_FirstName, ColumnAlignment.Left, DataValue.DataType.String, aliasUserRole_UserAccount, prefixUserRole_UserAccount);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserRole.Column.User_LastName:
-					SetUserRoleColDfn(columnDfn, "Last name", 120, SaxDbDfn.ColumnIdx.UserAccount_LastName, ColumnAlignment.Left, DataValue.DataType.String, aliasUserRole_UserAccount, prefixUserRole_UserAccount);
+					SetUserRoleColDfn(columnDfn, "Last name", 120, SaxDbDfn_Core.ColumnIdx.UserAccount_LastName, ColumnAlignment.Left, DataValue.DataType.String, aliasUserRole_UserAccount, prefixUserRole_UserAccount);
 					columnDfn.ReadOnly = true;
 					break;
 
@@ -303,27 +303,27 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				//-----------------------------------------------------------
 				// Common properties.
 				case SaxUserRole.Column.Notes:
-					SetUserRoleColDfn(columnDfn, "Notes", 240, SaxDbDfn.ColumnIdx.UserRole_Notes);
+					SetUserRoleColDfn(columnDfn, "Notes", 240, SaxDbDfn_Core.ColumnIdx.UserRole_Notes);
 					break;
 				case SaxUserRole.Column.Flags:
-					SetUserRoleColDfn(columnDfn, "Flags", 60, SaxDbDfn.ColumnIdx.UserRole_Flags, ColumnAlignment.Center, DataValue.DataType.Long);
+					SetUserRoleColDfn(columnDfn, "Flags", 60, SaxDbDfn_Core.ColumnIdx.UserRole_Flags, ColumnAlignment.Center, DataValue.DataType.Long);
 					break;
 				case SaxUserRole.Column.Status:
-					SetUserRoleColDfn(columnDfn, "Status", 80, SaxDbDfn.ColumnIdx.UserRole_Status, ColumnAlignment.Center);
+					SetUserRoleColDfn(columnDfn, "Status", 80, SaxDbDfn_Core.ColumnIdx.UserRole_Status, ColumnAlignment.Center);
 					break;
 				case SaxUserRole.Column.Status_Desc:
-					SetUserRoleColDfn(columnDfn, "Status", 90, SaxDbDfn.ColumnIdx.UserRole_Status, ColumnAlignment.Center);
+					SetUserRoleColDfn(columnDfn, "Status", 90, SaxDbDfn_Core.ColumnIdx.UserRole_Status, ColumnAlignment.Center);
 					break;
 				case SaxUserRole.Column.Status_Ind:
-					SetUserRoleColDfn(columnDfn, "Status", 80, SaxDbDfn.ColumnIdx.UserRole_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
+					SetUserRoleColDfn(columnDfn, "Status", 80, SaxDbDfn_Core.ColumnIdx.UserRole_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
 					columnDfn.TriStateFormat = ColumnTriStateFormat.Lights;
 					break;
 				case SaxUserRole.Column.CreateOn_Date:
-					SetUserRoleColDfn(columnDfn, "Created", 80, SaxDbDfn.ColumnIdx.UserRole_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
+					SetUserRoleColDfn(columnDfn, "Created", 80, SaxDbDfn_Core.ColumnIdx.UserRole_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserRole.Column.UpdateOn_Date:
-					SetUserRoleColDfn(columnDfn, "Updated", 80, SaxDbDfn.ColumnIdx.UserRole_UpdateOn, ColumnAlignment.Center, DataValue.DataType.Date);
+					SetUserRoleColDfn(columnDfn, "Updated", 80, SaxDbDfn_Core.ColumnIdx.UserRole_UpdateOn, ColumnAlignment.Center, DataValue.DataType.Date);
 					columnDfn.ReadOnly = true;
 					break;
 					//-----------------------------------------------------------
@@ -344,31 +344,31 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			// Item Ids.
 			String idsIncluded = prm.IdsIncluded.Concat(",");
 			if (!idsIncluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserRole_Id, aliasUserRole) + " IN (" + idsIncluded + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserRole_Id, aliasUserRole) + " IN (" + idsIncluded + ")");
 			String idsxcluded = prm.IdsExcluded.Concat(",");
 			if (!idsxcluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserRole_Id, aliasUserRole) + " NOT IN (" + idsxcluded + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserRole_Id, aliasUserRole) + " NOT IN (" + idsxcluded + ")");
 
 			// User accounts.
 			String userAccountIdsIncluded = prm.UserAccountIdsIncluded.Concat(",");
 			if (!userAccountIdsIncluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserRole_UserAccountId, aliasUserRole) + " IN (" + userAccountIdsIncluded + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserRole_UserAccountId, aliasUserRole) + " IN (" + userAccountIdsIncluded + ")");
 
 			// User roles.
 			List<TypeCodeDesc> userRoles = UserRoles;
 			String userRoleCodes = prm.UserRolesIncluded.Select(item => UserRoles.GetCodeForType(item)).ToList().Concat(",", "'", "'", true, true);
 			if (!userRoleCodes.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserRole_UserRoleCode, aliasUserRole) + " IN (" + userRoleCodes + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserRole_UserRoleCode, aliasUserRole) + " IN (" + userRoleCodes + ")");
 
 			// Notes.
 			if (!StringUtil.IsEmpty(prm.NotesPartial))
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserRole_Notes, aliasUserRole) + " LIKE '%" + DbQuery.FormatForLike(prm.NotesPartial) + "%'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserRole_Notes, aliasUserRole) + " LIKE '%" + DbQuery.FormatForLike(prm.NotesPartial) + "%'");
 
 			// Status.
 			if (prm.StatusCat == SaxUserRole.StatusCat.ActiveOnly)
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserRole_Status, aliasUserRole) + "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserRole_Status, aliasUserRole) + "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'");
 			else if (prm.StatusCat == SaxUserRole.StatusCat.NotDeleted)
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserRole_Status, aliasUserRole) + "!='" + SacsSystem.GetStatusCode(SaStatus.Deleted) + "'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserRole_Status, aliasUserRole) + "!='" + SacsSystem.GetStatusCode(SaStatus.Deleted) + "'");
 
 			if (filter.Count < 1) filter.Add("1=1");
 			return filter;
@@ -382,9 +382,9 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			{
 				// Need to ensure correct alias used for UserRole columns in case of conflict.
 				String sortCol = String.Empty;
-				if (SaxDbDfn.GetTableForColumn((SaxDbDfn.ColumnIdx)columnDfn.DbColumn) == SaxDbDfn.TableIdx.UserRole)
+				if (SaxDbDfn_Core.GetTableForColumn((SaxDbDfn_Core.ColumnIdx)columnDfn.DbColumn) == SaxDbDfn_Core.TableIdx.UserRole)
 				{
-					sortCol = SaxDbDfn.GetColumnNameQual((SaxDbDfn.ColumnIdx)columnDfn.DbColumn, aliasUserRole);
+					sortCol = SaxDbDfn_Core.GetColumnNameQual((SaxDbDfn_Core.ColumnIdx)columnDfn.DbColumn, aliasUserRole);
 				}
 				else
 				{
@@ -402,7 +402,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			if (sortColumnNames.IsEmpty())
 			{
 				// Default sort columns.
-				sortColumnNames.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserRole_Id, aliasUserRole) + " ASC");
+				sortColumnNames.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserRole_Id, aliasUserRole) + " ASC");
 			}
 			return sortColumnNames;
 		}
@@ -412,7 +412,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		private long GetUserRoleCount(String filter)
 		{
 			ClearErrorState();
-			return CoreDatabase.GetRowCount(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.UserRole) + " As " + aliasUserRole, filter);
+			return CoreDatabase.GetRowCount(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.UserRole) + " As " + aliasUserRole, filter);
 		}
 		public override long GetUserRoleCount(SaxUserRole.Params prm)
 		{
@@ -426,7 +426,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		{
 			List<SaxUserRole> userRoles = new List<SaxUserRole>();
 			DbQuery qry = new DbQuery(CoreDatabase.DbmsType);
-			qry.Tables.Add(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.UserRole), aliasUserRole);
+			qry.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.UserRole), aliasUserRole);
 			UserRole_Db dbUserRole = new UserRole_Db(CoreDbInfo);
 			qry.Columns.AddRange(dbUserRole.ExistingColumnNames);
 			qry.Filters.AddRange(GetUserRoleQueryFilter(prm));
@@ -451,7 +451,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				}
 				catch (Exception exc)
 				{
-					SaLogger.Warn(GetType().Name + ".GetUserRoleList\n\tQuery: " + dbCommand.CommandText + "\n\t" + exc.GetType().Name + ": " + exc.Message);
+					SaLogger.Warn(GetType().Name + ".GetUserRoleList\n\tQuery: " + dbCommand.CommandText + "\n\t" + ExceptionUtil.GetLogMessage(exc));
 				}
 			}
 			return userRoles;
@@ -466,43 +466,43 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			//---------------------------------------------------------------------
 			// Construct query.
 			DbQuery query = new DbQuery(CoreDatabase.DbmsType);
-			query.Tables.Add(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.UserRole), aliasUserRole);
+			query.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.UserRole), aliasUserRole);
 
 			// Add columns as defined in query list.
 			if (columns.HasId(SaxUserRole.Column.Id))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserRole_Id, aliasUserRole));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserRole_Id, aliasUserRole));
 			bool hasUserAccountCols = (columns.HasId(SaxUserRole.Column.User_EmailAddress) || columns.HasId(SaxUserRole.Column.User_DisplayName) || columns.HasId(SaxUserRole.Column.User_Title) || columns.HasId(SaxUserRole.Column.User_FirstName) || columns.HasId(SaxUserRole.Column.User_LastName));
 			if (columns.HasId(SaxUserRole.Column.UserAccountId) || hasUserAccountCols)
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserRole_UserAccountId, aliasUserRole));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserRole_UserAccountId, aliasUserRole));
 			if (columns.HasId(SaxUserRole.Column.UserRole) || columns.HasId(SaxUserRole.Column.UserRole_Desc))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserRole_UserRoleCode, aliasUserRole));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserRole_UserRoleCode, aliasUserRole));
 			// Common properties.
 			if (columns.HasId(SaxUserRole.Column.Notes))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserRole_Notes, aliasUserRole));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserRole_Notes, aliasUserRole));
 			if (columns.HasId(SaxUserRole.Column.Flags))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserRole_Flags, aliasUserRole));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserRole_Flags, aliasUserRole));
 			if (columns.HasId(SaxUserRole.Column.Status) || columns.HasId(SaxUserRole.Column.Status_Desc) || columns.HasId(SaxUserRole.Column.Status_Ind))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserRole_Status, aliasUserRole));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserRole_Status, aliasUserRole));
 			if (columns.HasId(SaxUserRole.Column.CreateOn_Date))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserRole_CreateOn, aliasUserRole));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserRole_CreateOn, aliasUserRole));
 			if (columns.HasId(SaxUserRole.Column.UpdateOn_Date))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserRole_UpdateOn, aliasUserRole));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserRole_UpdateOn, aliasUserRole));
 
 			//---------------------------------------------------------------------
 			// User Account.
 			if (hasUserAccountCols)
 			{
 				DbQueryJoin joinUserAccount = new DbQueryJoin(DbJoinType.LeftOuter);
-				joinUserAccount.Table = new StringPair(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.UserAccount), aliasUserRole_UserAccount);
-				joinUserAccount.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_Id, aliasUserRole_UserAccount) + "=" + SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserRole_UserAccountId, aliasUserRole));
+				joinUserAccount.Table = new StringPair(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.UserAccount), aliasUserRole_UserAccount);
+				joinUserAccount.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_Id, aliasUserRole_UserAccount) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserRole_UserAccountId, aliasUserRole));
 				query.Joins.Add(joinUserAccount);
-				List<SaxDbDfn.ColumnIdx> cols = new List<SaxDbDfn.ColumnIdx>();
-				cols.Add(SaxDbDfn.ColumnIdx.UserAccount_EmailAddress);
-				cols.Add(SaxDbDfn.ColumnIdx.UserAccount_Title);
-				cols.Add(SaxDbDfn.ColumnIdx.UserAccount_FirstName);
-				cols.Add(SaxDbDfn.ColumnIdx.UserAccount_LastName);
+				List<SaxDbDfn_Core.ColumnIdx> cols = new List<SaxDbDfn_Core.ColumnIdx>();
+				cols.Add(SaxDbDfn_Core.ColumnIdx.UserAccount_EmailAddress);
+				cols.Add(SaxDbDfn_Core.ColumnIdx.UserAccount_Title);
+				cols.Add(SaxDbDfn_Core.ColumnIdx.UserAccount_FirstName);
+				cols.Add(SaxDbDfn_Core.ColumnIdx.UserAccount_LastName);
 				foreach (var col in cols)
-					query.Columns.Add(SaxDbDfn.GetColumnNameQual(col, aliasUserRole_UserAccount), prefixUserRole_UserAccount + SaxDbDfn.GetColumnName(col, false));
+					query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(col, aliasUserRole_UserAccount), prefixUserRole_UserAccount + SaxDbDfn_Core.GetColumnName(col, false));
 			}
 
 			//---------------------------------------------------------------------

SaxoniteStandardDbas/Dbas/Mgr/SaxAccountMgr_Dbas-UserSport.cs

@@ -82,7 +82,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				catch (Exception exc)
 				{
 					SetErrorState("Database query exception");
-					SaLogger.Warn(GetType().Name + ".GetUserSport\n\tQuery: " + dbCommand.CommandText + "\n\t" + exc.GetType().Name + ": " + exc.Message);
+					SaLogger.Warn(GetType().Name + ".GetUserSport\n\tQuery: " + dbCommand.CommandText + "\n\t" + ExceptionUtil.GetLogMessage(exc));
 				}
 			}
 			return userSport;
@@ -189,7 +189,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 					dbUserSport.PopulateFrom(dbCommand, aliasUserSport, "Id=" + userSport.Id.ToString());
 					// Delete userSport.
 					dbCommand.CommandType = System.Data.CommandType.Text;
-					dbCommand.CommandText = "DELETE FROM " + SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.UserSport) + " WHERE Id=" + SysId.ToString(userSport.Id) + ";";
+					dbCommand.CommandText = "DELETE FROM " + SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.UserSport) + " WHERE Id=" + SysId.ToString(userSport.Id) + ";";
 					dbCommand.ExecuteNonQuery();
 					userSport.Changed = false;
 					if (DebugMode) SaLogger.Debug(fn + " Deleted. " + GetLogProperties(userSport).Concat(": ").Concat("", "\n\t"));
@@ -243,15 +243,15 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		private static readonly String aliasUserSport_Sport = "UsrSpt_Spt";
 		private static readonly String prefixUserSport_Sport = "UsrSpt_Spt_";
 		private void SetUserSportColDfn
-			(ColumnDfn col, String caption, int width, SaxDbDfn.ColumnIdx dbCol,
+			(ColumnDfn col, String caption, int width, SaxDbDfn_Core.ColumnIdx dbCol,
 			ColumnAlignment align = ColumnAlignment.Default, DataValue.DataType dataType = DataValue.DataType.String,
 			String alias = "", String prefix = "")
 		{
-			if (String.IsNullOrEmpty(alias) && SaxDbDfn.GetTableForColumn(dbCol) == SaxDbDfn.TableIdx.UserSport)
+			if (String.IsNullOrEmpty(alias) && SaxDbDfn_Core.GetTableForColumn(dbCol) == SaxDbDfn_Core.TableIdx.UserSport)
 				alias = aliasUserSport;
-			col.Set(caption, width, (int)dbCol, prefix + SaxDbDfn.GetColumnName(dbCol, false), SaxDbDfn.GetColumnNameQual(dbCol, alias), dataType, align);
-			if (dataType == DataValue.DataType.String && dbCol != SaxDbDfn.ColumnIdx.Unknown)
-				col.MaxLength = (int)SaxDbDfn.GetColTextLen(dbCol);
+			col.Set(caption, width, (int)dbCol, prefix + SaxDbDfn_Core.GetColumnName(dbCol, false), SaxDbDfn_Core.GetColumnNameQual(dbCol, alias), dataType, align);
+			if (dataType == DataValue.DataType.String && dbCol != SaxDbDfn_Core.ColumnIdx.Unknown)
+				col.MaxLength = (int)SaxDbDfn_Core.GetColTextLen(dbCol);
 		}
 		public override ColumnDfn GetUserSportColumnDfn(SaxUserSport.Column columnId, string caption = "", int width = 0)
 		{
@@ -260,51 +260,51 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			{
 				//-----------------------------------------------------------
 				case SaxUserSport.Column.Pos:
-					SetUserSportColDfn(columnDfn, "Pos", 60, SaxDbDfn.ColumnIdx.Unknown, ColumnAlignment.Right);
+					SetUserSportColDfn(columnDfn, "Pos", 60, SaxDbDfn_Core.ColumnIdx.Unknown, ColumnAlignment.Right);
 					columnDfn.SortMode = ColumnDfn.ColumnSortMode.Off;
 					columnDfn.ReadOnly = true;
 					columnDfn.Resizable = false;
 					break;
 				case SaxUserSport.Column.Id:
-					SetUserSportColDfn(columnDfn, "Id", 80, SaxDbDfn.ColumnIdx.UserSport_Id, ColumnAlignment.Right, DataValue.DataType.Long);
+					SetUserSportColDfn(columnDfn, "Id", 80, SaxDbDfn_Core.ColumnIdx.UserSport_Id, ColumnAlignment.Right, DataValue.DataType.Long);
 					columnDfn.ReadOnly = true;
 					break;
 
 				//-------------------------------------------------------
 				// User.
 				case SaxUserSport.Column.UserAccountId:
-					SetUserSportColDfn(columnDfn, "User Id", 80, SaxDbDfn.ColumnIdx.UserSport_UserAccountId, ColumnAlignment.Right, DataValue.DataType.Long);
+					SetUserSportColDfn(columnDfn, "User Id", 80, SaxDbDfn_Core.ColumnIdx.UserSport_UserAccountId, ColumnAlignment.Right, DataValue.DataType.Long);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserSport.Column.User_EmailAddress:
-					SetUserSportColDfn(columnDfn, "Email address", 160, SaxDbDfn.ColumnIdx.UserAccount_EmailAddress, ColumnAlignment.Left, DataValue.DataType.String, aliasUserSport_UserAccount, prefixUserSport_UserAccount);
+					SetUserSportColDfn(columnDfn, "Email address", 160, SaxDbDfn_Core.ColumnIdx.UserAccount_EmailAddress, ColumnAlignment.Left, DataValue.DataType.String, aliasUserSport_UserAccount, prefixUserSport_UserAccount);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserSport.Column.User_DisplayName:
-					SetUserSportColDfn(columnDfn, "User", 160, SaxDbDfn.ColumnIdx.Unknown, ColumnAlignment.Left, DataValue.DataType.String);
+					SetUserSportColDfn(columnDfn, "User", 160, SaxDbDfn_Core.ColumnIdx.Unknown, ColumnAlignment.Left, DataValue.DataType.String);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserSport.Column.User_Title:
-					SetUserSportColDfn(columnDfn, "TItle", 80, SaxDbDfn.ColumnIdx.UserAccount_Title, ColumnAlignment.Left, DataValue.DataType.String, aliasUserSport_UserAccount, prefixUserSport_UserAccount);
+					SetUserSportColDfn(columnDfn, "TItle", 80, SaxDbDfn_Core.ColumnIdx.UserAccount_Title, ColumnAlignment.Left, DataValue.DataType.String, aliasUserSport_UserAccount, prefixUserSport_UserAccount);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserSport.Column.User_FirstName:
-					SetUserSportColDfn(columnDfn, "First name", 120, SaxDbDfn.ColumnIdx.UserAccount_FirstName, ColumnAlignment.Left, DataValue.DataType.String, aliasUserSport_UserAccount, prefixUserSport_UserAccount);
+					SetUserSportColDfn(columnDfn, "First name", 120, SaxDbDfn_Core.ColumnIdx.UserAccount_FirstName, ColumnAlignment.Left, DataValue.DataType.String, aliasUserSport_UserAccount, prefixUserSport_UserAccount);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserSport.Column.User_LastName:
-					SetUserSportColDfn(columnDfn, "Last name", 120, SaxDbDfn.ColumnIdx.UserAccount_LastName, ColumnAlignment.Left, DataValue.DataType.String, aliasUserSport_UserAccount, prefixUserSport_UserAccount);
+					SetUserSportColDfn(columnDfn, "Last name", 120, SaxDbDfn_Core.ColumnIdx.UserAccount_LastName, ColumnAlignment.Left, DataValue.DataType.String, aliasUserSport_UserAccount, prefixUserSport_UserAccount);
 					columnDfn.ReadOnly = true;
 					break;
 
 				//-------------------------------------------------------
 				// Sport.
 				case SaxUserSport.Column.SportId:
-					SetUserSportColDfn(columnDfn, "Sport Id", 80, SaxDbDfn.ColumnIdx.UserSport_SportId, ColumnAlignment.Right, DataValue.DataType.Long);
+					SetUserSportColDfn(columnDfn, "Sport Id", 80, SaxDbDfn_Core.ColumnIdx.UserSport_SportId, ColumnAlignment.Right, DataValue.DataType.Long);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserSport.Column.Sport_Name:
-					SetUserSportColDfn(columnDfn, "Email address", 160, SaxDbDfn.ColumnIdx.Sport_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasUserSport_Sport, prefixUserSport_Sport);
+					SetUserSportColDfn(columnDfn, "Email address", 160, SaxDbDfn_Core.ColumnIdx.Sport_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasUserSport_Sport, prefixUserSport_Sport);
 					columnDfn.ReadOnly = true;
 					break;
 
@@ -314,27 +314,27 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				//-----------------------------------------------------------
 				// Common properties.
 				case SaxUserSport.Column.Notes:
-					SetUserSportColDfn(columnDfn, "Notes", 240, SaxDbDfn.ColumnIdx.UserSport_Notes);
+					SetUserSportColDfn(columnDfn, "Notes", 240, SaxDbDfn_Core.ColumnIdx.UserSport_Notes);
 					break;
 				case SaxUserSport.Column.Flags:
-					SetUserSportColDfn(columnDfn, "Flags", 60, SaxDbDfn.ColumnIdx.UserSport_Flags, ColumnAlignment.Center, DataValue.DataType.Long);
+					SetUserSportColDfn(columnDfn, "Flags", 60, SaxDbDfn_Core.ColumnIdx.UserSport_Flags, ColumnAlignment.Center, DataValue.DataType.Long);
 					break;
 				case SaxUserSport.Column.Status:
-					SetUserSportColDfn(columnDfn, "Status", 80, SaxDbDfn.ColumnIdx.UserSport_Status, ColumnAlignment.Center);
+					SetUserSportColDfn(columnDfn, "Status", 80, SaxDbDfn_Core.ColumnIdx.UserSport_Status, ColumnAlignment.Center);
 					break;
 				case SaxUserSport.Column.Status_Desc:
-					SetUserSportColDfn(columnDfn, "Status", 90, SaxDbDfn.ColumnIdx.UserSport_Status, ColumnAlignment.Center);
+					SetUserSportColDfn(columnDfn, "Status", 90, SaxDbDfn_Core.ColumnIdx.UserSport_Status, ColumnAlignment.Center);
 					break;
 				case SaxUserSport.Column.Status_Ind:
-					SetUserSportColDfn(columnDfn, "Status", 80, SaxDbDfn.ColumnIdx.UserSport_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
+					SetUserSportColDfn(columnDfn, "Status", 80, SaxDbDfn_Core.ColumnIdx.UserSport_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
 					columnDfn.TriStateFormat = ColumnTriStateFormat.Lights;
 					break;
 				case SaxUserSport.Column.CreateOn_Date:
-					SetUserSportColDfn(columnDfn, "Created", 80, SaxDbDfn.ColumnIdx.UserSport_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
+					SetUserSportColDfn(columnDfn, "Created", 80, SaxDbDfn_Core.ColumnIdx.UserSport_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxUserSport.Column.UpdateOn_Date:
-					SetUserSportColDfn(columnDfn, "Updated", 80, SaxDbDfn.ColumnIdx.UserSport_UpdateOn, ColumnAlignment.Center, DataValue.DataType.Date);
+					SetUserSportColDfn(columnDfn, "Updated", 80, SaxDbDfn_Core.ColumnIdx.UserSport_UpdateOn, ColumnAlignment.Center, DataValue.DataType.Date);
 					columnDfn.ReadOnly = true;
 					break;
 					//-----------------------------------------------------------
@@ -355,30 +355,30 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			// Item Ids.
 			String idsIncluded = prm.IdsIncluded.Concat(",");
 			if (!idsIncluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserSport_Id, aliasUserSport) + " IN (" + idsIncluded + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserSport_Id, aliasUserSport) + " IN (" + idsIncluded + ")");
 			String idsxcluded = prm.IdsExcluded.Concat(",");
 			if (!idsxcluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserSport_Id, aliasUserSport) + " NOT IN (" + idsxcluded + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserSport_Id, aliasUserSport) + " NOT IN (" + idsxcluded + ")");
 
 			// User accounts.
 			String userAccountIdsIncluded = prm.UserAccountIdsIncluded.Concat(",");
 			if (!userAccountIdsIncluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserSport_UserAccountId, aliasUserSport) + " IN (" + userAccountIdsIncluded + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserSport_UserAccountId, aliasUserSport) + " IN (" + userAccountIdsIncluded + ")");
 
 			// Sports.
 			String sportIdsIncluded = prm.SportIdsIncluded.Concat(",");
 			if (!sportIdsIncluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserSport_SportId, aliasUserSport) + " IN (" + sportIdsIncluded + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserSport_SportId, aliasUserSport) + " IN (" + sportIdsIncluded + ")");
 
 			// Notes.
 			if (!StringUtil.IsEmpty(prm.NotesPartial))
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserSport_Notes, aliasUserSport) + " LIKE '%" + DbQuery.FormatForLike(prm.NotesPartial) + "%'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserSport_Notes, aliasUserSport) + " LIKE '%" + DbQuery.FormatForLike(prm.NotesPartial) + "%'");
 
 			// Status.
 			if (prm.StatusCat == SaxUserSport.StatusCat.ActiveOnly)
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserSport_Status, aliasUserSport) + "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserSport_Status, aliasUserSport) + "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'");
 			else if (prm.StatusCat == SaxUserSport.StatusCat.NotDeleted)
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserSport_Status, aliasUserSport) + "!='" + SacsSystem.GetStatusCode(SaStatus.Deleted) + "'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserSport_Status, aliasUserSport) + "!='" + SacsSystem.GetStatusCode(SaStatus.Deleted) + "'");
 
 			if (filter.Count < 1) filter.Add("1=1");
 			return filter;
@@ -392,9 +392,9 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			{
 				// Need to ensure correct alias used for UserSport columns in case of conflict.
 				String sortCol = String.Empty;
-				if (SaxDbDfn.GetTableForColumn((SaxDbDfn.ColumnIdx)columnDfn.DbColumn) == SaxDbDfn.TableIdx.UserSport)
+				if (SaxDbDfn_Core.GetTableForColumn((SaxDbDfn_Core.ColumnIdx)columnDfn.DbColumn) == SaxDbDfn_Core.TableIdx.UserSport)
 				{
-					sortCol = SaxDbDfn.GetColumnNameQual((SaxDbDfn.ColumnIdx)columnDfn.DbColumn, aliasUserSport);
+					sortCol = SaxDbDfn_Core.GetColumnNameQual((SaxDbDfn_Core.ColumnIdx)columnDfn.DbColumn, aliasUserSport);
 				}
 				else
 				{
@@ -412,7 +412,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			if (sortColumnNames.IsEmpty())
 			{
 				// Default sort columns.
-				sortColumnNames.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserSport_Id, aliasUserSport) + " ASC");
+				sortColumnNames.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserSport_Id, aliasUserSport) + " ASC");
 			}
 			return sortColumnNames;
 		}
@@ -422,7 +422,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		private long GetUserSportCount(String filter)
 		{
 			ClearErrorState();
-			return CoreDatabase.GetRowCount(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.UserSport) + " As " + aliasUserSport, filter);
+			return CoreDatabase.GetRowCount(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.UserSport) + " As " + aliasUserSport, filter);
 		}
 		public override long GetUserSportCount(SaxUserSport.Params prm)
 		{
@@ -436,7 +436,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		{
 			List<SaxUserSport> userSports = new List<SaxUserSport>();
 			DbQuery qry = new DbQuery(CoreDatabase.DbmsType);
-			qry.Tables.Add(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.UserSport), aliasUserSport);
+			qry.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.UserSport), aliasUserSport);
 			UserSport_Db dbUserSport = new UserSport_Db(CoreDbInfo);
 			qry.Columns.AddRange(dbUserSport.ExistingColumnNames);
 			qry.Filters.AddRange(GetUserSportQueryFilter(prm));
@@ -461,7 +461,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				}
 				catch (Exception exc)
 				{
-					SaLogger.Warn(GetType().Name + ".GetUserSportList\n\tQuery: " + dbCommand.CommandText + "\n\t" + exc.GetType().Name + ": " + exc.Message);
+					SaLogger.Warn(GetType().Name + ".GetUserSportList\n\tQuery: " + dbCommand.CommandText + "\n\t" + ExceptionUtil.GetLogMessage(exc));
 				}
 			}
 			return userSports;
@@ -476,44 +476,44 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			//---------------------------------------------------------------------
 			// Construct query.
 			DbQuery query = new DbQuery(CoreDatabase.DbmsType);
-			query.Tables.Add(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.UserSport), aliasUserSport);
+			query.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.UserSport), aliasUserSport);
 
 			// Add columns as defined in query list.
 			if (columns.HasId(SaxUserSport.Column.Id))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserSport_Id, aliasUserSport));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserSport_Id, aliasUserSport));
 			bool hasUserAccountCols = (columns.HasId(SaxUserSport.Column.User_EmailAddress) || columns.HasId(SaxUserSport.Column.User_DisplayName) || columns.HasId(SaxUserSport.Column.User_Title) || columns.HasId(SaxUserSport.Column.User_FirstName) || columns.HasId(SaxUserSport.Column.User_LastName));
 			if (columns.HasId(SaxUserSport.Column.UserAccountId) || hasUserAccountCols)
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserSport_UserAccountId, aliasUserSport));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserSport_UserAccountId, aliasUserSport));
 			bool hasSportCols = (columns.HasId(SaxUserSport.Column.Sport_Name));
 			if (columns.HasId(SaxUserSport.Column.SportId) || hasSportCols)
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserSport_SportId, aliasUserSport));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserSport_SportId, aliasUserSport));
 			// Common properties.
 			if (columns.HasId(SaxUserSport.Column.Notes))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserSport_Notes, aliasUserSport));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserSport_Notes, aliasUserSport));
 			if (columns.HasId(SaxUserSport.Column.Flags))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserSport_Flags, aliasUserSport));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserSport_Flags, aliasUserSport));
 			if (columns.HasId(SaxUserSport.Column.Status) || columns.HasId(SaxUserSport.Column.Status_Desc) || columns.HasId(SaxUserSport.Column.Status_Ind))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserSport_Status, aliasUserSport));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserSport_Status, aliasUserSport));
 			if (columns.HasId(SaxUserSport.Column.CreateOn_Date))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserSport_CreateOn, aliasUserSport));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserSport_CreateOn, aliasUserSport));
 			if (columns.HasId(SaxUserSport.Column.UpdateOn_Date))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserSport_UpdateOn, aliasUserSport));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserSport_UpdateOn, aliasUserSport));
 
 			//---------------------------------------------------------------------
 			// User Account.
 			if (hasUserAccountCols)
 			{
 				DbQueryJoin joinUserAccount = new DbQueryJoin(DbJoinType.LeftOuter);
-				joinUserAccount.Table = new StringPair(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.UserAccount), aliasUserSport_UserAccount);
-				joinUserAccount.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_Id, aliasUserSport_UserAccount) + "=" + SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserSport_UserAccountId, aliasUserSport));
+				joinUserAccount.Table = new StringPair(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.UserAccount), aliasUserSport_UserAccount);
+				joinUserAccount.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_Id, aliasUserSport_UserAccount) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserSport_UserAccountId, aliasUserSport));
 				query.Joins.Add(joinUserAccount);
-				List<SaxDbDfn.ColumnIdx> cols = new List<SaxDbDfn.ColumnIdx>();
-				cols.Add(SaxDbDfn.ColumnIdx.UserAccount_EmailAddress);
-				cols.Add(SaxDbDfn.ColumnIdx.UserAccount_Title);
-				cols.Add(SaxDbDfn.ColumnIdx.UserAccount_FirstName);
-				cols.Add(SaxDbDfn.ColumnIdx.UserAccount_LastName);
+				List<SaxDbDfn_Core.ColumnIdx> cols = new List<SaxDbDfn_Core.ColumnIdx>();
+				cols.Add(SaxDbDfn_Core.ColumnIdx.UserAccount_EmailAddress);
+				cols.Add(SaxDbDfn_Core.ColumnIdx.UserAccount_Title);
+				cols.Add(SaxDbDfn_Core.ColumnIdx.UserAccount_FirstName);
+				cols.Add(SaxDbDfn_Core.ColumnIdx.UserAccount_LastName);
 				foreach (var col in cols)
-					query.Columns.Add(SaxDbDfn.GetColumnNameQual(col, aliasUserSport_UserAccount), prefixUserSport_UserAccount + SaxDbDfn.GetColumnName(col, false));
+					query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(col, aliasUserSport_UserAccount), prefixUserSport_UserAccount + SaxDbDfn_Core.GetColumnName(col, false));
 			}
 
 			//---------------------------------------------------------------------
@@ -521,13 +521,13 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			if (hasSportCols)
 			{
 				DbQueryJoin joinSport = new DbQueryJoin(DbJoinType.LeftOuter);
-				joinSport.Table = new StringPair(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.Sport), aliasUserSport_Sport);
-				joinSport.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Sport_Id, aliasUserSport_Sport) + "=" + SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserSport_SportId, aliasUserSport));
+				joinSport.Table = new StringPair(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Sport), aliasUserSport_Sport);
+				joinSport.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Sport_Id, aliasUserSport_Sport) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserSport_SportId, aliasUserSport));
 				query.Joins.Add(joinSport);
-				List<SaxDbDfn.ColumnIdx> cols = new List<SaxDbDfn.ColumnIdx>();
-				cols.Add(SaxDbDfn.ColumnIdx.Sport_Name);
+				List<SaxDbDfn_Core.ColumnIdx> cols = new List<SaxDbDfn_Core.ColumnIdx>();
+				cols.Add(SaxDbDfn_Core.ColumnIdx.Sport_Name);
 				foreach (var col in cols)
-					query.Columns.Add(SaxDbDfn.GetColumnNameQual(col, aliasUserSport_Sport), prefixUserSport_Sport + SaxDbDfn.GetColumnName(col, false));
+					query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(col, aliasUserSport_Sport), prefixUserSport_Sport + SaxDbDfn_Core.GetColumnName(col, false));
 			}
 
 			//---------------------------------------------------------------------

SaxoniteStandardDbas/Dbas/Mgr/SaxAccountMgr_Dbas.cs

@@ -16,7 +16,8 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 
 		//-------------------------------------------------------------------
 		// Construction.
-		public SaxAccountMgr_Dbas(SaxSessionContext sessionContext) : base (sessionContext)
+		public SaxAccountMgr_Dbas(SaxSessionContext sessionContext, SaxInternals internals) : 
+			base (sessionContext, internals)
 		{
 		}
 

SaxoniteStandardDbas/Dbas/Mgr/SaxActivityMgr_Dbas-ActivityIndex.cs

@@ -0,0 +1,570 @@
+using Sarand.Net.Standard.Dbas.Data;
+using Sarand.Net.Standard.Base.App;
+using Sarand.Net.Standard.Base.Bus;
+using Sarand.Net.Standard.Base.Core;
+using Sarand.Net.Standard.Base.Dbas;
+using Saxonite.Base.App;
+using Saxonite.Net.Standard.Dbas.Bus;
+using Saxonite.Net.Standard.Dbas.Internal;
+using Saxonite.Net.Standard.Base.App;
+using Saxonite.Net.Standard.Base.Bus;
+using System;
+using System.Collections.Generic;
+using System.Data.Common;
+using System.Text;
+using Sarand.Net.Standard.Base.Utils;
+using System.Linq;
+
+namespace Saxonite.Net.Standard.Dbas.Mgr
+{
+	//=======================================================================
+	partial class SaxActivityMgr_Dbas
+	{
+		//*******************************************************************
+		// Activity Mgr - ActivityIndex
+		//*******************************************************************
+		// Utilities.
+		private List<StringPair> GetLogProperties(SaxActivityIndex activityIndex)
+		{
+			return new List<StringPair>()
+			{
+				new StringPair("ItemId",ItemId.ToString(activityIndex.ItemId)),
+				new StringPair("Sport",SysId.ToString(activityIndex.SportId)),
+				new StringPair("Region",SysId.ToString(activityIndex.RegionId)),
+				new StringPair("Effective",DateUtil.Format(activityIndex.EffectiveOn, "d-MMM-yyyy")),
+			};
+		}
+
+		//-------------------------------------------------------------------
+		// Create item.
+		public override SaxActivityIndex CreateActivityIndex(ItemId itemId, SysId sportId, SysId regionId, DateTime effectiveOn)
+		{
+			ClearErrorState();
+			return new SaxActivityIndex_Dbas(CoreDatabase, itemId, sportId, regionId, effectiveOn, 0);
+		}
+		private SaxActivityIndex_Dbas CreateActivityIndex(ActivityIndex_Db dbActivityIndex)
+		{
+			ClearErrorState();
+			ItemId itemId = new ItemId(dbActivityIndex._ItemType, new SysId(dbActivityIndex._ItemId));
+			SaxActivityIndex_Dbas activityIndex = new SaxActivityIndex_Dbas(CoreDatabase, itemId, new SysId(dbActivityIndex._SportId), new SysId(dbActivityIndex._RegionId), dbActivityIndex._EffectiveOn, (UInt16)dbActivityIndex._Flags);
+			PopulateFrom(dbActivityIndex, activityIndex);
+			return activityIndex;
+		}
+
+		//-------------------------------------------------------------------
+		// Get item.
+		public override SaxActivityIndex GetActivityIndex(SaxActivityIndex.Params prm)
+		{
+			ClearErrorState();
+			return GetActivityIndex(GetActivityIndexQueryFilter(prm).Concat(" And ", "(", ")"));
+		}
+		private SaxActivityIndex GetActivityIndex(String filter)
+		{
+			ClearErrorState();
+			long count = GetActivityIndexCount(filter);
+			if (count == 0) return null;
+			if (count != 1)
+			{
+				SetErrorState("Multiple items found");
+				return null;
+			}
+			SaxActivityIndex activityIndex = null;
+			// Query data.
+			using (var dbConnection = CoreDatabase.CreateConnection())
+			using (var dbCommand = dbConnection.CreateCommand())
+			{
+				try
+				{
+					dbConnection.Open();
+					ActivityIndex_Db dbActivityIndex = new ActivityIndex_Db(CoreDbInfo);
+					dbActivityIndex.PopulateFrom(dbCommand, aliasActivityIndex, filter);
+					activityIndex = CreateActivityIndex(dbActivityIndex);
+				}
+				catch (Exception exc)
+				{
+					SetErrorState("Database query exception");
+					SaLogger.Warn(GetType().Name + ".GetActivityIndex\n\tQuery: " + dbCommand.CommandText + "\n\t" + ExceptionUtil.GetLogMessage(exc));
+				}
+			}
+			return activityIndex;
+		}
+
+		//-------------------------------------------------------------------
+		// Validate item.
+		public override bool IsValidActivityIndexData(SaxActivityIndex.Data data, SaxActivityIndex.ErrField errField)
+		{
+			ClearErrorState();
+			if (!base.IsValidActivityIndexData(data, errField)) return false;
+			return true;
+		}
+
+		//-------------------------------------------------------------------
+		// Insert item.
+		public override bool InsertActivityIndex(SaxActivityIndex activityIndex, DbUpdateInfo dbUpdateInfo)
+		{
+			String fn = GetType().Name + ".InsertActivityIndex";
+			ClearErrorState();
+			if (!IsValidActivityIndex(activityIndex)) return false;
+			//if (SysId.IsValid(activityIndex.Id)) return SetErrorState(ErrorMessage.ValiditemId);
+			using (var dbConnection = CoreDatabase.CreateConnection())
+			using (var dbCommand = dbConnection.CreateCommand())
+			{
+				try
+				{
+					dbConnection.Open();
+					ActivityIndex_Db dbActivityIndex = new ActivityIndex_Db(CoreDbInfo);
+					PopulateTo(dbActivityIndex, activityIndex, dbUpdateInfo);
+					if (ActivityIndex_Db.FieldsNonId.Contains("Id"))
+					{
+						// Generate next Id.
+						// ToDo dbActivityIndex._Id = CoreDatabase.GetNextIdFromTable("ActivityIndex");
+					}
+					dbActivityIndex.ExecuteInsertCommand(dbCommand);
+					//activityIndex.Id = new SysId(dbActivityIndex._Id);
+					activityIndex.Changed = false;
+					if (DebugMode) SaLogger.Debug(fn + " Inserted. " + GetLogProperties(activityIndex).Concat(": ").Concat("", "\n\t"));
+				}
+				catch (Exception exc) { SetErrorState(exc.Message); }
+			}
+			return !HasErrorState();
+		}
+
+		//-------------------------------------------------------------------
+		// Update item.
+		public override bool UpdateActivityIndex(SaxActivityIndex activityIndex, DbUpdateInfo dbUpdateInfo)
+		{
+			String fn = GetType().Name + ".UpdateActivityIndex";
+			ClearErrorState();
+			if (!IsValidActivityIndex(activityIndex)) return false;
+			//if (!SysId.IsValid(activityIndex.Id)) return SetErrorState(ErrorMessage.InvalidItemId);
+			if (!activityIndex.Changed)
+			{
+				if (DebugMode) SaLogger.Debug(fn + " Data not changed. " + GetLogProperties(activityIndex).Concat(": ").Concat("", "\n\t"));
+				return true;
+			}
+			using (var dbConnection = CoreDatabase.CreateConnection())
+			using (var dbCommand = dbConnection.CreateCommand())
+			{
+				try
+				{
+					// Retrieve item.
+					dbConnection.Open();
+					ActivityIndex_Db dbActivityIndex = new ActivityIndex_Db(CoreDbInfo);
+					dbActivityIndex.PopulateFrom(dbCommand, aliasActivityIndex, GetActivityIndexQueryFilter(activityIndex, aliasActivityIndex).Concat(" AND ", "(", ")"));
+					// ToDo SaxUpdateLogItemMonitor_ActivityIndex updateLogMonitor = new SaxUpdateLogItemMonitor_ActivityIndex(SessionContext, CreateActivityIndex(dbActivityIndex), dbUpdateInfo);
+					// Update properties.
+					PopulateTo(dbActivityIndex, activityIndex, dbUpdateInfo);
+					dbActivityIndex.ExecuteUpdateCommand(dbCommand);
+					activityIndex.Changed = false;
+					if (DebugMode) SaLogger.Debug(fn + " Updated. " + GetLogProperties(activityIndex).Concat(": ").Concat("", "\n\t"));
+					// Record updates.
+					// ToDo updateLogMonitor.RecordUpdatedValues(activityIndex);
+					// ToDo updateLogMonitor.LogUpdates();
+				}
+				catch (Exception exc) { SetErrorState(exc.Message); }
+			}
+			return !HasErrorState();
+		}
+
+		//-------------------------------------------------------------------
+		// Delete item.
+		public override bool ActivityIndexCanBeDeleted(SaxActivityIndex activityIndex)
+		{
+			ClearErrorState();
+			if (!base.ActivityIndexCanBeDeleted(activityIndex)) return false;
+			return true;
+		}
+		public override bool DeleteActivityIndex(SaxActivityIndex activityIndex, DbUpdateInfo dbUpdateInfo)
+		{
+			String fn = GetType().Name + ".DeleteActivityIndex";
+			ClearErrorState();
+			if (!ActivityIndexCanBeDeleted(activityIndex)) return false;
+			using (var dbConnection = CoreDatabase.CreateConnection())
+			using (var dbCommand = dbConnection.CreateCommand())
+			{
+				try
+				{
+					// Retrieve item.
+					dbConnection.Open();
+					ActivityIndex_Db dbActivityIndex = new ActivityIndex_Db(CoreDbInfo);
+					String filter = GetActivityIndexQueryFilter(activityIndex, aliasActivityIndex).Concat(" AND ", "(", ")");
+					dbActivityIndex.PopulateFrom(dbCommand, aliasActivityIndex, filter);
+					// Delete item.
+					dbCommand.CommandType = System.Data.CommandType.Text;
+					dbCommand.CommandText = "DELETE FROM " + SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.ActivityIndex) + " '" + aliasActivityIndex + "' WHERE " + filter + ";";
+					dbCommand.ExecuteNonQuery();
+					activityIndex.Changed = false;
+					if (DebugMode) SaLogger.Debug(fn + " Deleted. " + GetLogProperties(activityIndex).Concat(": ").Concat("", "\n\t"));
+				}
+				catch (Exception exc) { SetErrorState(exc.Message); }
+			}
+			return !HasErrorState();
+		}
+
+		//-------------------------------------------------------------------
+		// Copy data properties to and from database.
+		private void PopulateTo(ActivityIndex_Db dbActivityIndex, SaxActivityIndex activityIndex, DbUpdateInfo dbUpdateInfo)
+		{
+			dbActivityIndex._ItemType = activityIndex.ItemId.Type;
+			dbActivityIndex._ItemId = SysId.ToInt(activityIndex.ItemId.Id);
+			dbActivityIndex._SportId = SysId.ToInt(activityIndex.SportId);
+			dbActivityIndex._RegionId = SysId.ToInt(activityIndex.RegionId);
+			dbActivityIndex._EffectiveOn = activityIndex.EffectiveOn;
+			dbActivityIndex._Notes = activityIndex.Notes;
+			dbActivityIndex._Status = SacsSystem.GetStatusCode(activityIndex.Status);
+			dbActivityIndex._Flags = (short)activityIndex.Flags;
+			if (!DateUtil.IsValid(dbActivityIndex._CreateOn))
+			{
+				dbActivityIndex._CreateOn = DateTime.Now;
+				dbActivityIndex._CreateBy = dbUpdateInfo.UserId.ToInt();
+				dbActivityIndex._CreateHost = dbUpdateInfo.Host;
+			}
+			dbActivityIndex._UpdateOn = DateTime.Now;
+			dbActivityIndex._UpdateBy = dbUpdateInfo.UserId.ToInt();
+			dbActivityIndex._UpdateHost = dbUpdateInfo.Host;
+		}
+		private void PopulateFrom(ActivityIndex_Db dbActivityIndex, SaxActivityIndex activityIndex)
+		{
+			//activityIndex.ItemId = new ItemId(dbActivityIndex._ItemType, new SysId(dbActivityIndex._ItemId);
+			//activityIndex.SportId = new SysId(dbActivityIndex._SportId);
+			//activityIndex.RegionId = new SysId(dbActivityIndex._RegionId);
+			activityIndex.EffectiveOn = dbActivityIndex._EffectiveOn;
+			activityIndex.Notes = dbActivityIndex._Notes;
+			activityIndex.Status = SacsSystem.GetStatusForCode(dbActivityIndex._Status);
+			activityIndex.SetCreateStamp(dbActivityIndex._CreateOn, new SysId(dbActivityIndex._CreateBy), dbActivityIndex._CreateHost);
+			activityIndex.SetUpdateStamp(dbActivityIndex._UpdateOn, new SysId(dbActivityIndex._UpdateBy), dbActivityIndex._UpdateHost);
+			activityIndex.AcceptChanges();
+		}
+
+		//-------------------------------------------------------------------
+		// Item column definitions.
+		private static readonly String aliasActivityIndex = "ActIdx";
+		private static readonly String aliasActivityIndex_Region = "ActIdx_Reg";
+		private static readonly String prefixActivityIndex_Region = "ActIdx_Reg_";
+		private static readonly String aliasActivityIndex_Sport = "ActIdx_Spt";
+		private static readonly String prefixActivityIndex_Sport = "ActIdx_Spt_";
+		private void SetActivityIndexColDfn
+			(ColumnDfn col, String caption, int width, SaxDbDfn_Core.ColumnIdx dbCol,
+			ColumnAlignment align = ColumnAlignment.Default, DataValue.DataType dataType = DataValue.DataType.String,
+			String alias = "", String prefix = "")
+		{
+			if (String.IsNullOrEmpty(alias) && SaxDbDfn_Core.GetTableForColumn(dbCol) == SaxDbDfn_Core.TableIdx.ActivityIndex)
+				alias = aliasActivityIndex;
+			col.Set(caption, width, (int)dbCol, prefix + SaxDbDfn_Core.GetColumnName(dbCol, false), SaxDbDfn_Core.GetColumnNameQual(dbCol, alias), dataType, align);
+			if (dataType == DataValue.DataType.String && dbCol != SaxDbDfn_Core.ColumnIdx.Unknown)
+				col.MaxLength = (int)SaxDbDfn_Core.GetColTextLen(dbCol);
+		}
+		public override ColumnDfn GetActivityIndexColumnDfn(SaxActivityIndex.Column columnId, string caption = "", int width = 0)
+		{
+			ColumnDfn columnDfn = new ColumnDfn((int)columnId, caption, width);
+			switch (columnId)
+			{
+				//-----------------------------------------------------------
+				case SaxActivityIndex.Column.Pos:
+					SetActivityIndexColDfn(columnDfn, "Pos", 60, SaxDbDfn_Core.ColumnIdx.Unknown, ColumnAlignment.Right);
+					columnDfn.SortMode = ColumnDfn.ColumnSortMode.Off;
+					columnDfn.ReadOnly = true;
+					columnDfn.Resizable = false;
+					break;
+
+				//-----------------------------------------------------------
+				// Item.
+				case SaxActivityIndex.Column.ItemType:
+					SetActivityIndexColDfn(columnDfn, "Item type", 80, SaxDbDfn_Core.ColumnIdx.ActivityIndex_ItemType, ColumnAlignment.Center, DataValue.DataType.Long);
+					columnDfn.ReadOnly = true;
+					break;
+				case SaxActivityIndex.Column.ItemType_Code:
+					SetActivityIndexColDfn(columnDfn, "Item type", 80, SaxDbDfn_Core.ColumnIdx.ActivityIndex_ItemType, ColumnAlignment.Center, DataValue.DataType.String);
+					columnDfn.ReadOnly = true;
+					break;
+				case SaxActivityIndex.Column.ItemType_Desc:
+					SetActivityIndexColDfn(columnDfn, "Item type", 100, SaxDbDfn_Core.ColumnIdx.ActivityIndex_ItemType, ColumnAlignment.Center, DataValue.DataType.String);
+					columnDfn.ReadOnly = true;
+					break;
+				case SaxActivityIndex.Column.ItemId:
+					SetActivityIndexColDfn(columnDfn, "Item #", 80, SaxDbDfn_Core.ColumnIdx.ActivityIndex_ItemId, ColumnAlignment.Right, DataValue.DataType.Long);
+					columnDfn.ReadOnly = true;
+					break;
+
+				//-----------------------------------------------------------
+				// Region.
+				case SaxActivityIndex.Column.RegionId:
+					SetActivityIndexColDfn(columnDfn, "Region Id", 80, SaxDbDfn_Core.ColumnIdx.ActivityIndex_RegionId, ColumnAlignment.Right, DataValue.DataType.Long);
+					columnDfn.ReadOnly = true;
+					break;
+				case SaxActivityIndex.Column.Region_Name:
+					SetActivityIndexColDfn(columnDfn, "Region", 100, SaxDbDfn_Core.ColumnIdx.Region_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasActivityIndex_Region, prefixActivityIndex_Region);
+					columnDfn.ReadOnly = true;
+					break;
+
+				//-----------------------------------------------------------
+				// Sport.
+				case SaxActivityIndex.Column.SportId:
+					SetActivityIndexColDfn(columnDfn, "Sport Id", 80, SaxDbDfn_Core.ColumnIdx.ActivityIndex_SportId, ColumnAlignment.Right, DataValue.DataType.Long);
+					columnDfn.ReadOnly = true;
+					break;
+				case SaxActivityIndex.Column.Sport_Name:
+					SetActivityIndexColDfn(columnDfn, "Sport", 100, SaxDbDfn_Core.ColumnIdx.Sport_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasActivityIndex_Sport, prefixActivityIndex_Sport);
+					columnDfn.ReadOnly = true;
+					break;
+
+				//-----------------------------------------------------------
+				// Properties.
+				case SaxActivityIndex.Column.EffectiveOn:
+					SetActivityIndexColDfn(columnDfn, "Effective", 90, SaxDbDfn_Core.ColumnIdx.ActivityIndex_EffectiveOn, ColumnAlignment.Center, DataValue.DataType.Date);
+					columnDfn.DateFormat = "d-MMM-yyyy";
+					break;
+
+				//-----------------------------------------------------------
+				// Derived properties.
+
+				//-----------------------------------------------------------
+				// Common properties.
+				case SaxActivityIndex.Column.Notes:
+					SetActivityIndexColDfn(columnDfn, "Notes", 240, SaxDbDfn_Core.ColumnIdx.ActivityIndex_Notes);
+					break;
+				case SaxActivityIndex.Column.Flags:
+					SetActivityIndexColDfn(columnDfn, "Flags", 60, SaxDbDfn_Core.ColumnIdx.ActivityIndex_Flags, ColumnAlignment.Center, DataValue.DataType.Long);
+					break;
+				case SaxActivityIndex.Column.Status:
+					SetActivityIndexColDfn(columnDfn, "Status", 80, SaxDbDfn_Core.ColumnIdx.ActivityIndex_Status, ColumnAlignment.Center);
+					break;
+				case SaxActivityIndex.Column.Status_Desc:
+					SetActivityIndexColDfn(columnDfn, "Status", 90, SaxDbDfn_Core.ColumnIdx.ActivityIndex_Status, ColumnAlignment.Center);
+					break;
+				case SaxActivityIndex.Column.Status_Ind:
+					SetActivityIndexColDfn(columnDfn, "Status", 80, SaxDbDfn_Core.ColumnIdx.ActivityIndex_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
+					columnDfn.TriStateFormat = ColumnTriStateFormat.Lights;
+					break;
+				case SaxActivityIndex.Column.CreateOn_Date:
+					SetActivityIndexColDfn(columnDfn, "Created", 80, SaxDbDfn_Core.ColumnIdx.ActivityIndex_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
+					columnDfn.ReadOnly = true;
+					break;
+				case SaxActivityIndex.Column.UpdateOn_Date:
+					SetActivityIndexColDfn(columnDfn, "Updated", 80, SaxDbDfn_Core.ColumnIdx.ActivityIndex_UpdateOn, ColumnAlignment.Center, DataValue.DataType.Date);
+					columnDfn.ReadOnly = true;
+					break;
+
+					//-----------------------------------------------------------
+			}
+			if (!String.IsNullOrEmpty(caption))
+				columnDfn.Caption = caption;
+			if (width > 0)
+				columnDfn.Width = width;
+			return columnDfn;
+		}
+
+		//-------------------------------------------------------------------
+		// Item query filter.
+		public List<string> GetActivityIndexQueryFilter(SaxActivityIndex activityIndex, String aliasActivityIndex)
+		{
+			// NB Only the Ids need to be queried. Effective date is a property of the Ids.
+			List<String> filter = new List<String>();
+			filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ActivityIndex_ItemType, aliasActivityIndex) + "=" + activityIndex.ItemId.Type);
+			filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ActivityIndex_ItemId, aliasActivityIndex) + "=" + SysId.ToInt(activityIndex.ItemId.Id));
+			filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ActivityIndex_SportId, aliasActivityIndex) + " IN (" + activityIndex.SportId + ")");
+			filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ActivityIndex_RegionId, aliasActivityIndex) + " IN (" + activityIndex.RegionId + ")");
+			return filter;
+		}
+		public override List<string> GetActivityIndexQueryFilter(SaxActivityIndex.Params prm)
+		{
+			List<String> filter = new List<String>();
+			String aliasActivityIndex = StringUtil.OnEmpty(prm.Alias_ActivityIndex, SaxActivityMgr_Dbas.aliasActivityIndex);
+
+			// Item Ids.
+			if (!prm.ItemIdsIncluded.IsEmpty())
+			{
+				List<String> itemIdFilters = new List<string>();
+				foreach (ItemId itemId in prm.ItemIdsIncluded)
+				{
+					if (!ItemId.IsValid(itemId)) continue;
+					String itemIdFilter =
+						SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ActivityIndex_ItemType, aliasActivityIndex) + "=" + itemId.Type +
+						" AND " + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ActivityIndex_ItemId, aliasActivityIndex) + "=" + SysId.ToInt(itemId.Id);
+					itemIdFilters.Add(itemIdFilter);
+				}
+				if (!itemIdFilters.IsEmpty())
+					filter.Add(itemIdFilters.Concat(" OR ", "(", ")"));
+			}
+
+			// Sport Ids.
+			String sportIdsIncluded = prm.SportIdsIncluded.Concat(",");
+			if (!sportIdsIncluded.IsEmpty())
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ActivityIndex_SportId, aliasActivityIndex) + " IN (" + sportIdsIncluded + ")");
+
+			// Region Ids.
+			String regionIdsIncluded = prm.RegionIdsIncluded.Concat(",");
+			if (!regionIdsIncluded.IsEmpty())
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ActivityIndex_RegionId, aliasActivityIndex) + " IN (" + regionIdsIncluded + ")");
+
+			// Effective period.
+			if (DateUtil.IsValid(prm.EffectiveFrom))
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ActivityIndex_EffectiveOn, aliasActivityIndex) + ">=" + DbQuery.FormatDateForCondition(prm.EffectiveFrom.Date));
+			if (DateUtil.IsValid(prm.EffectiveTo))
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ActivityIndex_EffectiveOn, aliasActivityIndex) + "<" + DbQuery.FormatDateForCondition(DateUtil.IncrementDate(prm.EffectiveTo.Date, 1)));
+
+			if (filter.Count < 1) filter.Add("1=1");
+			return filter;
+		}
+		// Item sort columns.
+		public List<String> GetActivityIndexSortColumns(SaxActivityIndex.Params prm)
+		{
+			// Sort sequence:
+			List<String> sortColumnNames = new List<String>();
+			foreach (var columnDfn in prm.SortColumns)
+			{
+				// Need to ensure correct alias used for ActivityIndex columns in case of conflict.
+				String sortCol = String.Empty;
+				if (SaxDbDfn_Core.GetTableForColumn((SaxDbDfn_Core.ColumnIdx)columnDfn.DbColumn) == SaxDbDfn_Core.TableIdx.ActivityIndex)
+				{
+					sortCol = SaxDbDfn_Core.GetColumnNameQual((SaxDbDfn_Core.ColumnIdx)columnDfn.DbColumn, aliasActivityIndex);
+				}
+				else
+				{
+					sortCol = columnDfn.DataName;
+					if (!StringUtil.IsEmpty(columnDfn.SortDataName))
+						sortCol = columnDfn.SortDataName;
+				}
+				if (!sortCol.IsEmpty())
+				{
+					DbOrderByNullMode orderByNullMode = DbOrderByNullMode.Default; // eSaOrderByDemoteNulls, eSaOrderByPromoteNulls
+					sortColumnNames.Add(DbQuery.FormatForOrderBy(sortCol, columnDfn.SortAscending, orderByNullMode).Concat(", "));
+				}
+			}
+			sortColumnNames.RemoveBlanks();
+			if (sortColumnNames.IsEmpty())
+			{
+				// Default sort columns.
+				sortColumnNames.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ActivityIndex_ItemType, aliasActivityIndex) + " ASC");
+				sortColumnNames.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ActivityIndex_ItemId, aliasActivityIndex) + " ASC");
+			}
+			return sortColumnNames;
+		}
+
+		//-------------------------------------------------------------------
+		// Item count.
+		private long GetActivityIndexCount(String filter)
+		{
+			ClearErrorState();
+			return CoreDatabase.GetRowCount(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.ActivityIndex) + " As " + aliasActivityIndex, filter);
+		}
+		public override long GetActivityIndexCount(SaxActivityIndex.Params prm)
+		{
+			ClearErrorState();
+			return GetActivityIndexCount(GetActivityIndexQueryFilter(prm).Concat(" AND ", "(", ")"));
+		}
+
+		//-------------------------------------------------------------------
+		// Item list.
+		public override List<SaxActivityIndex> GetActivityIndexList(SaxActivityIndex.Params prm)
+		{
+			List<SaxActivityIndex> userActivitys = new List<SaxActivityIndex>();
+			DbQuery qry = new DbQuery(CoreDatabase.DbmsType);
+			qry.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.ActivityIndex), aliasActivityIndex);
+			ActivityIndex_Db dbActivityIndex = new ActivityIndex_Db(CoreDbInfo);
+			qry.Columns.AddRange(dbActivityIndex.ExistingColumnNames);
+			qry.Filters.AddRange(GetActivityIndexQueryFilter(prm));
+			qry.OrderBy.AddRange(GetActivityIndexSortColumns(prm));
+			// Query data.
+			using (var dbConnection = CoreDatabase.CreateConnection())
+			using (var dbCommand = dbConnection.CreateCommand())
+			{
+				try
+				{
+					dbConnection.Open();
+					dbCommand.CommandText = qry.BuildQuery(prm.ResultsPaging);
+					using (DbDataReader dbDataReader = dbCommand.ExecuteReader())
+					{
+						while (dbDataReader.Read())
+						{
+							dbActivityIndex = new ActivityIndex_Db(CoreDbInfo);
+							dbActivityIndex.PopulateFrom(dbDataReader);
+							userActivitys.Add(CreateActivityIndex(dbActivityIndex));
+						}
+					}
+				}
+				catch (Exception exc)
+				{
+					SaLogger.Warn(GetType().Name + ".GetActivityIndexList\n\tQuery: " + dbCommand.CommandText + "\n\t" + ExceptionUtil.GetLogMessage(exc));
+				}
+			}
+			return userActivitys;
+		}
+
+		//-------------------------------------------------------------------
+		// Item query execution.
+		public override DbResultSet ExecuteActivityIndexQuery(List<ColumnDfn> columns, SaxActivityIndex.Params prm)
+		{
+			ClearErrorState();
+
+			//---------------------------------------------------------------------
+			// Construct query.
+			DbQuery query = new DbQuery(CoreDatabase.DbmsType);
+			query.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.ActivityIndex), aliasActivityIndex);
+
+			// Add columns as defined in query list.
+			query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ActivityIndex_ItemType, aliasActivityIndex));
+			query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ActivityIndex_ItemId, aliasActivityIndex));
+			query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ActivityIndex_SportId, aliasActivityIndex));
+			query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ActivityIndex_RegionId, aliasActivityIndex));
+			query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ActivityIndex_EffectiveOn, aliasActivityIndex));
+			// Common properties.
+			if (columns.HasId(SaxActivityIndex.Column.Notes))
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ActivityIndex_Notes, aliasActivityIndex));
+			if (columns.HasId(SaxActivityIndex.Column.Flags))
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ActivityIndex_Flags, aliasActivityIndex));
+			if (columns.HasId(SaxActivityIndex.Column.Status) || columns.HasId(SaxActivityIndex.Column.Status_Desc) || columns.HasId(SaxActivityIndex.Column.Status_Ind))
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ActivityIndex_Status, aliasActivityIndex));
+			if (columns.HasId(SaxActivityIndex.Column.CreateOn_Date))
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ActivityIndex_CreateOn, aliasActivityIndex));
+			if (columns.HasId(SaxActivityIndex.Column.UpdateOn_Date))
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ActivityIndex_UpdateOn, aliasActivityIndex));
+
+			//---------------------------------------------------------------------
+			// Sport.
+			if (columns.HasId(SaxActivityIndex.Column.Sport_Name))
+			{
+				DbQueryJoin joinSport = new DbQueryJoin(DbJoinType.LeftOuter);
+				joinSport.Table = new StringPair(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Sport), aliasActivityIndex_Sport);
+				joinSport.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Sport_Id, aliasActivityIndex_Sport) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ActivityIndex_SportId, aliasActivityIndex));
+				query.Joins.Add(joinSport);
+				List<SaxDbDfn_Core.ColumnIdx> cols = new List<SaxDbDfn_Core.ColumnIdx>();
+				cols.Add(SaxDbDfn_Core.ColumnIdx.Sport_Name);
+				foreach (var col in cols)
+					query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(col, aliasActivityIndex_Sport), prefixActivityIndex_Sport + SaxDbDfn_Core.GetColumnName(col, false));
+			}
+
+			//---------------------------------------------------------------------
+			// Region.
+			if (columns.HasId(SaxActivityIndex.Column.Region_Name))
+			{
+				DbQueryJoin joinRegion = new DbQueryJoin(DbJoinType.LeftOuter);
+				joinRegion.Table = new StringPair(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Region), aliasActivityIndex_Region);
+				joinRegion.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_Id, aliasActivityIndex_Region) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ActivityIndex_RegionId, aliasActivityIndex));
+				query.Joins.Add(joinRegion);
+				List<SaxDbDfn_Core.ColumnIdx> cols = new List<SaxDbDfn_Core.ColumnIdx>();
+				cols.Add(SaxDbDfn_Core.ColumnIdx.Region_Name);
+				foreach (var col in cols)
+					query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(col, aliasActivityIndex_Region), prefixActivityIndex_Region + SaxDbDfn_Core.GetColumnName(col, false));
+			}
+
+			//---------------------------------------------------------------------
+			// Populate filter.
+			query.Filters.AddRange(GetActivityIndexQueryFilter(prm));
+
+			if (prm.IdsIncluded.Count != 1)
+			{
+				// Configure sort sequence.
+				foreach (String sortColumn in GetActivityIndexSortColumns(prm))
+					query.OrderBy.Add(sortColumn);
+			}
+
+			//---------------------------------------------------------------------
+			//return new DbResultSet_DataTableReader(db, query.BuildQuery(prm.ResultsPaging));
+			return DbResultSet_DataReader.ExecuteQuery(CoreDatabase, query.BuildQuery(prm.ResultsPaging));
+		}
+
+		//-------------------------------------------------------------------
+	}
+	//=======================================================================
+}

SaxoniteStandardDbas/Dbas/Mgr/SaxActivityMgr_Dbas-JournalistArticle.cs

@@ -82,7 +82,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				catch (Exception exc)
 				{
 					SetErrorState("Database query exception");
-					SaLogger.Warn(GetType().Name + ".GetJournalistArticle\n\tQuery: " + dbCommand.CommandText + "\n\t" + exc.GetType().Name + ": " + exc.Message);
+					SaLogger.Warn(GetType().Name + ".GetJournalistArticle\n\tQuery: " + dbCommand.CommandText + "\n\t" + ExceptionUtil.GetLogMessage(exc));
 				}
 			}
 			return journalistArticle;
@@ -189,7 +189,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 					dbJournalistArticle.PopulateFrom(dbCommand, aliasJournalistArticle, "Id=" + journalistArticle.Id.ToString());
 					// Delete journalistArticle.
 					dbCommand.CommandType = System.Data.CommandType.Text;
-					dbCommand.CommandText = "DELETE FROM " + SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.JournalistArticle) + " WHERE Id=" + SysId.ToString(journalistArticle.Id) + ";";
+					dbCommand.CommandText = "DELETE FROM " + SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.JournalistArticle) + " WHERE Id=" + SysId.ToString(journalistArticle.Id) + ";";
 					dbCommand.ExecuteNonQuery();
 					journalistArticle.Changed = false;
 					if (DebugMode) SaLogger.Debug(fn + " Deleted. " + GetLogProperties(journalistArticle).Concat(": ").Concat("", "\n\t"));
@@ -205,8 +205,8 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		{
 			dbJournalistArticle._Id = SysId.ToInt(journalistArticle.Id);
 			dbJournalistArticle._UserAccountIdJournalist = SysId.ToInt(journalistArticle.UserAccountIdJournalist);
-			dbJournalistArticle._RegionIdPrimary = SysId.ToInt(journalistArticle.RegionIdPrimary);
 			dbJournalistArticle._SportIdPrimary = SysId.ToInt(journalistArticle.SportIdPrimary);
+			dbJournalistArticle._RegionIdPrimary = SysId.ToInt(journalistArticle.RegionIdPrimary);
 			dbJournalistArticle._Headline = journalistArticle.Headline;
 			dbJournalistArticle._Summary = journalistArticle.Summary;
 			dbJournalistArticle._BodyData = journalistArticle.BodyData;
@@ -228,8 +228,8 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		{
 			//journalistArticle.Id = new SysId(dbJournalistArticle._Id);
 			//journalistArticle.UserAccountIdJournalist = new SysId(dbJournalistArticle._UserAccountIdJournalist);
-			journalistArticle.RegionIdPrimary = new SysId(dbJournalistArticle._RegionIdPrimary);
 			journalistArticle.SportIdPrimary = new SysId(dbJournalistArticle._SportIdPrimary);
+			journalistArticle.RegionIdPrimary = new SysId(dbJournalistArticle._RegionIdPrimary);
 			journalistArticle.Headline = dbJournalistArticle._Headline;
 			journalistArticle.Summary = dbJournalistArticle._Summary;
 			journalistArticle.BodyData = dbJournalistArticle._BodyData;
@@ -246,20 +246,20 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		private static readonly String aliasJournalistArticle = "Sprt";
 		private static readonly String aliasJournalistArticle_Journalist = "JrnArt_Jrn";
 		private static readonly String prefixJournalistArticle_Jourlalist = "JrnArt_Jrn_";
-		private static readonly String aliasJournalistArticle_Region = "JrnArt_Reg";
-		private static readonly String prefixJournalistArticle_Region = "JrnArt_Reg_";
 		private static readonly String aliasJournalistArticle_Sport = "JrnArt_Spt";
 		private static readonly String prefixJournalistArticle_Sport = "JrnArt_Spt_";
+		private static readonly String aliasJournalistArticle_Region = "JrnArt_Reg";
+		private static readonly String prefixJournalistArticle_Region = "JrnArt_Reg_";
 		private void SetJournalistArticleColDfn
-			(ColumnDfn col, String caption, int width, SaxDbDfn.ColumnIdx dbCol,
+			(ColumnDfn col, String caption, int width, SaxDbDfn_Core.ColumnIdx dbCol,
 			ColumnAlignment align = ColumnAlignment.Default, DataValue.DataType dataType = DataValue.DataType.String,
 			String alias = "", String prefix = "")
 		{
-			if (String.IsNullOrEmpty(alias) && SaxDbDfn.GetTableForColumn(dbCol) == SaxDbDfn.TableIdx.JournalistArticle)
+			if (String.IsNullOrEmpty(alias) && SaxDbDfn_Core.GetTableForColumn(dbCol) == SaxDbDfn_Core.TableIdx.JournalistArticle)
 				alias = aliasJournalistArticle;
-			col.Set(caption, width, (int)dbCol, prefix + SaxDbDfn.GetColumnName(dbCol, false), SaxDbDfn.GetColumnNameQual(dbCol, alias), dataType, align);
-			if (dataType == DataValue.DataType.String && dbCol != SaxDbDfn.ColumnIdx.Unknown)
-				col.MaxLength = (int)SaxDbDfn.GetColTextLen(dbCol);
+			col.Set(caption, width, (int)dbCol, prefix + SaxDbDfn_Core.GetColumnName(dbCol, false), SaxDbDfn_Core.GetColumnNameQual(dbCol, alias), dataType, align);
+			if (dataType == DataValue.DataType.String && dbCol != SaxDbDfn_Core.ColumnIdx.Unknown)
+				col.MaxLength = (int)SaxDbDfn_Core.GetColTextLen(dbCol);
 		}
 		public override ColumnDfn GetJournalistArticleColumnDfn(SaxJournalistArticle.Column columnId, string caption = "", int width = 0)
 		{
@@ -268,75 +268,75 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			{
 				//-----------------------------------------------------------
 				case SaxJournalistArticle.Column.Pos:
-					SetJournalistArticleColDfn(columnDfn, "Pos", 60, SaxDbDfn.ColumnIdx.Unknown, ColumnAlignment.Right);
+					SetJournalistArticleColDfn(columnDfn, "Pos", 60, SaxDbDfn_Core.ColumnIdx.Unknown, ColumnAlignment.Right);
 					columnDfn.SortMode = ColumnDfn.ColumnSortMode.Off;
 					columnDfn.ReadOnly = true;
 					columnDfn.Resizable = false;
 					break;
 				case SaxJournalistArticle.Column.Id:
-					SetJournalistArticleColDfn(columnDfn, "Id", 80, SaxDbDfn.ColumnIdx.JournalistArticle_Id, ColumnAlignment.Right, DataValue.DataType.Long);
+					SetJournalistArticleColDfn(columnDfn, "Id", 80, SaxDbDfn_Core.ColumnIdx.JournalistArticle_Id, ColumnAlignment.Right, DataValue.DataType.Long);
 					columnDfn.ReadOnly = true;
 					break;
 
 				//-----------------------------------------------------------
 				// Journalist.
 				case SaxJournalistArticle.Column.UserAccountIdJournalist:
-					SetJournalistArticleColDfn(columnDfn, "Journalist Id", 80, SaxDbDfn.ColumnIdx.JournalistArticle_UserAccountIdJournalist, ColumnAlignment.Right, DataValue.DataType.Long);
+					SetJournalistArticleColDfn(columnDfn, "Journalist Id", 80, SaxDbDfn_Core.ColumnIdx.JournalistArticle_UserAccountIdJournalist, ColumnAlignment.Right, DataValue.DataType.Long);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxJournalistArticle.Column.Journalist_DisplayName:
-					SetJournalistArticleColDfn(columnDfn, "Journalist", 120, SaxDbDfn.ColumnIdx.Unknown);
+					SetJournalistArticleColDfn(columnDfn, "Journalist", 120, SaxDbDfn_Core.ColumnIdx.Unknown);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxJournalistArticle.Column.Journalist_Title:
-					SetJournalistArticleColDfn(columnDfn, "Journalist Title", 80, SaxDbDfn.ColumnIdx.UserAccount_Title, ColumnAlignment.Left, DataValue.DataType.String, aliasJournalistArticle_Journalist, prefixJournalistArticle_Jourlalist);
+					SetJournalistArticleColDfn(columnDfn, "Journalist Title", 80, SaxDbDfn_Core.ColumnIdx.UserAccount_Title, ColumnAlignment.Left, DataValue.DataType.String, aliasJournalistArticle_Journalist, prefixJournalistArticle_Jourlalist);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxJournalistArticle.Column.Journalist_FirstName:
-					SetJournalistArticleColDfn(columnDfn, "Journalist First Name", 100, SaxDbDfn.ColumnIdx.UserAccount_FirstName, ColumnAlignment.Left, DataValue.DataType.String, aliasJournalistArticle_Journalist, prefixJournalistArticle_Jourlalist);
+					SetJournalistArticleColDfn(columnDfn, "Journalist First Name", 100, SaxDbDfn_Core.ColumnIdx.UserAccount_FirstName, ColumnAlignment.Left, DataValue.DataType.String, aliasJournalistArticle_Journalist, prefixJournalistArticle_Jourlalist);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxJournalistArticle.Column.Journalist_LastName:
-					SetJournalistArticleColDfn(columnDfn, "Journalist Last Name", 100, SaxDbDfn.ColumnIdx.UserAccount_LastName, ColumnAlignment.Left, DataValue.DataType.String, aliasJournalistArticle_Journalist, prefixJournalistArticle_Jourlalist);
-					columnDfn.ReadOnly = true;
-					break;
-
-				//-----------------------------------------------------------
-				// Region.
-				case SaxJournalistArticle.Column.RegionIdPrimary:
-					SetJournalistArticleColDfn(columnDfn, "Region Id", 80, SaxDbDfn.ColumnIdx.JournalistArticle_RegionIdPrimary, ColumnAlignment.Right, DataValue.DataType.Long);
-					columnDfn.ReadOnly = true;
-					break;
-				case SaxJournalistArticle.Column.Region_Name:
-					SetJournalistArticleColDfn(columnDfn, "Region", 100, SaxDbDfn.ColumnIdx.Region_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasJournalistArticle_Region, prefixJournalistArticle_Region);
+					SetJournalistArticleColDfn(columnDfn, "Journalist Last Name", 100, SaxDbDfn_Core.ColumnIdx.UserAccount_LastName, ColumnAlignment.Left, DataValue.DataType.String, aliasJournalistArticle_Journalist, prefixJournalistArticle_Jourlalist);
 					columnDfn.ReadOnly = true;
 					break;
 
 				//-----------------------------------------------------------
 				// Sport.
 				case SaxJournalistArticle.Column.SportIdPrimary:
-					SetJournalistArticleColDfn(columnDfn, "Sport Id", 80, SaxDbDfn.ColumnIdx.JournalistArticle_SportIdPrimary, ColumnAlignment.Right, DataValue.DataType.Long);
+					SetJournalistArticleColDfn(columnDfn, "Sport Id", 80, SaxDbDfn_Core.ColumnIdx.JournalistArticle_SportIdPrimary, ColumnAlignment.Right, DataValue.DataType.Long);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxJournalistArticle.Column.Sport_Name:
-					SetJournalistArticleColDfn(columnDfn, "Sport", 100, SaxDbDfn.ColumnIdx.Sport_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasJournalistArticle_Sport, prefixJournalistArticle_Sport);
+					SetJournalistArticleColDfn(columnDfn, "Sport", 100, SaxDbDfn_Core.ColumnIdx.Sport_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasJournalistArticle_Sport, prefixJournalistArticle_Sport);
+					columnDfn.ReadOnly = true;
+					break;
+
+				//-----------------------------------------------------------
+				// Region.
+				case SaxJournalistArticle.Column.RegionIdPrimary:
+					SetJournalistArticleColDfn(columnDfn, "Region Id", 80, SaxDbDfn_Core.ColumnIdx.JournalistArticle_RegionIdPrimary, ColumnAlignment.Right, DataValue.DataType.Long);
+					columnDfn.ReadOnly = true;
+					break;
+				case SaxJournalistArticle.Column.Region_Name:
+					SetJournalistArticleColDfn(columnDfn, "Region", 100, SaxDbDfn_Core.ColumnIdx.Region_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasJournalistArticle_Region, prefixJournalistArticle_Region);
 					columnDfn.ReadOnly = true;
 					break;
 
 				//-----------------------------------------------------------
 				// Article.
 				case SaxJournalistArticle.Column.Headline:
-					SetJournalistArticleColDfn(columnDfn, "Headline", 200, SaxDbDfn.ColumnIdx.JournalistArticle_Headline);
+					SetJournalistArticleColDfn(columnDfn, "Headline", 200, SaxDbDfn_Core.ColumnIdx.JournalistArticle_Headline);
 					break;
 				case SaxJournalistArticle.Column.Summary:
-					SetJournalistArticleColDfn(columnDfn, "Summary", 200, SaxDbDfn.ColumnIdx.JournalistArticle_Summary);
+					SetJournalistArticleColDfn(columnDfn, "Summary", 200, SaxDbDfn_Core.ColumnIdx.JournalistArticle_Summary);
 					break;
 				case SaxJournalistArticle.Column.PublishedAt_Date:
-					SetJournalistArticleColDfn(columnDfn, "Published", 80, SaxDbDfn.ColumnIdx.JournalistArticle_PublishedAt, ColumnAlignment.Center, DataValue.DataType.Date);
+					SetJournalistArticleColDfn(columnDfn, "Published", 80, SaxDbDfn_Core.ColumnIdx.JournalistArticle_PublishedAt, ColumnAlignment.Center, DataValue.DataType.Date);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxJournalistArticle.Column.PublishedAt_DateTime:
-					SetJournalistArticleColDfn(columnDfn, "Published", 100, SaxDbDfn.ColumnIdx.JournalistArticle_PublishedAt, ColumnAlignment.Center, DataValue.DataType.DateTime);
+					SetJournalistArticleColDfn(columnDfn, "Published", 100, SaxDbDfn_Core.ColumnIdx.JournalistArticle_PublishedAt, ColumnAlignment.Center, DataValue.DataType.DateTime);
 					columnDfn.ReadOnly = true;
 					break;
 
@@ -346,27 +346,27 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				//-----------------------------------------------------------
 				// Common properties.
 				case SaxJournalistArticle.Column.Notes:
-					SetJournalistArticleColDfn(columnDfn, "Notes", 240, SaxDbDfn.ColumnIdx.JournalistArticle_Notes);
+					SetJournalistArticleColDfn(columnDfn, "Notes", 240, SaxDbDfn_Core.ColumnIdx.JournalistArticle_Notes);
 					break;
 				case SaxJournalistArticle.Column.Flags:
-					SetJournalistArticleColDfn(columnDfn, "Flags", 60, SaxDbDfn.ColumnIdx.JournalistArticle_Flags, ColumnAlignment.Center, DataValue.DataType.Long);
+					SetJournalistArticleColDfn(columnDfn, "Flags", 60, SaxDbDfn_Core.ColumnIdx.JournalistArticle_Flags, ColumnAlignment.Center, DataValue.DataType.Long);
 					break;
 				case SaxJournalistArticle.Column.Status:
-					SetJournalistArticleColDfn(columnDfn, "Status", 80, SaxDbDfn.ColumnIdx.JournalistArticle_Status, ColumnAlignment.Center);
+					SetJournalistArticleColDfn(columnDfn, "Status", 80, SaxDbDfn_Core.ColumnIdx.JournalistArticle_Status, ColumnAlignment.Center);
 					break;
 				case SaxJournalistArticle.Column.Status_Desc:
-					SetJournalistArticleColDfn(columnDfn, "Status", 90, SaxDbDfn.ColumnIdx.JournalistArticle_Status, ColumnAlignment.Center);
+					SetJournalistArticleColDfn(columnDfn, "Status", 90, SaxDbDfn_Core.ColumnIdx.JournalistArticle_Status, ColumnAlignment.Center);
 					break;
 				case SaxJournalistArticle.Column.Status_Ind:
-					SetJournalistArticleColDfn(columnDfn, "Status", 80, SaxDbDfn.ColumnIdx.JournalistArticle_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
+					SetJournalistArticleColDfn(columnDfn, "Status", 80, SaxDbDfn_Core.ColumnIdx.JournalistArticle_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
 					columnDfn.TriStateFormat = ColumnTriStateFormat.Lights;
 					break;
 				case SaxJournalistArticle.Column.CreateOn_Date:
-					SetJournalistArticleColDfn(columnDfn, "Created", 80, SaxDbDfn.ColumnIdx.JournalistArticle_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
+					SetJournalistArticleColDfn(columnDfn, "Created", 80, SaxDbDfn_Core.ColumnIdx.JournalistArticle_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxJournalistArticle.Column.UpdateOn_Date:
-					SetJournalistArticleColDfn(columnDfn, "Updated", 80, SaxDbDfn.ColumnIdx.JournalistArticle_UpdateOn, ColumnAlignment.Center, DataValue.DataType.Date);
+					SetJournalistArticleColDfn(columnDfn, "Updated", 80, SaxDbDfn_Core.ColumnIdx.JournalistArticle_UpdateOn, ColumnAlignment.Center, DataValue.DataType.Date);
 					columnDfn.ReadOnly = true;
 					break;
 
@@ -388,33 +388,33 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			// Item Ids.
 			String idsIncluded = prm.IdsIncluded.Concat(",");
 			if (!idsIncluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.JournalistArticle_Id, aliasJournalistArticle) + " IN (" + idsIncluded + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.JournalistArticle_Id, aliasJournalistArticle) + " IN (" + idsIncluded + ")");
 			String idsExcluded = prm.IdsExcluded.Concat(",");
 			if (!idsExcluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.JournalistArticle_Id, aliasJournalistArticle) + " NOT IN (" + idsExcluded + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.JournalistArticle_Id, aliasJournalistArticle) + " NOT IN (" + idsExcluded + ")");
 
 			// User Account Ids.
 			String userAccountIdsIncluded = prm.UserAccountIdsJournalistIncluded.Concat(",");
 			if (!userAccountIdsIncluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.JournalistArticle_UserAccountIdJournalist, aliasJournalistArticle) + " IN (" + userAccountIdsIncluded + ")");
-
-			// Region Ids.
-			String regionIdsIncluded = prm.RegionIdsIncluded.Concat(",");
-			if (!regionIdsIncluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.JournalistArticle_RegionIdPrimary, aliasJournalistArticle) + " IN (" + regionIdsIncluded + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.JournalistArticle_UserAccountIdJournalist, aliasJournalistArticle) + " IN (" + userAccountIdsIncluded + ")");
 
 			// Sport Ids.
 			String sportIdsIncluded = prm.SportIdsIncluded.Concat(",");
 			if (!sportIdsIncluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.JournalistArticle_SportIdPrimary, aliasJournalistArticle) + " IN (" + sportIdsIncluded + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.JournalistArticle_SportIdPrimary, aliasJournalistArticle) + " IN (" + sportIdsIncluded + ")");
+
+			// Region Ids.
+			String regionIdsIncluded = prm.RegionIdsIncluded.Concat(",");
+			if (!regionIdsIncluded.IsEmpty())
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.JournalistArticle_RegionIdPrimary, aliasJournalistArticle) + " IN (" + regionIdsIncluded + ")");
 
 			// Headline.
 			if (!StringUtil.IsEmpty(prm.HeadlinePartial))
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.JournalistArticle_Headline, aliasJournalistArticle) + " Like '%" + DbQuery.FormatForLike(prm.HeadlinePartial, true) + "%'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.JournalistArticle_Headline, aliasJournalistArticle) + " Like '%" + DbQuery.FormatForLike(prm.HeadlinePartial, true) + "%'");
 
 			// Summary.
 			if (!StringUtil.IsEmpty(prm.SummaryPartial))
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.JournalistArticle_Summary, aliasJournalistArticle) + " Like '%" + DbQuery.FormatForLike(prm.SummaryPartial, true) + "%'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.JournalistArticle_Summary, aliasJournalistArticle) + " Like '%" + DbQuery.FormatForLike(prm.SummaryPartial, true) + "%'");
 
 			// Article.
 			if (!StringUtil.IsEmpty(prm.ArticleFilter))
@@ -426,21 +426,21 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				foreach (String filterWord in filterWords)
 				{
 					List<String> articleFilter = new List<String>();
-					articleFilter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.JournalistArticle_Headline, aliasJournalistArticle) + " Like '%" + DbQuery.FormatForLike(filterWord, true) + "%'");
-					articleFilter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.JournalistArticle_Summary, aliasJournalistArticle) + " Like '%" + DbQuery.FormatForLike(filterWord, true) + "%'");
+					articleFilter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.JournalistArticle_Headline, aliasJournalistArticle) + " Like '%" + DbQuery.FormatForLike(filterWord, true) + "%'");
+					articleFilter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.JournalistArticle_Summary, aliasJournalistArticle) + " Like '%" + DbQuery.FormatForLike(filterWord, true) + "%'");
 					filter.Add(articleFilter.Concat(" OR ", "(", ")"));
 				}
 			}
 
 			// Notes.
 			if (!StringUtil.IsEmpty(prm.NotesPartial))
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.JournalistArticle_Notes, aliasJournalistArticle) + " LIKE '%" + DbQuery.FormatForLike(prm.NotesPartial) + "%'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.JournalistArticle_Notes, aliasJournalistArticle) + " LIKE '%" + DbQuery.FormatForLike(prm.NotesPartial) + "%'");
 
 			// Status.
 			if (prm.StatusCat == SaxJournalistArticle.StatusCat.ActiveOnly)
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.JournalistArticle_Status, aliasJournalistArticle) + "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.JournalistArticle_Status, aliasJournalistArticle) + "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'");
 			else if (prm.StatusCat == SaxJournalistArticle.StatusCat.NotDeleted)
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.JournalistArticle_Status, aliasJournalistArticle) + "!='" + SacsSystem.GetStatusCode(SaStatus.Deleted) + "'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.JournalistArticle_Status, aliasJournalistArticle) + "!='" + SacsSystem.GetStatusCode(SaStatus.Deleted) + "'");
 
 			if (filter.Count < 1) filter.Add("1=1");
 			return filter;
@@ -454,9 +454,9 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			{
 				// Need to ensure correct alias used for JournalistArticle columns in case of conflict.
 				String sortCol = String.Empty;
-				if (SaxDbDfn.GetTableForColumn((SaxDbDfn.ColumnIdx)columnDfn.DbColumn) == SaxDbDfn.TableIdx.JournalistArticle)
+				if (SaxDbDfn_Core.GetTableForColumn((SaxDbDfn_Core.ColumnIdx)columnDfn.DbColumn) == SaxDbDfn_Core.TableIdx.JournalistArticle)
 				{
-					sortCol = SaxDbDfn.GetColumnNameQual((SaxDbDfn.ColumnIdx)columnDfn.DbColumn, aliasJournalistArticle);
+					sortCol = SaxDbDfn_Core.GetColumnNameQual((SaxDbDfn_Core.ColumnIdx)columnDfn.DbColumn, aliasJournalistArticle);
 				}
 				else
 				{
@@ -474,7 +474,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			if (sortColumnNames.IsEmpty())
 			{
 				// Default sort columns.
-				sortColumnNames.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.JournalistArticle_Id, aliasJournalistArticle) + " ASC");
+				sortColumnNames.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.JournalistArticle_Id, aliasJournalistArticle) + " ASC");
 			}
 			return sortColumnNames;
 		}
@@ -484,7 +484,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		private long GetJournalistArticleCount(String filter)
 		{
 			ClearErrorState();
-			return CoreDatabase.GetRowCount(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.JournalistArticle) + " As " + aliasJournalistArticle, filter);
+			return CoreDatabase.GetRowCount(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.JournalistArticle) + " As " + aliasJournalistArticle, filter);
 		}
 		public override long GetJournalistArticleCount(SaxJournalistArticle.Params prm)
 		{
@@ -498,7 +498,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		{
 			List<SaxJournalistArticle> userActivitys = new List<SaxJournalistArticle>();
 			DbQuery qry = new DbQuery(CoreDatabase.DbmsType);
-			qry.Tables.Add(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.JournalistArticle), aliasJournalistArticle);
+			qry.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.JournalistArticle), aliasJournalistArticle);
 			JournalistArticle_Db dbJournalistArticle = new JournalistArticle_Db(CoreDbInfo);
 			qry.Columns.AddRange(dbJournalistArticle.ExistingColumnNames);
 			qry.Filters.AddRange(GetJournalistArticleQueryFilter(prm));
@@ -523,7 +523,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				}
 				catch (Exception exc)
 				{
-					SaLogger.Warn(GetType().Name + ".GetJournalistArticleList\n\tQuery: " + dbCommand.CommandText + "\n\t" + exc.GetType().Name + ": " + exc.Message);
+					SaLogger.Warn(GetType().Name + ".GetJournalistArticleList\n\tQuery: " + dbCommand.CommandText + "\n\t" + ExceptionUtil.GetLogMessage(exc));
 				}
 			}
 			return userActivitys;
@@ -538,66 +538,52 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			//---------------------------------------------------------------------
 			// Construct query.
 			DbQuery query = new DbQuery(CoreDatabase.DbmsType);
-			query.Tables.Add(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.JournalistArticle), aliasJournalistArticle);
+			query.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.JournalistArticle), aliasJournalistArticle);
 
 			// Add columns as defined in query list.
 			if (columns.HasId(SaxJournalistArticle.Column.Id))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.JournalistArticle_Id, aliasJournalistArticle));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.JournalistArticle_Id, aliasJournalistArticle));
 			bool hasUserAccountCols = (columns.HasId(SaxJournalistArticle.Column.Journalist_DisplayName) || columns.HasId(SaxJournalistArticle.Column.Journalist_Title) || columns.HasId(SaxJournalistArticle.Column.Journalist_FirstName) || columns.HasId(SaxJournalistArticle.Column.Journalist_LastName));
 			if (columns.HasId(SaxJournalistArticle.Column.UserAccountIdJournalist) || hasUserAccountCols)
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.JournalistArticle_UserAccountIdJournalist, aliasJournalistArticle));
-			bool hasRegionCols = (columns.HasId(SaxJournalistArticle.Column.Region_Name));
-			if (columns.HasId(SaxJournalistArticle.Column.RegionIdPrimary) || hasRegionCols)
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.JournalistArticle_RegionIdPrimary, aliasJournalistArticle));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.JournalistArticle_UserAccountIdJournalist, aliasJournalistArticle));
 			bool hasSportCols = (columns.HasId(SaxJournalistArticle.Column.Sport_Name));
 			if (columns.HasId(SaxJournalistArticle.Column.SportIdPrimary) || hasSportCols)
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.JournalistArticle_SportIdPrimary, aliasJournalistArticle));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.JournalistArticle_SportIdPrimary, aliasJournalistArticle));
+			bool hasRegionCols = (columns.HasId(SaxJournalistArticle.Column.Region_Name));
+			if (columns.HasId(SaxJournalistArticle.Column.RegionIdPrimary) || hasRegionCols)
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.JournalistArticle_RegionIdPrimary, aliasJournalistArticle));
 			if (columns.HasId(SaxJournalistArticle.Column.Headline))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.JournalistArticle_Headline, aliasJournalistArticle));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.JournalistArticle_Headline, aliasJournalistArticle));
 			if (columns.HasId(SaxJournalistArticle.Column.Summary))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.JournalistArticle_Summary, aliasJournalistArticle));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.JournalistArticle_Summary, aliasJournalistArticle));
 			if (columns.HasId(SaxJournalistArticle.Column.PublishedAt_Date) || columns.HasId(SaxJournalistArticle.Column.PublishedAt_DateTime))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.JournalistArticle_PublishedAt, aliasJournalistArticle));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.JournalistArticle_PublishedAt, aliasJournalistArticle));
 			// Common properties.
 			if (columns.HasId(SaxJournalistArticle.Column.Notes))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.JournalistArticle_Notes, aliasJournalistArticle));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.JournalistArticle_Notes, aliasJournalistArticle));
 			if (columns.HasId(SaxJournalistArticle.Column.Flags))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.JournalistArticle_Flags, aliasJournalistArticle));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.JournalistArticle_Flags, aliasJournalistArticle));
 			if (columns.HasId(SaxJournalistArticle.Column.Status) || columns.HasId(SaxJournalistArticle.Column.Status_Desc) || columns.HasId(SaxJournalistArticle.Column.Status_Ind))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.JournalistArticle_Status, aliasJournalistArticle));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.JournalistArticle_Status, aliasJournalistArticle));
 			if (columns.HasId(SaxJournalistArticle.Column.CreateOn_Date))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.JournalistArticle_CreateOn, aliasJournalistArticle));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.JournalistArticle_CreateOn, aliasJournalistArticle));
 			if (columns.HasId(SaxJournalistArticle.Column.UpdateOn_Date))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.JournalistArticle_UpdateOn, aliasJournalistArticle));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.JournalistArticle_UpdateOn, aliasJournalistArticle));
 
 			//---------------------------------------------------------------------
 			// User Account.
 			if (hasUserAccountCols)
 			{
 				DbQueryJoin joinUserAccount = new DbQueryJoin(DbJoinType.LeftOuter);
-				joinUserAccount.Table = new StringPair(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.UserAccount), aliasJournalistArticle_Journalist);
-				joinUserAccount.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserAccount_Id, aliasJournalistArticle_Journalist) + "=" + SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.JournalistArticle_UserAccountIdJournalist, aliasJournalistArticle));
+				joinUserAccount.Table = new StringPair(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.UserAccount), aliasJournalistArticle_Journalist);
+				joinUserAccount.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_Id, aliasJournalistArticle_Journalist) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.JournalistArticle_UserAccountIdJournalist, aliasJournalistArticle));
 				query.Joins.Add(joinUserAccount);
-				List<SaxDbDfn.ColumnIdx> cols = new List<SaxDbDfn.ColumnIdx>();
-				cols.Add(SaxDbDfn.ColumnIdx.UserAccount_Title);
-				cols.Add(SaxDbDfn.ColumnIdx.UserAccount_FirstName);
-				cols.Add(SaxDbDfn.ColumnIdx.UserAccount_LastName);
+				List<SaxDbDfn_Core.ColumnIdx> cols = new List<SaxDbDfn_Core.ColumnIdx>();
+				cols.Add(SaxDbDfn_Core.ColumnIdx.UserAccount_Title);
+				cols.Add(SaxDbDfn_Core.ColumnIdx.UserAccount_FirstName);
+				cols.Add(SaxDbDfn_Core.ColumnIdx.UserAccount_LastName);
 				foreach (var col in cols)
-					query.Columns.Add(SaxDbDfn.GetColumnNameQual(col, aliasJournalistArticle_Journalist), prefixJournalistArticle_Jourlalist + SaxDbDfn.GetColumnName(col, false));
-			}
-
-			//---------------------------------------------------------------------
-			// Primary Region.
-			if (hasRegionCols)
-			{
-				DbQueryJoin joinRegion = new DbQueryJoin(DbJoinType.LeftOuter);
-				joinRegion.Table = new StringPair(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.Region), aliasJournalistArticle_Region);
-				joinRegion.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_Id, aliasJournalistArticle_Region) + "=" + SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.JournalistArticle_RegionIdPrimary, aliasJournalistArticle));
-				query.Joins.Add(joinRegion);
-				List<SaxDbDfn.ColumnIdx> cols = new List<SaxDbDfn.ColumnIdx>();
-				cols.Add(SaxDbDfn.ColumnIdx.Region_Name);
-				foreach (var col in cols)
-					query.Columns.Add(SaxDbDfn.GetColumnNameQual(col, aliasJournalistArticle_Region), prefixJournalistArticle_Region + SaxDbDfn.GetColumnName(col, false));
+					query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(col, aliasJournalistArticle_Journalist), prefixJournalistArticle_Jourlalist + SaxDbDfn_Core.GetColumnName(col, false));
 			}
 
 			//---------------------------------------------------------------------
@@ -605,13 +591,27 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			if (hasSportCols)
 			{
 				DbQueryJoin joinSport = new DbQueryJoin(DbJoinType.LeftOuter);
-				joinSport.Table = new StringPair(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.Sport), aliasJournalistArticle_Sport);
-				joinSport.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Sport_Id, aliasJournalistArticle_Sport) + "=" + SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.JournalistArticle_SportIdPrimary, aliasJournalistArticle));
+				joinSport.Table = new StringPair(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Sport), aliasJournalistArticle_Sport);
+				joinSport.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Sport_Id, aliasJournalistArticle_Sport) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.JournalistArticle_SportIdPrimary, aliasJournalistArticle));
 				query.Joins.Add(joinSport);
-				List<SaxDbDfn.ColumnIdx> cols = new List<SaxDbDfn.ColumnIdx>();
-				cols.Add(SaxDbDfn.ColumnIdx.Sport_Name);
+				List<SaxDbDfn_Core.ColumnIdx> cols = new List<SaxDbDfn_Core.ColumnIdx>();
+				cols.Add(SaxDbDfn_Core.ColumnIdx.Sport_Name);
 				foreach (var col in cols)
-					query.Columns.Add(SaxDbDfn.GetColumnNameQual(col, aliasJournalistArticle_Sport), prefixJournalistArticle_Sport + SaxDbDfn.GetColumnName(col, false));
+					query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(col, aliasJournalistArticle_Sport), prefixJournalistArticle_Sport + SaxDbDfn_Core.GetColumnName(col, false));
+			}
+
+			//---------------------------------------------------------------------
+			// Primary Region.
+			if (hasRegionCols)
+			{
+				DbQueryJoin joinRegion = new DbQueryJoin(DbJoinType.LeftOuter);
+				joinRegion.Table = new StringPair(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Region), aliasJournalistArticle_Region);
+				joinRegion.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_Id, aliasJournalistArticle_Region) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.JournalistArticle_RegionIdPrimary, aliasJournalistArticle));
+				query.Joins.Add(joinRegion);
+				List<SaxDbDfn_Core.ColumnIdx> cols = new List<SaxDbDfn_Core.ColumnIdx>();
+				cols.Add(SaxDbDfn_Core.ColumnIdx.Region_Name);
+				foreach (var col in cols)
+					query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(col, aliasJournalistArticle_Region), prefixJournalistArticle_Region + SaxDbDfn_Core.GetColumnName(col, false));
 			}
 
 			//---------------------------------------------------------------------

SaxoniteStandardDbas/Dbas/Mgr/SaxActivityMgr_Dbas-OrganisationOpportunity.cs

@@ -82,7 +82,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				catch (Exception exc)
 				{
 					SetErrorState("Database query exception");
-					SaLogger.Warn(GetType().Name + ".GetOrganisationOpportunity\n\tQuery: " + dbCommand.CommandText + "\n\t" + exc.GetType().Name + ": " + exc.Message);
+					SaLogger.Warn(GetType().Name + ".GetOrganisationOpportunity\n\tQuery: " + dbCommand.CommandText + "\n\t" + ExceptionUtil.GetLogMessage(exc));
 				}
 			}
 			return organisationOpportunity;
@@ -189,7 +189,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 					dbOrganisationOpportunity.PopulateFrom(dbCommand, aliasOrganisationOpportunity, "Id=" + organisationOpportunity.Id.ToString());
 					// Delete organisationOpportunity.
 					dbCommand.CommandType = System.Data.CommandType.Text;
-					dbCommand.CommandText = "DELETE FROM " + SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.OrganisationOpportunity) + " WHERE Id=" + SysId.ToString(organisationOpportunity.Id) + ";";
+					dbCommand.CommandText = "DELETE FROM " + SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.OrganisationOpportunity) + " WHERE Id=" + SysId.ToString(organisationOpportunity.Id) + ";";
 					dbCommand.ExecuteNonQuery();
 					organisationOpportunity.Changed = false;
 					if (DebugMode) SaLogger.Debug(fn + " Deleted. " + GetLogProperties(organisationOpportunity).Concat(": ").Concat("", "\n\t"));
@@ -205,8 +205,8 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		{
 			dbOrganisationOpportunity._Id = SysId.ToInt(organisationOpportunity.Id);
 			dbOrganisationOpportunity._OrganisationId = SysId.ToInt(organisationOpportunity.OrganisationId);
-			dbOrganisationOpportunity._RegionIdPrimary = SysId.ToInt(organisationOpportunity.RegionIdPrimary);
 			dbOrganisationOpportunity._SportIdPrimary = SysId.ToInt(organisationOpportunity.SportIdPrimary);
+			dbOrganisationOpportunity._RegionIdPrimary = SysId.ToInt(organisationOpportunity.RegionIdPrimary);
 			dbOrganisationOpportunity._OpportunityTypeCode = OpportunityTypes.GetCodeForType(organisationOpportunity.OpportunityType);
 			dbOrganisationOpportunity._Position = organisationOpportunity.Position;
 			dbOrganisationOpportunity._Outline = organisationOpportunity.Outline;
@@ -230,8 +230,8 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		{
 			//organisationOpportunity.Id = new SysId(dbOrganisationOpportunity._Id);
 			//organisationOpportunity.OrganisationId = new SysId(dbOrganisationOpportunity._OrganisationId);
-			organisationOpportunity.RegionIdPrimary = new SysId(dbOrganisationOpportunity._RegionIdPrimary);
 			organisationOpportunity.SportIdPrimary = new SysId(dbOrganisationOpportunity._SportIdPrimary);
+			organisationOpportunity.RegionIdPrimary = new SysId(dbOrganisationOpportunity._RegionIdPrimary);
 			organisationOpportunity.OpportunityType = (Sax.OpportunityType)OpportunityTypes.GetTypeForCode(dbOrganisationOpportunity._OpportunityTypeCode);
 			organisationOpportunity.Position = dbOrganisationOpportunity._Position;
 			organisationOpportunity.Outline = dbOrganisationOpportunity._Outline;
@@ -251,20 +251,20 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		private static readonly String aliasOrganisationOpportunity_Organisation = "OrgOpp_Org";
 		private static readonly String prefixOrganisationOpportunity_Organisation = "OrgOpp_Org_";
 		private static readonly String aliasOrganisationOpportunity_Organisation_UserOrganisation = "OrgOpp_Org_UsrOrg";
-		private static readonly String aliasOrganisationOpportunity_Region = "OrgOpp_Reg";
-		private static readonly String prefixOrganisationOpportunity_Region = "OrgOpp_Reg_";
 		private static readonly String aliasOrganisationOpportunity_Sport = "OrgOpp_Spt";
 		private static readonly String prefixOrganisationOpportunity_Sport = "OrgOpp_Spt_";
+		private static readonly String aliasOrganisationOpportunity_Region = "OrgOpp_Reg";
+		private static readonly String prefixOrganisationOpportunity_Region = "OrgOpp_Reg_";
 		private void SetOrganisationOpportunityColDfn
-			(ColumnDfn col, String caption, int width, SaxDbDfn.ColumnIdx dbCol,
+			(ColumnDfn col, String caption, int width, SaxDbDfn_Core.ColumnIdx dbCol,
 			ColumnAlignment align = ColumnAlignment.Default, DataValue.DataType dataType = DataValue.DataType.String,
 			String alias = "", String prefix = "")
 		{
-			if (String.IsNullOrEmpty(alias) && SaxDbDfn.GetTableForColumn(dbCol) == SaxDbDfn.TableIdx.OrganisationOpportunity)
+			if (String.IsNullOrEmpty(alias) && SaxDbDfn_Core.GetTableForColumn(dbCol) == SaxDbDfn_Core.TableIdx.OrganisationOpportunity)
 				alias = aliasOrganisationOpportunity;
-			col.Set(caption, width, (int)dbCol, prefix + SaxDbDfn.GetColumnName(dbCol, false), SaxDbDfn.GetColumnNameQual(dbCol, alias), dataType, align);
-			if (dataType == DataValue.DataType.String && dbCol != SaxDbDfn.ColumnIdx.Unknown)
-				col.MaxLength = (int)SaxDbDfn.GetColTextLen(dbCol);
+			col.Set(caption, width, (int)dbCol, prefix + SaxDbDfn_Core.GetColumnName(dbCol, false), SaxDbDfn_Core.GetColumnNameQual(dbCol, alias), dataType, align);
+			if (dataType == DataValue.DataType.String && dbCol != SaxDbDfn_Core.ColumnIdx.Unknown)
+				col.MaxLength = (int)SaxDbDfn_Core.GetColTextLen(dbCol);
 		}
 		public override ColumnDfn GetOrganisationOpportunityColumnDfn(SaxOrganisationOpportunity.Column columnId, string caption = "", int width = 0)
 		{
@@ -273,77 +273,77 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			{
 				//-----------------------------------------------------------
 				case SaxOrganisationOpportunity.Column.Pos:
-					SetOrganisationOpportunityColDfn(columnDfn, "Pos", 60, SaxDbDfn.ColumnIdx.Unknown, ColumnAlignment.Right);
+					SetOrganisationOpportunityColDfn(columnDfn, "Pos", 60, SaxDbDfn_Core.ColumnIdx.Unknown, ColumnAlignment.Right);
 					columnDfn.SortMode = ColumnDfn.ColumnSortMode.Off;
 					columnDfn.ReadOnly = true;
 					columnDfn.Resizable = false;
 					break;
 				case SaxOrganisationOpportunity.Column.Id:
-					SetOrganisationOpportunityColDfn(columnDfn, "Id", 80, SaxDbDfn.ColumnIdx.OrganisationOpportunity_Id, ColumnAlignment.Right, DataValue.DataType.Long);
+					SetOrganisationOpportunityColDfn(columnDfn, "Id", 80, SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_Id, ColumnAlignment.Right, DataValue.DataType.Long);
 					columnDfn.ReadOnly = true;
 					break;
 
 				//-----------------------------------------------------------
 				// Organisation.
 				case SaxOrganisationOpportunity.Column.OrganisationId:
-					SetOrganisationOpportunityColDfn(columnDfn, "Organisation Id", 80, SaxDbDfn.ColumnIdx.OrganisationOpportunity_OrganisationId, ColumnAlignment.Right, DataValue.DataType.Long);
+					SetOrganisationOpportunityColDfn(columnDfn, "Organisation Id", 80, SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_OrganisationId, ColumnAlignment.Right, DataValue.DataType.Long);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxOrganisationOpportunity.Column.Organisation_Name:
-					SetOrganisationOpportunityColDfn(columnDfn, "Organisation", 160, SaxDbDfn.ColumnIdx.Organisation_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasOrganisationOpportunity_Organisation, prefixOrganisationOpportunity_Organisation);
-					columnDfn.ReadOnly = true;
-					break;
-
-				//-----------------------------------------------------------
-				// Region.
-				case SaxOrganisationOpportunity.Column.RegionIdPrimary:
-					SetOrganisationOpportunityColDfn(columnDfn, "Region Id", 80, SaxDbDfn.ColumnIdx.OrganisationOpportunity_RegionIdPrimary, ColumnAlignment.Right, DataValue.DataType.Long);
-					columnDfn.ReadOnly = true;
-					break;
-				case SaxOrganisationOpportunity.Column.Region_Name:
-					SetOrganisationOpportunityColDfn(columnDfn, "Region", 100, SaxDbDfn.ColumnIdx.Region_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasOrganisationOpportunity_Region, prefixOrganisationOpportunity_Region);
+					SetOrganisationOpportunityColDfn(columnDfn, "Organisation", 160, SaxDbDfn_Core.ColumnIdx.Organisation_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasOrganisationOpportunity_Organisation, prefixOrganisationOpportunity_Organisation);
 					columnDfn.ReadOnly = true;
 					break;
 
 				//-----------------------------------------------------------
 				// Sport.
 				case SaxOrganisationOpportunity.Column.SportIdPrimary:
-					SetOrganisationOpportunityColDfn(columnDfn, "Sport Id", 80, SaxDbDfn.ColumnIdx.OrganisationOpportunity_SportIdPrimary, ColumnAlignment.Right, DataValue.DataType.Long);
+					SetOrganisationOpportunityColDfn(columnDfn, "Sport Id", 80, SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_SportIdPrimary, ColumnAlignment.Right, DataValue.DataType.Long);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxOrganisationOpportunity.Column.Sport_Name:
-					SetOrganisationOpportunityColDfn(columnDfn, "Sport", 100, SaxDbDfn.ColumnIdx.Sport_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasOrganisationOpportunity_Sport, prefixOrganisationOpportunity_Sport);
+					SetOrganisationOpportunityColDfn(columnDfn, "Sport", 100, SaxDbDfn_Core.ColumnIdx.Sport_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasOrganisationOpportunity_Sport, prefixOrganisationOpportunity_Sport);
+					columnDfn.ReadOnly = true;
+					break;
+
+				//-----------------------------------------------------------
+				// Region.
+				case SaxOrganisationOpportunity.Column.RegionIdPrimary:
+					SetOrganisationOpportunityColDfn(columnDfn, "Region Id", 80, SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_RegionIdPrimary, ColumnAlignment.Right, DataValue.DataType.Long);
+					columnDfn.ReadOnly = true;
+					break;
+				case SaxOrganisationOpportunity.Column.Region_Name:
+					SetOrganisationOpportunityColDfn(columnDfn, "Region", 100, SaxDbDfn_Core.ColumnIdx.Region_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasOrganisationOpportunity_Region, prefixOrganisationOpportunity_Region);
 					columnDfn.ReadOnly = true;
 					break;
 
 				//-----------------------------------------------------------
 				// Opportunity.
 				case SaxOrganisationOpportunity.Column.OpportunityTypeCode:
-					SetOrganisationOpportunityColDfn(columnDfn, "Opportunity", 90, SaxDbDfn.ColumnIdx.OrganisationOpportunity_OpportunityTypeCode, ColumnAlignment.Center);
+					SetOrganisationOpportunityColDfn(columnDfn, "Opportunity", 90, SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_OpportunityTypeCode, ColumnAlignment.Center);
 					break;
 				case SaxOrganisationOpportunity.Column.OpportunityType_Desc:
-					SetOrganisationOpportunityColDfn(columnDfn, "Opportunbity", 120, SaxDbDfn.ColumnIdx.OrganisationOpportunity_OpportunityTypeCode, ColumnAlignment.Center);
+					SetOrganisationOpportunityColDfn(columnDfn, "Opportunbity", 120, SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_OpportunityTypeCode, ColumnAlignment.Center);
 					break;
 				case SaxOrganisationOpportunity.Column.Position:
-					SetOrganisationOpportunityColDfn(columnDfn, "Position", 200, SaxDbDfn.ColumnIdx.OrganisationOpportunity_Position);
+					SetOrganisationOpportunityColDfn(columnDfn, "Position", 200, SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_Position);
 					break;
 				case SaxOrganisationOpportunity.Column.Outline:
-					SetOrganisationOpportunityColDfn(columnDfn, "Outline", 200, SaxDbDfn.ColumnIdx.OrganisationOpportunity_Outline);
+					SetOrganisationOpportunityColDfn(columnDfn, "Outline", 200, SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_Outline);
 					break;
 				case SaxOrganisationOpportunity.Column.PublishedAt_Date:
-					SetOrganisationOpportunityColDfn(columnDfn, "Published", 80, SaxDbDfn.ColumnIdx.OrganisationOpportunity_PublishedAt, ColumnAlignment.Center, DataValue.DataType.Date);
+					SetOrganisationOpportunityColDfn(columnDfn, "Published", 80, SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_PublishedAt, ColumnAlignment.Center, DataValue.DataType.Date);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxOrganisationOpportunity.Column.PublishedAt_DateTime:
-					SetOrganisationOpportunityColDfn(columnDfn, "Published", 100, SaxDbDfn.ColumnIdx.OrganisationOpportunity_PublishedAt, ColumnAlignment.Center, DataValue.DataType.DateTime);
+					SetOrganisationOpportunityColDfn(columnDfn, "Published", 100, SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_PublishedAt, ColumnAlignment.Center, DataValue.DataType.DateTime);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxOrganisationOpportunity.Column.ExpiresAt_Date:
-					SetOrganisationOpportunityColDfn(columnDfn, "Expires", 80, SaxDbDfn.ColumnIdx.OrganisationOpportunity_ExpiresAt, ColumnAlignment.Center, DataValue.DataType.Date);
+					SetOrganisationOpportunityColDfn(columnDfn, "Expires", 80, SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_ExpiresAt, ColumnAlignment.Center, DataValue.DataType.Date);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxOrganisationOpportunity.Column.ExpiresAt_DateTime:
-					SetOrganisationOpportunityColDfn(columnDfn, "Expires", 100, SaxDbDfn.ColumnIdx.OrganisationOpportunity_ExpiresAt, ColumnAlignment.Center, DataValue.DataType.DateTime);
+					SetOrganisationOpportunityColDfn(columnDfn, "Expires", 100, SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_ExpiresAt, ColumnAlignment.Center, DataValue.DataType.DateTime);
 					columnDfn.ReadOnly = true;
 					break;
 
@@ -353,27 +353,27 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				//-----------------------------------------------------------
 				// Common properties.
 				case SaxOrganisationOpportunity.Column.Notes:
-					SetOrganisationOpportunityColDfn(columnDfn, "Notes", 240, SaxDbDfn.ColumnIdx.OrganisationOpportunity_Notes);
+					SetOrganisationOpportunityColDfn(columnDfn, "Notes", 240, SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_Notes);
 					break;
 				case SaxOrganisationOpportunity.Column.Flags:
-					SetOrganisationOpportunityColDfn(columnDfn, "Flags", 60, SaxDbDfn.ColumnIdx.OrganisationOpportunity_Flags, ColumnAlignment.Center, DataValue.DataType.Long);
+					SetOrganisationOpportunityColDfn(columnDfn, "Flags", 60, SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_Flags, ColumnAlignment.Center, DataValue.DataType.Long);
 					break;
 				case SaxOrganisationOpportunity.Column.Status:
-					SetOrganisationOpportunityColDfn(columnDfn, "Status", 80, SaxDbDfn.ColumnIdx.OrganisationOpportunity_Status, ColumnAlignment.Center);
+					SetOrganisationOpportunityColDfn(columnDfn, "Status", 80, SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_Status, ColumnAlignment.Center);
 					break;
 				case SaxOrganisationOpportunity.Column.Status_Desc:
-					SetOrganisationOpportunityColDfn(columnDfn, "Status", 90, SaxDbDfn.ColumnIdx.OrganisationOpportunity_Status, ColumnAlignment.Center);
+					SetOrganisationOpportunityColDfn(columnDfn, "Status", 90, SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_Status, ColumnAlignment.Center);
 					break;
 				case SaxOrganisationOpportunity.Column.Status_Ind:
-					SetOrganisationOpportunityColDfn(columnDfn, "Status", 80, SaxDbDfn.ColumnIdx.OrganisationOpportunity_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
+					SetOrganisationOpportunityColDfn(columnDfn, "Status", 80, SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
 					columnDfn.TriStateFormat = ColumnTriStateFormat.Lights;
 					break;
 				case SaxOrganisationOpportunity.Column.CreateOn_Date:
-					SetOrganisationOpportunityColDfn(columnDfn, "Created", 80, SaxDbDfn.ColumnIdx.OrganisationOpportunity_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
+					SetOrganisationOpportunityColDfn(columnDfn, "Created", 80, SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxOrganisationOpportunity.Column.UpdateOn_Date:
-					SetOrganisationOpportunityColDfn(columnDfn, "Updated", 80, SaxDbDfn.ColumnIdx.OrganisationOpportunity_UpdateOn, ColumnAlignment.Center, DataValue.DataType.Date);
+					SetOrganisationOpportunityColDfn(columnDfn, "Updated", 80, SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_UpdateOn, ColumnAlignment.Center, DataValue.DataType.Date);
 					columnDfn.ReadOnly = true;
 					break;
 
@@ -395,10 +395,10 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			// Item Ids.
 			String idsIncluded = prm.IdsIncluded.Concat(",");
 			if (!idsIncluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.OrganisationOpportunity_Id, aliasOrganisationOpportunity) + " IN (" + idsIncluded + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_Id, aliasOrganisationOpportunity) + " IN (" + idsIncluded + ")");
 			String idsExcluded = prm.IdsExcluded.Concat(",");
 			if (!idsExcluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.OrganisationOpportunity_Id, aliasOrganisationOpportunity) + " NOT IN (" + idsExcluded + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_Id, aliasOrganisationOpportunity) + " NOT IN (" + idsExcluded + ")");
 
 			// User Account Ids.
 			String userAccountIdsIncluded = prm.UserAccountIdsIncluded.Concat(",");
@@ -408,44 +408,44 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				if (!StringUtil.IsEmpty(prm.Alias_UserOrganisation))
 				{
 					// Filter directly on the joined User Organisation table.
-					filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserOrganisation_UserAccountId, prm.Alias_UserOrganisation) + " IN (" + userAccountIdsIncluded + ")");
+					filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserOrganisation_UserAccountId, prm.Alias_UserOrganisation) + " IN (" + userAccountIdsIncluded + ")");
 				}
 				else
 				{
 					// User Organisation query.
 					String alias_UserOrganisation = aliasOrganisationOpportunity_Organisation_UserOrganisation;
 					DbQuery queryUserOrganisation = new DbQuery(CoreDatabase.DbmsType);
-					queryUserOrganisation.Tables.Add(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.UserOrganisation), alias_UserOrganisation);
-					queryUserOrganisation.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserOrganisation_UserAccountId, alias_UserOrganisation) + " IN (" + userAccountIdsIncluded + ")");
+					queryUserOrganisation.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.UserOrganisation), alias_UserOrganisation);
+					queryUserOrganisation.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserOrganisation_UserAccountId, alias_UserOrganisation) + " IN (" + userAccountIdsIncluded + ")");
 
 					// Filter Organisation directly against the Organisation Opportunity.
-					queryUserOrganisation.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.UserOrganisation_OrganisationId, alias_UserOrganisation));
-					filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.OrganisationOpportunity_OrganisationId, aliasOrganisationOpportunity) + " IN (" + queryUserOrganisation.BuildQuery() + ")");
+					queryUserOrganisation.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserOrganisation_OrganisationId, alias_UserOrganisation));
+					filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_OrganisationId, aliasOrganisationOpportunity) + " IN (" + queryUserOrganisation.BuildQuery() + ")");
 				}
 			}
 
 			// Organisation Ids.
 			String organisationIdsIncluded = prm.OrganisationIdsIncluded.Concat(",");
 			if (!organisationIdsIncluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.OrganisationOpportunity_OrganisationId, aliasOrganisationOpportunity) + " IN (" + organisationIdsIncluded + ")");
-
-			// Region Ids.
-			String regionIdsIncluded = prm.RegionIdsIncluded.Concat(",");
-			if (!regionIdsIncluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.OrganisationOpportunity_RegionIdPrimary, aliasOrganisationOpportunity) + " IN (" + regionIdsIncluded + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_OrganisationId, aliasOrganisationOpportunity) + " IN (" + organisationIdsIncluded + ")");
 
 			// Sport Ids.
 			String sportIdsIncluded = prm.SportIdsIncluded.Concat(",");
 			if (!sportIdsIncluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.OrganisationOpportunity_SportIdPrimary, aliasOrganisationOpportunity) + " IN (" + sportIdsIncluded + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_SportIdPrimary, aliasOrganisationOpportunity) + " IN (" + sportIdsIncluded + ")");
+
+			// Region Ids.
+			String regionIdsIncluded = prm.RegionIdsIncluded.Concat(",");
+			if (!regionIdsIncluded.IsEmpty())
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_RegionIdPrimary, aliasOrganisationOpportunity) + " IN (" + regionIdsIncluded + ")");
 
 			// Position.
 			if (!StringUtil.IsEmpty(prm.PositionPartial))
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.OrganisationOpportunity_Position, aliasOrganisationOpportunity) + " Like '%" + DbQuery.FormatForLike(prm.PositionPartial, true) + "%'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_Position, aliasOrganisationOpportunity) + " Like '%" + DbQuery.FormatForLike(prm.PositionPartial, true) + "%'");
 
 			// Outline.
 			if (!StringUtil.IsEmpty(prm.OutlinePartial))
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.OrganisationOpportunity_Outline, aliasOrganisationOpportunity) + " Like '%" + DbQuery.FormatForLike(prm.OutlinePartial, true) + "%'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_Outline, aliasOrganisationOpportunity) + " Like '%" + DbQuery.FormatForLike(prm.OutlinePartial, true) + "%'");
 
 			// Article.
 			if (!StringUtil.IsEmpty(prm.OpportunityFilter))
@@ -457,21 +457,21 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				foreach (String filterWord in filterWords)
 				{
 					List<String> articleFilter = new List<String>();
-					articleFilter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.OrganisationOpportunity_Position, aliasOrganisationOpportunity) + " Like '%" + DbQuery.FormatForLike(filterWord, true) + "%'");
-					articleFilter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.OrganisationOpportunity_Outline, aliasOrganisationOpportunity) + " Like '%" + DbQuery.FormatForLike(filterWord, true) + "%'");
+					articleFilter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_Position, aliasOrganisationOpportunity) + " Like '%" + DbQuery.FormatForLike(filterWord, true) + "%'");
+					articleFilter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_Outline, aliasOrganisationOpportunity) + " Like '%" + DbQuery.FormatForLike(filterWord, true) + "%'");
 					filter.Add(articleFilter.Concat(" OR ", "(", ")"));
 				}
 			}
 
 			// Notes.
 			if (!StringUtil.IsEmpty(prm.NotesPartial))
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.OrganisationOpportunity_Notes, aliasOrganisationOpportunity) + " LIKE '%" + DbQuery.FormatForLike(prm.NotesPartial) + "%'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_Notes, aliasOrganisationOpportunity) + " LIKE '%" + DbQuery.FormatForLike(prm.NotesPartial) + "%'");
 
 			// Status.
 			if (prm.StatusCat == SaxOrganisationOpportunity.StatusCat.ActiveOnly)
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.OrganisationOpportunity_Status, aliasOrganisationOpportunity) + "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_Status, aliasOrganisationOpportunity) + "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'");
 			else if (prm.StatusCat == SaxOrganisationOpportunity.StatusCat.NotDeleted)
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.OrganisationOpportunity_Status, aliasOrganisationOpportunity) + "!='" + SacsSystem.GetStatusCode(SaStatus.Deleted) + "'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_Status, aliasOrganisationOpportunity) + "!='" + SacsSystem.GetStatusCode(SaStatus.Deleted) + "'");
 
 			if (filter.Count < 1) filter.Add("1=1");
 			return filter;
@@ -485,9 +485,9 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			{
 				// Need to ensure correct alias used for OrganisationOpportunity columns in case of conflict.
 				String sortCol = String.Empty;
-				if (SaxDbDfn.GetTableForColumn((SaxDbDfn.ColumnIdx)columnDfn.DbColumn) == SaxDbDfn.TableIdx.OrganisationOpportunity)
+				if (SaxDbDfn_Core.GetTableForColumn((SaxDbDfn_Core.ColumnIdx)columnDfn.DbColumn) == SaxDbDfn_Core.TableIdx.OrganisationOpportunity)
 				{
-					sortCol = SaxDbDfn.GetColumnNameQual((SaxDbDfn.ColumnIdx)columnDfn.DbColumn, aliasOrganisationOpportunity);
+					sortCol = SaxDbDfn_Core.GetColumnNameQual((SaxDbDfn_Core.ColumnIdx)columnDfn.DbColumn, aliasOrganisationOpportunity);
 				}
 				else
 				{
@@ -505,7 +505,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			if (sortColumnNames.IsEmpty())
 			{
 				// Default sort columns.
-				sortColumnNames.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.OrganisationOpportunity_Id, aliasOrganisationOpportunity) + " ASC");
+				sortColumnNames.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_Id, aliasOrganisationOpportunity) + " ASC");
 			}
 			return sortColumnNames;
 		}
@@ -515,7 +515,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		private long GetOrganisationOpportunityCount(String filter)
 		{
 			ClearErrorState();
-			return CoreDatabase.GetRowCount(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.OrganisationOpportunity) + " As " + aliasOrganisationOpportunity, filter);
+			return CoreDatabase.GetRowCount(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.OrganisationOpportunity) + " As " + aliasOrganisationOpportunity, filter);
 		}
 		public override long GetOrganisationOpportunityCount(SaxOrganisationOpportunity.Params prm)
 		{
@@ -529,7 +529,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		{
 			List<SaxOrganisationOpportunity> userActivitys = new List<SaxOrganisationOpportunity>();
 			DbQuery qry = new DbQuery(CoreDatabase.DbmsType);
-			qry.Tables.Add(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.OrganisationOpportunity), aliasOrganisationOpportunity);
+			qry.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.OrganisationOpportunity), aliasOrganisationOpportunity);
 			OrganisationOpportunity_Db dbOrganisationOpportunity = new OrganisationOpportunity_Db(CoreDbInfo);
 			qry.Columns.AddRange(dbOrganisationOpportunity.ExistingColumnNames);
 			qry.Filters.AddRange(GetOrganisationOpportunityQueryFilter(prm));
@@ -554,7 +554,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				}
 				catch (Exception exc)
 				{
-					SaLogger.Warn(GetType().Name + ".GetOrganisationOpportunityList\n\tQuery: " + dbCommand.CommandText + "\n\t" + exc.GetType().Name + ": " + exc.Message);
+					SaLogger.Warn(GetType().Name + ".GetOrganisationOpportunityList\n\tQuery: " + dbCommand.CommandText + "\n\t" + ExceptionUtil.GetLogMessage(exc));
 				}
 			}
 			return userActivitys;
@@ -569,83 +569,83 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			//---------------------------------------------------------------------
 			// Construct query.
 			DbQuery query = new DbQuery(CoreDatabase.DbmsType);
-			query.Tables.Add(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.OrganisationOpportunity), aliasOrganisationOpportunity);
+			query.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.OrganisationOpportunity), aliasOrganisationOpportunity);
 
 			// Add columns as defined in query list.
 			if (columns.HasId(SaxOrganisationOpportunity.Column.Id))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.OrganisationOpportunity_Id, aliasOrganisationOpportunity));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_Id, aliasOrganisationOpportunity));
 			bool hasOrganisationCols = (columns.HasId(SaxOrganisationOpportunity.Column.Organisation_Name));
 			if (columns.HasId(SaxOrganisationOpportunity.Column.OrganisationId) || hasOrganisationCols)
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.OrganisationOpportunity_OrganisationId, aliasOrganisationOpportunity));
-			bool hasRegionCols = (columns.HasId(SaxOrganisationOpportunity.Column.Region_Name));
-			if (columns.HasId(SaxOrganisationOpportunity.Column.RegionIdPrimary) || hasRegionCols)
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.OrganisationOpportunity_RegionIdPrimary, aliasOrganisationOpportunity));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_OrganisationId, aliasOrganisationOpportunity));
 			bool hasSportCols = (columns.HasId(SaxOrganisationOpportunity.Column.Sport_Name));
 			if (columns.HasId(SaxOrganisationOpportunity.Column.SportIdPrimary) || hasSportCols)
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.OrganisationOpportunity_SportIdPrimary, aliasOrganisationOpportunity));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_SportIdPrimary, aliasOrganisationOpportunity));
+			bool hasRegionCols = (columns.HasId(SaxOrganisationOpportunity.Column.Region_Name));
+			if (columns.HasId(SaxOrganisationOpportunity.Column.RegionIdPrimary) || hasRegionCols)
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_RegionIdPrimary, aliasOrganisationOpportunity));
 			if (columns.HasId(SaxOrganisationOpportunity.Column.OpportunityTypeCode) || columns.HasId(SaxOrganisationOpportunity.Column.OpportunityType_Desc))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.OrganisationOpportunity_OpportunityTypeCode, aliasOrganisationOpportunity));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_OpportunityTypeCode, aliasOrganisationOpportunity));
 			if (columns.HasId(SaxOrganisationOpportunity.Column.Position))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.OrganisationOpportunity_Position, aliasOrganisationOpportunity));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_Position, aliasOrganisationOpportunity));
 			if (columns.HasId(SaxOrganisationOpportunity.Column.Outline))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.OrganisationOpportunity_Outline, aliasOrganisationOpportunity));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_Outline, aliasOrganisationOpportunity));
 			if (columns.HasId(SaxOrganisationOpportunity.Column.PublishedAt_Date) || columns.HasId(SaxOrganisationOpportunity.Column.PublishedAt_DateTime))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.OrganisationOpportunity_PublishedAt, aliasOrganisationOpportunity));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_PublishedAt, aliasOrganisationOpportunity));
 			if (columns.HasId(SaxOrganisationOpportunity.Column.ExpiresAt_Date) || columns.HasId(SaxOrganisationOpportunity.Column.ExpiresAt_DateTime))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.OrganisationOpportunity_ExpiresAt, aliasOrganisationOpportunity));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_ExpiresAt, aliasOrganisationOpportunity));
 			// Common properties.
 			if (columns.HasId(SaxOrganisationOpportunity.Column.Notes))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.OrganisationOpportunity_Notes, aliasOrganisationOpportunity));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_Notes, aliasOrganisationOpportunity));
 			if (columns.HasId(SaxOrganisationOpportunity.Column.Flags))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.OrganisationOpportunity_Flags, aliasOrganisationOpportunity));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_Flags, aliasOrganisationOpportunity));
 			if (columns.HasId(SaxOrganisationOpportunity.Column.Status) || columns.HasId(SaxOrganisationOpportunity.Column.Status_Desc) || columns.HasId(SaxOrganisationOpportunity.Column.Status_Ind))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.OrganisationOpportunity_Status, aliasOrganisationOpportunity));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_Status, aliasOrganisationOpportunity));
 			if (columns.HasId(SaxOrganisationOpportunity.Column.CreateOn_Date))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.OrganisationOpportunity_CreateOn, aliasOrganisationOpportunity));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_CreateOn, aliasOrganisationOpportunity));
 			if (columns.HasId(SaxOrganisationOpportunity.Column.UpdateOn_Date))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.OrganisationOpportunity_UpdateOn, aliasOrganisationOpportunity));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_UpdateOn, aliasOrganisationOpportunity));
 
 			//---------------------------------------------------------------------
 			// Organisation.
 			if (hasOrganisationCols)
 			{
 				DbQueryJoin joinOrganisation = new DbQueryJoin(DbJoinType.LeftOuter);
-				joinOrganisation.Table = new StringPair(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.Organisation), aliasOrganisationOpportunity_Organisation);
-				joinOrganisation.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Organisation_Id, aliasOrganisationOpportunity_Organisation) + "=" + SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.OrganisationOpportunity_OrganisationId, aliasOrganisationOpportunity));
+				joinOrganisation.Table = new StringPair(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Organisation), aliasOrganisationOpportunity_Organisation);
+				joinOrganisation.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_Id, aliasOrganisationOpportunity_Organisation) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_OrganisationId, aliasOrganisationOpportunity));
 				query.Joins.Add(joinOrganisation);
-				List<SaxDbDfn.ColumnIdx> cols = new List<SaxDbDfn.ColumnIdx>();
-				cols.Add(SaxDbDfn.ColumnIdx.Organisation_Name);
+				List<SaxDbDfn_Core.ColumnIdx> cols = new List<SaxDbDfn_Core.ColumnIdx>();
+				cols.Add(SaxDbDfn_Core.ColumnIdx.Organisation_Name);
 				foreach (var col in cols)
-					query.Columns.Add(SaxDbDfn.GetColumnNameQual(col, aliasOrganisationOpportunity_Organisation), prefixOrganisationOpportunity_Organisation + SaxDbDfn.GetColumnName(col, false));
+					query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(col, aliasOrganisationOpportunity_Organisation), prefixOrganisationOpportunity_Organisation + SaxDbDfn_Core.GetColumnName(col, false));
 				prm.Alias_Organisation = aliasOrganisationOpportunity_Organisation;
 			}
 
-			//---------------------------------------------------------------------
-			// Primary Region.
-			if (hasRegionCols)
-			{
-				DbQueryJoin joinRegion = new DbQueryJoin(DbJoinType.LeftOuter);
-				joinRegion.Table = new StringPair(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.Region), aliasOrganisationOpportunity_Region);
-				joinRegion.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_Id, aliasOrganisationOpportunity_Region) + "=" + SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.OrganisationOpportunity_RegionIdPrimary, aliasOrganisationOpportunity));
-				query.Joins.Add(joinRegion);
-				List<SaxDbDfn.ColumnIdx> cols = new List<SaxDbDfn.ColumnIdx>();
-				cols.Add(SaxDbDfn.ColumnIdx.Region_Name);
-				foreach (var col in cols)
-					query.Columns.Add(SaxDbDfn.GetColumnNameQual(col, aliasOrganisationOpportunity_Region), prefixOrganisationOpportunity_Region + SaxDbDfn.GetColumnName(col, false));
-			}
-
 			//---------------------------------------------------------------------
 			// Primary Sport.
 			if (hasSportCols)
 			{
 				DbQueryJoin joinSport = new DbQueryJoin(DbJoinType.LeftOuter);
-				joinSport.Table = new StringPair(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.Sport), aliasOrganisationOpportunity_Sport);
-				joinSport.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Sport_Id, aliasOrganisationOpportunity_Sport) + "=" + SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.OrganisationOpportunity_SportIdPrimary, aliasOrganisationOpportunity));
+				joinSport.Table = new StringPair(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Sport), aliasOrganisationOpportunity_Sport);
+				joinSport.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Sport_Id, aliasOrganisationOpportunity_Sport) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_SportIdPrimary, aliasOrganisationOpportunity));
 				query.Joins.Add(joinSport);
-				List<SaxDbDfn.ColumnIdx> cols = new List<SaxDbDfn.ColumnIdx>();
-				cols.Add(SaxDbDfn.ColumnIdx.Sport_Name);
+				List<SaxDbDfn_Core.ColumnIdx> cols = new List<SaxDbDfn_Core.ColumnIdx>();
+				cols.Add(SaxDbDfn_Core.ColumnIdx.Sport_Name);
 				foreach (var col in cols)
-					query.Columns.Add(SaxDbDfn.GetColumnNameQual(col, aliasOrganisationOpportunity_Sport), prefixOrganisationOpportunity_Sport + SaxDbDfn.GetColumnName(col, false));
+					query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(col, aliasOrganisationOpportunity_Sport), prefixOrganisationOpportunity_Sport + SaxDbDfn_Core.GetColumnName(col, false));
+			}
+
+			//---------------------------------------------------------------------
+			// Primary Region.
+			if (hasRegionCols)
+			{
+				DbQueryJoin joinRegion = new DbQueryJoin(DbJoinType.LeftOuter);
+				joinRegion.Table = new StringPair(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Region), aliasOrganisationOpportunity_Region);
+				joinRegion.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_Id, aliasOrganisationOpportunity_Region) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.OrganisationOpportunity_RegionIdPrimary, aliasOrganisationOpportunity));
+				query.Joins.Add(joinRegion);
+				List<SaxDbDfn_Core.ColumnIdx> cols = new List<SaxDbDfn_Core.ColumnIdx>();
+				cols.Add(SaxDbDfn_Core.ColumnIdx.Region_Name);
+				foreach (var col in cols)
+					query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(col, aliasOrganisationOpportunity_Region), prefixOrganisationOpportunity_Region + SaxDbDfn_Core.GetColumnName(col, false));
 			}
 
 			//---------------------------------------------------------------------

SaxoniteStandardDbas/Dbas/Mgr/SaxActivityMgr_Dbas.cs

@@ -16,7 +16,8 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 
 		//-------------------------------------------------------------------
 		// Construction.
-		public SaxActivityMgr_Dbas(SaxSessionContext sessionContext) : base (sessionContext)
+		public SaxActivityMgr_Dbas(SaxSessionContext sessionContext, SaxInternals internals) :
+			base(sessionContext, internals)
 		{
 		}
 

SaxoniteStandardDbas/Dbas/Mgr/SaxItemDataMgr_Dbas-ItemSport.cs

@@ -44,7 +44,8 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		private SaxItemSport_Dbas CreateItemSport(ItemSport_Db dbItemSport)
 		{
 			ClearErrorState();
-			SaxItemSport_Dbas itemSport = new SaxItemSport_Dbas(CoreDatabase, new SysId(dbItemSport._Id), new ItemId(dbItemSport._ItemType, new SysId(dbItemSport._ItemId)), new SysId(dbItemSport._SportId), (ushort)dbItemSport._Flags);
+			ItemId itemId = new ItemId(dbItemSport._ItemType, new SysId(dbItemSport._ItemId));
+			SaxItemSport_Dbas itemSport = new SaxItemSport_Dbas(CoreDatabase, new SysId(dbItemSport._Id), itemId, new SysId(dbItemSport._SportId), (ushort)dbItemSport._Flags);
 			PopulateFrom(dbItemSport, itemSport);
 			return itemSport;
 		}
@@ -81,7 +82,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				catch (Exception exc)
 				{
 					SetErrorState("Database query exception");
-					SaLogger.Warn(GetType().Name + ".GetItemSport\n\tQuery: " + dbCommand.CommandText + "\n\t" + exc.GetType().Name + ": " + exc.Message);
+					SaLogger.Warn(GetType().Name + ".GetItemSport\n\tQuery: " + dbCommand.CommandText + "\n\t" + ExceptionUtil.GetLogMessage(exc));
 				}
 			}
 			return itemSport;
@@ -188,7 +189,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 					dbItemSport.PopulateFrom(dbCommand, aliasItemSport, "Id=" + itemSport.Id.ToString());
 					// Delete itemSport.
 					dbCommand.CommandType = System.Data.CommandType.Text;
-					dbCommand.CommandText = "DELETE FROM " + SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.ItemSport) + " WHERE Id=" + SysId.ToString(itemSport.Id) + ";";
+					dbCommand.CommandText = "DELETE FROM " + SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.ItemSport) + " WHERE Id=" + SysId.ToString(itemSport.Id) + ";";
 					dbCommand.ExecuteNonQuery();
 					itemSport.Changed = false;
 					if (DebugMode) SaLogger.Debug(fn + " Deleted. " + GetLogProperties(itemSport).Concat(": ").Concat("", "\n\t"));
@@ -239,17 +240,17 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		// Item column definitions.
 		private static readonly String aliasItemSport = "ItmSpt";
 		private static readonly String aliasItemSport_Sport = "ItmSpt_Spt";
-		private static readonly String prefixItemSport_Sport= "ItmSpt_Spt_";
+		private static readonly String prefixItemSport_Sport = "ItmSpt_Spt_";
 		private void SetItemSportColDfn
-			(ColumnDfn col, String caption, int width, SaxDbDfn.ColumnIdx dbCol,
+			(ColumnDfn col, String caption, int width, SaxDbDfn_Core.ColumnIdx dbCol,
 			ColumnAlignment align = ColumnAlignment.Default, DataValue.DataType dataType = DataValue.DataType.String,
 			String alias = "", String prefix = "")
 		{
-			if (String.IsNullOrEmpty(alias) && SaxDbDfn.GetTableForColumn(dbCol) == SaxDbDfn.TableIdx.ItemSport)
+			if (String.IsNullOrEmpty(alias) && SaxDbDfn_Core.GetTableForColumn(dbCol) == SaxDbDfn_Core.TableIdx.ItemSport)
 				alias = aliasItemSport;
-			col.Set(caption, width, (int)dbCol, prefix + SaxDbDfn.GetColumnName(dbCol, false), SaxDbDfn.GetColumnNameQual(dbCol, alias), dataType, align);
-			if (dataType == DataValue.DataType.String && dbCol != SaxDbDfn.ColumnIdx.Unknown)
-				col.MaxLength = (int)SaxDbDfn.GetColTextLen(dbCol);
+			col.Set(caption, width, (int)dbCol, prefix + SaxDbDfn_Core.GetColumnName(dbCol, false), SaxDbDfn_Core.GetColumnNameQual(dbCol, alias), dataType, align);
+			if (dataType == DataValue.DataType.String && dbCol != SaxDbDfn_Core.ColumnIdx.Unknown)
+				col.MaxLength = (int)SaxDbDfn_Core.GetColTextLen(dbCol);
 		}
 		public override ColumnDfn GetItemSportColumnDfn(SaxItemSport.Column columnId, string caption = "", int width = 0)
 		{
@@ -258,40 +259,40 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			{
 				//-----------------------------------------------------------
 				case SaxItemSport.Column.Pos:
-					SetItemSportColDfn(columnDfn, "Pos", 60, SaxDbDfn.ColumnIdx.Unknown, ColumnAlignment.Right);
+					SetItemSportColDfn(columnDfn, "Pos", 60, SaxDbDfn_Core.ColumnIdx.Unknown, ColumnAlignment.Right);
 					columnDfn.SortMode = ColumnDfn.ColumnSortMode.Off;
 					columnDfn.ReadOnly = true;
 					columnDfn.Resizable = false;
 					break;
 				case SaxItemSport.Column.Id:
-					SetItemSportColDfn(columnDfn, "Id", 80, SaxDbDfn.ColumnIdx.ItemSport_Id, ColumnAlignment.Right, DataValue.DataType.Long);
+					SetItemSportColDfn(columnDfn, "Id", 80, SaxDbDfn_Core.ColumnIdx.ItemSport_Id, ColumnAlignment.Right, DataValue.DataType.Long);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxItemSport.Column.ItemType:
-					SetItemSportColDfn(columnDfn, "Item type", 80, SaxDbDfn.ColumnIdx.ItemSport_ItemType, ColumnAlignment.Center, DataValue.DataType.Long);
+					SetItemSportColDfn(columnDfn, "Item type", 80, SaxDbDfn_Core.ColumnIdx.ItemSport_ItemType, ColumnAlignment.Center, DataValue.DataType.Long);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxItemSport.Column.ItemType_Code:
-					SetItemSportColDfn(columnDfn, "Item type", 80, SaxDbDfn.ColumnIdx.ItemSport_ItemType, ColumnAlignment.Center);
+					SetItemSportColDfn(columnDfn, "Item type", 80, SaxDbDfn_Core.ColumnIdx.ItemSport_ItemType, ColumnAlignment.Center);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxItemSport.Column.ItemType_Desc:
-					SetItemSportColDfn(columnDfn, "Item type", 80, SaxDbDfn.ColumnIdx.ItemSport_ItemType, ColumnAlignment.Center);
+					SetItemSportColDfn(columnDfn, "Item type", 80, SaxDbDfn_Core.ColumnIdx.ItemSport_ItemType, ColumnAlignment.Center);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxItemSport.Column.ItemId:
-					SetItemSportColDfn(columnDfn, "Item Id", 80, SaxDbDfn.ColumnIdx.ItemSport_ItemId, ColumnAlignment.Right, DataValue.DataType.Long);
+					SetItemSportColDfn(columnDfn, "Item Id", 80, SaxDbDfn_Core.ColumnIdx.ItemSport_ItemId, ColumnAlignment.Right, DataValue.DataType.Long);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxItemSport.Column.SportId:
-					SetItemSportColDfn(columnDfn, "Sport Id", 80, SaxDbDfn.ColumnIdx.ItemSport_SportId, ColumnAlignment.Right, DataValue.DataType.Long);
+					SetItemSportColDfn(columnDfn, "Sport Id", 80, SaxDbDfn_Core.ColumnIdx.ItemSport_SportId, ColumnAlignment.Right, DataValue.DataType.Long);
 					columnDfn.ReadOnly = true;
 					break;
 
 				//-----------------------------------------------------------
 				// Sport properties.
 				case SaxItemSport.Column.Sport_Name:
-					SetItemSportColDfn(columnDfn, "Sport", 120, SaxDbDfn.ColumnIdx.Sport_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasItemSport_Sport, prefixItemSport_Sport);
+					SetItemSportColDfn(columnDfn, "Sport", 120, SaxDbDfn_Core.ColumnIdx.Sport_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasItemSport_Sport, prefixItemSport_Sport);
 					columnDfn.ReadOnly = true;
 					break;
 
@@ -301,27 +302,27 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				//-----------------------------------------------------------
 				// Common properties.
 				case SaxItemSport.Column.Notes:
-					SetItemSportColDfn(columnDfn, "Notes", 240, SaxDbDfn.ColumnIdx.ItemSport_Notes);
+					SetItemSportColDfn(columnDfn, "Notes", 240, SaxDbDfn_Core.ColumnIdx.ItemSport_Notes);
 					break;
 				case SaxItemSport.Column.Flags:
-					SetItemSportColDfn(columnDfn, "Flags", 60, SaxDbDfn.ColumnIdx.ItemSport_Flags, ColumnAlignment.Center, DataValue.DataType.Long);
+					SetItemSportColDfn(columnDfn, "Flags", 60, SaxDbDfn_Core.ColumnIdx.ItemSport_Flags, ColumnAlignment.Center, DataValue.DataType.Long);
 					break;
 				case SaxItemSport.Column.Status:
-					SetItemSportColDfn(columnDfn, "Status", 80, SaxDbDfn.ColumnIdx.ItemSport_Status, ColumnAlignment.Center);
+					SetItemSportColDfn(columnDfn, "Status", 80, SaxDbDfn_Core.ColumnIdx.ItemSport_Status, ColumnAlignment.Center);
 					break;
 				case SaxItemSport.Column.Status_Desc:
-					SetItemSportColDfn(columnDfn, "Status", 90, SaxDbDfn.ColumnIdx.ItemSport_Status, ColumnAlignment.Center);
+					SetItemSportColDfn(columnDfn, "Status", 90, SaxDbDfn_Core.ColumnIdx.ItemSport_Status, ColumnAlignment.Center);
 					break;
 				case SaxItemSport.Column.Status_Ind:
-					SetItemSportColDfn(columnDfn, "Status", 80, SaxDbDfn.ColumnIdx.ItemSport_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
+					SetItemSportColDfn(columnDfn, "Status", 80, SaxDbDfn_Core.ColumnIdx.ItemSport_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
 					columnDfn.TriStateFormat = ColumnTriStateFormat.Lights;
 					break;
 				case SaxItemSport.Column.CreateOn_Date:
-					SetItemSportColDfn(columnDfn, "Created", 80, SaxDbDfn.ColumnIdx.ItemSport_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
+					SetItemSportColDfn(columnDfn, "Created", 80, SaxDbDfn_Core.ColumnIdx.ItemSport_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxItemSport.Column.UpdateOn_Date:
-					SetItemSportColDfn(columnDfn, "Updated", 80, SaxDbDfn.ColumnIdx.ItemSport_UpdateOn, ColumnAlignment.Center, DataValue.DataType.Date);
+					SetItemSportColDfn(columnDfn, "Updated", 80, SaxDbDfn_Core.ColumnIdx.ItemSport_UpdateOn, ColumnAlignment.Center, DataValue.DataType.Date);
 					columnDfn.ReadOnly = true;
 					break;
 					//-----------------------------------------------------------
@@ -342,10 +343,10 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			// Item Ids.
 			String idsIncluded = prm.IdsIncluded.Concat(",");
 			if (!idsIncluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.ItemSport_Id, aliasItemSport) + " IN (" + idsIncluded + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_Id, aliasItemSport) + " IN (" + idsIncluded + ")");
 			String idsExcluded = prm.IdsExcluded.Concat(",");
 			if (!idsExcluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.ItemSport_Id, aliasItemSport) + " NOT IN (" + idsExcluded + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_Id, aliasItemSport) + " NOT IN (" + idsExcluded + ")");
 
 			// Item Ids.
 			if (!prm.ItemIdsIncluded.IsEmpty())
@@ -354,8 +355,10 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				foreach (ItemId itemId in prm.ItemIdsIncluded)
 				{
 					if (!ItemId.IsValid(itemId)) continue;
-					itemIdFilters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.ItemSport_ItemType, aliasItemSport) + "=" + itemId.Type);
-					itemIdFilters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.ItemSport_ItemId, aliasItemSport) + "=" + SysId.ToInt(itemId.Id));
+					String itemIdFilter =
+						SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_ItemType, aliasItemSport) + "=" + itemId.Type +
+						" AND " + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_ItemId, aliasItemSport) + "=" + SysId.ToInt(itemId.Id);
+					itemIdFilters.Add(itemIdFilter);
 				}
 				if (!itemIdFilters.IsEmpty())
 					filter.Add(itemIdFilters.Concat(" OR ", "(", ")"));
@@ -364,17 +367,17 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			// Sport Ids.
 			String sportIdsIncluded = prm.SportIdsIncluded.Concat(",");
 			if (!sportIdsIncluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.ItemSport_SportId, aliasItemSport) + " IN (" + sportIdsIncluded + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_SportId, aliasItemSport) + " IN (" + sportIdsIncluded + ")");
 
 			// Notes.
 			if (!StringUtil.IsEmpty(prm.NotesPartial))
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.ItemSport_Notes, aliasItemSport) + " LIKE '%" + DbQuery.FormatForLike(prm.NotesPartial) + "%'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_Notes, aliasItemSport) + " LIKE '%" + DbQuery.FormatForLike(prm.NotesPartial) + "%'");
 
 			// Status.
 			if (prm.StatusCat == SaxItemSport.StatusCat.ActiveOnly)
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.ItemSport_Status, aliasItemSport) + "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_Status, aliasItemSport) + "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'");
 			else if (prm.StatusCat == SaxItemSport.StatusCat.NotDeleted)
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.ItemSport_Status, aliasItemSport) + "!='" + SacsSystem.GetStatusCode(SaStatus.Deleted) + "'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_Status, aliasItemSport) + "!='" + SacsSystem.GetStatusCode(SaStatus.Deleted) + "'");
 
 			if (filter.Count < 1) filter.Add("1=1");
 			return filter;
@@ -388,9 +391,9 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			{
 				// Need to ensure correct alias used for ItemSport columns in case of conflict.
 				String sortCol = String.Empty;
-				if (SaxDbDfn.GetTableForColumn((SaxDbDfn.ColumnIdx)columnDfn.DbColumn) == SaxDbDfn.TableIdx.ItemSport)
+				if (SaxDbDfn_Core.GetTableForColumn((SaxDbDfn_Core.ColumnIdx)columnDfn.DbColumn) == SaxDbDfn_Core.TableIdx.ItemSport)
 				{
-					sortCol = SaxDbDfn.GetColumnNameQual((SaxDbDfn.ColumnIdx)columnDfn.DbColumn, aliasItemSport);
+					sortCol = SaxDbDfn_Core.GetColumnNameQual((SaxDbDfn_Core.ColumnIdx)columnDfn.DbColumn, aliasItemSport);
 				}
 				else
 				{
@@ -408,7 +411,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			if (sortColumnNames.IsEmpty())
 			{
 				// Default sort columns.
-				sortColumnNames.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.ItemSport_Id, aliasItemSport) + " ASC");
+				sortColumnNames.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_Id, aliasItemSport) + " ASC");
 			}
 			return sortColumnNames;
 		}
@@ -418,7 +421,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		private long GetItemSportCount(String filter)
 		{
 			ClearErrorState();
-			return CoreDatabase.GetRowCount(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.ItemSport) + " As " + aliasItemSport, filter);
+			return CoreDatabase.GetRowCount(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.ItemSport) + " As " + aliasItemSport, filter);
 		}
 		public override long GetItemSportCount(SaxItemSport.Params prm)
 		{
@@ -432,7 +435,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		{
 			List<SaxItemSport> itemSports = new List<SaxItemSport>();
 			DbQuery qry = new DbQuery(CoreDatabase.DbmsType);
-			qry.Tables.Add(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.ItemSport), aliasItemSport);
+			qry.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.ItemSport), aliasItemSport);
 			ItemSport_Db dbItemSport = new ItemSport_Db(CoreDbInfo);
 			qry.Columns.AddRange(dbItemSport.ExistingColumnNames);
 			qry.Filters.AddRange(GetItemSportQueryFilter(prm));
@@ -457,7 +460,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				}
 				catch (Exception exc)
 				{
-					SaLogger.Warn(GetType().Name + ".GetItemSportList\n\tQuery: " + dbCommand.CommandText + "\n\t" + exc.GetType().Name + ": " + exc.Message);
+					SaLogger.Warn(GetType().Name + ".GetItemSportList\n\tQuery: " + dbCommand.CommandText + "\n\t" + ExceptionUtil.GetLogMessage(exc));
 				}
 			}
 			return itemSports;
@@ -472,42 +475,42 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			//---------------------------------------------------------------------
 			// Construct query.
 			DbQuery query = new DbQuery(CoreDatabase.DbmsType);
-			query.Tables.Add(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.ItemSport), aliasItemSport);
+			query.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.ItemSport), aliasItemSport);
 
 			// Add columns as defined in query list.
 			if (columns.HasId(SaxItemSport.Column.Id))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.ItemSport_Id, aliasItemSport));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_Id, aliasItemSport));
 			if (columns.HasId(SaxItemSport.Column.ItemType) || columns.HasId(SaxItemSport.Column.ItemType_Code) || columns.HasId(SaxItemSport.Column.ItemType_Desc))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.ItemSport_ItemType, aliasItemSport));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_ItemType, aliasItemSport));
 			if (columns.HasId(SaxItemSport.Column.ItemId))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.ItemSport_ItemId, aliasItemSport));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_ItemId, aliasItemSport));
 			bool hasSportCols = (columns.HasId(SaxItemSport.Column.Sport_Name));
 			if (columns.HasId(SaxItemSport.Column.SportId) || hasSportCols)
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.ItemSport_SportId, aliasItemSport));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_SportId, aliasItemSport));
 			// Common properties.
 			if (columns.HasId(SaxItemSport.Column.Notes))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.ItemSport_Notes, aliasItemSport));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_Notes, aliasItemSport));
 			if (columns.HasId(SaxItemSport.Column.Flags))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.ItemSport_Flags, aliasItemSport));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_Flags, aliasItemSport));
 			if (columns.HasId(SaxItemSport.Column.Status) || columns.HasId(SaxItemSport.Column.Status_Desc) || columns.HasId(SaxItemSport.Column.Status_Ind))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.ItemSport_Status, aliasItemSport));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_Status, aliasItemSport));
 			if (columns.HasId(SaxItemSport.Column.CreateOn_Date))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.ItemSport_CreateOn, aliasItemSport));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_CreateOn, aliasItemSport));
 			if (columns.HasId(SaxItemSport.Column.UpdateOn_Date))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.ItemSport_UpdateOn, aliasItemSport));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_UpdateOn, aliasItemSport));
 
 			//---------------------------------------------------------------------
 			// Sport.
 			if (hasSportCols)
 			{
 				DbQueryJoin joinSport = new DbQueryJoin(DbJoinType.LeftOuter);
-				joinSport.Table = new StringPair(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.Sport), aliasItemSport_Sport);
-				joinSport.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Sport_Id, aliasItemSport_Sport) + "=" + SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.ItemSport_SportId, aliasItemSport));
+				joinSport.Table = new StringPair(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Sport), aliasItemSport_Sport);
+				joinSport.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Sport_Id, aliasItemSport_Sport) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_SportId, aliasItemSport));
 				query.Joins.Add(joinSport);
-				List<SaxDbDfn.ColumnIdx> cols = new List<SaxDbDfn.ColumnIdx>();
-				cols.Add(SaxDbDfn.ColumnIdx.Sport_Name);
+				List<SaxDbDfn_Core.ColumnIdx> cols = new List<SaxDbDfn_Core.ColumnIdx>();
+				cols.Add(SaxDbDfn_Core.ColumnIdx.Sport_Name);
 				foreach (var col in cols)
-					query.Columns.Add(SaxDbDfn.GetColumnNameQual(col, aliasItemSport_Sport), prefixItemSport_Sport + SaxDbDfn.GetColumnName(col, false));
+					query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(col, aliasItemSport_Sport), prefixItemSport_Sport + SaxDbDfn_Core.GetColumnName(col, false));
 			}
 
 			//---------------------------------------------------------------------

SaxoniteStandardDbas/Dbas/Mgr/SaxItemDataMgr_Dbas.cs

@@ -14,7 +14,8 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 
 		//-------------------------------------------------------------------
 		// Construction.
-		public SaxItemDataMgr_Dbas(SaxSessionContext sessionContext) : base(sessionContext)
+		public SaxItemDataMgr_Dbas(SaxSessionContext sessionContext, SaxInternals internals) :
+			base(sessionContext, internals)
 		{
 		}
 

SaxoniteStandardDbas/Dbas/Mgr/SaxReferenceMgr_Dbas-Region.cs

@@ -82,7 +82,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				catch (Exception exc)
 				{
 					SetErrorState("Database query exception");
-					SaLogger.Warn(GetType().Name + ".GetRegion\n\tQuery: " + dbCommand.CommandText + "\n\t" + exc.GetType().Name + ": " + exc.Message);
+					SaLogger.Warn(GetType().Name + ".GetRegion\n\tQuery: " + dbCommand.CommandText + "\n\t" + ExceptionUtil.GetLogMessage(exc));
 				}
 			}
 			return region;
@@ -189,7 +189,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 					dbRegion.PopulateFrom(dbCommand, aliasRegion, "Id=" + region.Id.ToString());
 					// Delete region.
 					dbCommand.CommandType = System.Data.CommandType.Text;
-					dbCommand.CommandText = "DELETE FROM " + SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.Region) + " WHERE Id=" + SysId.ToString(region.Id) + ";";
+					dbCommand.CommandText = "DELETE FROM " + SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Region) + " WHERE Id=" + SysId.ToString(region.Id) + ";";
 					dbCommand.ExecuteNonQuery();
 					region.Changed = false;
 					if (DebugMode) SaLogger.Debug(fn + " Deleted. " + GetLogProperties(region).Concat(": ").Concat("", "\n\t"));
@@ -246,15 +246,15 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		private static readonly String prefixRegion_Parent = "PrtRgn_";
 		private static readonly String colRegion_ChildRegion_Count = "Rgn_ChildRegionCount";
 		private void SetRegionColDfn
-			(ColumnDfn col, String caption, int width, SaxDbDfn.ColumnIdx dbCol,
+			(ColumnDfn col, String caption, int width, SaxDbDfn_Core.ColumnIdx dbCol,
 			ColumnAlignment align = ColumnAlignment.Default, DataValue.DataType dataType = DataValue.DataType.String,
 			String alias = "", String prefix = "")
 		{
-			if (String.IsNullOrEmpty(alias) && SaxDbDfn.GetTableForColumn(dbCol) == SaxDbDfn.TableIdx.Region)
+			if (String.IsNullOrEmpty(alias) && SaxDbDfn_Core.GetTableForColumn(dbCol) == SaxDbDfn_Core.TableIdx.Region)
 				alias = aliasRegion;
-			col.Set(caption, width, (int)dbCol, prefix + SaxDbDfn.GetColumnName(dbCol, false), SaxDbDfn.GetColumnNameQual(dbCol, alias), dataType, align);
-			if (dataType == DataValue.DataType.String && dbCol != SaxDbDfn.ColumnIdx.Unknown)
-				col.MaxLength = (int)SaxDbDfn.GetColTextLen(dbCol);
+			col.Set(caption, width, (int)dbCol, prefix + SaxDbDfn_Core.GetColumnName(dbCol, false), SaxDbDfn_Core.GetColumnNameQual(dbCol, alias), dataType, align);
+			if (dataType == DataValue.DataType.String && dbCol != SaxDbDfn_Core.ColumnIdx.Unknown)
+				col.MaxLength = (int)SaxDbDfn_Core.GetColTextLen(dbCol);
 		}
 		public override ColumnDfn GetRegionColumnDfn(SaxRegion.Column columnId, string caption = "", int width = 0)
 		{
@@ -263,50 +263,50 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			{
 				//-----------------------------------------------------------
 				case SaxRegion.Column.Pos:
-					SetRegionColDfn(columnDfn, "Pos", 60, SaxDbDfn.ColumnIdx.Unknown, ColumnAlignment.Right);
+					SetRegionColDfn(columnDfn, "Pos", 60, SaxDbDfn_Core.ColumnIdx.Unknown, ColumnAlignment.Right);
 					columnDfn.SortMode = ColumnDfn.ColumnSortMode.Off;
 					columnDfn.ReadOnly = true;
 					columnDfn.Resizable = false;
 					break;
 				case SaxRegion.Column.Id:
-					SetRegionColDfn(columnDfn, "Id", 80, SaxDbDfn.ColumnIdx.Region_Id, ColumnAlignment.Right, DataValue.DataType.Long);
+					SetRegionColDfn(columnDfn, "Id", 80, SaxDbDfn_Core.ColumnIdx.Region_Id, ColumnAlignment.Right, DataValue.DataType.Long);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxRegion.Column.RegionType:
-					SetRegionColDfn(columnDfn, "Type", 80, SaxDbDfn.ColumnIdx.Region_RegionType, ColumnAlignment.Center, DataValue.DataType.Long);
+					SetRegionColDfn(columnDfn, "Type", 80, SaxDbDfn_Core.ColumnIdx.Region_RegionType, ColumnAlignment.Center, DataValue.DataType.Long);
 					break;
 				case SaxRegion.Column.RegionType_Desc:
-					SetRegionColDfn(columnDfn, "Type", 100, SaxDbDfn.ColumnIdx.Region_RegionType, ColumnAlignment.Center, DataValue.DataType.String);
+					SetRegionColDfn(columnDfn, "Type", 100, SaxDbDfn_Core.ColumnIdx.Region_RegionType, ColumnAlignment.Center, DataValue.DataType.String);
 					break;
 				case SaxRegion.Column.CountryIso2Code:
-					SetRegionColDfn(columnDfn, "ISO2", 60, SaxDbDfn.ColumnIdx.Region_CountryIso2Code, ColumnAlignment.Center);
+					SetRegionColDfn(columnDfn, "ISO2", 60, SaxDbDfn_Core.ColumnIdx.Region_CountryIso2Code, ColumnAlignment.Center);
 					break;
 				case SaxRegion.Column.Name:
-					SetRegionColDfn(columnDfn, "Name", 120, SaxDbDfn.ColumnIdx.Region_Name);
+					SetRegionColDfn(columnDfn, "Name", 120, SaxDbDfn_Core.ColumnIdx.Region_Name);
 					break;
 
 				//-----------------------------------------------------------
 				// Parent Region.
 				case SaxRegion.Column.RegionIdParent:
-					SetRegionColDfn(columnDfn, "Parent Id", 80, SaxDbDfn.ColumnIdx.Region_RegionIdParent, ColumnAlignment.Right, DataValue.DataType.Long);
+					SetRegionColDfn(columnDfn, "Parent Id", 80, SaxDbDfn_Core.ColumnIdx.Region_RegionIdParent, ColumnAlignment.Right, DataValue.DataType.Long);
 					break;
 				case SaxRegion.Column.Parent_RegionType:
-					SetRegionColDfn(columnDfn, "Parent type", 80, SaxDbDfn.ColumnIdx.Region_RegionType, ColumnAlignment.Center, DataValue.DataType.Long, aliasRegion_Parent, prefixRegion_Parent);
+					SetRegionColDfn(columnDfn, "Parent type", 80, SaxDbDfn_Core.ColumnIdx.Region_RegionType, ColumnAlignment.Center, DataValue.DataType.Long, aliasRegion_Parent, prefixRegion_Parent);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxRegion.Column.Parent_RegionType_Desc:
-					SetRegionColDfn(columnDfn, "Parent type", 100, SaxDbDfn.ColumnIdx.Region_RegionType, ColumnAlignment.Center, DataValue.DataType.String, aliasRegion_Parent, prefixRegion_Parent);
+					SetRegionColDfn(columnDfn, "Parent type", 100, SaxDbDfn_Core.ColumnIdx.Region_RegionType, ColumnAlignment.Center, DataValue.DataType.String, aliasRegion_Parent, prefixRegion_Parent);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxRegion.Column.Parent_Name:
-					SetRegionColDfn(columnDfn, "Parent", 120, SaxDbDfn.ColumnIdx.Region_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasRegion_Parent, prefixRegion_Parent);
+					SetRegionColDfn(columnDfn, "Parent", 120, SaxDbDfn_Core.ColumnIdx.Region_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasRegion_Parent, prefixRegion_Parent);
 					columnDfn.ReadOnly = true;
 					break;
 
 				//-----------------------------------------------------------
 				// Derived properties.
 				case SaxRegion.Column.ChildRegionCount:
-					SetRegionColDfn(columnDfn, "Sub regions", 90, SaxDbDfn.ColumnIdx.Unknown, ColumnAlignment.Center, DataValue.DataType.Long);
+					SetRegionColDfn(columnDfn, "Sub regions", 90, SaxDbDfn_Core.ColumnIdx.Unknown, ColumnAlignment.Center, DataValue.DataType.Long);
 					columnDfn.DataName = colRegion_ChildRegion_Count;
 					columnDfn.ReadOnly = true;
 					break;
@@ -314,27 +314,27 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				//-----------------------------------------------------------
 				// Common properties.
 				case SaxRegion.Column.Notes:
-					SetRegionColDfn(columnDfn, "Notes", 240, SaxDbDfn.ColumnIdx.Region_Notes);
+					SetRegionColDfn(columnDfn, "Notes", 240, SaxDbDfn_Core.ColumnIdx.Region_Notes);
 					break;
 				case SaxRegion.Column.Flags:
-					SetRegionColDfn(columnDfn, "Flags", 60, SaxDbDfn.ColumnIdx.Region_Flags, ColumnAlignment.Center, DataValue.DataType.Long);
+					SetRegionColDfn(columnDfn, "Flags", 60, SaxDbDfn_Core.ColumnIdx.Region_Flags, ColumnAlignment.Center, DataValue.DataType.Long);
 					break;
 				case SaxRegion.Column.Status:
-					SetRegionColDfn(columnDfn, "Status", 80, SaxDbDfn.ColumnIdx.Region_Status, ColumnAlignment.Center);
+					SetRegionColDfn(columnDfn, "Status", 80, SaxDbDfn_Core.ColumnIdx.Region_Status, ColumnAlignment.Center);
 					break;
 				case SaxRegion.Column.Status_Desc:
-					SetRegionColDfn(columnDfn, "Status", 90, SaxDbDfn.ColumnIdx.Region_Status, ColumnAlignment.Center);
+					SetRegionColDfn(columnDfn, "Status", 90, SaxDbDfn_Core.ColumnIdx.Region_Status, ColumnAlignment.Center);
 					break;
 				case SaxRegion.Column.Status_Ind:
-					SetRegionColDfn(columnDfn, "Status", 80, SaxDbDfn.ColumnIdx.Region_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
+					SetRegionColDfn(columnDfn, "Status", 80, SaxDbDfn_Core.ColumnIdx.Region_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
 					columnDfn.TriStateFormat = ColumnTriStateFormat.Lights;
 					break;
 				case SaxRegion.Column.CreateOn_Date:
-					SetRegionColDfn(columnDfn, "Created", 80, SaxDbDfn.ColumnIdx.Region_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
+					SetRegionColDfn(columnDfn, "Created", 80, SaxDbDfn_Core.ColumnIdx.Region_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxRegion.Column.UpdateOn_Date:
-					SetRegionColDfn(columnDfn, "Updated", 80, SaxDbDfn.ColumnIdx.Region_UpdateOn, ColumnAlignment.Center, DataValue.DataType.Date);
+					SetRegionColDfn(columnDfn, "Updated", 80, SaxDbDfn_Core.ColumnIdx.Region_UpdateOn, ColumnAlignment.Center, DataValue.DataType.Date);
 					columnDfn.ReadOnly = true;
 					break;
 					//-----------------------------------------------------------
@@ -355,25 +355,25 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			// Item Ids.
 			String idsIncluded = prm.IdsIncluded.Concat(",");
 			if (!idsIncluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_Id, aliasRegion) + " IN (" + idsIncluded + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_Id, aliasRegion) + " IN (" + idsIncluded + ")");
 			String idsExcluded = prm.IdsExcluded.Concat(",");
 			if (!idsExcluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_Id, aliasRegion) + " NOT IN (" + idsExcluded + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_Id, aliasRegion) + " NOT IN (" + idsExcluded + ")");
 
 			// Parent Region Ids.
-			String includedParentRegionIds = prm.IncludedParentRegionIds.Concat(",");
+			String includedParentRegionIds = prm.ParentRegionIdsIncluded.Concat(",");
 			if (!includedParentRegionIds.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_RegionIdParent, aliasRegion) + " IN (" + includedParentRegionIds + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_RegionIdParent, aliasRegion) + " IN (" + includedParentRegionIds + ")");
 
 			// Region type.
 			if ((int)prm.RegionType > 0)
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_RegionType, aliasRegion) + "=" + (int)prm.RegionType);
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_RegionType, aliasRegion) + "=" + (int)prm.RegionType);
 
 			// ISO 2 codes.
 			if (!prm.CountryIso2CodesIncluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_CountryIso2Code, aliasRegion) + " IN (" + DbQuery.FormatForIn(prm.CountryIso2CodesIncluded, true, false) + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_CountryIso2Code, aliasRegion) + " IN (" + DbQuery.FormatForIn(prm.CountryIso2CodesIncluded, true, false) + ")");
 			if (!prm.CountryIso2CodesExcluded.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_CountryIso2Code, aliasRegion) + " NOT IN (" + DbQuery.FormatForIn(prm.CountryIso2CodesExcluded, true, false) + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_CountryIso2Code, aliasRegion) + " NOT IN (" + DbQuery.FormatForIn(prm.CountryIso2CodesExcluded, true, false) + ")");
 
 			// Generic filter.
 			if (!StringUtil.IsEmpty(prm.RegionFilter))
@@ -385,27 +385,27 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				foreach (String filterWord in filterWords)
 				{
 					List<String> regionFilter = new List<String>();
-					regionFilter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_CountryIso2Code, aliasRegion) + " Like '%" + DbQuery.FormatForLike(filterWord, true) + "%'");
-					regionFilter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_Name, aliasRegion) + " Like '%" + DbQuery.FormatForLike(filterWord, true) + "%'");
+					regionFilter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_CountryIso2Code, aliasRegion) + " Like '%" + DbQuery.FormatForLike(filterWord, true) + "%'");
+					regionFilter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_Name, aliasRegion) + " Like '%" + DbQuery.FormatForLike(filterWord, true) + "%'");
 					filter.Add(regionFilter.Concat(" OR ", "(", ")"));
 				}
 			}
 
 			// Name.
 			if (!StringUtil.IsEmpty(prm.NameFull))
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_Name, aliasRegion) + "='" + DbQuery.FormatForCondition(prm.NameFull) + "'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_Name, aliasRegion) + "='" + DbQuery.FormatForCondition(prm.NameFull) + "'");
 			if (!StringUtil.IsEmpty(prm.NamePartial))
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_Name, aliasRegion) + " Like '%" + DbQuery.FormatForLike(prm.NamePartial, true) + "%'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_Name, aliasRegion) + " Like '%" + DbQuery.FormatForLike(prm.NamePartial, true) + "%'");
 
 			// Notes.
 			if (!StringUtil.IsEmpty(prm.NotesPartial))
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_Notes, aliasRegion) + " LIKE '%" + DbQuery.FormatForLike(prm.NotesPartial) + "%'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_Notes, aliasRegion) + " LIKE '%" + DbQuery.FormatForLike(prm.NotesPartial) + "%'");
 
 			// Status.
 			if (prm.StatusCat == SaxRegion.StatusCat.ActiveOnly)
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_Status, aliasRegion) + "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_Status, aliasRegion) + "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'");
 			else if (prm.StatusCat == SaxRegion.StatusCat.NotDeleted)
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_Status, aliasRegion) + "!='" + SacsSystem.GetStatusCode(SaStatus.Deleted) + "'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_Status, aliasRegion) + "!='" + SacsSystem.GetStatusCode(SaStatus.Deleted) + "'");
 
 			if (filter.Count < 1) filter.Add("1=1");
 			return filter;
@@ -419,9 +419,9 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			{
 				// Need to ensure correct alias used for Region columns in case of conflict.
 				String sortCol = String.Empty;
-				if (SaxDbDfn.GetTableForColumn((SaxDbDfn.ColumnIdx)columnDfn.DbColumn) == SaxDbDfn.TableIdx.Region)
+				if (SaxDbDfn_Core.GetTableForColumn((SaxDbDfn_Core.ColumnIdx)columnDfn.DbColumn) == SaxDbDfn_Core.TableIdx.Region)
 				{
-					sortCol = SaxDbDfn.GetColumnNameQual((SaxDbDfn.ColumnIdx)columnDfn.DbColumn, aliasRegion);
+					sortCol = SaxDbDfn_Core.GetColumnNameQual((SaxDbDfn_Core.ColumnIdx)columnDfn.DbColumn, aliasRegion);
 				}
 				else
 				{
@@ -439,7 +439,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			if (sortColumnNames.IsEmpty())
 			{
 				// Default sort columns.
-				sortColumnNames.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_Id, aliasRegion) + " ASC");
+				sortColumnNames.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_Id, aliasRegion) + " ASC");
 			}
 			return sortColumnNames;
 		}
@@ -449,7 +449,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		private long GetRegionCount(String filter)
 		{
 			ClearErrorState();
-			return CoreDatabase.GetRowCount(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.Region) + " As " + aliasRegion, filter);
+			return CoreDatabase.GetRowCount(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Region) + " As " + aliasRegion, filter);
 		}
 		public override long GetRegionCount(SaxRegion.Params prm)
 		{
@@ -463,7 +463,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		{
 			List<SaxRegion> userReferences = new List<SaxRegion>();
 			DbQuery qry = new DbQuery(CoreDatabase.DbmsType);
-			qry.Tables.Add(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.Region), aliasRegion);
+			qry.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Region), aliasRegion);
 			Region_Db dbRegion = new Region_Db(CoreDbInfo);
 			qry.Columns.AddRange(dbRegion.ExistingColumnNames);
 			qry.Filters.AddRange(GetRegionQueryFilter(prm));
@@ -488,7 +488,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				}
 				catch (Exception exc)
 				{
-					SaLogger.Warn(GetType().Name + ".GetRegionList\n\tQuery: " + dbCommand.CommandText + "\n\t" + exc.GetType().Name + ": " + exc.Message);
+					SaLogger.Warn(GetType().Name + ".GetRegionList\n\tQuery: " + dbCommand.CommandText + "\n\t" + ExceptionUtil.GetLogMessage(exc));
 				}
 			}
 			return userReferences;
@@ -503,45 +503,45 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			//---------------------------------------------------------------------
 			// Construct query.
 			DbQuery query = new DbQuery(CoreDatabase.DbmsType);
-			query.Tables.Add(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.Region), aliasRegion);
+			query.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Region), aliasRegion);
 
 			// Add columns as defined in query list.
 			if (columns.HasId(SaxRegion.Column.Id))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_Id, aliasRegion));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_Id, aliasRegion));
 			if (columns.HasId(SaxRegion.Column.RegionType) || columns.HasId(SaxRegion.Column.RegionType_Desc))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_RegionType, aliasRegion));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_RegionType, aliasRegion));
 			if (columns.HasId(SaxRegion.Column.CountryIso2Code))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_CountryIso2Code, aliasRegion));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_CountryIso2Code, aliasRegion));
 			if (columns.HasId(SaxRegion.Column.Name))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_Name, aliasRegion));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_Name, aliasRegion));
 			bool hasParentRegionCols = columns.HasId(SaxRegion.Column.Parent_RegionType) || columns.HasId(SaxRegion.Column.Parent_RegionType_Desc) || columns.HasId(SaxRegion.Column.Parent_Name);
 			if (columns.HasId(SaxRegion.Column.RegionIdParent) || hasParentRegionCols)
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_RegionIdParent, aliasRegion));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_RegionIdParent, aliasRegion));
 			// Common properties.
 			if (columns.HasId(SaxRegion.Column.Notes))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_Notes, aliasRegion));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_Notes, aliasRegion));
 			if (columns.HasId(SaxRegion.Column.Flags))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_Flags, aliasRegion));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_Flags, aliasRegion));
 			if (columns.HasId(SaxRegion.Column.Status) || columns.HasId(SaxRegion.Column.Status_Desc) || columns.HasId(SaxRegion.Column.Status_Ind))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_Status, aliasRegion));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_Status, aliasRegion));
 			if (columns.HasId(SaxRegion.Column.CreateOn_Date))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_CreateOn, aliasRegion));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_CreateOn, aliasRegion));
 			if (columns.HasId(SaxRegion.Column.UpdateOn_Date))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_UpdateOn, aliasRegion));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_UpdateOn, aliasRegion));
 
 			//---------------------------------------------------------------------
 			// Parent Region.
 			if (hasParentRegionCols)
 			{
 				DbQueryJoin joinParentRegion = new DbQueryJoin(DbJoinType.LeftOuter);
-				joinParentRegion.Table = new StringPair(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.Region), aliasRegion_Parent);
-				joinParentRegion.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_Id, aliasRegion_Parent) + "=" + SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_RegionIdParent, aliasRegion));
+				joinParentRegion.Table = new StringPair(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Region), aliasRegion_Parent);
+				joinParentRegion.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_Id, aliasRegion_Parent) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_RegionIdParent, aliasRegion));
 				query.Joins.Add(joinParentRegion);
-				List<SaxDbDfn.ColumnIdx> cols = new List<SaxDbDfn.ColumnIdx>();
-				cols.Add(SaxDbDfn.ColumnIdx.Region_RegionType);
-				cols.Add(SaxDbDfn.ColumnIdx.Region_Name);
+				List<SaxDbDfn_Core.ColumnIdx> cols = new List<SaxDbDfn_Core.ColumnIdx>();
+				cols.Add(SaxDbDfn_Core.ColumnIdx.Region_RegionType);
+				cols.Add(SaxDbDfn_Core.ColumnIdx.Region_Name);
 				foreach (var col in cols)
-					query.Columns.Add(SaxDbDfn.GetColumnNameQual(col, aliasRegion_Parent), prefixRegion_Parent + SaxDbDfn.GetColumnName(col, false));
+					query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(col, aliasRegion_Parent), prefixRegion_Parent + SaxDbDfn_Core.GetColumnName(col, false));
 			}
 
 			//---------------------------------------------------------------------
@@ -550,9 +550,9 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			{
 				String aliasCount = "aChildRgn";
 				DbQuery queryCount = new DbQuery(CoreDatabase.DbmsType);
-				queryCount.Tables.Add(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.Region), aliasCount);
+				queryCount.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Region), aliasCount);
 				queryCount.Columns.Add("Count(*)");
-				queryCount.Filters.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_RegionIdParent, aliasCount) + "=" + SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Region_Id, aliasRegion));
+				queryCount.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_RegionIdParent, aliasCount) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_Id, aliasRegion));
 				query.Columns.Add("(" + queryCount.BuildQuery() + ")", colRegion_ChildRegion_Count);
 			}
 

SaxoniteStandardDbas/Dbas/Mgr/SaxReferenceMgr_Dbas-Sport.cs

@@ -81,7 +81,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				catch (Exception exc)
 				{
 					SetErrorState("Database query exception");
-					SaLogger.Warn(GetType().Name + ".GetSport\n\tQuery: " + dbCommand.CommandText + "\n\t" + exc.GetType().Name + ": " + exc.Message);
+					SaLogger.Warn(GetType().Name + ".GetSport\n\tQuery: " + dbCommand.CommandText + "\n\t" + ExceptionUtil.GetLogMessage(exc));
 				}
 			}
 			return sport;
@@ -188,7 +188,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 					dbSport.PopulateFrom(dbCommand, aliasSport, "Id=" + sport.Id.ToString());
 					// Delete sport.
 					dbCommand.CommandType = System.Data.CommandType.Text;
-					dbCommand.CommandText = "DELETE FROM " + SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.Sport) + " WHERE Id=" + SysId.ToString(sport.Id) + ";";
+					dbCommand.CommandText = "DELETE FROM " + SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Sport) + " WHERE Id=" + SysId.ToString(sport.Id) + ";";
 					dbCommand.ExecuteNonQuery();
 					sport.Changed = false;
 					if (DebugMode) SaLogger.Debug(fn + " Deleted. " + GetLogProperties(sport).Concat(": ").Concat("", "\n\t"));
@@ -233,15 +233,15 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		private static readonly String aliasSport = "Sprt";
 		//private static readonly String colSport_AssociatedData_Count   = "UsrAct_AD_Count";
 		private void SetSportColDfn
-			(ColumnDfn col, String caption, int width, SaxDbDfn.ColumnIdx dbCol,
+			(ColumnDfn col, String caption, int width, SaxDbDfn_Core.ColumnIdx dbCol,
 			ColumnAlignment align = ColumnAlignment.Default, DataValue.DataType dataType = DataValue.DataType.String,
 			String alias = "", String prefix = "")
 		{
-			if (String.IsNullOrEmpty(alias) && SaxDbDfn.GetTableForColumn(dbCol) == SaxDbDfn.TableIdx.Sport)
+			if (String.IsNullOrEmpty(alias) && SaxDbDfn_Core.GetTableForColumn(dbCol) == SaxDbDfn_Core.TableIdx.Sport)
 				alias = aliasSport;
-			col.Set(caption, width, (int)dbCol, prefix + SaxDbDfn.GetColumnName(dbCol, false), SaxDbDfn.GetColumnNameQual(dbCol, alias), dataType, align);
-			if (dataType == DataValue.DataType.String && dbCol != SaxDbDfn.ColumnIdx.Unknown)
-				col.MaxLength = (int)SaxDbDfn.GetColTextLen(dbCol);
+			col.Set(caption, width, (int)dbCol, prefix + SaxDbDfn_Core.GetColumnName(dbCol, false), SaxDbDfn_Core.GetColumnNameQual(dbCol, alias), dataType, align);
+			if (dataType == DataValue.DataType.String && dbCol != SaxDbDfn_Core.ColumnIdx.Unknown)
+				col.MaxLength = (int)SaxDbDfn_Core.GetColTextLen(dbCol);
 		}
 		public override ColumnDfn GetSportColumnDfn(SaxSport.Column columnId, string caption = "", int width = 0)
 		{
@@ -250,44 +250,44 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			{
 				//-----------------------------------------------------------
 				case SaxSport.Column.Pos:
-					SetSportColDfn(columnDfn, "Pos", 60, SaxDbDfn.ColumnIdx.Unknown, ColumnAlignment.Right);
+					SetSportColDfn(columnDfn, "Pos", 60, SaxDbDfn_Core.ColumnIdx.Unknown, ColumnAlignment.Right);
 					columnDfn.SortMode = ColumnDfn.ColumnSortMode.Off;
 					columnDfn.ReadOnly = true;
 					columnDfn.Resizable = false;
 					break;
 				case SaxSport.Column.Id:
-					SetSportColDfn(columnDfn, "Id", 80, SaxDbDfn.ColumnIdx.Sport_Id, ColumnAlignment.Right, DataValue.DataType.Long);
+					SetSportColDfn(columnDfn, "Id", 80, SaxDbDfn_Core.ColumnIdx.Sport_Id, ColumnAlignment.Right, DataValue.DataType.Long);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxSport.Column.Name:
-					SetSportColDfn(columnDfn, "Name", 120, SaxDbDfn.ColumnIdx.Sport_Name);
+					SetSportColDfn(columnDfn, "Name", 120, SaxDbDfn_Core.ColumnIdx.Sport_Name);
 					break;
 				//-----------------------------------------------------------
 				// Derived properties.
 				//-----------------------------------------------------------
 				// Common properties.
 				case SaxSport.Column.Notes:
-					SetSportColDfn(columnDfn, "Notes", 240, SaxDbDfn.ColumnIdx.Sport_Notes);
+					SetSportColDfn(columnDfn, "Notes", 240, SaxDbDfn_Core.ColumnIdx.Sport_Notes);
 					break;
 				case SaxSport.Column.Flags:
-					SetSportColDfn(columnDfn, "Flags", 60, SaxDbDfn.ColumnIdx.Sport_Flags, ColumnAlignment.Center, DataValue.DataType.Long);
+					SetSportColDfn(columnDfn, "Flags", 60, SaxDbDfn_Core.ColumnIdx.Sport_Flags, ColumnAlignment.Center, DataValue.DataType.Long);
 					break;
 				case SaxSport.Column.Status:
-					SetSportColDfn(columnDfn, "Status", 80, SaxDbDfn.ColumnIdx.Sport_Status, ColumnAlignment.Center);
+					SetSportColDfn(columnDfn, "Status", 80, SaxDbDfn_Core.ColumnIdx.Sport_Status, ColumnAlignment.Center);
 					break;
 				case SaxSport.Column.Status_Desc:
-					SetSportColDfn(columnDfn, "Status", 90, SaxDbDfn.ColumnIdx.Sport_Status, ColumnAlignment.Center);
+					SetSportColDfn(columnDfn, "Status", 90, SaxDbDfn_Core.ColumnIdx.Sport_Status, ColumnAlignment.Center);
 					break;
 				case SaxSport.Column.Status_Ind:
-					SetSportColDfn(columnDfn, "Status", 80, SaxDbDfn.ColumnIdx.Sport_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
+					SetSportColDfn(columnDfn, "Status", 80, SaxDbDfn_Core.ColumnIdx.Sport_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
 					columnDfn.TriStateFormat = ColumnTriStateFormat.Lights;
 					break;
 				case SaxSport.Column.CreateOn_Date:
-					SetSportColDfn(columnDfn, "Created", 80, SaxDbDfn.ColumnIdx.Sport_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
+					SetSportColDfn(columnDfn, "Created", 80, SaxDbDfn_Core.ColumnIdx.Sport_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
 					columnDfn.ReadOnly = true;
 					break;
 				case SaxSport.Column.UpdateOn_Date:
-					SetSportColDfn(columnDfn, "Updated", 80, SaxDbDfn.ColumnIdx.Sport_UpdateOn, ColumnAlignment.Center, DataValue.DataType.Date);
+					SetSportColDfn(columnDfn, "Updated", 80, SaxDbDfn_Core.ColumnIdx.Sport_UpdateOn, ColumnAlignment.Center, DataValue.DataType.Date);
 					columnDfn.ReadOnly = true;
 					break;
 					//-----------------------------------------------------------
@@ -308,10 +308,10 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			// Item Ids.
 			String includedIds = prm.IdsIncluded.Concat(",");
 			if (!includedIds.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Sport_Id, aliasSport) + " IN (" + includedIds + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Sport_Id, aliasSport) + " IN (" + includedIds + ")");
 			String excludedIds = prm.IdsExcluded.Concat(",");
 			if (!excludedIds.IsEmpty())
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Sport_Id, aliasSport) + " NOT IN (" + excludedIds + ")");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Sport_Id, aliasSport) + " NOT IN (" + excludedIds + ")");
 
 			// Generic filter.
 			if (!StringUtil.IsEmpty(prm.SportFilter))
@@ -323,26 +323,26 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				foreach (String filterWord in filterWords)
 				{
 					List<String> sportFilter = new List<String>();
-					sportFilter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Sport_Name, aliasSport) + " Like '%" + DbQuery.FormatForLike(filterWord, true) + "%'");
+					sportFilter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Sport_Name, aliasSport) + " Like '%" + DbQuery.FormatForLike(filterWord, true) + "%'");
 					filter.Add(sportFilter.Concat(" OR ", "(", ")"));
 				}
 			}
 
 			// Name.
 			if (!StringUtil.IsEmpty(prm.NameFull))
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Sport_Name, aliasSport) + "='" + DbQuery.FormatForCondition(prm.NameFull) + "'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Sport_Name, aliasSport) + "='" + DbQuery.FormatForCondition(prm.NameFull) + "'");
 			if (!StringUtil.IsEmpty(prm.NamePartial))
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Sport_Name, aliasSport) + " Like '%" + DbQuery.FormatForLike(prm.NamePartial, true) + "%'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Sport_Name, aliasSport) + " Like '%" + DbQuery.FormatForLike(prm.NamePartial, true) + "%'");
 
 			// Notes.
 			if (!StringUtil.IsEmpty(prm.NotesPartial))
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Sport_Notes, aliasSport) + " LIKE '%" + DbQuery.FormatForLike(prm.NotesPartial) + "%'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Sport_Notes, aliasSport) + " LIKE '%" + DbQuery.FormatForLike(prm.NotesPartial) + "%'");
 
 			// Status.
 			if (prm.StatusCat == SaxSport.StatusCat.ActiveOnly)
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Sport_Status, aliasSport) + "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Sport_Status, aliasSport) + "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'");
 			else if (prm.StatusCat == SaxSport.StatusCat.NotDeleted)
-				filter.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Sport_Status, aliasSport) + "!='" + SacsSystem.GetStatusCode(SaStatus.Deleted) + "'");
+				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Sport_Status, aliasSport) + "!='" + SacsSystem.GetStatusCode(SaStatus.Deleted) + "'");
 
 			if (filter.Count < 1) filter.Add("1=1");
 			return filter;
@@ -356,9 +356,9 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			{
 				// Need to ensure correct alias used for Sport columns in case of conflict.
 				String sortCol = String.Empty;
-				if (SaxDbDfn.GetTableForColumn((SaxDbDfn.ColumnIdx)columnDfn.DbColumn) == SaxDbDfn.TableIdx.Sport)
+				if (SaxDbDfn_Core.GetTableForColumn((SaxDbDfn_Core.ColumnIdx)columnDfn.DbColumn) == SaxDbDfn_Core.TableIdx.Sport)
 				{
-					sortCol = SaxDbDfn.GetColumnNameQual((SaxDbDfn.ColumnIdx)columnDfn.DbColumn, aliasSport);
+					sortCol = SaxDbDfn_Core.GetColumnNameQual((SaxDbDfn_Core.ColumnIdx)columnDfn.DbColumn, aliasSport);
 				}
 				else
 				{
@@ -376,7 +376,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			if (sortColumnNames.IsEmpty())
 			{
 				// Default sort columns.
-				sortColumnNames.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Sport_Id, aliasSport) + " ASC");
+				sortColumnNames.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Sport_Id, aliasSport) + " ASC");
 			}
 			return sortColumnNames;
 		}
@@ -386,7 +386,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		private long GetSportCount(String filter)
 		{
 			ClearErrorState();
-			return CoreDatabase.GetRowCount(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.Sport) + " As " + aliasSport, filter);
+			return CoreDatabase.GetRowCount(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Sport) + " As " + aliasSport, filter);
 		}
 		public override long GetSportCount(SaxSport.Params prm)
 		{
@@ -400,7 +400,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 		{
 			List<SaxSport> userReferences = new List<SaxSport>();
 			DbQuery qry = new DbQuery(CoreDatabase.DbmsType);
-			qry.Tables.Add(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.Sport), aliasSport);
+			qry.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Sport), aliasSport);
 			Sport_Db dbSport = new Sport_Db(CoreDbInfo);
 			qry.Columns.AddRange(dbSport.ExistingColumnNames);
 			qry.Filters.AddRange(GetSportQueryFilter(prm));
@@ -425,7 +425,7 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 				}
 				catch (Exception exc)
 				{
-					SaLogger.Warn(GetType().Name + ".GetSportList\n\tQuery: " + dbCommand.CommandText + "\n\t" + exc.GetType().Name + ": " + exc.Message);
+					SaLogger.Warn(GetType().Name + ".GetSportList\n\tQuery: " + dbCommand.CommandText + "\n\t" + ExceptionUtil.GetLogMessage(exc));
 				}
 			}
 			return userReferences;
@@ -440,24 +440,24 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 			//---------------------------------------------------------------------
 			// Construct query.
 			DbQuery query = new DbQuery(CoreDatabase.DbmsType);
-			query.Tables.Add(SaxDbDfn.GetTableName(SaxDbDfn.TableIdx.Sport), aliasSport);
+			query.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Sport), aliasSport);
 
 			// Add columns as defined in query list.
 			if (columns.HasId(SaxSport.Column.Id))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Sport_Id, aliasSport));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Sport_Id, aliasSport));
 			if (columns.HasId(SaxSport.Column.Name))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Sport_Name, aliasSport));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Sport_Name, aliasSport));
 			// Common properties.
 			if (columns.HasId(SaxSport.Column.Notes))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Sport_Notes, aliasSport));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Sport_Notes, aliasSport));
 			if (columns.HasId(SaxSport.Column.Flags))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Sport_Flags, aliasSport));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Sport_Flags, aliasSport));
 			if (columns.HasId(SaxSport.Column.Status) || columns.HasId(SaxSport.Column.Status_Desc) || columns.HasId(SaxSport.Column.Status_Ind))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Sport_Status, aliasSport));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Sport_Status, aliasSport));
 			if (columns.HasId(SaxSport.Column.CreateOn_Date))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Sport_CreateOn, aliasSport));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Sport_CreateOn, aliasSport));
 			if (columns.HasId(SaxSport.Column.UpdateOn_Date))
-				query.Columns.Add(SaxDbDfn.GetColumnNameQual(SaxDbDfn.ColumnIdx.Sport_UpdateOn, aliasSport));
+				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Sport_UpdateOn, aliasSport));
 
 			//---------------------------------------------------------------------
 			// Movement count.

SaxoniteStandardDbas/Dbas/Mgr/SaxReferenceMgr_Dbas.cs

@@ -16,7 +16,8 @@ namespace Saxonite.Net.Standard.Dbas.Mgr
 
 		//-------------------------------------------------------------------
 		// Construction.
-		public SaxReferenceMgr_Dbas(SaxSessionContext sessionContext) : base (sessionContext)
+		public SaxReferenceMgr_Dbas(SaxSessionContext sessionContext, SaxInternals internals) : 
+			base (sessionContext, internals)
 		{
 		}