using DocumentFormat.OpenXml.Office2016.Excel;
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 Sarand.Net.Standard.Base.Utils;
using Sarand.Net.Standard.Dbas.Data;
using Saxonite.Base.App;
using Saxonite.Net.Standard.Base.App;
using Saxonite.Net.Standard.Base.Bus;
using Saxonite.Net.Standard.Base.Bus.Reference;
using Saxonite.Net.Standard.Dbas.Bus.Reference;
using Saxonite.Net.Standard.Dbas.Internal.Reference;
using System;
using System.Collections.Generic;
using System.Data.Common;
using System.Linq;

namespace Saxonite.Net.Standard.Dbas.Mgr.Reference
{
	//=======================================================================
	partial class SaxReferenceGolfMgr_Dbas
	{
		//*******************************************************************
		// Support Mgr - User Report
		//*******************************************************************
		// Utilities.
		private List<StringPair> GetLogProperties(SaxGolfUsgaCourse usgaCourse)
		{
			return new List<StringPair>()
			{
				new StringPair("Id",SysId.ToString(usgaCourse.Id)),
				new StringPair("Facility Id",SysId.ToString(usgaCourse.FacilityId)),
				new StringPair("Usga Course Id",SysId.ToString(usgaCourse.UsgaCourseId)),
				new StringPair("Caption",usgaCourse.Caption),
				new StringPair("Status",usgaCourse.StatusCode)
			};
		}

		//-------------------------------------------------------------------
		// Create item.
		public override SaxGolfUsgaCourse CreateUsgaCourse(SysId facilityId)
		{
			ClearErrorState();
			return new SaxGolfUsgaCourse_Dbas(ReferenceDatabase, null, facilityId, 0);
		}
		private SaxGolfUsgaCourse_Dbas CreateUsgaCourse(Golf_UsgaCourse_Db dbUsgaCourse)
		{
			ClearErrorState();
			SaxGolfUsgaCourse_Dbas usgaCourse = new SaxGolfUsgaCourse_Dbas(ReferenceDatabase, new SysId(dbUsgaCourse._Id), new SysId(dbUsgaCourse._FacilityId), (ushort)dbUsgaCourse._Flags);
			PopulateFrom(dbUsgaCourse, usgaCourse);
			return usgaCourse;
		}

		//-------------------------------------------------------------------
		// Get item.
		public override SaxGolfUsgaCourse GetUsgaCourse(SaxGolfUsgaCourse.Params prm)
		{
			ClearErrorState();
			return GetUsgaCourse(GetUsgaCourseQueryFilter(prm).Concat(" And ", "(", ")"));
		}
		private SaxGolfUsgaCourse GetUsgaCourse(String filter)
		{
			ClearErrorState();
			long count = GetUsgaCourseCount(filter);
			if (count == 0) return null;
			if (count != 1)
			{
				SetErrorState("Multiple items found");
				return null;
			}
			SaxGolfUsgaCourse usgaCourse = null;
			// Query data.
			using (var dbConnection = ReferenceDatabase.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					Golf_UsgaCourse_Db dbUsgaCourse = new Golf_UsgaCourse_Db(ReferenceDbInfo);
					dbUsgaCourse.PopulateFrom(dbCommand, aliasUsgaCourse, filter);
					usgaCourse = CreateUsgaCourse(dbUsgaCourse);
				}
				catch (Exception exc)
				{
					SetErrorState("Database query exception");
					SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
				}
			}
			return usgaCourse;
		}

		//-------------------------------------------------------------------
		// Validate item.
		public override bool IsValidUsgaCourseData(SaxGolfUsgaCourse.Data data, SaxGolfUsgaCourse.ErrField errField)
		{
			ClearErrorState();
			if (!base.IsValidUsgaCourseData(data, errField)) return false;
			return true;
		}

