using Sarand.BusinessMgr.Net.Standard.Base.App;
using Sarand.BusinessMgr.Net.Standard.Base.Bus;
using Sarand.BusinessMgr.Net.Standard.Base.Bus.Control;
using Sarand.BusinessMgr.Net.Standard.Base.Mgr;
using Sarand.BusinessMgr.Net.Standard.Base.Mgr.Control;
using Sarand.BusinessMgr.Net.Standard.Dbas.Bus;
using Sarand.BusinessMgr.Net.Standard.Dbas.Bus.Control;
using Sarand.BusinessMgr.Net.Standard.Dbas.Internal;
using Sarand.BusinessMgr.Net.Standard.Dbas.Internal.Control;
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;
using System.Text.RegularExpressions;

namespace Sarand.BusinessMgr.Net.Standard.Dbas.Mgr
{
	//=======================================================================
	// Control - Item Manager - ItemParams.
	//=======================================================================
	partial class SbmcItemMgr_Dbas
	{
		//-------------------------------------------------------------------
		// Utilities.
		private List<StringPair> GetLogProperties(SbmcItemParam itemParam)
		{
			return new List<StringPair>()
			{
				new StringPair("Id",SysId.ToString(itemParam.Id)),
				new StringPair("ItemId",ItemId.ToString(itemParam.ItemId)),
				new StringPair("Context",itemParam.Context),
				new StringPair("Name",itemParam.Name),
				new StringPair("Status",itemParam.StatusCode)
			};
		}

		//-------------------------------------------------------------------
		// Create item.
		public override SbmcItemParam CreateItemParam(ItemId itemId)
		{
			return new SbmcItemParam_Dbas(null, itemId, 0);
		}
		private SbmcItemParam_Dbas CreateItemParam(ItemParam_Db dbItemParam)
		{
			ClearErrorState();
			SbmcItemParam_Dbas itemParam = new SbmcItemParam_Dbas(new SysId(dbItemParam._Id), new ItemId(dbItemParam._ItemType, new SysId(dbItemParam._ItemId)), (ushort)dbItemParam._Flags);
			PopulateFrom(dbItemParam, itemParam);
			return itemParam;
		}

		//-------------------------------------------------------------------
		// Get item.
		public override SbmcItemParam GetItemParam(SbmcItemParam.Params prm)
		{
			return GetItemParam(GetItemParamQueryFilter(prm).Concat(" AND ", "(", ")"));
		}
		private SbmcItemParam GetItemParam(String filter)
		{
			ClearErrorState();
			long count = GetItemParamCount(filter);
			if (count == 0) return null;
			if (count != 1)
			{
				SetErrorState("Multiple ItemParames found");
				return null;
			}
			SbmcItemParam itemParam = null;
			// Query data.
			using (var dbConnection = db.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					ItemParam_Db dbItemParam = new ItemParam_Db(DbInfo);
					dbItemParam.PopulateFrom(dbCommand, aliasItemParam, filter);
					itemParam = CreateItemParam(dbItemParam);
				}
				catch (Exception exc)
				{
					SetErrorState("ItemParam query exception");
					SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
				}
			}
			return itemParam;
		}

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

