// TODO: Is this a static Utils class? Or does each IAttributes implementation have
// its specific AttributeHarvester? Or will there be a DatasetHarvester/ModelHarvester
// that can create instances of this class (for the right IAttributes implementation)
// in order to more loosely couple them with the domain classes?
//private readonly IAttributes _attributeContainer;
//public AttributeHarvester(IAttributes attributeContainer)
//{
// _attributeContainer = attributeContainer;
//}
#region AttributedAssociation Attribute harvesting
public static void HarvestAttributes([NotNull] AttributedAssociation attributedAssociation)
{
// TODO: support for configurator?
attributedAssociation.ClearAttributeMaps();
using (_msg.IncrementIndentation(
"Harvesting attributes for attributed association {0}", attributedAssociation.Name))
{
const bool allowAlways = true;
IRelationshipClass relationshipClass =
ModelElementUtils.TryOpenFromMasterDatabase(attributedAssociation, allowAlways);
Assert.NotNull(relationshipClass,
"Relationship class not found in model master database: {0}",
attributedAssociation.Name);
var table = (ITable)relationshipClass;
IList <IField> fields = DatasetUtils.GetFields(table);
for (var fieldIndex = 0; fieldIndex < fields.Count; fieldIndex++)
{
IField field = fields[fieldIndex];
AddOrUpdateAttribute(attributedAssociation, field, fieldIndex);
}
DeleteAttributesNotInList(attributedAssociation, fields);
attributedAssociation.ClearAttributeMaps();
}
}
/// <summary>
/// Reads the object types from the geodatabase.
/// </summary>
public static void HarvestObjectTypes([NotNull] ObjectDataset objectDataset)
{
IWorkspaceContext workspaceContext =
ModelElementUtils.GetMasterDatabaseWorkspaceContext(objectDataset);
Assert.NotNull(workspaceContext, "The master database is not accessible");
IObjectClass objectClass = workspaceContext.OpenObjectClass(objectDataset);
Assert.NotNull(objectClass, "Unable to open object class {0}", objectDataset.Name);
HarvestObjectTypes(objectDataset, objectClass);
}
public static void HarvestAttributes(
[NotNull] ObjectDataset objectDataset,
[CanBeNull] IWorkspaceContext workspaceContext = null,
[CanBeNull] IAttributeConfigurator configurator = null)
{
if (workspaceContext == null)
{
workspaceContext =
ModelElementUtils.GetMasterDatabaseWorkspaceContext(objectDataset);
}
Assert.NotNull(workspaceContext, "The master database is not accessible");
IObjectClass objectClass = workspaceContext.OpenObjectClass(objectDataset);
Assert.NotNull(objectClass, "Unable to open object class {0}", objectDataset.Name);
HarvestAttributes(objectDataset, configurator, objectClass);
}
public string GetRelationshipClassName(string associationName, Model model)
{
if (InnerModelContext is IQueryTableContext queryTableContext)
{
return(queryTableContext.GetRelationshipClassName(associationName, model));
}
Association association = ModelElementUtils.GetAssociationFromStoredName(
associationName, model, ignoreUnknownAssociation: true);
if (association == null)
{
return(null);
}
IRelationshipClass relClass = InnerModelContext.OpenRelationshipClass(association);
return(relClass == null ? null : DatasetUtils.GetName(relClass));
}
public static IObjectClass OpenFromDefaultDatabase(
[NotNull] IObjectDataset objectDataset)
{
Assert.ArgumentNotNull(objectDataset, nameof(objectDataset));
IWorkspaceContext masterDbContext =
ModelElementUtils.GetMasterDatabaseWorkspaceContext(objectDataset);
Assert.NotNull(masterDbContext,
"The model master database for dataset {0} is not accessible",
objectDataset.Name);
IObjectClass result = masterDbContext.OpenObjectClass(objectDataset);
Assert.NotNull(result, "Object class {0} not found in master database",
objectDataset.Name);
return(result);
}
private bool TryGetArgumentValue(
[NotNull] TestParameter parameter,
[NotNull] IOpenDataset datasetContext,
[CanBeNull] ICollection <TableConstraint> tableConstraints,
[CanBeNull] out object value)
{
if (Condition == null)
{
value = null;
return(false);
}
var valuesForParameter = new List <object>();
var parameterValueList = new List <DatasetTestParameterValue>();
foreach (TestParameterValue parameterValue in Condition.ParameterValues)
{
if (!Equals(parameterValue.TestParameterName, parameter.Name))
{
continue;
}
object valueForParameter = GetValue(parameterValue, parameter, datasetContext);
valuesForParameter.Add(valueForParameter);
// add value to list anyway,
// correct type is checked at the end of parameterIndex Loop
parameterValueList.Add(parameterValue as DatasetTestParameterValue);
}
if (valuesForParameter.Count == 0 && !parameter.IsConstructorParameter)
{
value = null;
return(false);
}
value = GetArgumentValue(parameter, valuesForParameter);
// if correct type, add to dataSetList
if (tableConstraints != null &&
valuesForParameter.Count > 0 &&
valuesForParameter[0] is ITable)
{
foreach (DatasetTestParameterValue datasetParameterValue in parameterValueList)
{
Dataset dataset =
Assert.NotNull(datasetParameterValue.DatasetValue, "dataset is null");
var table = (ITable)datasetContext.OpenDataset(
dataset, Assert.NotNull(datasetParameterValue.DataType));
Assert.NotNull(table, "Dataset not found in current context: {0}",
dataset.Name);
DdxModel dataModel = dataset.Model;
bool useCaseSensitiveSql = dataModel != null &&
ModelElementUtils.UseCaseSensitiveSql(
table, dataModel.SqlCaseSensitivity);
tableConstraints.Add(new TableConstraint(
table, datasetParameterValue.FilterExpression,
useCaseSensitiveSql));
}
}
return(true);
}
public void CanTranslateSql()
{
IFeatureClass fc;
ITable table;
IRelationshipClass rc;
CreateTestWorkspace(
"CanTranslateSql_master", "fc", "table", "rc",
out fc, out table, out rc);
IFeatureClass fc_child;
ITable table_child;
IRelationshipClass rc_child;
IFeatureWorkspace childWorkspace = CreateTestWorkspace(
"CanTranslateSql_child", "fc_child", "table_child", "rc_child",
out fc_child, out table_child, out rc_child);
IRow t = table_child.CreateRow();
t.Value[table_child.FindField("TEXT")] = "table"; // same as table name
int pk = t.OID;
t.Store();
IFeature f = fc_child.CreateFeature();
f.Value[fc_child.FindField("FKEY")] = pk;
f.Shape = GeometryFactory.CreatePoint(100, 200);
f.Store();
var model = new SimpleModel("model", fc);
ModelVectorDataset vectorDataset = model.AddDataset(
new ModelVectorDataset(DatasetUtils.GetName(fc)));
ModelTableDataset tableDataset = model.AddDataset(
new ModelTableDataset(DatasetUtils.GetName(table)));
AttributeHarvestingUtils.HarvestAttributes(
vectorDataset, ModelElementUtils.GetMasterDatabaseWorkspaceContext(vectorDataset));
AttributeHarvestingUtils.HarvestAttributes(
tableDataset, ModelElementUtils.GetMasterDatabaseWorkspaceContext(tableDataset));
ObjectAttribute fkAttribute = vectorDataset.GetAttribute("FKEY");
ObjectAttribute pkAttribute = tableDataset.GetAttribute(table.OIDFieldName);
Assert.NotNull(fkAttribute);
Assert.NotNull(pkAttribute);
Association association =
model.AddAssociation(new ForeignKeyAssociation(DatasetUtils.GetName(rc),
AssociationCardinality.OneToMany,
fkAttribute, pkAttribute));
var childWorkspaceContext = new SimpleWorkspaceContext(
model, childWorkspace,
new[]
{
new WorkspaceDataset("fc_child", null, vectorDataset),
new WorkspaceDataset("table_child", null, tableDataset),
},
new[]
{
new WorkspaceAssociation("rc_child", null, association)
});
var clsDesc = new ClassDescriptor(typeof(QaRelConstraint));
var tstDesc = new TestDescriptor("RelConstraint", clsDesc);
QualityCondition condition = new QualityCondition("fc_table_constraints", tstDesc);
QualityConditionParameterUtils.AddParameterValue(condition, "relationTables", vectorDataset);
QualityConditionParameterUtils.AddParameterValue(condition, "relationTables", tableDataset);
QualityConditionParameterUtils.AddParameterValue(condition, "relation", "rc");
QualityConditionParameterUtils.AddParameterValue(condition, "join", JoinType.InnerJoin);
QualityConditionParameterUtils.AddParameterValue(condition, "constraint",
"(fc.OBJECTID = 1 AND table.OBJECTID = 1) AND (table.TEXT = 'table')");
var factory = new QaRelConstraint {
Condition = condition
};
ITest test = factory.CreateTests(new SimpleDatasetOpener(childWorkspaceContext))[0];
var runner = new QaContainerTestRunner(1000, test);
runner.Execute(GeometryFactory.CreateEnvelope(0, 0, 1000, 1000));
AssertUtils.NoError(runner);
}
