private IQueryFilter GetQueryFilter([NotNull] IFeatureClass featureClass,
int tableIndex,
[CanBeNull] IGeometry geometry)
{
Assert.ArgumentNotNull(featureClass, nameof(featureClass));
string routeIdFieldName = GetRouteIdFieldName(featureClass, tableIndex);
IQueryFilter result;
if (geometry == null)
{
result = new QueryFilterClass();
}
else
{
result = new SpatialFilterClass
{
GeometryField = featureClass.ShapeFieldName,
SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects,
Geometry = geometry
};
}
result.WhereClause = GetWhereClause(tableIndex, routeIdFieldName);
GdbQueryUtils.SetSubFields(result,
featureClass.OIDFieldName,
featureClass.ShapeFieldName,
routeIdFieldName);
return(result);
}
private IQueryFilter CreateFilter([NotNull] IFeatureClass featureClass,
[CanBeNull] string filterExpression)
{
IQueryFilter filter =
new QueryFilterClass
{
SubFields = _shapeFieldName,
WhereClause =
GetWhereClause(featureClass, filterExpression,
_dontFilterPolycurvesByZeroLength)
};
var subfields = new List <string> {
_shapeFieldName
};
if (featureClass.HasOID)
{
subfields.Add(featureClass.OIDFieldName);
}
GdbQueryUtils.SetSubFields(filter, subfields);
return(filter);
}
private int ExecuteGeometry([CanBeNull] IGeometry geometry)
{
if (!_canHaveNonLinearSegments)
{
return(NoError);
}
IQueryFilter filter = TestUtils.CreateFilter(geometry, AreaOfInterest,
GetConstraint(0),
(ITable)_featureClass,
null);
GdbQueryUtils.SetSubFields(filter,
_featureClass.OIDFieldName,
_featureClass.ShapeFieldName);
int errorCount = 0;
const bool recycle = true;
foreach (IFeature feature in
GdbQueryUtils.GetFeatures(_featureClass, filter, recycle))
{
errorCount += VerifyFeature(feature);
}
return(errorCount);
}
private static IQueryFilter GetQueryFilter([NotNull] IEnumerable <string> keyFields,
[CanBeNull] string whereClause)
{
var result = new QueryFilterClass {
WhereClause = whereClause
};
GdbQueryUtils.SetSubFields(result, keyFields);
return(result);
}
private void EnsureReferenceInfos()
{
if (_referencingTableInfos != null)
{
return;
}
_referencedTableInfo = new ReferencedTableInfo(_referencedTable,
_referencedTableKey);
_referencingTableInfos = new List <ReferencingTableInfo>();
for (var i = 0; i < _referencingTables.Count; i++)
{
ITable referencingTable = _referencingTables[i];
int referencingTableIndex = i + 1; // first index is referenced table
string whereClause = GetConstraint(referencingTableIndex);
string relation = _relations[i];
var referencingTableInfo = new ReferencingTableInfo(
referencingTable, relation, whereClause);
bool supported =
KeySetUtils.IsSupportedTypeCombination(
_referencedTableInfo.KeyFieldType,
referencingTableInfo.ForeignKeyFieldType);
Assert.ArgumentCondition(
supported,
"key fields have unsupported combination of types: " +
"referencing table = {0}, foreign key = {1}, referenced key = {2}",
((IDataset)referencingTableInfo.Table).Name,
referencingTableInfo.ForeignKeyFieldType,
_referencedTableInfo.KeyFieldType);
_referencingTableInfos.Add(referencingTableInfo);
}
_referencedTableFilter = new QueryFilterClass
{
WhereClause = GetConstraint(0)
};
GdbQueryUtils.SetSubFields(_referencedTableFilter,
_referencedTableInfo.KeyFieldName,
_referencedTable.OIDFieldName);
}
private IEnumerable <KeyValuePair <int, object> > LookupKeys(
[NotNull] IEnumerable <int> oids)
{
string oidFieldName = _table.OIDFieldName;
var queryFilter = new QueryFilterClass();
GdbQueryUtils.SetSubFields(queryFilter, oidFieldName, KeyFieldName);
const bool recycle = true;
foreach (IRow row in GdbQueryUtils.GetRowsInList(
_table, oidFieldName, oids, recycle, queryFilter))
{
yield return(new KeyValuePair <int, object>(row.OID, row.Value[_keyFieldIndex]));
}
}
private int ExecuteGeometry([CanBeNull] IGeometry geometry)
{
if (!(_referencedTable is IFeatureClass))
{
geometry = null;
}
//TODO use TableJoinUtils where appropriate
IQueryFilter filter = TestUtils.CreateFilter(geometry, AreaOfInterest,
GetConstraint(0),
_referencedTable,
null);
GdbQueryUtils.SetSubFields(filter,
_referencedTable.OIDFieldName,
_referencedTableKey);
const bool recycle = true;
var enumCursor = new EnumCursor(_referencedTable, filter, recycle);
return(VerifyRows(enumCursor));
}
private static IQueryFilter CreateQueryFilter(
[CanBeNull] string filterExpression,
[NotNull] string constraintField,
[CanBeNull] string constraintDescriptionField)
{
IQueryFilter result = new QueryFilterClass
{
WhereClause = filterExpression,
SubFields = constraintField
};
var subfields = new List <string> {
constraintField
};
if (StringUtils.IsNotEmpty(constraintDescriptionField))
{
subfields.Add(constraintDescriptionField);
}
GdbQueryUtils.SetSubFields(result, subfields);
return(result);
}
private static ITable GetInvolvedTableAndQueryFilter(
[NotNull] IObjectDataset involvedObjectDataset,
[NotNull] IDatasetContext datasetContext,
bool includeDateOfChangeField,
[NotNull] out IQueryFilter queryFilter,
out int dateOfChangeFieldIndex)
{
ITable result;
try
{
result = datasetContext.OpenTable(involvedObjectDataset);
Assert.NotNull(result, "Dataset not found in current context: {0}",
involvedObjectDataset.Name);
}
catch (Exception e)
{
string message;
if (involvedObjectDataset.Deleted)
{
message = string.Format(
"The dataset '{0}' referenced in allowed errors is registered as deleted, unable to open",
involvedObjectDataset.Name);
}
else
{
message = string.Format(
"Error opening dataset '{0}' referenced in allowed errors: {1}",
involvedObjectDataset.Name,
e.Message);
}
throw new InvolvedTableOpenException(message, e);
}
queryFilter = new QueryFilterClass();
var subfields = new List <string> {
result.OIDFieldName
};
if (includeDateOfChangeField)
{
ObjectAttribute dateOfChangeAttribute =
involvedObjectDataset.GetAttribute(AttributeRole.DateOfChange);
dateOfChangeFieldIndex =
dateOfChangeAttribute != null
? AttributeUtils.GetFieldIndex(result, dateOfChangeAttribute)
: -1;
if (dateOfChangeAttribute != null && dateOfChangeFieldIndex >= 0)
{
subfields.Add(dateOfChangeAttribute.Name);
}
}
else
{
dateOfChangeFieldIndex = -1;
}
GdbQueryUtils.SetSubFields(queryFilter, subfields);
return(result);
}