		//-------------------------------------------------------------------
		// Insert item.
		public override bool InsertItemParam(SbmcItemParam itemParam, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!IsValidItemParam(itemParam)) return false;
			if (SysId.IsValid(itemParam.Id)) return SetErrorState(ErrorMessage.ValiditemId);
			using (var dbConnection = db.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					ItemParam_Db dbItemParam = new ItemParam_Db(DbInfo);
					PopulateTo(dbItemParam, itemParam, dbUpdateInfo);
					if (ItemParam_Db.FieldsNonId.Contains("Id"))
					{
						// Generate next Id.
						dbItemParam._Id = SysId.ToInt(db.GetNextId("ItemParam", dbUpdateInfo));
					}
					dbItemParam.ExecuteInsertCommand(dbCommand);
					itemParam.Id = new SysId(dbItemParam._Id);
					itemParam.Changed = false;
					if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Inserted. {GetLogProperties(itemParam).Concat(": ").Concat("", "\n\t")}");
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
		// Update item.
		public override bool UpdateItemParam(SbmcItemParam itemParam, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!IsValidItemParam(itemParam)) return false;
			if (!SysId.IsValid(itemParam.Id)) return SetErrorState(ErrorMessage.InvalidItemId);
			if (!itemParam.Changed)
			{
				if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Data not changed. {GetLogProperties(itemParam).Concat(": ").Concat("", "\n\t")}");
				return true;
			}
			using (var dbConnection = db.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					// Retrieve item.
					dbConnection.Open();
					ItemParam_Db dbItemParam = new ItemParam_Db(DbInfo);
					dbItemParam.PopulateFrom(dbCommand, aliasItemParam, $"Id={SysId.ToString(itemParam.Id)}");
					//SbmUpdateLogItemMonitor_ItemParam updateLogMonitor = new SbmUpdateLogItemMonitor_ItemParam(Internals, CreateItemParam(dbItemParam));

					// Update properties.
					PopulateTo(dbItemParam, itemParam, dbUpdateInfo);
					dbItemParam.ExecuteUpdateCommand(dbCommand);
					itemParam.Changed = false;
					if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Updated. {GetLogProperties(itemParam).Concat(": ").Concat("", "\n\t")}");

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

		//-------------------------------------------------------------------
		// Delete item.
		public override bool ItemParamCanBeDeleted(SbmcItemParam itemParam)
		{
			ClearErrorState();
			if (!base.ItemParamCanBeDeleted(itemParam)) return false;
			return true;
		}
		public override bool DeleteItemParam(SbmcItemParam itemParam, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!ItemParamCanBeDeleted(itemParam)) return false;
			using (var dbConnection = db.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					// Retrieve item.
					dbConnection.Open();
					ItemParam_Db dbItemParam = new ItemParam_Db(DbInfo);
					dbItemParam.PopulateFrom(dbCommand, aliasItemParam, $"Id={SysId.ToString(itemParam.Id)}");
					// Delete item.
					dbCommand.CommandType = System.Data.CommandType.Text;
					dbCommand.CommandText = $"DELETE FROM {SbmDbDfn_Control.GetTableName(SbmDbDfn_Control.TableIdx.ItemParam)} WHERE Id={SysId.ToString(itemParam.Id)};";
					dbCommand.ExecuteNonQuery();
					itemParam.Changed = false;
					if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Deleted. {GetLogProperties(itemParam).Concat(": ").Concat("", "\n\t")}");
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
		// Copy data properties to and from item.
		private void PopulateTo(ItemParam_Db dbItemParam, SbmcItemParam itemParam, DbUpdateInfo dbUpdateInfo)
		{
			dbItemParam._Id = itemParam.Id.ToInt();
			dbItemParam._ItemType = itemParam.ItemId.Type;
			dbItemParam._ItemId = itemParam.ItemId.Id.ToLong();
			dbItemParam._Context = itemParam.Context;
			dbItemParam._Name = itemParam.Name;
			dbItemParam._Value = itemParam.Value;
			// Common properties.
			dbItemParam._Notes = itemParam.Notes;
			dbItemParam._Status = SacsSystem.GetStatusCode(itemParam.Status);
			dbItemParam._Flags = (short)itemParam.Flags;
			if (!SysId.IsValid(itemParam.Id))
			{
				dbItemParam._CreateOn = DateTime.UtcNow;
				dbItemParam._CreateBy = dbUpdateInfo.UserId.ToInt();
				dbItemParam._CreateHost = dbUpdateInfo.Host;
			}
			dbItemParam._UpdateOn = DateTime.UtcNow;
			dbItemParam._UpdateBy = dbUpdateInfo.UserId.ToInt();
			dbItemParam._UpdateHost = dbUpdateInfo.Host;
		}
		private void PopulateFrom(ItemParam_Db dbItemParam, SbmcItemParam itemParam)
		{
			//itemParam.Id = new SysId(dbItemParam._Id);
			//itemParam.ItemId = new ItemId(dbItemParam._ItemType, new SysId(dbItemParam._ItemId));
			itemParam.Name = dbItemParam._Name;
			itemParam.Context = dbItemParam._Context;
			itemParam.Value = dbItemParam._Value;
			// Common properties.
			itemParam.Notes = dbItemParam._Notes;
			itemParam.Status = SacsSystem.GetStatusForCode(dbItemParam._Status);
			itemParam.SetCreateStamp(dbItemParam._CreateOn, new SysId(dbItemParam._CreateBy), dbItemParam._CreateHost);
			itemParam.SetUpdateStamp(dbItemParam._UpdateOn, new SysId(dbItemParam._UpdateBy), dbItemParam._UpdateHost);
			itemParam.AcceptChanges();
		}

		//-------------------------------------------------------------------
		// Item column definitions.
		private static readonly String aliasItemParam = "Ipm";
		private static readonly String aliasItemParam_Item_Owner = "Ipm_Itm_Own";
		private static readonly String aliasItemParam_Item_Repository = "Ipm_Itm_Rty";
		private static readonly String colNameItemParam_ItemCaption = "ItemCaption";
		private void SetItemParamColDfn
			(ColumnDfn col, String caption, int width, SbmDbDfn_Control.ColumnIdx dbCol,
			ColumnAlignment align = ColumnAlignment.Default, DataValue.DataType dataType = DataValue.DataType.String,
			String alias = "", String prefix = "")
		{
			if (String.IsNullOrEmpty(alias) && SbmDbDfn_Control.GetTableForColumn(dbCol) == SbmDbDfn_Control.TableIdx.ItemParam)
				alias = aliasItemParam;
			col.Set(caption, width, (int)dbCol, prefix + SbmDbDfn_Control.GetColumnName(dbCol, false), SbmDbDfn_Control.GetColumnNameQual(dbCol, alias), dataType, align);
			if (dataType == DataValue.DataType.String && dbCol != SbmDbDfn_Control.ColumnIdx.Unknown)
				col.MaxLength = (int)SbmDbDfn_Control.GetColTextLen(dbCol);
		}

		//-------------------------------------------------------------------
		// Item column definition.
		public override ColumnDfn GetItemParamColumnDfn(SbmcItemParam.Column columnId, string caption = "", int width = 0)
		{
			ColumnDfn columnDfn = new ColumnDfn((int)columnId, caption, width);
			switch (columnId)
			{
				case SbmcItemParam.Column.Pos:
					SetItemParamColDfn(columnDfn, "Pos", 45, SbmDbDfn_Control.ColumnIdx.Unknown, ColumnAlignment.Right);
					columnDfn.SortMode = ColumnDfn.ColumnSortMode.Off;
					columnDfn.ReadOnly = true;
					columnDfn.Resizable = false;
					break;
				case SbmcItemParam.Column.Id:
					SetItemParamColDfn(columnDfn, "Id", 60, SbmDbDfn_Control.ColumnIdx.ItemParam_Id, ColumnAlignment.Right, DataValue.DataType.Long);
					columnDfn.ReadOnly = true;
					break;

				// Item properties.
				case SbmcItemParam.Column.ItemType:
					SetItemParamColDfn(columnDfn, "Item type", 80, SbmDbDfn_Control.ColumnIdx.ItemParam_ItemType, ColumnAlignment.Center, DataValue.DataType.Long);
					break;
				case SbmcItemParam.Column.ItemType_Caption:
					SetItemParamColDfn(columnDfn, "Item type", 120, SbmDbDfn_Control.ColumnIdx.ItemParam_ItemType, ColumnAlignment.Center, DataValue.DataType.String);
					break;
				case SbmcItemParam.Column.ItemId:
					SetItemParamColDfn(columnDfn, "Item id", 160, SbmDbDfn_Control.ColumnIdx.ItemParam_ItemId, ColumnAlignment.Center, DataValue.DataType.Long);
					break;
				case SbmcItemParam.Column.Item_Caption:
					SetItemParamColDfn(columnDfn, "Item", 160, SbmDbDfn_Control.ColumnIdx.Unknown, ColumnAlignment.Left, DataValue.DataType.String);
					columnDfn.DataName = colNameItemParam_ItemCaption;
					break;

				// Properties.
				case SbmcItemParam.Column.Context:
					SetItemParamColDfn(columnDfn, "Context", 160, SbmDbDfn_Control.ColumnIdx.ItemParam_Context, ColumnAlignment.Left, DataValue.DataType.String);
					break;
				case SbmcItemParam.Column.Name:
					SetItemParamColDfn(columnDfn, "Name", 160, SbmDbDfn_Control.ColumnIdx.ItemParam_Name, ColumnAlignment.Left, DataValue.DataType.String);
					break;
				case SbmcItemParam.Column.Value:
					SetItemParamColDfn(columnDfn, "Value", 240, SbmDbDfn_Control.ColumnIdx.ItemParam_Value, ColumnAlignment.Left, DataValue.DataType.String);
					break;

				// Common properties.
				case SbmcItemParam.Column.Notes:
					SetItemParamColDfn(columnDfn, "Notes", 200, SbmDbDfn_Control.ColumnIdx.ItemParam_Notes);
					break;
				case SbmcItemParam.Column.Flags:
					SetItemParamColDfn(columnDfn, "Flags", 40, SbmDbDfn_Control.ColumnIdx.ItemParam_Flags, ColumnAlignment.Center, DataValue.DataType.Long);
					break;
				case SbmcItemParam.Column.Status:
					SetItemParamColDfn(columnDfn, "Status", 50, SbmDbDfn_Control.ColumnIdx.ItemParam_Status, ColumnAlignment.Center);
					break;
				case SbmcItemParam.Column.Status_Desc:
					SetItemParamColDfn(columnDfn, "Status", 50, SbmDbDfn_Control.ColumnIdx.ItemParam_Status, ColumnAlignment.Center);
					break;
				case SbmcItemParam.Column.Status_Ind:
					SetItemParamColDfn(columnDfn, "Status", 50, SbmDbDfn_Control.ColumnIdx.ItemParam_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
					columnDfn.TriStateFormat = ColumnTriStateFormat.Lights;
					break;
				case SbmcItemParam.Column.CreateOn_Date:
					SetItemParamColDfn(columnDfn, "Created", 65, SbmDbDfn_Control.ColumnIdx.ItemParam_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
					columnDfn.ReadOnly = true;
					break;
				case SbmcItemParam.Column.UpdateOn_Date:
					SetItemParamColDfn(columnDfn, "Updated", 65, SbmDbDfn_Control.ColumnIdx.ItemParam_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> GetItemParamQueryFilter(SbmcItemParam.Params prm)
		{
			List<String> filter = new List<String>();
			String colId = SbmDbDfn_Control.GetColumnNameQual(SbmDbDfn_Control.ColumnIdx.ItemParam_Id, aliasItemParam);
			String colContext = SbmDbDfn_Control.GetColumnNameQual(SbmDbDfn_Control.ColumnIdx.ItemParam_Context, aliasItemParam);
			String colName = SbmDbDfn_Control.GetColumnNameQual(SbmDbDfn_Control.ColumnIdx.ItemParam_Name, aliasItemParam);

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


			// Item Id.
			if (prm.ItemIdsIncluded.Any())
			{
				String colItemType = SbmDbDfn_Control.GetColumnNameQual(SbmDbDfn_Control.ColumnIdx.ItemParam_ItemType, aliasItemParam);
				String colItemId = SbmDbDfn_Control.GetColumnNameQual(SbmDbDfn_Control.ColumnIdx.ItemParam_ItemId, aliasItemParam);
				HashSet<String> itemFilter = new HashSet<string>();
				foreach (ItemId itemId in prm.ItemIdsIncluded)
					itemFilter.Add($"{colItemType}={itemId.Type} And {colItemId}={SysId.ToLong(itemId.Id)}");
				filter.Add(itemFilter.Concat(" Or ", "(", ")"));
			}

			// Context.
			if (!StringUtil.IsBlank(prm.Context))
				filter.Add($"{colContext}='{DbQuery.FormatForCondition(prm.Context)}'");

			// Name.
			if (!StringUtil.IsBlank(prm.Name))
				filter.Add($"{colName}='{DbQuery.FormatForCondition(prm.Name)}'");

			// Generic search.
			if (!StringUtil.IsBlank(prm.Search))
			{
				foreach (String search in Regex.Split(prm.Search, "[\\s,;\\-+]+"))
				{
					if (StringUtil.IsBlank(search)) continue;
					String searchForLike = DbQuery.FormatForLike(search, true);
					List<String> searchFilter = new List<string>();
					searchFilter.Add($"{colName} LIKE '%{searchForLike}%'");
					searchFilter.Add($"{colContext} LIKE '%{searchForLike}%'");
					filter.Add(searchFilter.Concat(" OR ", "(", ")"));
				}
			}
			// Common Properties.

			// Notes.
			if (!StringUtil.IsBlank(prm.NotesPartial))
				filter.Add($"{SbmDbDfn_Control.GetColumnNameQual(SbmDbDfn_Control.ColumnIdx.ItemParam_Notes, aliasItemParam)} LIKE '%{DbQuery.FormatForLike(prm.NotesPartial)}%'");

			// Status.
			String statusFilter = GetItemParamStatusCatFilterCondition(prm.StatusCat);
			if (!StringUtil.IsBlank(statusFilter))
				filter.Add($"{SbmDbDfn_Control.GetColumnNameQual(SbmDbDfn_Control.ColumnIdx.ItemParam_Status, aliasItemParam)}{statusFilter}");

			if (filter.Count < 1 && prm.IncludeDefaultFilter) filter.Add("1=1");
			return filter;
		}
		internal static String GetItemParamStatusCatFilterCondition(SbmcItemParam.StatusCat statusCat)
		{
			if (statusCat == SbmcItemParam.StatusCat.ActiveOnly)
				return $"='{SacsSystem.GetStatusCode(SaStatus.Active)}'";
			if (statusCat == SbmcItemParam.StatusCat.InactiveOnly)
				return $"='{SacsSystem.GetStatusCode(SaStatus.Inactive)}'";
			if (statusCat == SbmcItemParam.StatusCat.NotDeleted)
				return $"!='{SacsSystem.GetStatusCode(SaStatus.Deleted)}'";
			if (statusCat == SbmcItemParam.StatusCat.DeletedOnly)
				return $"='{SacsSystem.GetStatusCode(SaStatus.Deleted)}'";
			return "";
		}

		//-------------------------------------------------------------------
		// Item sort columns.
		public List<String> GetItemParamSortColumns(SbmcItemParam.Params prm)
		{
			// Sort sequence:
			List<String> sortColumnNames = new List<String>();
			foreach (var columnDfn in prm.SortColumns)
			{
				// Need to ensure correct alias used for ItemParam columns in case of conflict.
				String sortCol = String.Empty;
				if (SbmDbDfn_Control.GetTableForColumn((SbmDbDfn_Control.ColumnIdx)columnDfn.DbColumn) == SbmDbDfn_Control.TableIdx.ItemParam)
				{
					sortCol = SbmDbDfn_Control.GetColumnNameQual((SbmDbDfn_Control.ColumnIdx)columnDfn.DbColumn, aliasItemParam);
				}
				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(SbmDbDfn_Control.GetColumnNameQual(SbmDbDfn_Control.ColumnIdx.ItemParam_ItemType, aliasItemParam) + " ASC");
				sortColumnNames.Add(SbmDbDfn_Control.GetColumnNameQual(SbmDbDfn_Control.ColumnIdx.ItemParam_ItemId, aliasItemParam) + " ASC");
				sortColumnNames.Add(SbmDbDfn_Control.GetColumnNameQual(SbmDbDfn_Control.ColumnIdx.ItemParam_Context, aliasItemParam) + " ASC");
				sortColumnNames.Add(SbmDbDfn_Control.GetColumnNameQual(SbmDbDfn_Control.ColumnIdx.ItemParam_Name, aliasItemParam) + " ASC");
			}
			return sortColumnNames;
		}

		//-------------------------------------------------------------------
		// Item count.
		private long GetItemParamCount(String filter)
		{
			ClearErrorState();
			return db.GetRowCount($"{SbmDbDfn_Control.GetTableName(SbmDbDfn_Control.TableIdx.ItemParam)} As {aliasItemParam}", filter);
		}
		public override long GetItemParamCount(SbmcItemParam.Params prm)
		{
			ClearErrorState();
			return GetItemParamCount(GetItemParamQueryFilter(prm).Concat(" AND ", "(", ")"));
		}

		//-------------------------------------------------------------------
		// Item list.
		public override List<SbmcItemParam> GetItemParamList(SbmcItemParam.Params prm)
		{
			ClearErrorState();
			List<SbmcItemParam> addresses = new List<SbmcItemParam>();
			DbQuery qry = new DbQuery(db.DbmsType);
			qry.Tables.Add(SbmDbDfn_Control.GetTableName(SbmDbDfn_Control.TableIdx.ItemParam), aliasItemParam);
			ItemParam_Db dbItemParam = new ItemParam_Db(DbInfo);
			qry.Columns.AddRange(dbItemParam.ExistingColumnNames);
			qry.Filters.AddRange(GetItemParamQueryFilter(prm));
			qry.OrderBy.AddRange(GetItemParamSortColumns(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())
						{
							dbItemParam = new ItemParam_Db(DbInfo);
							dbItemParam.PopulateFrom(dbDataReader);
							addresses.Add(CreateItemParam(dbItemParam));
						}
					}
				}
				catch (Exception exc)
				{
					SetErrorState("ItemParam query exception");
					SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
				}
			}
			return addresses;
		}

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

			//---------------------------------------------------------------
			// Construct query.
			DbQuery query = new DbQuery(db.DbmsType);
			query.Tables.Add(SbmDbDfn_Control.GetTableName(SbmDbDfn_Control.TableIdx.ItemParam), aliasItemParam);

			// Item Properties - add columns as defined in query list.
			if (columns.HasId(SbmcItemParam.Column.Id))
				query.Columns.Add(SbmDbDfn_Control.GetColumnNameQual(SbmDbDfn_Control.ColumnIdx.ItemParam_Id, aliasItemParam));
			if (columns.HasId(SbmcItemParam.Column.ItemType) || columns.HasId(SbmcItemParam.Column.ItemType_Caption) || columns.HasId(SbmcItemParam.Column.Item_Caption))
				query.Columns.Add(SbmDbDfn_Control.GetColumnNameQual(SbmDbDfn_Control.ColumnIdx.ItemParam_ItemType, aliasItemParam));
			if (columns.HasId(SbmcItemParam.Column.ItemId) || columns.HasId(SbmcItemParam.Column.Item_Caption))
				query.Columns.Add(SbmDbDfn_Control.GetColumnNameQual(SbmDbDfn_Control.ColumnIdx.ItemParam_ItemId, aliasItemParam));
			if (columns.HasId(SbmcItemParam.Column.Context) || columns.HasId(SbmcItemParam.Column.Value))
				query.Columns.Add(SbmDbDfn_Control.GetColumnNameQual(SbmDbDfn_Control.ColumnIdx.ItemParam_Context, aliasItemParam));
			if (columns.HasId(SbmcItemParam.Column.Name) || columns.HasId(SbmcItemParam.Column.Value))
				query.Columns.Add(SbmDbDfn_Control.GetColumnNameQual(SbmDbDfn_Control.ColumnIdx.ItemParam_Name, aliasItemParam));
			if (columns.HasId(SbmcItemParam.Column.Value))
				query.Columns.Add(SbmDbDfn_Control.GetColumnNameQual(SbmDbDfn_Control.ColumnIdx.ItemParam_Value, aliasItemParam));

			// Common Properties
			if (columns.HasId(SbmcItemParam.Column.Notes))
				query.Columns.Add(SbmDbDfn_Control.GetColumnNameQual(SbmDbDfn_Control.ColumnIdx.ItemParam_Notes, aliasItemParam));
			if (columns.HasId(SbmcItemParam.Column.Flags) || columns.HasId(SbmcItemParam.Column.Value))
				query.Columns.Add(SbmDbDfn_Control.GetColumnNameQual(SbmDbDfn_Control.ColumnIdx.ItemParam_Flags, aliasItemParam));
			if (columns.HasId(SbmcItemParam.Column.Status) || columns.HasId(SbmcItemParam.Column.Status_Desc) || columns.HasId(SbmcItemParam.Column.Status_Ind))
				query.Columns.Add(SbmDbDfn_Control.GetColumnNameQual(SbmDbDfn_Control.ColumnIdx.ItemParam_Status, aliasItemParam));
			if (columns.HasId(SbmcItemParam.Column.CreateOn_Date))
				query.Columns.Add(SbmDbDfn_Control.GetColumnNameQual(SbmDbDfn_Control.ColumnIdx.ItemParam_CreateOn, aliasItemParam));
			if (columns.HasId(SbmcItemParam.Column.UpdateOn_Date))
				query.Columns.Add(SbmDbDfn_Control.GetColumnNameQual(SbmDbDfn_Control.ColumnIdx.ItemParam_UpdateOn, aliasItemParam));

			//---------------------------------------------------------------
			// Item.
			if (columns.HasId(SbmcItemParam.Column.Item_Caption))
			{
				// Item - Owner.
				{
					DbQueryJoin joinOwner = new DbQueryJoin(DbJoinType.LeftOuter);
					joinOwner.Table = new StringPair(SbmDbDfn_Control.GetTableNameQual(SbmDbDfn_Control.TableIdx.Owner), aliasItemParam_Item_Owner);
					joinOwner.Filters.Add($"{SbmDbDfn_Control.GetColumnNameQual(SbmDbDfn_Control.ColumnIdx.ItemParam_ItemType, aliasItemParam)}={(int)SbmcHierarchyItem.ItemType.Owner}");
					joinOwner.Filters.Add($"{SbmDbDfn_Control.GetColumnNameQual(SbmDbDfn_Control.ColumnIdx.Owner_Id, aliasItemParam_Item_Owner)}={SbmDbDfn_Control.GetColumnNameQual(SbmDbDfn_Control.ColumnIdx.ItemParam_ItemId, aliasItemParam)}");
					query.Joins.Add(joinOwner);
					prm.Alias_Item_Owner = aliasItemParam_Item_Owner;
				}
				// Item - Repository.
				{
					DbQueryJoin joinRepository = new DbQueryJoin(DbJoinType.LeftOuter);
					joinRepository.Table = new StringPair(SbmDbDfn_Control.GetTableNameQual(SbmDbDfn_Control.TableIdx.Repository), aliasItemParam_Item_Repository);
					joinRepository.Filters.Add($"{SbmDbDfn_Control.GetColumnNameQual(SbmDbDfn_Control.ColumnIdx.ItemParam_ItemType, aliasItemParam)}={(int)SbmcHierarchyItem.ItemType.Repository}");
					joinRepository.Filters.Add($"{SbmDbDfn_Control.GetColumnNameQual(SbmDbDfn_Control.ColumnIdx.Repository_Id, aliasItemParam_Item_Repository)}={SbmDbDfn_Control.GetColumnNameQual(SbmDbDfn_Control.ColumnIdx.ItemParam_ItemId, aliasItemParam)}");
					query.Joins.Add(joinRepository);
					prm.Alias_Item_Repository = aliasItemParam_Item_Repository;
				}
				query.Columns.Add($"Coalesce({SbmDbDfn_Control.GetColumnNameQual(SbmDbDfn_Control.ColumnIdx.Owner_Name, aliasItemParam_Item_Owner)},{SbmDbDfn_Control.GetColumnNameQual(SbmDbDfn_Control.ColumnIdx.Repository_Context, aliasItemParam_Item_Repository)})", colNameItemParam_ItemCaption);
			}

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

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

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

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