public static IGeometry GetShapeCopy([NotNull] IRow row,
[CanBeNull] RelatedTables relatedTables)
{
return(relatedTables == null
? GetShapeCopy(row)
: relatedTables.GetGeometry(row));
}
protected IList <InvolvedRow> GetInvolvedRows([NotNull] ITableIndexRow tableIndexRow)
{
IRow row = tableIndexRow.GetRow(InvolvedTables);
RelatedTables related = GetRelatedTables(row);
return(related?.GetInvolvedRows(row) ?? new[] { new InvolvedRow(row) });
}
private static int CompareRelatedRows([NotNull] IRow row0,
[NotNull] IRow row1,
[NotNull] RelatedTables relTables)
{
IList <InvolvedRow> relatedList0 = relTables.GetInvolvedRows(row0);
IList <InvolvedRow> relatedList1 = relTables.GetInvolvedRows(row1);
int relatedCount = relatedList0.Count;
Assert.AreEqual(relatedCount, relatedList1.Count, "Invalid involved rows");
for (var idxRelated = 0; idxRelated < relatedCount; idxRelated++)
{
InvolvedRow relatedRow0 = relatedList0[idxRelated];
InvolvedRow relatedRow1 = relatedList1[idxRelated];
Assert.AreEqual(relatedRow0.TableName, relatedRow1.TableName,
"Involved Rows not sorted");
int relOidDifference = relatedRow0.OID - relatedRow1.OID;
if (relOidDifference != 0)
{
return(relOidDifference);
}
}
return(0);
}
public int Compare(IRow row0, IRow row1)
{
if (row0 == row1)
{
return(0);
}
int oidDifference = row0.OID - row1.OID;
if (oidDifference != 0)
{
return(oidDifference);
}
// oids are equal
ITable table0 = row0.Table;
ITable table1 = row1.Table;
if (table0 == table1)
{
RelatedTables relTables = _relatedTablesProvider.GetRelatedTables(row0);
return(relTables == null
? 0
: CompareRelatedRows(row0, row1, relTables));
}
// TODO names might not be unique (if multiple workspaces are involved)
string name0 = ((IDataset)table0).Name;
string name1 = ((IDataset)table1).Name;
return(string.Compare(name0, name1, StringComparison.Ordinal));
}
public void SetRelatedTables([NotNull] IList <ITable> relatedTables)
{
Assert.True(_tables.Count == 1,
"Related tables are not supported for multiple test tables");
_relatedTables = RelatedTables.Create(relatedTables, _tables[0]);
}
public void AddRelatedTables([NotNull] ITable joined,
[NotNull] IList <ITable> related)
{
Assert.ArgumentNotNull(joined, nameof(joined));
Assert.ArgumentNotNull(related, nameof(related));
if (_dictRelated == null)
{
_dictRelated = new Dictionary <ITable, RelatedTables>();
}
RelatedTables relatedTables = RelatedTables.Create(related, joined);
_dictRelated.Add(joined, relatedTables);
}
/// <summary>
/// Initializes a new instance of the <see cref="DistinctValueGroupStatistics"/> class.
/// </summary>
/// <param name="groupExpression">The group expression.</param>
/// <param name="minDistinctCount">The min distinct count.</param>
/// <param name="maxDistinctCount">The max distinct count.</param>
/// <param name="tableNames">The table names.</param>
/// <param name="relatedTables">The related tables (optional).</param>
/// <param name="relatedOidFields">The related oid fields (optional).</param>
public DistinctValueGroupStatistics(
[NotNull] string groupExpression,
int minDistinctCount,
int?maxDistinctCount,
[NotNull] IList <string> tableNames,
[CanBeNull] RelatedTables relatedTables,
[CanBeNull] IDictionary <RelatedTable, int> relatedOidFields)
{
Assert.ArgumentNotNull(groupExpression, nameof(groupExpression));
Assert.ArgumentNotNull(tableNames, nameof(tableNames));
_groupExpression = groupExpression;
_minDistinctCount = minDistinctCount;
_maxDistinctCount = maxDistinctCount;
_tableNames = tableNames;
_relatedTables = relatedTables;
_relatedOidFields = relatedOidFields;
}
/// <summary>
/// Get involved rows related to IRow
/// </summary>
/// <param name="row"></param>
/// <returns></returns>
protected IList <InvolvedRow> GetInvolvedRows([NotNull] IRow row)
{
RelatedTables related = GetRelatedTables(row);
return(related?.GetInvolvedRows(row) ?? new[] { new InvolvedRow(row) });
}
