using Sarand.BusinessMgr.Net.Standard.Base.App;
using Sarand.BusinessMgr.Net.Standard.Base.Bus;
using Sarand.BusinessMgr.Net.Standard.Dbas.Bus;
using Sarand.BusinessMgr.Net.Standard.Dbas.Internal;
using Sarand.BusinessMgr.Net.Standard.Dbas.UpdateLog;
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 System;
using System.Collections.Generic;
using System.Data.Common;
using System.Linq;

namespace Sarand.BusinessMgr.Net.Standard.Dbas.Mgr
{
	//=======================================================================
	partial class SbmProcessMgr_Dbas
	{
		//*******************************************************************
		//                         P r o c e s s e s
		//*******************************************************************
		// Utilities.
		private List<StringPair> GetLogProperties(SbmProcess process)
		{
			return new List<StringPair>()
			{
				new StringPair("Id",SysId.ToString(process.Id)),
				new StringPair("DescBrief",process.DescBrief),
				new StringPair("Status",process.StatusCode)
			};
		}

		//-------------------------------------------------------------------
		// Processes by type.
		private class ProcessInfoCache
		{
			public Dictionary<Sbm.ProcessCategory, long> ProcessCountByCategory { get; set; } = null;
		}
		private ProcessInfoCache processInfoCache = new SbmProcessMgr_Dbas.ProcessInfoCache();
		public override bool HasProcesses(Sbm.ProcessCategory processCategory)
		{
			if (!SysId.IsValid(AffiliateId_Owner)) return false;
			if (processInfoCache.ProcessCountByCategory == null)
			{
				// Populate cache with process count by category.
				processInfoCache.ProcessCountByCategory = new Dictionary<Sbm.ProcessCategory, long>();
				DbQuery query = new DbQuery(Database.DbmsType);
				query.Tables.Add(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.Process));
				query.Filters.Add(SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.Process_AffIdOwner, false) + "=" + SysId.ToString(AffiliateId_Owner));
				String colCategory = "ProcessCategory";
				String colCount = "ProcessCount";
				query.Columns.Add(SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.Process_Category), colCategory);
				query.Columns.Add("Count(*)", colCount);
				query.GroupBy.Add(SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.Process_Category));
				using (DbResultSet resultSet = DbResultSet_DataReader.ExecuteQuery(db, query.BuildQuery()))
				{
					while (resultSet.NextRecord())
					{
						NamedValue.Map values = resultSet.GetRecordValues();
						Sbm.ProcessCategory category = (Sbm.ProcessCategory)values.GetLong(colCategory);
						long count = values.GetLong(colCount);
						processInfoCache.ProcessCountByCategory[category] = count;
					}
				}

				List<String> filters = new List<String>();
				filters.Add(SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.Process_AffIdOwner) + "=" + SysId.ToString(AffiliateId_Owner));
				if (processCategory > 0)
					filters.Add(SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.Process_Category) + "=" + ((int)processCategory).ToString());
				//return db.GetRowCount(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.Process), filters.Concat(" AND ", "(", ")")) > 0;
			}
			return processInfoCache.ProcessCountByCategory.GetValue(processCategory, 0) > 0;
		}

		//-------------------------------------------------------------------
		// Get Process.
		public override SbmProcess GetProcess(SbmProcess.Params prm)
		{
			return GetProcess(GetProcessQueryFilter(prm).Concat(" AND ", "(", ")"));
		}
		private SbmProcess GetProcess(String filter)
		{
			ClearErrorState();
			long count = GetProcessCount(filter);
			if (count == 0) return null;
			if (count != 1)
			{
				SetErrorState("Multiple Asset Processes found");
				return null;
			}
			SbmProcess prmProcess = null;
			// Query data.
			using (var dbConnection = db.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					Process_Db dbProcess = new Process_Db(DbInfo);
					dbProcess.PopulateFrom(dbCommand, aliasProcess, filter);
					prmProcess = CreateProcess(dbProcess);
				}
				catch (Exception exc)
				{
					SetErrorState("Database query exception");
					SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
				}
			}
			return prmProcess;
		}

		public override short GetProcessSeqMax()
		{
			if (!SysId.IsValid(AffiliateId_Owner)) return 0;
			String filter = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.Process_AffIdOwner) + "=" + AffiliateId_Owner.ToString();
			return (short)db.GetRowValue(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.Process), SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.Process_Seq), filter, DbGetValueType.eDbValueMax).AsLong();
		}

		//-------------------------------------------------------------------
		// Create Process.
		public override SbmProcess CreateProcess(Sbm.ProcessCategory processCategory)
		{
			ClearErrorState();
			SbmProcess process = null;
			if (processCategory > 0)
				process = new SbmProcess_Dbas(Internals, new SysId(), AffiliateId_Owner, processCategory, 0);
			else SetErrorState("Asset type not identified");
			return process;
		}
		private SbmProcess_Dbas CreateProcess(Process_Db dbProcess)
		{
			ClearErrorState();
			SbmProcess_Dbas process = new SbmProcess_Dbas(Internals, new SysId(dbProcess._Id), new SysId(dbProcess._AffIdOwner), (Sbm.ProcessCategory)dbProcess._Category, (ushort)dbProcess._Flags);
			PopulateFrom(dbProcess, process);
			return process;
		}

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

		//-------------------------------------------------------------------
		// Insert Process.
		public override bool InsertProcess(SbmProcess process, DbUpdateInfo dbUpdateInfo)
		{
			String fn = GetType().Name + ".InsertProcess";
			ClearErrorState();
			if (!IsValidProcess(process)) return false;
			if (SysId.IsValid(process.Id)) return SetErrorState(ErrorMessage.ValiditemId);
			using (var dbConnection = db.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					Process_Db dbProcess = new Process_Db(DbInfo);
					PopulateTo(dbProcess, process, dbUpdateInfo);
					if (Process_Db.FieldsNonId.Contains("Id"))
					{
						// Generate next Id.
						dbProcess._Id = SysId.ToInt(db.GetNextId("Process", dbUpdateInfo));
					}
					dbProcess.ExecuteInsertCommand(dbCommand);
					process.Id = new SysId(dbProcess._Id);
					process.Changed = false;
					if (DebugMode) SaLogger.Debug(fn + " Inserted. " + GetLogProperties(process).Concat(": ").Concat("", "\n\t"));
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
		// Update Process.
		public override bool UpdateProcess(SbmProcess process, DbUpdateInfo dbUpdateInfo)
		{
			String fn = GetType().Name + ".UpdateProcess";
			ClearErrorState();
			if (!IsValidProcess(process)) return false;
			if (!SysId.IsValid(process.Id)) return SetErrorState(ErrorMessage.InvalidItemId);
			if (!process.Changed)
			{
				if (DebugMode) SaLogger.Debug(fn + " Data not changed. " + GetLogProperties(process).Concat(": ").Concat("", "\n\t"));
				return true;
			}
			using (var dbConnection = db.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					// Retrieve Process.
					dbConnection.Open();
					Process_Db dbProcess = new Process_Db(DbInfo);
					dbProcess.PopulateFrom(dbCommand, aliasProcess, "Id=" + SysId.ToString(process.Id));
					SbmUpdateLogItemMonitor_Process updateLogMonitor = new SbmUpdateLogItemMonitor_Process(Internals, CreateProcess(dbProcess));

					// Update properties.
					PopulateTo(dbProcess, process, dbUpdateInfo);
					dbProcess.ExecuteUpdateCommand(dbCommand);
					process.Changed = false;
					if (DebugMode) SaLogger.Debug(fn + " Updated. " + GetLogProperties(process).Concat(": ").Concat("", "\n\t"));

					// Record updates.
					updateLogMonitor.RecordUpdatedValues(process);
					updateLogMonitor.LogUpdates();
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
		// Delete Process.
		public override bool ProcessCanBeDeleted(SbmProcess process)
		{
			ClearErrorState();
			if (!base.ProcessCanBeDeleted(process)) return false;
			return true;
		}
		public override bool DeleteProcess(SbmProcess process, DbUpdateInfo dbUpdateInfo)
		{
			String fn = GetType().Name + ".DeleteProcess";
			ClearErrorState();
			if (!ProcessCanBeDeleted(process)) return false;
			using (var dbConnection = db.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					// Retrieve prmProcess.
					dbConnection.Open();
					Process_Db dbProcess = new Process_Db(DbInfo);
					dbProcess.PopulateFrom(dbCommand, aliasProcess, "Id=" + process.Id.ToString());
					// Delete prmProcess.
					dbCommand.CommandType = System.Data.CommandType.Text;
					dbCommand.CommandText = "DELETE FROM " + SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.Process) + " WHERE Id=" + SysId.ToString(process.Id) + ";";
					dbCommand.ExecuteNonQuery();
					process.Changed = false;
					if (DebugMode) SaLogger.Debug(fn + " Deleted. " + GetLogProperties(process).Concat(": ").Concat("", "\n\t"));
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
		// Copy data properties to and from database.
		private void PopulateTo(Process_Db dbProcess, SbmProcess process, DbUpdateInfo dbUpdateInfo)
		{
			dbProcess._Id = process.Id.ToInt();
			dbProcess._Category = (short)process.ProcessCategory;
			dbProcess._Type = (short)process.ProcessType;
			dbProcess._Seq = process.Seq;
			dbProcess._DescBrief = process.DescBrief;
			dbProcess._DescOutline = process.DescOutline;
			// Common properties.
			dbProcess._Notes = process.Notes;
			dbProcess._Status = SacsSystem.GetStatusCode(process.Status);
			dbProcess._Flags = (short)process.Flags;
			if (!SysId.IsValid(process.Id))
			{
				dbProcess._CreateOn = DateTime.UtcNow;
				dbProcess._CreateBy = dbUpdateInfo.UserId.ToInt();
				dbProcess._CreateHost = dbUpdateInfo.Host;
			}
			dbProcess._UpdateOn = DateTime.UtcNow;
			dbProcess._UpdateBy = dbUpdateInfo.UserId.ToInt();
			dbProcess._UpdateHost = dbUpdateInfo.Host;
		}
		private void PopulateFrom(Process_Db dbProcess, SbmProcess process)
		{
			//process.Id = new SysId(dbProcess._Id);
			process.ProcessCategory = (Sbm.ProcessCategory)dbProcess._Category;
			process.ProcessType = (Sbm.ProcessType)dbProcess._Type;
			process.Seq = dbProcess._Seq;
			process.DescBrief = dbProcess._DescBrief;
			process.DescOutline = dbProcess._DescOutline;
			// Common properties.
			process.Notes = dbProcess._Notes;
			process.Status = SacsSystem.GetStatusForCode(dbProcess._Status);
			process.SetCreateStamp(dbProcess._CreateOn, new SysId(dbProcess._CreateBy), dbProcess._CreateHost);
			process.SetUpdateStamp(dbProcess._UpdateOn, new SysId(dbProcess._UpdateBy), dbProcess._UpdateHost);
			process.AcceptChanges();
		}

		//-------------------------------------------------------------------
		// Column definitions.
		private static readonly String aliasProcess = "aPrc";

		// Column definition population.
		private void SetProcessColDfn
			(ColumnDfn col, String caption, int width, SbmDbDfn.ColumnIdx dbCol,
			ColumnAlignment align = ColumnAlignment.Default, DataValue.DataType dataType = DataValue.DataType.String,
			String alias = "", String prefix = "")
		{
			if (String.IsNullOrEmpty(alias) && SbmDbDfn.GetTableForColumn(dbCol) == SbmDbDfn.TableIdx.Process)
				alias = aliasProcess;
			col.Set(caption, width, (int)dbCol, prefix + SbmDbDfn.GetColumnName(dbCol, false), SbmDbDfn.GetColumnNameQual(dbCol, alias), dataType, align);
			if (dataType == DataValue.DataType.String && dbCol != SbmDbDfn.ColumnIdx.Unknown)
				col.MaxLength = (int)SbmDbDfn.GetColTextLen(dbCol);
		}
		//-------------------------------------------------------------------
		// Getting Process column definition.
		public override ColumnDfn GetProcessColumnDfn(SbmProcess.Column columnId, string caption = "", int width = 0)
		{
			ColumnDfn columnDfn = new ColumnDfn((int)columnId, caption, width);
			switch (columnId)
			{
				// Process Properties
				case SbmProcess.Column.Pos:
					SetProcessColDfn(columnDfn, "Pos", 45, SbmDbDfn.ColumnIdx.Unknown, ColumnAlignment.Right);
					columnDfn.SortMode = ColumnDfn.ColumnSortMode.Off;
					columnDfn.ReadOnly = true;
					columnDfn.Resizable = false;
					break;
				/*case SbmProcess.Column.Id:
					SetProcessColDfn(columnDfn, "Id", 60, SbmDbDfn.ColumnIdx.Process_Id, ColumnAlignment.Right, DataValue.DataType.Long);
					columnDfn.ReadOnly = true;
					break;*/
				case SbmProcess.Column.Category:
					SetProcessColDfn(columnDfn, "Category", 80, SbmDbDfn.ColumnIdx.Process_Category, ColumnAlignment.Center, DataValue.DataType.Long);
					break;
				case SbmProcess.Column.Category_Desc:
					SetProcessColDfn(columnDfn, "Category Desc", 100, SbmDbDfn.ColumnIdx.Process_Category, ColumnAlignment.Left, DataValue.DataType.String);
					break;
				case SbmProcess.Column.Type:
					SetProcessColDfn(columnDfn, "Type", 80, SbmDbDfn.ColumnIdx.Process_Type, ColumnAlignment.Center, DataValue.DataType.Long);
					break;
				case SbmProcess.Column.Type_Desc:
					SetProcessColDfn(columnDfn, "Type Desc", 00, SbmDbDfn.ColumnIdx.Process_Type, ColumnAlignment.Left, DataValue.DataType.String);
					break;
				case SbmProcess.Column.Seq:
					SetProcessColDfn(columnDfn, "Sequence", 80, SbmDbDfn.ColumnIdx.Process_Seq, ColumnAlignment.Center, DataValue.DataType.Long);
					break;
				case SbmProcess.Column.DescBrief:
					SetProcessColDfn(columnDfn, "Description", 120, SbmDbDfn.ColumnIdx.Process_DescBrief);
					break;
				case SbmProcess.Column.DescOutline:
					SetProcessColDfn(columnDfn, "Outline", 140, SbmDbDfn.ColumnIdx.Process_DescOutline);
					break;

				// Common properties.
				case SbmProcess.Column.Notes:
					SetProcessColDfn(columnDfn, "Notes", 200, SbmDbDfn.ColumnIdx.Process_Notes);
					break;
				case SbmProcess.Column.Flag:
					SetProcessColDfn(columnDfn, "Flags", 40, SbmDbDfn.ColumnIdx.Process_Flags, ColumnAlignment.Center, DataValue.DataType.Long);
					break;
				case SbmProcess.Column.Status:
					SetProcessColDfn(columnDfn, "Status", 80, SbmDbDfn.ColumnIdx.Process_Status, ColumnAlignment.Center);
					break;
				case SbmProcess.Column.Status_Desc:
					SetProcessColDfn(columnDfn, "Status", 80, SbmDbDfn.ColumnIdx.Process_Status);
					break;
				case SbmProcess.Column.Status_Ind:
					SetProcessColDfn(columnDfn, "Status", 80, SbmDbDfn.ColumnIdx.Process_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
					columnDfn.TriStateFormat = ColumnTriStateFormat.Lights;
					break;
				case SbmProcess.Column.CreateOn_Date:
					SetProcessColDfn(columnDfn, "Created", 80, SbmDbDfn.ColumnIdx.Process_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
					columnDfn.DateFormat = "d-MMM-yy";
					columnDfn.ReadOnly = true;
					break;
				case SbmProcess.Column.UpdateOn_Date:
					SetProcessColDfn(columnDfn, "Updated", 80, SbmDbDfn.ColumnIdx.Process_UpdateOn, ColumnAlignment.Center, DataValue.DataType.Date);
					columnDfn.DateFormat = "d-MMM-yy";
					columnDfn.ReadOnly = true;
					break;
			}
			if (!String.IsNullOrEmpty(caption))
				columnDfn.Caption = caption;
			if (width > 0)
				columnDfn.Width = width;
			return columnDfn;
		}

		//-------------------------------------------------------------------
		// Process query filter.
		public override List<string> GetProcessQueryFilter(SbmProcess.Params prm)
		{
			List<String> filter = new List<String>();

			//--------------------------------------------------------------- -
			// Process Id.
			String includedIds = prm.IncludedIds.Concat(",");
			String colProcess_Id = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Process_Id, aliasProcess);
			if (!includedIds.IsEmpty())
				filter.Add(colProcess_Id + " IN (" + includedIds + ")");
			String excludedIds = prm.ExcludedIds.Concat(",");
			if (!excludedIds.IsEmpty())
				filter.Add(colProcess_Id + " NOT IN (" + excludedIds + ")");

			// Affiliate Owner.
			filter.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Process_AffIdOwner, aliasProcess) + "=" + AffiliateId_Owner.ToString());

			// Category.
			String colProcess_Category = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Process_Category, aliasProcess);
			if (prm.ProcessCategory > 0)
				filter.Add(colProcess_Category + "=" + ((int)prm.ProcessCategory).ToString());

			// Type.
			String colProcess_Type = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Process_Type, aliasProcess);
			if (prm.ProcessType > 0)
				filter.Add(colProcess_Type + "=" + ((int)prm.ProcessType).ToString());

			// DescBrief.
			String colProcess_DescBrief = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Process_DescBrief, aliasProcess);
			if (!StringUtil.IsEmpty(prm.DescBrief))
				filter.Add(colProcess_DescBrief + " LIKE '" + DbQuery.FormatForLike(prm.DescBrief) + "%'");

			//--------------------------------------------------------------- -
			// Restrict to active.
			if (prm.RestrictToActive)
				filter.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Process_Status, aliasProcess) + "='" + StatusActive + "'");

			// Restrict to commodity defaults.
			if (prm.RestrictToDefaults)
			{
				filter.Add(DbQuery.BuildBitMappedFilter(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Process_Flags, aliasProcess), SbmProcess.Flag_Default, true));
			}

			if (filter.Count < 1 && prm.IncludeDefaultFilter) filter.Add("1=1");
			return filter;
		}

		// Process sort columns.
		public List<String> GetProcessSortColumns(SbmProcess.Params prm)
		{
			// Sort sequence:
			List<String> sortColumnCodes = new List<String>();
			foreach (var columnDfn in prm.SortColumns)
			{
				// Need to ensure correct alias used for Process columns in case of conflict.
				String sortCol = String.Empty;
				if (SbmDbDfn.GetTableForColumn((SbmDbDfn.ColumnIdx)columnDfn.DbColumn) == SbmDbDfn.TableIdx.Process)
				{
					sortCol = SbmDbDfn.GetColumnNameQual((SbmDbDfn.ColumnIdx)columnDfn.DbColumn, aliasProcess);
				}
				else
				{
					sortCol = columnDfn.DataName;
					if (!StringUtil.IsEmpty(columnDfn.SortDataName))
						sortCol = columnDfn.SortDataName;
				}
				if (!sortCol.IsEmpty())
				{
					DbOrderByNullMode orderByNullMode = DbOrderByNullMode.Default; // eSaOrderByDemoteNulls, eSaOrderByPromoteNulls
					sortColumnCodes.Add(DbQuery.FormatForOrderBy(sortCol, columnDfn.SortAscending, orderByNullMode).Concat(", "));
				}
			}
			sortColumnCodes.RemoveBlanks();
			if (sortColumnCodes.IsEmpty())
			{
				// Default sort columns:
				sortColumnCodes.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Process_AffIdOwner, aliasProcess) + " ASC");
			}
			return sortColumnCodes;
		}

		//-------------------------------------------------------------------
		// Process count.
		private long GetProcessCount(String filter)
		{
			ClearErrorState();
			return db.GetRowCount(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.Process) + " As " + aliasProcess, filter);
		}
		public override long GetProcessCount(SbmProcess.Params prm)
		{
			ClearErrorState();
			return GetProcessCount(GetProcessQueryFilter(prm).Concat(" AND ", "(", ")"));
		}

		//-------------------------------------------------------------------
		// Process list.
		public override List<SbmProcess> GetProcessList(SbmProcess.Params prm)
		{
			ClearErrorState();
			List<SbmProcess> processes = new List<SbmProcess>();
			DbQuery qry = new DbQuery(db.DbmsType);
			qry.Tables.Add(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.Process), aliasProcess);
			Process_Db dbProcess = new Process_Db(DbInfo);
			qry.Columns.AddRange(dbProcess.ExistingColumnNames);
			qry.Filters.AddRange(GetProcessQueryFilter(prm));
			qry.OrderBy.AddRange(GetProcessSortColumns(prm));
			// Query data.
			using (var dbConnection = db.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					dbCommand.CommandText = qry.BuildQuery(prm.ResultsPaging);
					using (DbDataReader dbDataReader = dbCommand.ExecuteReader())
					{
						while (dbDataReader.Read())
						{
							dbProcess = new Process_Db(DbInfo);
							dbProcess.PopulateFrom(dbDataReader);
							processes.Add(CreateProcess(dbProcess));
						}
					}
				}
				catch (Exception exc)
				{
					SetErrorState("Database query exception");
					SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
				}
			}
			return processes;
		}

		//-------------------------------------------------------------------
		// Process query execution.
		public override DbResultSet ExecuteProcessQuery(List<ColumnDfn> columns, SbmProcess.Params prm)
		{
			ClearErrorState();
			//---------------------------------------------------------------------
			// Construct build database query.
			DbQuery query = new DbQuery(db.DbmsType);
			query.Tables.Add(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.Process), aliasProcess);

			// Process Properties - add columns as defined in query list.
			if (columns.HasId((int)SbmProcess.Column.Category) || columns.HasId((int)SbmProcess.Column.Category_Desc))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Process_Category, aliasProcess));
			if (columns.HasId((int)SbmProcess.Column.Type) || columns.HasId((int)SbmProcess.Column.Type_Desc))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Process_Type, aliasProcess));
			if (columns.HasId((int)SbmProcess.Column.DescBrief))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Process_DescBrief, aliasProcess));
			if (columns.HasId((int)SbmProcess.Column.DescOutline))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Process_DescOutline, aliasProcess));
			if (columns.HasId((int)SbmProcess.Column.Seq))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Process_Seq, aliasProcess));

			// Common Properties
			if (columns.HasId((int)SbmProcess.Column.Notes))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Process_Notes, aliasProcess));
			if (columns.HasId((int)SbmProcess.Column.Flag))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Process_Flags, aliasProcess));
			if (columns.HasId((int)SbmProcess.Column.Status) || columns.HasId((int)SbmProcess.Column.Status_Desc) || columns.HasId((int)SbmProcess.Column.Status_Ind))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Process_Status, aliasProcess));
			if (columns.HasId((int)SbmProcess.Column.CreateOn_Date))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Process_CreateOn, aliasProcess));
			if (columns.HasId((int)SbmProcess.Column.UpdateOn_Date))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Process_UpdateOn, aliasProcess));

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

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

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