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 SbmPriceMgr_Dbas
	{
		//*******************************************************************
		//                         P r i c e   S e t
		//*******************************************************************
		// Utilities.
		private List<StringPair> GetLogProperties(SbmPriceSet priceSet)
		{
			return new List<StringPair>()
			{
				new StringPair("Id",SysId.ToString(priceSet.Id)),
				new StringPair("PriceType",priceSet.PriceType.ToString()),
				new StringPair("Name",priceSet.Name),
				new StringPair("Status",priceSet.StatusCode)
			};
		}

		//-------------------------------------------------------------------
		// Get item.
		public override SbmPriceSet GetPriceSet(SbmPriceSet.Params prm)
		{
			return GetPriceSet(GetPriceSetQueryFilter(prm).Concat(" AND ", "(", ")"));
		}
		private SbmPriceSet GetPriceSet(String filter)
		{
			ClearErrorState();
			long count = GetPriceSetCount(filter);
			if (count == 0) return null;
			if (count != 1)
			{
				SetErrorState("Multiple Price Sets found");
				return null;
			}
			SbmPriceSet priceSet = null;
			// Query data.
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					SaPriceSet_Db dbPriceSet = new SaPriceSet_Db(DbInfo);
					dbPriceSet.PopulateFrom(dbCommand, aliasPriceSet, filter);
					priceSet = CreatePriceSet(dbPriceSet);
				}
				catch (Exception exc)
				{
					SetErrorState("Database query exception");
					SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
				}
			}
			return priceSet;
		}

		//-------------------------------------------------------------------
		// Create item.
		public override SbmPriceSet CreatePriceSet(String reference, Sbm.PriceType priceType)
		{
			ClearErrorState();
			return new SbmPriceSet_Dbas(Internals, new SysId(), UserContext.OrganisationAffiliateId, reference, priceType, 0);
		}
		private SbmPriceSet_Dbas CreatePriceSet(SaPriceSet_Db dbPriceSet)
		{
			ClearErrorState();
			SbmPriceSet_Dbas priceSet = new SbmPriceSet_Dbas(Internals, new SysId(dbPriceSet._Id), new SysId(dbPriceSet._AffIdOwner), dbPriceSet._Ref, (Sbm.PriceType)dbPriceSet._Type, (ushort)dbPriceSet._Flags);
			PopulateFrom(dbPriceSet, priceSet);
			return priceSet;
		}

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

		//-------------------------------------------------------------------
		// Insert item.
		public override bool InsertPriceSet(SbmPriceSet priceSet, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!IsValidPriceSet(priceSet)) return false;
			if (SysId.IsValid(priceSet.Id)) return SetErrorState(ErrorMessage.ValiditemId);
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					SaPriceSet_Db dbPriceSet = new SaPriceSet_Db(DbInfo);
					PopulateTo(dbPriceSet, priceSet, dbUpdateInfo);
					if (SaPriceSet_Db.FieldsNonId.Contains("Id"))
					{
						// Generate next Id.
						dbPriceSet._Id = SysId.ToInt(Database.GetNextId("PriceSet", dbUpdateInfo));
					}
					dbPriceSet.ExecuteInsertCommand(dbCommand);
					priceSet.Id = new SysId(dbPriceSet._Id);
					priceSet.Changed = false;
					if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Inserted." + GetLogProperties(priceSet).Concat(": ").Concat("", "\n\t"));
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
		// Update item.
		public override bool UpdatePriceSet(SbmPriceSet priceSet, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!IsValidPriceSet(priceSet)) return false;
			if (!SysId.IsValid(priceSet.Id)) return SetErrorState(ErrorMessage.InvalidItemId);
			if (!priceSet.Changed)
			{
				if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Data not changed." + GetLogProperties(priceSet).Concat(": ").Concat("", "\n\t"));
				return true;
			}
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					// Retrieve PriceSet.
					dbConnection.Open();
					SaPriceSet_Db dbPriceSet = new SaPriceSet_Db(DbInfo);
					dbPriceSet.PopulateFrom(dbCommand, aliasPriceSet, "Id=" + SysId.ToString(priceSet.Id));
					SbmUpdateLogItemMonitor_PriceSet updateLogMonitor = new SbmUpdateLogItemMonitor_PriceSet(Internals, CreatePriceSet(dbPriceSet));

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

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

		//-------------------------------------------------------------------
		// Delete item.
		public override bool PriceSetCanBeDeleted(SbmPriceSet priceSet)
		{
			ClearErrorState();
			if (!base.PriceSetCanBeDeleted(priceSet)) return false;
			return true;
		}
		public override bool DeletePriceSet(SbmPriceSet priceSet, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!PriceSetCanBeDeleted(priceSet)) return false;
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					// Retrieve PriceSet.
					dbConnection.Open();
					SaPriceSet_Db dbPriceSet = new SaPriceSet_Db(DbInfo);
					dbPriceSet.PopulateFrom(dbCommand, aliasPriceSet, "Id=" + priceSet.Id.ToString());
					// Delete PriceSet.
					dbCommand.CommandType = System.Data.CommandType.Text;
					dbCommand.CommandText = "DELETE FROM " + SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.SaPriceSet) + " WHERE Id=" + SysId.ToString(priceSet.Id) + ";";
					dbCommand.ExecuteNonQuery();
					priceSet.Changed = false;
					if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Deleted." + GetLogProperties(priceSet).Concat(": ").Concat("", "\n\t"));
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
		// Copy data properties to and from database.
		private void PopulateTo(SaPriceSet_Db dbPriceSet, SbmPriceSet priceSet, DbUpdateInfo dbUpdateInfo)
		{
			dbPriceSet._Id = priceSet.Id.ToInt();
			dbPriceSet._AffIdOwner = priceSet.AffiliateIdOwner.ToInt();
			dbPriceSet._Ref = priceSet.Reference;
			dbPriceSet._Type = (short)priceSet.PriceType;
			dbPriceSet._Name = priceSet.Name;
			dbPriceSet._CurrencyId = priceSet.CurrencyId.ToInt();
			// Common properties.
			dbPriceSet._Notes = priceSet.Notes;
			dbPriceSet._Status = SacsSystem.GetStatusCode(priceSet.Status);
			dbPriceSet._Flags = (short)priceSet.Flags;
			if (!SysId.IsValid(priceSet.Id))
			{
				dbPriceSet._CreateOn = DateTime.UtcNow;
				dbPriceSet._CreateBy = dbUpdateInfo.UserId.ToInt();
				dbPriceSet._CreateHost = dbUpdateInfo.Host;
			}
			dbPriceSet._UpdateOn = DateTime.UtcNow;
			dbPriceSet._UpdateBy = dbUpdateInfo.UserId.ToInt();
			dbPriceSet._UpdateHost = dbUpdateInfo.Host;
		}
		private void PopulateFrom(SaPriceSet_Db dbPriceSet, SbmPriceSet priceSet)
		{
			//priceSet.Id = new SysId(dbPriceSet._Id);
			//priceSet.AffiliateIdOwner = new SysId(dbPriceSet._AffIdOwner);
			//priceSet.Reference = dbPriceSet._Ref;
			priceSet.PriceType = (Sbm.PriceType)(dbPriceSet._Type ?? 0);
			priceSet.Name = dbPriceSet._Name;
			priceSet.CurrencyId = new SysId(dbPriceSet._CurrencyId ?? 0);
			// Common properties.
			priceSet.Notes = dbPriceSet._Notes;
			priceSet.Status = SacsSystem.GetStatusForCode(dbPriceSet._Status);
			priceSet.SetCreateStamp(dbPriceSet._CreateOn ?? default(DateTime), new SysId(dbPriceSet._CreateBy ?? 0), dbPriceSet._CreateHost);
			priceSet.SetUpdateStamp(dbPriceSet._UpdateOn ?? default(DateTime), new SysId(dbPriceSet._UpdateBy ?? 0), dbPriceSet._UpdateHost);
			priceSet.AcceptChanges();
		}

		//-------------------------------------------------------------------
		// Column definitions.
		private static readonly String aliasPriceSet = "aPrcSet";
		private static readonly String aliasPriceSet_Currency = "PrcSet_Cur";
		private static readonly String prefixPriceSet_Currency = aliasPriceSet_Currency + "_";
		private static readonly String colNamePriceSet_PriceCount = "PrcSet_PriceCount";

		// Column definition population.
		private void SetPriceSetColDfn
			(ColumnDfn col, String caption, int width, SbmDbDfn.ColumnIdx dbCol,
			ColumnAlignment align = ColumnAlignment.Default, DataValue.DataType dataCategoryId = DataValue.DataType.String,
			String alias = "", String prefix = "")
		{
			if (String.IsNullOrEmpty(alias) && SbmDbDfn.GetTableForColumn(dbCol) == SbmDbDfn.TableIdx.SaPriceSet)
				alias = aliasPriceSet;
			col.Set(caption, width, (int)dbCol, prefix + SbmDbDfn.GetColumnName(dbCol, false), SbmDbDfn.GetColumnNameQual(dbCol, alias), dataCategoryId, align);
			if (dataCategoryId == DataValue.DataType.String && dbCol != SbmDbDfn.ColumnIdx.Unknown)
				col.MaxLength = (int)SbmDbDfn.GetColTextLen(dbCol);
		}

		//-------------------------------------------------------------------
		// Item column definitions.
		public override ColumnDfn GetPriceSetColumnDfn(SbmPriceSet.Column columnId, string caption = "", int width = 0)
		{
			ColumnDfn columnDfn = new ColumnDfn((int)columnId, caption, width);
			switch (columnId)
			{
				case SbmPriceSet.Column.Pos:
					SetPriceSetColDfn(columnDfn, "Pos", 45, SbmDbDfn.ColumnIdx.Unknown, ColumnAlignment.Right);
					columnDfn.SortMode = ColumnDfn.ColumnSortMode.Off;
					columnDfn.ReadOnly = true;
					columnDfn.Resizable = false;
					break;
				case SbmPriceSet.Column.Id:
					SetPriceSetColDfn(columnDfn, "Id", 60, SbmDbDfn.ColumnIdx.SaPriceSet_Id, ColumnAlignment.Right, DataValue.DataType.Long);
					columnDfn.ReadOnly = true;
					break;
				// PriceSet Properties.
				case SbmPriceSet.Column.PriceType:
					SetPriceSetColDfn(columnDfn, "Price type", 80, SbmDbDfn.ColumnIdx.SaPriceSet_Type, ColumnAlignment.Right, DataValue.DataType.Long);
					break;
				case SbmPriceSet.Column.PriceType_Desc:
					SetPriceSetColDfn(columnDfn, "Price type", 100, SbmDbDfn.ColumnIdx.SaPriceSet_Type);
					break;
				case SbmPriceSet.Column.Reference:
					SetPriceSetColDfn(columnDfn, "Reference", 80, SbmDbDfn.ColumnIdx.SaPriceSet_Ref);
					break;
				case SbmPriceSet.Column.Name:
					SetPriceSetColDfn(columnDfn, "Name", 80, SbmDbDfn.ColumnIdx.SaPriceSet_Name);
					break;
				case SbmPriceSet.Column.CurrencyId:
					SetPriceSetColDfn(columnDfn, "Currency #", 60, SbmDbDfn.ColumnIdx.SaPriceSet_CurrencyId, ColumnAlignment.Default, DataValue.DataType.Long);
					break;
				case SbmPriceSet.Column.Currency_Code:
					SetPriceSetColDfn(columnDfn, "Currency code", 80, SbmDbDfn.ColumnIdx.Currency_Code, ColumnAlignment.Default, DataValue.DataType.String, aliasPriceSet_Currency, prefixPriceSet_Currency);
					break;
				case SbmPriceSet.Column.Currency_Name:
					SetPriceSetColDfn(columnDfn, "Currency", 80, SbmDbDfn.ColumnIdx.Currency_Code, ColumnAlignment.Default, DataValue.DataType.String, aliasPriceSet_Currency, prefixPriceSet_Currency);
					break;
				case SbmPriceSet.Column.HasStaticPrices_Y:
					SetPriceSetColDfn(columnDfn, "Static prices", 80, SbmDbDfn.ColumnIdx.SaPriceSet_Flags, ColumnAlignment.Center, DataValue.DataType.String);
					break;
				case SbmPriceSet.Column.HasStaticPrices_Tick:
					SetPriceSetColDfn(columnDfn, "Static prices", 80, SbmDbDfn.ColumnIdx.SaPriceSet_Flags, ColumnAlignment.Center, DataValue.DataType.Bool);
					columnDfn.BoolFormat = ColumnBoolFormat.Tick;
					break;
				case SbmPriceSet.Column.PriceCount:
					SetPriceSetColDfn(columnDfn, "Prices", 80, SbmDbDfn.ColumnIdx.Unknown, ColumnAlignment.Center, DataValue.DataType.Long);
					columnDfn.DataName = colNamePriceSet_PriceCount;
					columnDfn.ReadOnly = true;
					break;
				// Common properties.
				case SbmPriceSet.Column.Notes:
					SetPriceSetColDfn(columnDfn, "Notes", 200, SbmDbDfn.ColumnIdx.SaPriceSet_Notes);
					break;
				case SbmPriceSet.Column.Status:
					SetPriceSetColDfn(columnDfn, "Status", 50, SbmDbDfn.ColumnIdx.SaPriceSet_Status, ColumnAlignment.Center);
					break;
				case SbmPriceSet.Column.Status_Desc:
					SetPriceSetColDfn(columnDfn, "Status", 50, SbmDbDfn.ColumnIdx.SaPriceSet_Status);
					break;
				case SbmPriceSet.Column.Status_Ind:
					SetPriceSetColDfn(columnDfn, "Status", 50, SbmDbDfn.ColumnIdx.SaPriceSet_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
					columnDfn.TriStateFormat = ColumnTriStateFormat.Lights;
					break;
				case SbmPriceSet.Column.CreateOn_Date:
					SetPriceSetColDfn(columnDfn, "Created", 65, SbmDbDfn.ColumnIdx.SaPriceSet_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
					columnDfn.DateFormat = "d-MMM-yy";
					columnDfn.ReadOnly = true;
					break;
				case SbmPriceSet.Column.UpdateOn_Date:
					SetPriceSetColDfn(columnDfn, "Updated", 65, SbmDbDfn.ColumnIdx.SaPriceSet_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;
		}

		//-------------------------------------------------------------------
		// Item query filter.
		public override List<string> GetPriceSetQueryFilter(SbmPriceSet.Params prm)
		{
			List<String> filter = new List<String>();

			// PriceSet Id.
			String includedIds = prm.IdsIncluded.Concat(",");
			String colPriceSet_Id = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaPriceSet_Id, aliasPriceSet);
			if (!includedIds.IsEmpty())
				filter.Add(colPriceSet_Id + " IN (" + includedIds + ")");
			String excludedIds = prm.IdsExcluded.Concat(",");
			if (!excludedIds.IsEmpty())
				filter.Add(colPriceSet_Id + " NOT IN (" + excludedIds + ")");

			// Price Type.
			String colSaPriceSet_PriceType = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaPriceSet_Type, aliasPriceSet);
			if (prm.PriceType > 0)
				filter.Add(colSaPriceSet_PriceType + "=" + ((int)prm.PriceType).ToString());

			// Reference.
			String colPriceSet_Reference = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaPriceSet_Ref, aliasPriceSet);
			if (!StringUtil.IsEmpty(prm.Reference))
				filter.Add(colPriceSet_Reference + "='" + DbQuery.FormatForCondition(prm.Reference) + "'");
			else if (!StringUtil.IsEmpty(prm.ReferencePartial))
				filter.Add(colPriceSet_Reference + "  Like '%" + DbQuery.FormatForCondition(prm.ReferencePartial) + "%'");

			// Name.
			String colPriceSet_Name = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaPriceSet_Name, aliasPriceSet);
			if (!StringUtil.IsEmpty(prm.Name))
				filter.Add(colPriceSet_Name + "='" + DbQuery.FormatForCondition(prm.Name) + "'");
			else if (!StringUtil.IsEmpty(prm.NamePartial))
				filter.Add(colPriceSet_Name + "  Like '%" + DbQuery.FormatForCondition(prm.NamePartial) + "%'");

			// Status.
			String colPriceSet_Status = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaPriceSet_Status, aliasPriceSet);
			if (prm.StatusCat == SbmPriceSet.StatusCat.ActiveOnly)
				filter.Add(colPriceSet_Status + "='" + StatusActive + "'");

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

		// Item sort columns.
		public List<String> GetPriceSetSortColumns(SbmPriceSet.Params prm)
		{
			// Sort sequence:
			List<String> sortColumnCodes = new List<String>();
			foreach (var columnDfn in prm.SortColumns)
			{
				// Need to ensure correct alias used for PriceSet columns in case of conflict.
				String sortCol = String.Empty;
				if (SbmDbDfn.GetTableForColumn((SbmDbDfn.ColumnIdx)columnDfn.DbColumn) == SbmDbDfn.TableIdx.SaPriceSet)
				{
					sortCol = SbmDbDfn.GetColumnNameQual((SbmDbDfn.ColumnIdx)columnDfn.DbColumn, aliasPriceSet);
				}
				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.SaPriceSet_Ref, aliasPriceSet) + " ASC");
			}
			return sortColumnCodes;
		}

		//-------------------------------------------------------------------
		// Item count.
		private long GetPriceSetCount(String filter)
		{
			ClearErrorState();
			return Database.GetRowCount(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.SaPriceSet) + " As " + aliasPriceSet, filter);
		}
		public override long GetPriceSetCount(SbmPriceSet.Params prm)
		{
			ClearErrorState();
			return GetPriceSetCount(GetPriceSetQueryFilter(prm).Concat(" AND ", "(", ")"));
		}

		//-------------------------------------------------------------------
		// Item list.
		public override List<SbmPriceSet> GetPriceSetList(SbmPriceSet.Params prm)
		{
			ClearErrorState();
			List<SbmPriceSet> priceSets = new List<SbmPriceSet>();
			DbQuery qry = new DbQuery(Database.DbmsType);
			qry.Tables.Add(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.SaPriceSet), aliasPriceSet);
			SaPriceSet_Db dbPriceSet = new SaPriceSet_Db(DbInfo);
			qry.Columns.AddRange(dbPriceSet.ExistingColumnNames);
			qry.Filters.AddRange(GetPriceSetQueryFilter(prm));
			qry.OrderBy.AddRange(GetPriceSetSortColumns(prm));
			// Query data.
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					dbCommand.CommandText = qry.BuildQuery(prm.ResultsPaging);
					using (DbDataReader dbDataReader = dbCommand.ExecuteReader())
					{
						while (dbDataReader.Read())
						{
							dbPriceSet = new SaPriceSet_Db(DbInfo);
							dbPriceSet.PopulateFrom(dbDataReader);
							priceSets.Add(CreatePriceSet(dbPriceSet));
						}
					}
				}
				catch (Exception exc)
				{
					SetErrorState("Database query exception");
					SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
				}
			}
			return priceSets;
		}

		//-------------------------------------------------------------------
		// PriceSet query execution.
		public override DbResultSet ExecutePriceSetQuery(List<ColumnDfn> columns, SbmPriceSet.Params prm)
		{
			ClearErrorState();
			//---------------------------------------------------------------------
			// Construct build database query.
			DbQuery query = new DbQuery(Database.DbmsType);
			query.Tables.Add(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.SaPriceSet), aliasPriceSet);

			// PriceSet Properties - add columns as defined in query list.
			if (columns.HasId((int)SbmPriceSet.Column.Id))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaPriceSet_Id, aliasPriceSet));
			if (columns.HasId((int)SbmPriceSet.Column.PriceType) || columns.HasId((int)SbmPriceSet.Column.PriceType_Desc))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaPriceSet_Type, aliasPriceSet));
			if (columns.HasId((int)SbmPriceSet.Column.Reference))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaPriceSet_Ref, aliasPriceSet));
			if (columns.HasId((int)SbmPriceSet.Column.Name))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaPriceSet_Name, aliasPriceSet));
			if (columns.HasId((int)SbmPriceSet.Column.CurrencyId))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaPriceSet_CurrencyId, aliasPriceSet));
			if (columns.HasId((int)SbmPriceSet.Column.HasStaticPrices_Tick) || columns.HasId((int)SbmPriceSet.Column.HasStaticPrices_Y))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaPriceSet_Flags, aliasPriceSet));
			// Common Properties
			if (columns.HasId((int)SbmPriceSet.Column.Notes))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaPriceSet_Notes, aliasPriceSet));
			if (columns.HasId((int)SbmPriceSet.Column.Status) || columns.HasId((int)SbmPriceSet.Column.Status_Desc) || columns.HasId((int)SbmPriceSet.Column.Status_Ind))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaPriceSet_Status, aliasPriceSet));
			if (columns.HasId((int)SbmPriceSet.Column.CreateOn_Date))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaPriceSet_CreateOn, aliasPriceSet));
			if (columns.HasId((int)SbmPriceSet.Column.UpdateOn_Date))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaPriceSet_UpdateOn, aliasPriceSet));

			//---------------------------------------------------------------
			// Currency.
			bool hasCurrencyCols = false;
			if (!hasCurrencyCols) hasCurrencyCols = columns.HasId((int)SbmPriceSet.Column.Currency_Code);
			if (!hasCurrencyCols) hasCurrencyCols = columns.HasId((int)SbmPriceSet.Column.Currency_Name);
			if (hasCurrencyCols)
			{
				DbQueryJoin joinCurrency = new DbQueryJoin(DbJoinType.LeftOuter);
				joinCurrency.Table = new StringPair(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.Currency), aliasPriceSet_Currency);
				joinCurrency.Filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Currency_Id, aliasPriceSet_Currency) + "=" + SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaPriceSet_CurrencyId, aliasPriceSet));
				query.Joins.Add(joinCurrency);
				// Add the PriceSet Category columns:
				List<SbmDbDfn.ColumnIdx> dbColumns = new List<SbmDbDfn.ColumnIdx>()
				{
					SbmDbDfn.ColumnIdx.Currency_Code,
					SbmDbDfn.ColumnIdx.Currency_Name,
				};
				foreach (SbmDbDfn.ColumnIdx dbColumn in dbColumns)
					query.Columns.Add(SbmDbDfn.GetColumnNameQual(dbColumn, aliasPriceSet_Currency), prefixPriceSet_Currency + SbmDbDfn.GetColumnName(dbColumn, false));
			}

			//---------------------------------------------------------------
			// Price count.
			if (columns.HasId((int)SbmPriceSet.Column.PriceCount))
			{
				String aliasPriceCount = "PriceCount";
				DbQuery qryPrice = new DbQuery(Database.DbmsType);
				qryPrice.Tables.Add(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.SaPrice), aliasPriceCount);
				qryPrice.Columns.Add("Count(*)");
				qryPrice.Filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaPrice_PriceSetId, aliasPriceCount) + "=" + SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaPriceSet_Id, aliasPriceSet));
				query.Columns.Add("(" + qryPrice.BuildQuery() + ")", colNamePriceSet_PriceCount);
			}

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

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

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

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