		//-------------------------------------------------------------------
		// Insert item.
		public override bool InsertUsgaCourse(SaxGolfUsgaCourse usgaCourse, DbUpdateInfo dbUpdateInfo)
		{
			String fn = GetType().Name + ".InsertUsgaCourse";
			ClearErrorState();
			if (!IsValidUsgaCourse(usgaCourse)) return false;
			if (SysId.IsValid(usgaCourse.Id)) return SetErrorState(ErrorMessage.ValidItemId);
			using (var dbConnection = ReferenceDatabase.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					Golf_UsgaCourse_Db dbUsgaCourse = new Golf_UsgaCourse_Db(ReferenceDbInfo);
					PopulateTo(dbUsgaCourse, usgaCourse, dbUpdateInfo);
					if (Golf_UsgaCourse_Db.FieldsNonId.Contains("Id"))
					{
						// Generate next Id.
						dbUsgaCourse._Id = ReferenceDatabase.GetNextIdFromTable("UsgaCourse");
					}
					dbUsgaCourse.ExecuteInsertCommand(dbCommand);
					usgaCourse.Id = new SysId(dbUsgaCourse._Id);
					usgaCourse.Changed = false;
					if (DebugMode) SaLogger.Debug(fn + " Inserted. " + GetLogProperties(usgaCourse).Concat(": ").Concat("", "\n\t"));
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
		// Update item.
		public override bool UpdateUsgaCourse(SaxGolfUsgaCourse usgaCourse, DbUpdateInfo dbUpdateInfo)
		{
			String fn = GetType().Name + ".UpdateUsgaCourse";
			ClearErrorState();
			if (!IsValidUsgaCourse(usgaCourse)) return false;
			if (!SysId.IsValid(usgaCourse.Id)) return SetErrorState(ErrorMessage.InvalidItemId);
			if (!usgaCourse.Changed)
			{
				if (DebugMode) SaLogger.Debug(fn + " Data not changed. " + GetLogProperties(usgaCourse).Concat(": ").Concat("", "\n\t"));
				return true;
			}
			using (var dbConnection = ReferenceDatabase.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					// Retrieve item.
					dbConnection.Open();
					Golf_UsgaCourse_Db dbUsgaCourse = new Golf_UsgaCourse_Db(ReferenceDbInfo);
					dbUsgaCourse.PopulateFrom(dbCommand, aliasUsgaCourse, "Id=" + SysId.ToString(usgaCourse.Id));
					// ToDo SaxUpdateLogItemMonitor_UsgaCourse updateLogMonitor = new SaxUpdateLogItemMonitor_UsgaCourse(SessionContext, CreateUsgaCourse(dbUsgaCourse), dbUpdateInfo);
					// Update item.
					PopulateTo(dbUsgaCourse, usgaCourse, dbUpdateInfo);
					dbUsgaCourse.ExecuteUpdateCommand(dbCommand);
					usgaCourse.Changed = false;
					if (DebugMode) SaLogger.Debug(fn + " Updated. " + GetLogProperties(usgaCourse).Concat(": ").Concat("", "\n\t"));
					// Record updates.
					// ToDo updateLogMonitor.RecordUpdatedValues(usgaCourse);
					// ToDo updateLogMonitor.LogUpdates();
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
		// Delete item.
		public override bool UsgaCourseCanBeDeleted(SaxGolfUsgaCourse usgaCourse)
		{
			ClearErrorState();
			if (!base.UsgaCourseCanBeDeleted(usgaCourse)) return false;
			return true;
		}
		public override bool DeleteUsgaCourse(SaxGolfUsgaCourse usgaCourse, DbUpdateInfo dbUpdateInfo)
		{
			String fn = GetType().Name + ".DeleteUsgaCourse";
			ClearErrorState();
			if (!UsgaCourseCanBeDeleted(usgaCourse)) return false;

			// User Roles are logically deleted by changing the status.
			usgaCourse.Status = SaStatus.Deleted;
			return UpdateUsgaCourse(usgaCourse, dbUpdateInfo);

			/*
			 * Physical deletion.
			using (var dbConnection = ReferenceDatabase.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					// Retrieve item.
					dbConnection.Open();
					Golf_UsgaCourse_Db dbUsgaCourse = new Golf_UsgaCourse_Db(ReferenceDbInfo);
					dbUsgaCourse.PopulateFrom(dbCommand, aliasUsgaCourse, "Id=" + usgaCourse.Id.ToString());
					// Delete item.
					dbCommand.CommandType = System.Data.CommandType.Text;
					dbCommand.CommandText = "DELETE FROM " + SaxDbDfn_Reference.GetTableNameQual(SaxDbDfn_Reference.TableIdx.UsgaCourse) + " WHERE Id=" + SysId.ToString(usgaCourse.Id) + ";";
					dbCommand.ExecuteNonQuery();
					usgaCourse.Changed = false;
					if (DebugMode) SaLogger.Debug(fn + " Deleted. " + GetLogProperties(usgaCourse).Concat(": ").Concat("", "\n\t"));
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return !HasErrorState();
			*/
		}

		//-------------------------------------------------------------------
		// Copy data properties to and from database.
		private void PopulateTo(Golf_UsgaCourse_Db dbUsgaCourse, SaxGolfUsgaCourse usgaCourse, DbUpdateInfo dbUpdateInfo)
		{
			dbUsgaCourse._Id = SysId.ToLong(usgaCourse.Id);
			dbUsgaCourse._FacilityId = SysId.ToInt(usgaCourse.FacilityId);
			dbUsgaCourse._UsgaCourseId = SysId.ToInt(usgaCourse.UsgaCourseId);
			dbUsgaCourse._LegacyCrpCourseId = SysId.ToInt(usgaCourse.LegacyCrpCourseId);
			dbUsgaCourse._Caption = usgaCourse.Caption;
			dbUsgaCourse._CourseName = usgaCourse.CourseName;
			dbUsgaCourse._FullName = usgaCourse.FullName;
			dbUsgaCourse._Address1 = usgaCourse.Address1;
			dbUsgaCourse._Address2 = usgaCourse.Address2;
			dbUsgaCourse._City = usgaCourse.City;
			dbUsgaCourse._PostalCode = usgaCourse.PostalCode;
			dbUsgaCourse._Latitude = usgaCourse.Latitude;
			dbUsgaCourse._Longitude = usgaCourse.Longitude;
			dbUsgaCourse._Email = usgaCourse.Email;
			dbUsgaCourse._Telephone = usgaCourse.Telephone;
			dbUsgaCourse._MarkersUpdateAt = usgaCourse.MarkersUpdateAt;
			dbUsgaCourse._MarkersData = usgaCourse.MarkersData;
			// Common.
			dbUsgaCourse._Notes = usgaCourse.Notes;
			dbUsgaCourse._Status = SacsSystem.GetStatusCode(usgaCourse.Status);
			dbUsgaCourse._Flags = (short)usgaCourse.Flags;
			if (!SysId.IsValid(usgaCourse.Id))
			{
				dbUsgaCourse._CreateOn = DateTime.Now;
				dbUsgaCourse._CreateBy = dbUpdateInfo.UserId.ToInt();
				dbUsgaCourse._CreateHost = dbUpdateInfo.Host;
			}
			dbUsgaCourse._UpdateOn = DateTime.Now;
			dbUsgaCourse._UpdateBy = dbUpdateInfo.UserId.ToInt();
			dbUsgaCourse._UpdateHost = dbUpdateInfo.Host;
		}
		private void PopulateFrom(Golf_UsgaCourse_Db dbUsgaCourse, SaxGolfUsgaCourse usgaCourse)
		{
			//usgaCourse.Id = new SysId(dbUsgaCourse._Id);
			usgaCourse.FacilityId = new SysId(dbUsgaCourse._FacilityId);
			usgaCourse.UsgaCourseId = new SysId(dbUsgaCourse._UsgaCourseId);
			usgaCourse.LegacyCrpCourseId = new SysId(dbUsgaCourse._LegacyCrpCourseId);
			usgaCourse.Caption = dbUsgaCourse._Caption;
			usgaCourse.CourseName = dbUsgaCourse._CourseName;
			usgaCourse.FullName = dbUsgaCourse._FullName;
			usgaCourse.Address1 = dbUsgaCourse._Address1;
			usgaCourse.Address2 = dbUsgaCourse._Address2;
			usgaCourse.City = dbUsgaCourse._City;
			usgaCourse.PostalCode = dbUsgaCourse._PostalCode;
			usgaCourse.Latitude = dbUsgaCourse._Latitude;
			usgaCourse.Longitude = dbUsgaCourse._Longitude;
			usgaCourse.Email = dbUsgaCourse._Email;
			usgaCourse.Telephone = dbUsgaCourse._Telephone;
			usgaCourse.MarkersUpdateAt = dbUsgaCourse._MarkersUpdateAt;
			usgaCourse.MarkersData = dbUsgaCourse._MarkersData;
			// Common.
			usgaCourse.Notes = dbUsgaCourse._Notes;
			usgaCourse.Status = SacsSystem.GetStatusForCode(dbUsgaCourse._Status);
			usgaCourse.SetCreateStamp(dbUsgaCourse._CreateOn, new SysId(dbUsgaCourse._CreateBy), dbUsgaCourse._CreateHost);
			usgaCourse.SetUpdateStamp(dbUsgaCourse._UpdateOn, new SysId(dbUsgaCourse._UpdateBy), dbUsgaCourse._UpdateHost);
			usgaCourse.AcceptChanges();
		}

		//-------------------------------------------------------------------
		// Bulk updates.
		/// <summary>
		/// Bulk update USGA Courses.
		/// <para>- Facility Id must be supplied to identify parent.</para>
		/// <para>- Course Id must be supplied to act as identifier.</para>
		/// <para>- Other properties are validated as per course rules - check error state.</para>
		/// <para>- Other properties are left as is if null.</para>
		/// </summary>
		public override bool BulkUpdateUsgaCourses(List<UsgaCourseData> courses, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			List<UsgaCourseData> coursesToUpdate = new List<UsgaCourseData>();

			// Validate supplied data.
			foreach (UsgaCourseData course in courses)
			{
				// Validate course properties.
				// Facility and Course Codes are mandatory, other values only validated if non-null.
				if (!SysId.IsValid(course.UsgaFacilityId)) return SetErrorState("Facility Id must be supplied");
				if (!SysId.IsValid(course.UsgaCourseId)) return SetErrorState("USGA Course Id must be supplied");
				if (course.Caption != null && !IsValidValue(course.Caption, "caption", (long)SaxDbDfn_Reference.GetColTextLen(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Caption), true)) return false;
				if (course.CourseName != null && !IsValidValue(course.CourseName, "name", (long)SaxDbDfn_Reference.GetColTextLen(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_CourseName))) return false;
				if (course.FullName != null && !IsValidValue(course.FullName, "full name", (long)SaxDbDfn_Reference.GetColTextLen(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_FullName))) return false;
				if (course.Address1 != null && !IsValidValue(course.Address1, "address 1", (long)SaxDbDfn_Reference.GetColTextLen(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Address1))) return false;
				if (course.Address2 != null && !IsValidValue(course.Address2, "address 2", (long)SaxDbDfn_Reference.GetColTextLen(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Address2))) return false;
				if (course.City != null && !IsValidValue(course.City, "city", (long)SaxDbDfn_Reference.GetColTextLen(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_City))) return false;
				if (course.Email != null && !IsValidValue(course.Email, "email", (long)SaxDbDfn_Reference.GetColTextLen(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Email))) return false;
				if (course.Telephone != null && !IsValidValue(course.Telephone, "telephone", (long)SaxDbDfn_Reference.GetColTextLen(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Telephone))) return false;
				coursesToUpdate.Add(course);
			}
			int MaxBulkUpdateBatchSize = 64;
			int batchSize = coursesToUpdate.Any() ? (int)Math.Ceiling(coursesToUpdate.Count() / Math.Ceiling((double)coursesToUpdate.Count() / MaxBulkUpdateBatchSize)) : MaxBulkUpdateBatchSize;
			while (coursesToUpdate.Any())
			{
				List<String> query = new List<string>();
				query.Add($"Declare @statusActive VarChar(3)   = '{SacsSystem.GetStatusCode(SaxGolfUsgaCourse.DefaultStatus)}';");
				query.Add($"Declare @updateOn     DateTime     = GetDate();");
				query.Add($"Declare @updateBy     Int          = {SysId.ToLong(dbUpdateInfo.UserId)};");
				query.Add($"Declare @updateHost   VarChar(100) = '{DbQuery.FormatForCondition(dbUpdateInfo.Host)}';");
				query.Add("Merge");
				query.Add($"Into {SaxDbDfn_Reference.GetTableNameQual(SaxDbDfn_Reference.TableIdx.UsgaCourse)} uCrs");
				query.Add("Using");
				query.Add("(");
				query.Add("Select dFty.Id FacilityId, dCrs.UsgaFacilityId, dCrs.UsgaCourseId, dCrs.LegacyCrpCourseId, dCrs.Caption, dCrs.CourseName, dCrs.FullName, dCrs.Address1, dCrs.Address2, dCrs.City, dCrs.PostalCode, dCrs.Email, dCrs.Telephone");
				query.Add("From");
				query.Add("(");
				query.Add("Select 0 UsgaFacilityId, 0 UsgaCourseId, 0 LegacyCrpCourseId, '' Caption, '' CourseName, '' FullName, '' Address1, '' Address2, '' City, '' PostalCode, '' Email, '' Telephone");
				foreach (UsgaCourseData course in coursesToUpdate.ExtractRange(0, batchSize))
					query.Add($"Union Select {course.UsgaFacilityId}, {course.UsgaCourseId}, " +
						(SysId.IsValid(course.LegacyCrpCourseId) ? $"{course.LegacyCrpCourseId}" : "Null") + "," +
						(course.Caption != null ? $"'{DbQuery.FormatForCondition(course.Caption)}'" : "Null") + "," +
						(course.CourseName != null ? $"'{DbQuery.FormatForCondition(course.CourseName)}'" : "Null") + "," +
						(course.FullName != null ? $"'{DbQuery.FormatForCondition(course.FullName)}'" : "Null") + "," +
						(course.Address1 != null ? $"'{DbQuery.FormatForCondition(course.Address1)}'" : "Null") + "," +
						(course.Address2 != null ? $"'{DbQuery.FormatForCondition(course.Address2)}'" : "Null") + "," +
						(course.City != null ? $"'{DbQuery.FormatForCondition(course.City)}'" : "Null") + "," +
						(course.PostalCode != null ? $"'{DbQuery.FormatForCondition(course.PostalCode)}'" : "Null") + "," +
						(course.Email != null ? $"'{DbQuery.FormatForCondition(course.Email)}'" : "Null") + "," +
						(course.Telephone != null ? $"'{DbQuery.FormatForCondition(course.Telephone)}'" : "Null"));
				query.Add(") dCrs");
				query.Add($"Inner Join {SaxDbDfn_Reference.GetTableNameQual(SaxDbDfn_Reference.TableIdx.UsgaFacility)} dFty On dFty.UsgaFacilityId=dCrs.UsgaFacilityId");
				query.Add(") dCrs");
				query.Add("On uCrs.FacilityId=dCrs.FacilityId And uCrs.UsgaCourseId=dCrs.UsgaCourseId");
				query.Add("When Matched And ((dCrs.LegacyCrpCourseId Is Not Null And uCrs.LegacyCrpCourseId!=dCrs.LegacyCrpCourseId) Or (dCrs.Caption Is Not Null And uCrs.Caption!=dCrs.Caption) Or (dCrs.CourseName Is Not Null And uCrs.CourseName!=dCrs.CourseName) Or (dCrs.FullName Is Not Null And uCrs.FullName!=dCrs.FullName) Or (dCrs.Address1 Is Not Null And uCrs.Address1!=dCrs.Address1) Or (dCrs.Address2 Is Not Null And uCrs.Address2!=dCrs.Address2) Or (dCrs.City Is Not Null And uCrs.City!=dCrs.City) Or (dCrs.PostalCode Is Not Null And uCrs.PostalCode!=dCrs.PostalCode) Or (dCrs.Email Is Not Null And uCrs.Email!=dCrs.Email) Or (dCrs.Telephone Is Not Null And uCrs.Telephone!=dCrs.Telephone) Or uCrs.Status!=@statusActive)");
				query.Add("Then Update Set");
				query.Add(" LegacyCrpCourseId=Coalesce(dCrs.LegacyCrpCourseId,uCrs.LegacyCrpCourseId),");
				query.Add(" Caption=Coalesce(dCrs.Caption,uCrs.Caption),");
				query.Add(" CourseName=Coalesce(dCrs.CourseName,uCrs.CourseName),");
				query.Add(" FullName=Coalesce(dCrs.FullName,uCrs.FullName),");
				query.Add(" Address1=Coalesce(dCrs.Address1,uCrs.Address1),");
				query.Add(" Address2=Coalesce(dCrs.Address2,uCrs.Address2),");
				query.Add(" City=Coalesce(dCrs.City,uCrs.City),");
				query.Add(" PostalCode=Coalesce(dCrs.PostalCode,uCrs.PostalCode),");
				query.Add(" Email=Coalesce(dCrs.Email,uCrs.Email),");
				query.Add(" Telephone=Coalesce(dCrs.Telephone,uCrs.Telephone),");
				query.Add(" Status=@statusActive,");
				query.Add(" UpdateOn=@updateOn,");
				query.Add(" UpdateBy=@updateBy,");
				query.Add(" UpdateHost=@updateHost");
				query.Add("When Not Matched And Len(Coalesce(dCrs.Caption,''))>0");
				query.Add("Then Insert (FacilityId,UsgaCourseId,LegacyCrpCourseId,Caption,CourseName,FullName,Address1,Address2,City,PostalCode,Email,Telephone,MarkersData,Notes,Flags,Status,CreateOn,CreateBy,CreateHost,UpdateOn,UpdateBy,UpdateHost)");
				query.Add($"Values (dCrs.FacilityId,dCrs.UsgaCourseId,Coalesce(dCrs.LegacyCrpCourseId,0),dCrs.Caption,Coalesce(dCrs.CourseName,''),Coalesce(dCrs.FullName,''),Coalesce(dCrs.Address1,''),Coalesce(dCrs.Address2,''),Coalesce(dCrs.City,''),Coalesce(dCrs.PostalCode,''),Coalesce(dCrs.Email,''),Coalesce(dCrs.Telephone,''),'','',0,@statusActive,@updateOn,@updateBy,@updateHost,@updateOn,@updateBy,@updateHost)");
				query.Add(";");
				//SaLogger.Info($"{SysUtil.Fn} Bulk USGA Course update query:\n\t{query.Concat("\n\t")}");

				try
				{
					int result = ReferenceDatabase.ExecuteNonQuery(query.Concat("\n"));
					if (ReferenceDatabase.HasErrorState())
						SaLogger.Warn($"{SysUtil.Fn} Error executing bulk USGA Course update - {ReferenceDatabase.ErrorStateMessage}");
				}
				catch (Exception exc)
				{
					SaLogger.Warn(SysUtil.Fn + " " + ExceptionUtil.GetLogMessage(exc, " executing bulk USGA Course update"));
				}
			}
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
		// Item column definitions.
		private static readonly String aliasUsgaCourse = "UsgCrs";
		private static readonly String aliasUsgaCourse_Facility = "UsgCrs_Cty";
		private static readonly String prefixUsgaCourse_Facility = aliasUsgaCourse_Facility + "_";
		private static readonly String colCourse_Marker_Count = "Crs_Mkr_Count";
		private static readonly String colCourse_Marker_Active_Count = "Crs_Mkr_Act_Count";
		private void SetUsgaCourseColDfn
			(ColumnDfn col, String caption, int width, SaxDbDfn_Reference.ColumnIdx dbCol,
			ColumnAlignment align = ColumnAlignment.Default, DataValue.DataType dataType = DataValue.DataType.String,
			String alias = "", String prefix = "")
		{
			if (String.IsNullOrEmpty(alias) && SaxDbDfn_Reference.GetTableForColumn(dbCol) == SaxDbDfn_Reference.TableIdx.UsgaCourse)
				alias = aliasUsgaCourse;
			col.Set(caption, width, (int)dbCol, prefix + SaxDbDfn_Reference.GetColumnName(dbCol, false), SaxDbDfn_Reference.GetColumnNameQual(dbCol, alias), dataType, align);
			if (dataType == DataValue.DataType.String && dbCol != SaxDbDfn_Reference.ColumnIdx.Unknown)
				col.MaxLength = (int)SaxDbDfn_Reference.GetColTextLen(dbCol);
		}
		public override ColumnDfn GetUsgaCourseColumnDfn(SaxGolfUsgaCourse.Column columnId, string caption = "", int width = 0)
		{
			ColumnDfn columnDfn = new ColumnDfn((int)columnId, caption, width);
			switch (columnId)
			{
				//-----------------------------------------------------------
				case SaxGolfUsgaCourse.Column.Pos:
					SetUsgaCourseColDfn(columnDfn, "Pos", 60, SaxDbDfn_Reference.ColumnIdx.Unknown, ColumnAlignment.Right);
					columnDfn.SortMode = ColumnDfn.ColumnSortMode.Off;
					columnDfn.ReadOnly = true;
					columnDfn.Resizable = false;
					break;
				case SaxGolfUsgaCourse.Column.Id:
					SetUsgaCourseColDfn(columnDfn, "Id", 80, SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Id, ColumnAlignment.Right, DataValue.DataType.Long);
					columnDfn.ReadOnly = true;
					break;

				//-------------------------------------------------------
				case SaxGolfUsgaCourse.Column.FacilityId:
					SetUsgaCourseColDfn(columnDfn, "Facility #", 80, SaxDbDfn_Reference.ColumnIdx.UsgaCourse_FacilityId, ColumnAlignment.Center, DataValue.DataType.Long);
					columnDfn.ReadOnly = true;
					break;
				case SaxGolfUsgaCourse.Column.Facility_Name:
					SetUsgaCourseColDfn(columnDfn, "Facility", 120, SaxDbDfn_Reference.ColumnIdx.UsgaFacility_FacilityName, ColumnAlignment.Center, DataValue.DataType.String, aliasUsgaCourse_Facility, prefixUsgaCourse_Facility);
					columnDfn.ReadOnly = true;
					break;

				//-------------------------------------------------------
				case SaxGolfUsgaCourse.Column.UsgaCourseId:
					SetUsgaCourseColDfn(columnDfn, "Id", 80, SaxDbDfn_Reference.ColumnIdx.UsgaCourse_UsgaCourseId, ColumnAlignment.Center, DataValue.DataType.Long);
					columnDfn.ReadOnly = true;
					break;
				case SaxGolfUsgaCourse.Column.LegacyCrpCourseId:
					SetUsgaCourseColDfn(columnDfn, "CRP Id", 80, SaxDbDfn_Reference.ColumnIdx.UsgaCourse_LegacyCrpCourseId, ColumnAlignment.Center, DataValue.DataType.Long);
					columnDfn.ReadOnly = true;
					break;
				case SaxGolfUsgaCourse.Column.Caption:
					SetUsgaCourseColDfn(columnDfn, "Caption", 120, SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Caption, ColumnAlignment.Center);
					columnDfn.ReadOnly = true;
					break;
				case SaxGolfUsgaCourse.Column.CourseName:
					SetUsgaCourseColDfn(columnDfn, "Name", 120, SaxDbDfn_Reference.ColumnIdx.UsgaCourse_CourseName, ColumnAlignment.Center);
					columnDfn.ReadOnly = true;
					break;
				case SaxGolfUsgaCourse.Column.FullName:
					SetUsgaCourseColDfn(columnDfn, "Full Name", 120, SaxDbDfn_Reference.ColumnIdx.UsgaCourse_FullName, ColumnAlignment.Center);
					columnDfn.ReadOnly = true;
					break;
				case SaxGolfUsgaCourse.Column.Address1:
					SetUsgaCourseColDfn(columnDfn, "Address 1", 120, SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Address1, ColumnAlignment.Center);
					columnDfn.ReadOnly = true;
					break;
				case SaxGolfUsgaCourse.Column.Address2:
					SetUsgaCourseColDfn(columnDfn, "Address 2", 120, SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Address2, ColumnAlignment.Center);
					columnDfn.ReadOnly = true;
					break;
				case SaxGolfUsgaCourse.Column.City:
					SetUsgaCourseColDfn(columnDfn, "City", 120, SaxDbDfn_Reference.ColumnIdx.UsgaCourse_City, ColumnAlignment.Center);
					columnDfn.ReadOnly = true;
					break;
				case SaxGolfUsgaCourse.Column.Email:
					SetUsgaCourseColDfn(columnDfn, "Email", 120, SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Email, ColumnAlignment.Center);
					columnDfn.ReadOnly = true;
					break;
				case SaxGolfUsgaCourse.Column.Telephone:
					SetUsgaCourseColDfn(columnDfn, "Telephone", 120, SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Telephone, ColumnAlignment.Center);
					columnDfn.ReadOnly = true;
					break;
				case SaxGolfUsgaCourse.Column.MarkersUpdateOn_Date:
					SetUsgaCourseColDfn(columnDfn, "Markers updated", 120, SaxDbDfn_Reference.ColumnIdx.UsgaCourse_MarkersUpdateAt, ColumnAlignment.Center, DataValue.DataType.Date);
					columnDfn.ReadOnly = true;
					break;

				//-----------------------------------------------------------
				// Derived properties.
				case SaxGolfUsgaCourse.Column.MarkerCount_All:
					SetUsgaProvinceColDfn(columnDfn, "Markers", 60, SaxDbDfn_Reference.ColumnIdx.Unknown, ColumnAlignment.Center, DataValue.DataType.Long);
					columnDfn.DataName = colCourse_Marker_Count;
					break;
				case SaxGolfUsgaCourse.Column.MarkerCount_Active:
					SetUsgaProvinceColDfn(columnDfn, "Markers (act)", 60, SaxDbDfn_Reference.ColumnIdx.Unknown, ColumnAlignment.Center, DataValue.DataType.Long);
					columnDfn.DataName = colCourse_Marker_Active_Count;
					break;

				//-----------------------------------------------------------
				// Common properties.
				case SaxGolfUsgaCourse.Column.Notes:
					SetUsgaCourseColDfn(columnDfn, "Notes", 240, SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Notes);
					break;
				case SaxGolfUsgaCourse.Column.Flags:
					SetUsgaCourseColDfn(columnDfn, "Flags", 60, SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Flags, ColumnAlignment.Center, DataValue.DataType.Long);
					columnDfn.ReadOnly = true;
					break;
				case SaxGolfUsgaCourse.Column.Status:
					SetUsgaCourseColDfn(columnDfn, "Status", 80, SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Status, ColumnAlignment.Center);
					columnDfn.ReadOnly = true;
					break;
				case SaxGolfUsgaCourse.Column.Status_Desc:
					SetUsgaCourseColDfn(columnDfn, "Status", 90, SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Status, ColumnAlignment.Center);
					columnDfn.ReadOnly = true;
					break;
				case SaxGolfUsgaCourse.Column.Status_Ind:
					SetUsgaCourseColDfn(columnDfn, "Status", 80, SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
					columnDfn.TriStateFormat = ColumnTriStateFormat.Lights;
					columnDfn.ReadOnly = true;
					break;
				case SaxGolfUsgaCourse.Column.CreateOn_Date:
					SetUsgaCourseColDfn(columnDfn, "Created", 80, SaxDbDfn_Reference.ColumnIdx.UsgaCourse_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
					columnDfn.ReadOnly = true;
					break;
				case SaxGolfUsgaCourse.Column.UpdateOn_Date:
					SetUsgaCourseColDfn(columnDfn, "Updated", 80, SaxDbDfn_Reference.ColumnIdx.UsgaCourse_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 override List<string> GetUsgaCourseQueryFilter(SaxGolfUsgaCourse.Params prm)
		{
			List<String> filter = new List<String>();
			String col_Id = SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Id, aliasUsgaCourse);
			String col_FacilityId = SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_FacilityId, aliasUsgaCourse);
			String col_CourseName = SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_CourseName, aliasUsgaCourse);

			// Item Ids.
			if (prm.IdsIncluded.HasValidIds())
				filter.Add($"{col_Id} IN ({prm.IdsIncluded.Concat(",")})");
			if (prm.IdsExcluded.HasValidIds())
				filter.Add($"{col_Id} NOT IN ({prm.IdsExcluded.Concat(",")})");

			// Provinces.
			if (prm.ProvinceIdsIncluded.HasValidIds())
			{
				String provinceIdsIncluded = prm.ProvinceIdsIncluded.Concat(",");
				if (StringUtil.IsBlank(prm.Alias_Province))
					filter.Add($"{col_FacilityId} IN (SELECT Id FROM {SaxDbDfn_Reference.GetTableNameQual(SaxDbDfn_Reference.TableIdx.UsgaFacility)} WHERE ProvinceId IN ({provinceIdsIncluded}))");
				else
					filter.Add($"{SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaProvince_Id, prm.Alias_Province)} IN ({provinceIdsIncluded})");
			}

			// Facilities.
			if (prm.FacilityIdsIncluded.HasValidIds())
				filter.Add($"{col_FacilityId} IN ({prm.FacilityIdsIncluded.Concat(",")})");

			// USGA Course Ids.
			if (prm.UsgaCourseIdsIncluded.HasValidIds())
				filter.Add($"{SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_UsgaCourseId, aliasUsgaCourse)} IN ({prm.UsgaCourseIdsIncluded.Concat(",")})");

			if (!StringUtil.IsBlank(prm.CourseFilter))
			{
				// Split filter into words.
				List<String> filterWords = prm.CourseFilter.Split((char[])null).ToList();
				filterWords.RemoveDuplicatesCI();
				filterWords.RemoveBlanks();
				foreach (String filterWord in filterWords)
				{
					List<String> courseFilter = new List<String>();
					courseFilter.Add($"{col_CourseName} Like '%{DbQuery.FormatForLike(filterWord, true)}%'");
					courseFilter.Add($"{SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_FullName, aliasUsgaCourse)} Like '%{DbQuery.FormatForLike(filterWord, true)}%'");
					courseFilter.Add($"{SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Address1, aliasUsgaCourse)} Like '%{DbQuery.FormatForLike(filterWord, true)}%'");
					courseFilter.Add($"{SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Address2, aliasUsgaCourse)} Like '%{DbQuery.FormatForLike(filterWord, true)}%'");
					courseFilter.Add($"{SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_City, aliasUsgaCourse)} Like '%{DbQuery.FormatForLike(filterWord, true)}%'");
					filter.Add(courseFilter.Concat(" OR ", "(", ")"));
				}
			}

			// Name.
			if (!StringUtil.IsEmpty(prm.CourseNameFull))
				filter.Add($"{col_CourseName}='{DbQuery.FormatForCondition(prm.CourseNameFull)}'");
			if (!StringUtil.IsEmpty(prm.CourseNamePartial))
				filter.Add($"{col_CourseName} LIKE '%{DbQuery.FormatForLike(prm.CourseNamePartial)}%'");

			// Markers data.
			if (prm.HasMarkersData != SacsHierarchyItem.Params.BoolState.Either)
			{
				String lenComparison = (prm.HasMarkers == SacsHierarchyItem.Params.BoolState.True ? ">0" : "<1");
				filter.Add($"Len(LTrim(RTrim(IsNull({SaxDbDfn_Reference.GetTableNameQual(SaxDbDfn_Reference.TableIdx.UsgaMarker)})))){lenComparison}");
			}

			// Flags.
			if (prm.PriorityFlagState != SacsHierarchyItem.Params.FlagState.Either)
				filter.Add(DbQuery.BuildBitMappedFilter(SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Flags, aliasUsgaCourse), SaxGolfUsgaCourse.Flag_Priority, prm.PriorityFlagState == SacsHierarchyItem.Params.FlagState.True));

			// Associated data.
			if (prm.HasMarkers != SacsHierarchyItem.Params.BoolState.Either)
			{
				String existsPrefix = (prm.HasMarkers == SacsHierarchyItem.Params.BoolState.True ? "" : "Not ");
				filter.Add($"{existsPrefix} Exists (Select 1 From {SaxDbDfn_Reference.GetTableNameQual(SaxDbDfn_Reference.TableIdx.UsgaMarker)} Where {SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaMarker_CourseId)}={col_Id})");
			}

			// Notes.
			if (!StringUtil.IsEmpty(prm.NotesPartial))
				filter.Add($"{SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Notes, aliasUsgaCourse)} LIKE '%{DbQuery.FormatForLike(prm.NotesPartial)}%'");

			// Status.
			if (prm.StatusCat != SaxGolfUsgaCourse.StatusCat.Any)
				filter.Add($"{SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Status, aliasUsgaCourse)} {GetUsgaCourseStatusCatFilterCondition(prm.StatusCat)}");

			if (filter.Count < 1 && prm.IncludeDefaultFilter) filter.Add("1=1");
			return filter;
		}
		internal static String GetUsgaCourseStatusCatFilterCondition(SaxGolfUsgaCourse.StatusCat statusCat)
		{
			if (statusCat == SaxGolfUsgaCourse.StatusCat.ActiveOnly)
				return $"='{SacsSystem.GetStatusCode(SaStatus.Active)}'";
			if (statusCat == SaxGolfUsgaCourse.StatusCat.InactiveOnly)
				return $"='{SacsSystem.GetStatusCode(SaStatus.Inactive)}'";
			if (statusCat == SaxGolfUsgaCourse.StatusCat.NotDeleted)
				return $"!='{SacsSystem.GetStatusCode(SaStatus.Deleted)}'";
			if (statusCat == SaxGolfUsgaCourse.StatusCat.DeletedOnly)
				return $"='{SacsSystem.GetStatusCode(SaStatus.Deleted)}'";
			return "";
		}
		// Item sort columns.
		public HashSet<String> GetUsgaCourseSortColumns(SaxGolfUsgaCourse.Params prm)
		{
			// Sort sequence:
			HashSet<String> sortColumnNames = new HashSet<String>();
			foreach (var columnDfn in prm.SortColumns)
			{
				// Need to ensure correct alias used for UsgaCourse columns in case of conflict.
				String sortCol = String.Empty;
				if (SaxDbDfn_Reference.GetTableForColumn((SaxDbDfn_Reference.ColumnIdx)columnDfn.DbColumn) == SaxDbDfn_Reference.TableIdx.UsgaCourse)
				{
					sortCol = SaxDbDfn_Reference.GetColumnNameQual((SaxDbDfn_Reference.ColumnIdx)columnDfn.DbColumn, aliasUsgaCourse);
				}
				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();
			AddRandomSortColumn(prm, sortColumnNames);
			if (sortColumnNames.IsEmpty())
			{
				// Default sort columns.
				sortColumnNames.Add(SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Id, aliasUsgaCourse) + " ASC");
			}
			return sortColumnNames;
		}

		//-------------------------------------------------------------------
		// Item count.
		private long GetUsgaCourseCount(String filter)
		{
			ClearErrorState();
			return ReferenceDatabase.GetRowCount(SaxDbDfn_Reference.GetTableNameQual(SaxDbDfn_Reference.TableIdx.UsgaCourse) + " As " + aliasUsgaCourse, filter);
		}
		public override long GetUsgaCourseCount(SaxGolfUsgaCourse.Params prm)
		{
			ClearErrorState();
			return GetUsgaCourseCount(GetUsgaCourseQueryFilter(prm).Concat(" AND ", "(", ")"));
		}

		//-------------------------------------------------------------------
		// Item list.
		public override List<SaxGolfUsgaCourse> GetUsgaCourseList(SaxGolfUsgaCourse.Params prm)
		{
			ClearErrorState();
			List<SaxGolfUsgaCourse> userRoles = new List<SaxGolfUsgaCourse>();
			DbQuery qry = new DbQuery(ReferenceDatabase.DbmsType);
			qry.Tables.Add(SaxDbDfn_Reference.GetTableNameQual(SaxDbDfn_Reference.TableIdx.UsgaCourse), aliasUsgaCourse);
			Golf_UsgaCourse_Db dbUsgaCourse = new Golf_UsgaCourse_Db(ReferenceDbInfo);
			qry.Columns.AddRange(dbUsgaCourse.ExistingColumnNames);
			qry.Filters.AddRange(GetUsgaCourseQueryFilter(prm));
			qry.OrderBy.AddRange(GetUsgaCourseSortColumns(prm));
			// Query data.
			using (var dbConnection = ReferenceDatabase.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					dbCommand.CommandText = qry.BuildQuery(prm.ResultsPaging);
					using (DbDataReader dbDataReader = dbCommand.ExecuteReader())
					{
						while (dbDataReader.Read())
						{
							dbUsgaCourse = new Golf_UsgaCourse_Db(ReferenceDbInfo);
							dbUsgaCourse.PopulateFrom(dbDataReader);
							userRoles.Add(CreateUsgaCourse(dbUsgaCourse));
						}
					}
				}
				catch (Exception exc)
				{
					SetErrorState("Database query exception");
					SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
				}
			}
			return userRoles;
		}

		//-------------------------------------------------------------------
		// Item query execution.
		public override DbResultSet ExecuteUsgaCourseQuery(List<ColumnDfn> columns, SaxGolfUsgaCourse.Params prm)
		{
			ClearErrorState();

			//---------------------------------------------------------------------
			// Construct query.
			DbQuery query = new DbQuery(ReferenceDatabase.DbmsType);
			query.Tables.Add(SaxDbDfn_Reference.GetTableNameQual(SaxDbDfn_Reference.TableIdx.UsgaCourse), aliasUsgaCourse);

			// Add columns as defined in query list.
			if (columns.HasId(SaxGolfUsgaCourse.Column.Id))
				query.Columns.Add(SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Id, aliasUsgaCourse));
			bool hasFacilityCols = (columns.HasId(SaxGolfUsgaCourse.Column.Facility_Name));
			if (columns.HasId(SaxGolfUsgaCourse.Column.FacilityId) || hasFacilityCols)
				query.Columns.Add(SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_FacilityId, aliasUsgaCourse));
			if (columns.HasId(SaxGolfUsgaCourse.Column.UsgaCourseId))
				query.Columns.Add(SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_UsgaCourseId, aliasUsgaCourse));
			if (columns.HasId(SaxGolfUsgaCourse.Column.LegacyCrpCourseId))
				query.Columns.Add(SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_LegacyCrpCourseId, aliasUsgaCourse));
			if (columns.HasId(SaxGolfUsgaCourse.Column.Caption))
				query.Columns.Add(SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Caption, aliasUsgaCourse));
			if (columns.HasId(SaxGolfUsgaCourse.Column.CourseName))
				query.Columns.Add(SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_CourseName, aliasUsgaCourse));
			if (columns.HasId(SaxGolfUsgaCourse.Column.FullName))
				query.Columns.Add(SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_FullName, aliasUsgaCourse));
			if (columns.HasId(SaxGolfUsgaCourse.Column.Address1))
				query.Columns.Add(SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Address1, aliasUsgaCourse));
			if (columns.HasId(SaxGolfUsgaCourse.Column.Address2))
				query.Columns.Add(SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Address2, aliasUsgaCourse));
			if (columns.HasId(SaxGolfUsgaCourse.Column.City))
				query.Columns.Add(SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_City, aliasUsgaCourse));
			if (columns.HasId(SaxGolfUsgaCourse.Column.Email))
				query.Columns.Add(SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Email, aliasUsgaCourse));
			if (columns.HasId(SaxGolfUsgaCourse.Column.Telephone))
				query.Columns.Add(SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Telephone, aliasUsgaCourse));
			if (columns.HasId(SaxGolfUsgaCourse.Column.MarkersUpdateOn_Date))
				query.Columns.Add(SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_MarkersUpdateAt, aliasUsgaCourse));
			// Common properties.
			if (columns.HasId(SaxGolfUsgaCourse.Column.Notes))
				query.Columns.Add(SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Notes, aliasUsgaCourse));
			if (columns.HasId(SaxGolfUsgaCourse.Column.Flags))
				query.Columns.Add(SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Flags, aliasUsgaCourse));
			if (columns.HasId(SaxGolfUsgaCourse.Column.Status) || columns.HasId(SaxGolfUsgaCourse.Column.Status_Desc) || columns.HasId(SaxGolfUsgaCourse.Column.Status_Ind))
				query.Columns.Add(SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Status, aliasUsgaCourse));
			if (columns.HasId(SaxGolfUsgaCourse.Column.CreateOn_Date))
				query.Columns.Add(SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_CreateOn, aliasUsgaCourse));
			if (columns.HasId(SaxGolfUsgaCourse.Column.UpdateOn_Date))
				query.Columns.Add(SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_UpdateOn, aliasUsgaCourse));

			//---------------------------------------------------------------------
			// Facility.
			if (hasFacilityCols)
			{
				DbQueryJoin joinFacility = new DbQueryJoin(DbJoinType.LeftOuter);
				joinFacility.Table = new StringPair(SaxDbDfn_Reference.GetTableNameQual(SaxDbDfn_Reference.TableIdx.UsgaFacility), aliasUsgaCourse_Facility);
				joinFacility.Filters.Add(SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaFacility_Id, aliasUsgaCourse_Facility) + "=" + SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_FacilityId, aliasUsgaCourse));
				query.Joins.Add(joinFacility);
				List<SaxDbDfn_Reference.ColumnIdx> cols = new List<SaxDbDfn_Reference.ColumnIdx>();
				cols.Add(SaxDbDfn_Reference.ColumnIdx.UsgaFacility_UsgaFacilityId);
				cols.Add(SaxDbDfn_Reference.ColumnIdx.UsgaFacility_FacilityName);
				foreach (var col in cols)
					query.Columns.Add(SaxDbDfn_Reference.GetColumnNameQual(col, aliasUsgaCourse_Facility), prefixUsgaCourse_Facility + SaxDbDfn_Reference.GetColumnName(col, false));
				prm.Alias_Facility = aliasUsgaCourse_Facility;
			}

			//---------------------------------------------------------------------
			// Marker count.
			if (columns.HasId(SaxGolfUsgaCourse.Column.MarkerCount_All))
			{
				String aliasMarker = "aCrsMkr_Count";
				DbQuery queryMarker = new DbQuery(CoreDatabase.DbmsType);
				queryMarker.Tables.Add(SaxDbDfn_Reference.GetTableNameQual(SaxDbDfn_Reference.TableIdx.UsgaMarker), aliasMarker);
				queryMarker.Columns.Add("Count(*)");
				queryMarker.Filters.Add(SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaMarker_CourseId, aliasMarker) + "=" + SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Id, aliasUsgaCourse));
				query.Columns.Add("(" + queryMarker.BuildQuery() + ")", colCourse_Marker_Count);
			}

			// Active Marker count.
			if (columns.HasId(SaxGolfUsgaCourse.Column.MarkerCount_Active))
			{
				String aliasMarker = "aCrsMkrAct_Count";
				DbQuery queryMarker = new DbQuery(CoreDatabase.DbmsType);
				queryMarker.Tables.Add(SaxDbDfn_Reference.GetTableNameQual(SaxDbDfn_Reference.TableIdx.UsgaMarker), aliasMarker);
				queryMarker.Columns.Add("Count(*)");
				queryMarker.Filters.Add(SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaMarker_CourseId, aliasMarker) + "=" + SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaCourse_Id, aliasUsgaCourse));
				queryMarker.Filters.Add(SaxDbDfn_Reference.GetColumnNameQual(SaxDbDfn_Reference.ColumnIdx.UsgaMarker_Status, aliasMarker) + "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'");
				query.Columns.Add("(" + queryMarker.BuildQuery() + ")", colCourse_Marker_Active_Count);
			}

			//---------------------------------------------------------------------
			// Populate filter.
			query.Filters.AddRange(GetUsgaCourseQueryFilter(prm));

			if (prm.IdsIncluded.Count != 1)
			{
				// Configure sort sequence.
				foreach (String sortColumn in GetUsgaCourseSortColumns(prm))
					query.OrderBy.Add(sortColumn);
			}

			//---------------------------------------------------------------------
			//return new DbResultSet_DataTableReader(db, query.BuildQuery(prm.ResultsPaging));
			return DbResultSet_DataReader.ExecuteQuery(ReferenceDatabase, query.BuildQuery(prm.ResultsPaging));
		}

		//-------------------------------------------------------------------
	}
	//=======================================================================
}