private static void TestNMRelation(IFeatureWorkspace ws)
{
IFieldsEdit fields1 = new FieldsClass();
fields1.AddField(FieldUtils.CreateOIDField());
fields1.AddField(FieldUtils.CreateIntegerField("Pk"));
ITable tbl1 = DatasetUtils.CreateTable(ws, "TestNMRelation1", null, fields1);
IFieldsEdit fields2 = new FieldsClass();
fields2.AddField(FieldUtils.CreateOIDField());
fields2.AddField(FieldUtils.CreateIntegerField("Fk"));
ITable tbl2 = DatasetUtils.CreateTable(ws, "TestNMRelation2", null, fields2);
IRelationshipClass rel = CreateSimpleMNRelationship(ws, "TestNMRelationRel", tbl1,
tbl2, "Pk", "Fk");
((IWorkspaceEdit)ws).StartEditing(false);
IRow r11 = CreateRow(tbl1, 8);
IRow r12 = CreateRow(tbl1, 12);
IRow r13 = CreateRow(tbl1, 7);
IRow r21 = CreateRow(tbl2, 9);
IRow r22 = CreateRow(tbl2, 5);
IRow r23 = CreateRow(tbl2, 4);
Assert.NotNull(r12); // not used otherwise
rel.CreateRelationship((IObject)r11, (IObject)r21);
rel.CreateRelationship((IObject)r11, (IObject)r23);
rel.CreateRelationship((IObject)r13, (IObject)r22);
r22.set_Value(1, 6);
r22.Store();
((IWorkspaceEdit)ws).StopEditing(true);
var test = new QaUnreferencedRows(tbl1,
new[] { tbl2 },
new[] { "pk,pk,TestNMRelationRel,fk,fk" });
using (var r = new QaTestRunner(test))
{
r.Execute();
Assert.AreEqual(2, r.Errors.Count);
}
var container = new QaContainerTestRunner(10000, test);
container.Execute();
Assert.AreEqual(2, container.Errors.Count);
}
/// <summary>
/// Creates a new relationship between the two specified objects.
/// </summary>
/// <param name="source">The relationship class that participates in a many to many relationship.</param>
/// <param name="originObject">The origin object.</param>
/// <param name="destinationObject">The destination object.</param>
/// <param name="mode">The mode.</param>
/// <returns>
/// Returns a <see cref="IRelationship" /> representing the relationship between the two objects.
/// </returns>
public static IRelationship CreateRelationship(this IRelationshipClass source, IObject originObject, IObject destinationObject, mmAutoUpdaterMode mode)
{
if (source == null)
{
return(null);
}
using (new AutoUpdaterModeReverter(mode))
{
return(source.CreateRelationship(originObject, destinationObject));
}
}
/// <summary>
/// 创建图形要素和标注要素之间的关联关系[使用前确保要素层与标注层，确实存在关联关系]
/// </summary>
/// <param name="OriginObject">图形要素</param>
/// <param name="DestinationObject">标注要素</param>
/// <returns></returns>
public static IRelationship CreateRelationship(IFeature OriginObject,
IAnnotationFeature2 DestinationObject)
{
IFeatureClass pfClass = (IFeatureClass)OriginObject.Class;
IEnumRelationshipClass pEnumRelation =
pfClass.get_RelationshipClasses(esriRelRole.esriRelRoleAny);
IRelationshipClass pRelationship = pEnumRelation.Next();
if (pRelationship == null)
{
return(null);
}
IRelationship pRelation = null;
pRelation = pRelationship.CreateRelationship((IObject)OriginObject,
(IObject)DestinationObject);
return(pRelation);
//IObject OriginObject, IObject DestinationObject
}
private static void CanDetectNtoMNonUnique([NotNull] IFeatureWorkspace ws)
{
const string uniqueFieldName = "FIELD_UNIQUE";
const string foreignKeyFieldName = "FOREIGN_KEY_FIELD";
const string origTableName = "OrigTable2";
const string destTableName = "DestTable2";
ITable originTable;
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateField(uniqueFieldName,
esriFieldType.esriFieldTypeInteger));
ITable table = TestWorkspaceUtils.CreateSimpleTable(
ws, origTableName, fields);
originTable = table;
}
ITable destinationTable;
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateField(
foreignKeyFieldName, esriFieldType.esriFieldTypeInteger));
ITable table = TestWorkspaceUtils.CreateSimpleTable(
ws, destTableName, fields);
destinationTable = table;
}
IRelationshipClass relClass = TestWorkspaceUtils.CreateSimpleMNRelationship(
ws, "relNonUnique", originTable, destinationTable,
"OrigFKey", "DestFKey");
{
// insert Data
((IWorkspaceEdit)ws).StartEditing(false);
for (var i = 0; i < 10; i++)
{
IRow row = originTable.CreateRow();
row.set_Value(1, i);
row.Store();
}
for (var i = 0; i < 10; i++)
{
IRow row = destinationTable.CreateRow();
row.set_Value(1, i);
row.Store();
relClass.CreateRelationship((IObject)originTable.GetRow(i + 1),
(IObject)row);
}
{
IRow row = destinationTable.CreateRow();
row.set_Value(1, 5);
row.Store();
relClass.CreateRelationship((IObject)originTable.GetRow(5 + 1),
(IObject)row);
}
{
IRow row = destinationTable.CreateRow();
row.set_Value(1, 5);
row.Store();
relClass.CreateRelationship((IObject)originTable.GetRow(5 + 1),
(IObject)row);
}
{
IRow row = destinationTable.CreateRow();
row.set_Value(1, 7);
row.Store();
relClass.CreateRelationship((IObject)originTable.GetRow(7 + 1),
(IObject)row);
}
((IWorkspaceEdit)ws).StopEditing(true);
}
ITable relTab = TableJoinUtils.CreateQueryTable(relClass, JoinType.InnerJoin);
foreach (bool forceInMemoryTableSort in new[] { true, false })
{
var test = new QaUnique(relTab, origTableName + "." + uniqueFieldName)
{
ForceInMemoryTableSorting = forceInMemoryTableSort
};
test.SetRelatedTables(new[] { originTable, destinationTable });
var runner = new QaTestRunner(test);
runner.Execute();
Assert.AreEqual(5, runner.Errors.Count);
}
}
private static void CanDetectNtoMUnique([NotNull] IFeatureWorkspace workspace)
{
const string uniqueFieldName = "FIELD_UNIQUE";
const string foreignKeyFieldName = "FOREIGN_KEY_FIELD";
ITable tableOrig;
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateField(uniqueFieldName,
esriFieldType.esriFieldTypeInteger));
ITable table = TestWorkspaceUtils.CreateSimpleTable(workspace, "RelateUnique1",
fields,
null);
tableOrig = table;
}
ITable tableRel;
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateField(foreignKeyFieldName,
esriFieldType.esriFieldTypeInteger));
ITable table = TestWorkspaceUtils.CreateSimpleTable(workspace, "RelateUnique2",
fields,
null);
tableRel = table;
}
IRelationshipClass rel = TestWorkspaceUtils.CreateSimpleMNRelationship(
workspace, "NToMRelTable", tableOrig, tableRel, uniqueFieldName,
foreignKeyFieldName);
{
((IWorkspaceEdit)workspace).StartEditing(false);
for (var i = 0; i < 10; i++)
{
IRow row = tableOrig.CreateRow();
row.set_Value(1, i);
row.Store();
}
for (var i = 0; i < 10; i++)
{
IRow row = tableRel.CreateRow();
row.set_Value(1, i);
row.Store();
rel.CreateRelationship((IObject)tableOrig.GetRow(i + 1),
(IObject)row);
}
((IWorkspaceEdit)workspace).StopEditing(true);
}
ITable relTab = TableJoinUtils.CreateQueryTable(rel, JoinType.InnerJoin);
foreach (bool forceInMemoryTableSort in new[] { true, false })
{
var test = new QaUnique(relTab, "RelateUnique1." + uniqueFieldName)
{
ForceInMemoryTableSorting = forceInMemoryTableSort
};
var runner = new QaTestRunner(test);
runner.Execute();
AssertUtils.NoError(runner);
}
}
public void TestRelatedFactory()
{
IFeatureWorkspace initTestWs = _testWs;
try
{
_testWs = RelTestWs;
IFeatureClass fc1 = CreateFeatureClass("TestRelatedFactory",
esriGeometryType.esriGeometryPolyline);
var ds1 = (IDataset)fc1;
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateIntegerField(_fkFieldName));
fields.AddField(FieldUtils.CreateTextField(_textFieldName, 200));
string tableName = ds1.Name + "_table";
ITable table = TestWorkspaceUtils.CreateSimpleTable(_testWs, tableName, fields);
var tableDataset = (IDataset)table;
string relClassName = "relClass" + Math.Abs(Environment.TickCount);
IRelationshipClass rel = TestWorkspaceUtils.CreateSimpleMNRelationship(
_testWs, relClassName, table, (ITable)fc1, "fkGrp", "fkFc");
((IWorkspaceEdit)_testWs).StartEditing(false);
IFeature f = AddFeature(fc1,
CurveConstruction.StartLine(0, 0)
.LineTo(4, 0)
.Curve);
IRow r = AddRow(table, textFieldValue: "A");
rel.CreateRelationship((IObject)r, f);
r = AddRow(table, textFieldValue: "B");
rel.CreateRelationship((IObject)r, f);
f = AddFeature(fc1,
CurveConstruction.StartLine(4, 0)
.LineTo(4, 8)
.Curve);
r = AddRow(table, textFieldValue: "A");
rel.CreateRelationship((IObject)r, f);
((IWorkspaceEdit)_testWs).StopEditing(true);
var model = new SimpleModel("model", fc1);
Dataset mds1 = model.AddDataset(new ModelVectorDataset(ds1.Name));
Dataset mdsRel = model.AddDataset(new ModelTableDataset(tableDataset.Name));
var clsDesc = new ClassDescriptor(typeof(QaRelRegularExpression));
var tstDesc = new TestDescriptor("GroupEnds", clsDesc);
var condition = new QualityCondition("cndGroupEnds", tstDesc);
QualityConditionParameterUtils.AddParameterValue(condition, "relationTables", mds1);
QualityConditionParameterUtils.AddParameterValue(condition, "relationTables", mdsRel);
QualityConditionParameterUtils.AddParameterValue(condition, "relation", relClassName);
QualityConditionParameterUtils.AddParameterValue(condition, "join", JoinType.InnerJoin);
QualityConditionParameterUtils.AddParameterValue(condition, "pattern", "A");
QualityConditionParameterUtils.AddParameterValue(condition, "fieldNames",
$"{tableName}.{_textFieldName}");
QualityConditionParameterUtils.AddParameterValue(condition, "MatchIsError", false);
//condition.AddParameterValue("PatternDescription", "Hallo");
var factory = new QaRelRegularExpression {
Condition = condition
};
IList <ITest> tests =
factory.CreateTests(new SimpleDatasetOpener(model.MasterDatabaseWorkspaceContext));
Assert.AreEqual(1, tests.Count);
IList <QaError> errors = Run(tests[0], 1000);
AssertErrors(1, errors);
IList <InvolvedRow> involvedRows = errors[0].InvolvedRows;
Assert.AreEqual(2, involvedRows.Count);
Assert.AreEqual($"{tableName}.{_textFieldName}", errors[0].AffectedComponent);
Assert.AreEqual("RegularExpression.FieldValueDoesNotMatchRegularExpression",
errors[0].IssueCode?.ID);
// TOP-4945: expected involved dataset name: base table name, not joined table name
Assert.IsTrue(tableName == involvedRows[0].TableName ||
tableName == involvedRows[1].TableName);
}
finally
{
_testWs = initTestWs;
}
}