private static void AddExtraRelationships(IDataTableFinder TableFinder, VirtualDataTable aData, TRelationshipList Relations, TBand band, TMasterDetailLinkList MasterDetailLinkList)
{
foreach (TRelationship tr in Relations)
{
TDataSourceInfo dParent = TableFinder.TryGetDataTable(tr.ParentTable);
if (dParent == null || dParent.Table == null)
{
FlxMessages.ThrowException(FlxErr.ErrInvalidManualRelationshipDatasetNull, tr.ParentTable);
}
TDataSourceInfo dChild = TableFinder.TryGetDataTable(tr.ChildTable);
if (dChild == null || dChild.Table == null)
{
FlxMessages.ThrowException(FlxErr.ErrInvalidManualRelationshipDatasetNull, tr.ChildTable);
}
if (SameTable(dChild.Table, aData) && SameTable(dParent.Table, band.DataSource.Data))
{
GetColIndexes(dParent.Table, tr.ParentColumns, true); //we do it here so it checks all columns exist in the parent. They might not exist in our table, and that is ok if our table is a distinct for example)
GetColIndexes(dChild.Table, tr.ChildColumns, true);
int[] ChildCols = GetColIndexes(aData, tr.ChildColumns, false);
int[] ParentCols = GetColIndexes(band.DataSource.Data, tr.ParentColumns, false);
if (ChildCols != null && ParentCols != null)
{
MasterDetailLinkList.AddRelation(band.DataSource.DataState,
new TRelation(band.DataSource.Data, aData, ParentCols,
ChildCols));
}
}
}
}
public TAdoDotNetDataTable(string aTableName, VirtualDataTable aCreatedBy, DataTable aData, bool aDataNeedsDispose, DataTable aOriginalTable) : base(aTableName, aCreatedBy)
{
Data = aData;
DataNeedsDispose = aDataNeedsDispose;
LookupDataViews = new TLookupCacheList();
OriginalTable = aOriginalTable;
}
public TEFDataTableState(VirtualDataTable aTableData, IQueryable <T> aData, PropertyInfo[] aFields,
TFieldExpressions <T> aFieldExpressions, Dictionary <string, int> aFieldsByName,
string[] aFilters,
string sort, TMasterDetailLink[] masterDetailLinks, TSplitLink splitLink)
: base(aTableData, aData, aFields, aFieldExpressions, aFieldsByName, aFilters, sort, masterDetailLinks, splitLink)
{
}
/// <summary>
/// Creates a new relation with the given values.
/// </summary>
/// <param name="aParentTable">See <see cref="ParentTable"/></param>
/// <param name="aChildTable">See <see cref="ChildTable"/></param>
/// <param name="aParentColumns">See <see cref="ParentColumns"/></param>
/// <param name="aChildColumns">See <see cref="ChildColumns"/></param>
public TRelation(VirtualDataTable aParentTable, VirtualDataTable aChildTable, int[] aParentColumns, int[] aChildColumns)
{
FParentTable = aParentTable;
FChildTable = aChildTable;
FParentColumns = aParentColumns;
FChildColumns = aChildColumns;
}
/// <summary>
/// Call this method ONLY if the collection owns the objects.
/// As this is not always the case, we cannot follow a more common Dispose pattern.
/// </summary>
public void DestroyTables()
{
if (FTable != null && FDisposeVirtualTable)
{
FTable.Dispose();
}
FTable = null;
}
internal TDataSourceInfo(string aName, VirtualDataTable aTable, string aRowFilter, string aSort, bool aDisposeVirtualTable, bool aTempTable, IDataTableFinder aTableFinder)
{
Filter(ref aTable, aRowFilter, ref aDisposeVirtualTable, aName);
FTable = aTable;
FSort = aSort;
FDisposeVirtualTable = aDisposeVirtualTable;
FTempTable = aTempTable;
TableFinder = aTableFinder;
}
public TColumnsDataTable(string aTableName, VirtualDataTable aCreatedBy, VirtualDataTable MasterTable)
: base(aTableName, aCreatedBy)
{
Columns = new TPositionAndName[MasterTable.ColumnCount];
for (int i = 0; i < Columns.Length; i++)
{
Columns[i] = new TPositionAndName(i, MasterTable.GetColumnName(i));
}
}
private static void Filter(ref VirtualDataTable aTable, string RowFilter, ref bool TableNeedsDispose, string aName)
{
RowFilter = RowFilter.Trim();
if (string.IsNullOrEmpty(RowFilter))
{
if (aTable.TableName != aName)
{
VirtualDataTable nTable = aTable.FilterData(aName, null);
if (aTable != null && TableNeedsDispose)
{
aTable.Dispose();
}
aTable = nTable;
TableNeedsDispose = true;
}
return;
}
int fPos = RowFilter.IndexOf(ReportTag.StrOpenParen);
if (fPos > 2)
{
if (String.Equals(RowFilter.Substring(0, fPos).Trim(), ReportTag.ConfigTag(ConfigTagEnum.Distinct), StringComparison.InvariantCultureIgnoreCase))
{
if (RowFilter[RowFilter.Length - 1] != ReportTag.StrCloseParen)
{
FlxMessages.ThrowException(FlxErr.ErrInvalidFilterParen, RowFilter);
}
VirtualDataTable bTable = aTable.GetDistinct(aName, GetColumnsForDistinct(aTable, RowFilter.Substring(fPos + 1, RowFilter.Length - fPos - 2)));
if (aTable != null && TableNeedsDispose)
{
aTable.Dispose();
}
aTable = bTable;
TableNeedsDispose = true;
return;
}
}
VirtualDataTable cTable = aTable.FilterData(aName, RowFilter);
if (aTable != null && TableNeedsDispose)
{
aTable.Dispose();
}
aTable = cTable;
TableNeedsDispose = true;
}
private static bool SameTable(VirtualDataTable relatedData, VirtualDataTable data)
{
if (data == null)
{
return(relatedData == null);
}
if (relatedData == null)
{
return(false);
}
if (relatedData.TableName == data.TableName)
{
return(true);
}
return(SameTable(relatedData, data.CreatedBy));
}
public TAdoDotNetDataTableState(VirtualDataTable aTableData, DataTable Data, string sort, TMasterDetailLink[] masterDetailLinks, TSplitLink splitLink) : base(aTableData)
{
if (masterDetailLinks.Length > 0 || splitLink != null)
{
SourceForFilteredData = new DataView(Data, String.Empty, GetSortColumns(masterDetailLinks), DataViewRowState.CurrentRows);
FilteredData = Data.Clone(); //we will have to fill this table each time.
FilteredDataNeedsDispose = true;
}
else
{
FilteredData = Data; //The table is the same as the original.
}
SortedFilteredData = new DataView(FilteredData);
SortedFilteredData.Sort = sort;
}
public override TRelation GetRelationWith(VirtualDataTable aDetail)
{
TAdoDotNetDataTable AdoDetail = aDetail as TAdoDotNetDataTable; //DataRelationships only happen between DataTables.
if (AdoDetail != null && OriginalTable.ChildRelations != null)
{
foreach (DataRelation dr in OriginalTable.ChildRelations)
{
if (dr.ChildTable == AdoDetail.OriginalTable)
{
return(new TRelation(this, AdoDetail, GetColumnOrdinals(dr.ParentColumns, this), GetColumnOrdinals(dr.ChildColumns, AdoDetail)));
}
}
}
return(null);
}
private static int[] GetColumnsForDistinct(VirtualDataTable aTable, string SortString)
{
if (SortString.Trim().Length == 0)
{
FlxMessages.ThrowException(FlxErr.ErrInvalidDistinctParams);
}
int start = 0;
int count = 0;
do
{
start = SortString.IndexOf(ReportTag.ParamDelim, start);
if (start > 0)
{
count++;
start++;
}
}while (start > 0);
start = 0;
int oldStart = 0;
int[] Result = new int[count + 1];
for (int i = 0; i < count; i++)
{
start = SortString.IndexOf(ReportTag.ParamDelim, oldStart);
Result[i] = aTable.GetColumn(SortString.Substring(oldStart, start - oldStart).Trim());
if (Result[i] < 0)
{
FlxMessages.ThrowException(FlxErr.ErrColumNotFound, SortString.Substring(oldStart, start - oldStart).Trim(), aTable.TableName);
}
if (i < count)
{
oldStart = start + 1;
}
}
Result[count] = aTable.GetColumn(SortString.Substring(oldStart).Trim());
if (Result[count] < 0)
{
FlxMessages.ThrowException(FlxErr.ErrColumNotFound, SortString.Substring(oldStart).Trim(), aTable.TableName);
}
return(Result);
}
public TFlexCelDataSource(string dtName, VirtualDataTable aData, TRelationshipList ExtraRelations, TRelationshipList StaticRelations,
TBand MasterBand, string Sort, IDataTableFinder TableFinder)
{
SplitLink = null;
TBand band = MasterBand;
TMasterDetailLinkList MasterDetailLinkList = new TMasterDetailLinkList();
while (band != null)
{
if (band.DataSource != null)
{
TRelation RelToMaster = band.DataSource.Data.GetRelationWith(aData);
if (RelToMaster != null)
{
MasterDetailLinkList.AddRelation(band.DataSource.DataState, RelToMaster);
}
//Create the splitlink.
TMasterSplitDataTableState SplitMaster = band.DataSource.DataState as TMasterSplitDataTableState;
if (SplitMaster != null && String.Equals(SplitMaster.DetailName, dtName, StringComparison.CurrentCultureIgnoreCase))
{
if (SplitLink != null)
{
FlxMessages.ThrowException(FlxErr.ErrSplitNeedsOnlyOneMaster, dtName, SplitMaster.TableName, SplitLink.ParentDataSource.TableName);
}
SplitLink = new TSplitLink(SplitMaster, SplitMaster.SplitCount);
}
AddExtraRelationships(TableFinder, aData, ExtraRelations, band, MasterDetailLinkList);
AddExtraRelationships(TableFinder, aData, StaticRelations, band, MasterDetailLinkList);
}
band = band.MasterBand;
}
MasterDetailLinks = MasterDetailLinkList.ToArray();
Data = aData;
DataState = aData.CreateState(Sort, MasterDetailLinks, SplitLink);
DataState.FTableName = dtName;
FName = dtName;
}
internal static VirtualDataTable FindLinkedTable(TBand MasterBand, string Name, VirtualDataTable Table)
{
TBand band = MasterBand;
while (band != null)
{
if (band.DataSource != null)
{
VirtualDataTable vt = band.DataSource.GetDetail(Name, Table);
{
if (vt != null)
{
return(vt);
}
}
}
band = band.MasterBand;
}
return(Table);
}
private static int[] GetColIndexes(VirtualDataTable Table, string[] ColNames, bool ThrowExceptions)
{
int[] ColIdx = new int[ColNames.Length];
for (int i = 0; i < ColIdx.Length; i++)
{
int cs = Table.GetColumn(ColNames[i]);
if (cs < 0)
{
if (ThrowExceptions)
{
FlxMessages.ThrowException(FlxErr.ErrColumNotFound, ColNames[i], Table.TableName);
}
else
{
return(null);
}
}
ColIdx[i] = cs;
}
return(ColIdx);
}
public TTopDataTableState(VirtualDataTable aTableData, int aTopCount, VirtualDataTableState aActualDataState) : base(aTableData)
{
ActualDataState = aActualDataState;
TopCount = aTopCount;
}
internal DataTable OriginalTable; //Data relations are bound to this one.
#endregion
#region Constructors
public TAdoDotNetDataTable(string aTableName, VirtualDataTable aCreatedBy, DataTable aData, bool aDataNeedsDispose) : this(aTableName, aCreatedBy, aData, aDataNeedsDispose, aData)
{
}
public TMasterSplitDataTableState(VirtualDataTable aTableData) : base(aTableData)
{
LastPosition = -1;
}
public TColumnsDataTableState(VirtualDataTable aTableData, TPositionAndName[] aColumns)
: base(aTableData)
{
Columns = aColumns;
}
public TColumnsDataTable(string aTableName, VirtualDataTable aCreatedBy, TPositionAndName[] aColumns)
: base(aTableName, aCreatedBy)
{
Columns = aColumns;
}
internal VirtualDataTable GetDetail(string DataTableName, VirtualDataTable DataTable)
{
return(Data.GetDetail(DataTableName, DataTable));
}
public TNRowsDataTableState(VirtualDataTable aTableData, int aRecordCount)
: base(aTableData)
{
RecordCount = aRecordCount;
}
internal void Add(string dtName, VirtualDataTable dt, bool VirtualTableNeedsDispose)
{
DestroyItem(dtName);
FList[dtName] = new TDataSourceInfo(dtName, dt, "", "", VirtualTableNeedsDispose, VirtualTableNeedsDispose, TableFinder);
}
public TMasterSplitDataTable(string aTableName, VirtualDataTable aCreatedBy, string aDetailName, int aSplitCount) : base(aTableName, aCreatedBy)
{
DetailName = aDetailName;
SplitCount = aSplitCount;
}
public TTopDataTable(string aTableName, VirtualDataTable aCreatedBy, VirtualDataTable aActualData, int aTopCount)
: base(aTableName, aCreatedBy)
{
ActualData = aActualData;
TopCount = aTopCount;
}
internal TFlexCelDataSource CreateDataSource(TBand MasterBand, TRelationshipList ExtraRelations, TRelationshipList StaticRelations)
{
VirtualDataTable LinkedTable = FindLinkedTable(MasterBand, Name, FTable);
return(new TFlexCelDataSource(LinkedTable.TableName, LinkedTable, ExtraRelations, StaticRelations, MasterBand, FSort, TableFinder));
}
public TEFDataTable(string aTableName, VirtualDataTable aCreatedBy, IQueryable <T> aData, TLinqDataTable <T> aOrigTable, string[] aFilters) :
base(aTableName, aCreatedBy, aData, aOrigTable, aFilters)
{
}
public TEFDataTable(string aTableName, VirtualDataTable aCreatedBy, IQueryable <T> aData)
: base(aTableName, aCreatedBy, aData)
{
}
protected override VirtualDataTable CreateNewDataTable(string aTableName, VirtualDataTable aCreatedBy, IQueryable <T> aData, TLinqDataTable <T> aOrigTable, string[] aFilters)
{
return(new TEFDataTable <T>(aTableName, aCreatedBy, aData, aOrigTable, aFilters));
}
public TNRowsDataTable(string aTableName, VirtualDataTable aCreatedBy, int aRecordCount)
: base(aTableName, aCreatedBy)
{
RecordCount = aRecordCount;
}
