public void Missing()
{
ITable table = DatasetUtils.CreateTable(
_workspace, MethodBase.GetCurrentMethod().Name,
FieldUtils.CreateOIDField("OBJECTID", "Object ID"),
FieldUtils.CreateTextField("FIELD1", 10, "Field 1"),
FieldUtils.CreateTextField("FIELD2", 10, " "),
FieldUtils.CreateTextField("FIELD3", 10, "Field 3"),
FieldUtils.CreateTextField("FIELD4", 10, " "));
const bool requireUniqueAliasNames = true;
const bool allowCustomSystemFieldAlias = true;
var runner = new QaTestRunner(
new QaSchemaFieldAliases(table, 30, ExpectedCase.Mixed,
requireUniqueAliasNames, allowCustomSystemFieldAlias,
ExpectedStringDifference.CaseInsensitiveDifference));
runner.Execute();
Assert.AreEqual(2, runner.Errors.Count);
}
private IFeatureClass CreateFeatureClass([NotNull] string name,
esriGeometryType geometryType,
bool zAware = false,
bool mAware = false)
{
ISpatialReference sref = SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
true);
SpatialReferenceUtils.SetXYDomain(sref, -10000, -10000, 10000, 10000, 0.0001,
0.001);
IFields fields = FieldUtils.CreateFields(
FieldUtils.CreateOIDField(),
FieldUtils.CreateShapeField("Shape",
geometryType,
sref, 1000,
zAware, mAware));
return(DatasetUtils.CreateSimpleFeatureClass(_testWs, name, fields));
}
public void CanExportToXml()
{
IWorkspace workspace = TestUtils.OpenUserWorkspaceOracle();
IFeatureClass fclass =
DatasetUtils.OpenFeatureClass(workspace, "TOPGIS_TLM.TLM_STRASSE");
ISpatialReference spatialReference = ((IGeoDataset)fclass).SpatialReference;
string xml = SpatialReferenceUtils.ToXmlString(spatialReference);
Console.WriteLine(xml);
Assert.IsNotNull(xml);
Assert.IsNotEmpty(xml);
ISpatialReference imported = SpatialReferenceUtils.FromXmlString(xml);
Assert.IsTrue(
SpatialReferenceUtils.AreEqual(imported, spatialReference));
}
public QaInteriorRings(
[Doc(nameof(DocStrings.QaInteriorRings_polygonClass))][NotNull]
IFeatureClass polygonClass,
[Doc(nameof(DocStrings.QaInteriorRings_maximumInteriorRingCount))]
int maximumInteriorRingCount)
: base((ITable)polygonClass)
{
Assert.ArgumentNotNull(polygonClass, nameof(polygonClass));
Assert.ArgumentCondition(
polygonClass.ShapeType == esriGeometryType.esriGeometryPolygon,
"polygon feature class expected");
_maximumInteriorRingCount = maximumInteriorRingCount;
_shapeFieldName = polygonClass.ShapeFieldName;
_spatialReference = DatasetUtils.GetSpatialReference(polygonClass);
IgnoreInnerRingsLargerThan = _defaultIgnoreInnerRingsLargerThan;
ReportIndividualRings = _defaultReportIndividualRings;
ReportOnlySmallestRingsExceedingMaximumCount =
_defaultReportOnlySmallestRingsExceedingMaximumCount;
}
public void TestUniqueStrings()
{
ISpatialReference sref = SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
true);
SpatialReferenceUtils.SetXYDomain(sref, -10000, -10000, 10000, 10000, 0.0001, 0.001);
IFields fields = FieldUtils.CreateFields(
FieldUtils.CreateOIDField(),
FieldUtils.CreateTextField("Unique", 100),
FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPoint,
sref, 1000));
IFeatureClass featureClass = DatasetUtils.CreateSimpleFeatureClass(_pgdbWorkspace,
"TestUniqueStrings",
fields);
for (var i = 0; i < 10; i++)
{
IFeature feature = featureClass.CreateFeature();
feature.set_Value(1, string.Format("A'{0}{1}", i, "\""));
feature.Shape = GeometryFactory.CreatePoint(100, 100, sref);
feature.Store();
}
IEnvelope testEnvelope = GeometryFactory.CreateEnvelope(0, 0, 200, 200, sref);
foreach (bool forceInMemoryTableSort in new[] { false, true })
{
var test = new QaUnique((ITable)featureClass, "Unique")
{
ForceInMemoryTableSorting = forceInMemoryTableSort
};
var runner = new QaTestRunner(test);
runner.Execute(testEnvelope);
AssertUtils.NoError(runner);
}
}
async Task MakeDatasetsUnAvailable(Sandbox sandbox, bool continueOnError = true, CancellationToken cancellation = default)
{
var resourceGroupResource = CloudResourceUtil.GetResourceByType(sandbox.Resources, AzureResourceType.ResourceGroup, true);
var vNetResource = CloudResourceUtil.GetResourceByType(sandbox.Resources, AzureResourceType.VirtualNetwork, true);
if (resourceGroupResource == null)
{
throw new Exception($"Could not locate Resource Group entry for Sandbox {sandbox.Id}");
}
if (vNetResource == null)
{
throw new Exception($"Could not locate VNet entry for Sandbox {sandbox.Id}");
}
var sandboxDatasets = await _sandboxDatasetModelService.GetSandboxDatasetsForPhaseShiftAsync(sandbox.Id);
foreach (var curDatasetRelation in sandboxDatasets)
{
try
{
if (!curDatasetRelation.Dataset.StudySpecific)
{
throw new Exception($"Only study specific datasets are supported. Please remove dataset {curDatasetRelation.Dataset.Name} from Sandbox");
}
var datasetResourceEntry = DatasetUtils.GetStudySpecificStorageAccountResourceEntry(curDatasetRelation.Dataset);
await _azureStorageAccountNetworkRuleService.RemoveStorageAccountFromVNet(datasetResourceEntry.ResourceGroupName, datasetResourceEntry.ResourceName, resourceGroupResource.ResourceName, vNetResource.ResourceName, cancellation);
}
catch (Exception ex)
{
_logger.LogError(ex, $"Unable to make dataset {curDatasetRelation.Dataset.Name} unavailable");
if (!continueOnError)
{
throw;
}
}
}
}
public void TooLong()
{
IDomain domain1 = DomainUtils.AddDomain(_workspace,
DomainUtils.CreateCodedValueDomain(
"DOM_FIELD1",
esriFieldType.esriFieldTypeInteger,
"Description of DOM_FIELD1_toolong",
new CodedValue(1, "Value 1"),
new CodedValue(2, "Value 2")));
IDomain domain2 = DomainUtils.AddDomain(_workspace,
DomainUtils.CreateCodedValueDomain(
"DOM_FIELD2",
esriFieldType.esriFieldTypeInteger,
"Description of DOM_FIELD2",
new CodedValue(1, "Value 1"),
new CodedValue(2, "Value 2")));
IField field1 = FieldUtils.CreateField("FIELD1", esriFieldType.esriFieldTypeInteger);
IField field2 = FieldUtils.CreateField("FIELD2", esriFieldType.esriFieldTypeInteger);
IField field3 = FieldUtils.CreateTextField("FIELD3", 20);
((IFieldEdit)field1).Domain_2 = domain1;
((IFieldEdit)field2).Domain_2 = domain2;
ITable table = DatasetUtils.CreateTable(_workspace,
MethodBase.GetCurrentMethod().Name,
FieldUtils.CreateOIDField(),
field1, field2, field3);
const int maxLength = 25;
const bool noDuplicates = true;
var runner =
new QaTestRunner(new QaSchemaFieldDomainDescriptions(table, maxLength,
noDuplicates,
null));
runner.Execute();
Assert.AreEqual(1, runner.Errors.Count);
}
private static IDictionary <string, string> GetTableNameReplacements(
[NotNull] IEnumerable <DatasetTestParameterValue> datasetParameterValues,
[NotNull] IOpenDataset datasetContext,
[NotNull] string associationName,
[NotNull] string relationshipClassName)
{
var replacements = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
if (!string.Equals(associationName, relationshipClassName,
StringComparison.OrdinalIgnoreCase))
{
replacements.Add(associationName, relationshipClassName);
}
foreach (DatasetTestParameterValue datasetParameterValue in datasetParameterValues)
{
Dataset dataset = datasetParameterValue.DatasetValue;
if (dataset == null)
{
continue;
}
var table = datasetContext.OpenDataset(
dataset, Assert.NotNull(datasetParameterValue.DataType)) as ITable;
if (table == null)
{
continue;
}
string tableName = DatasetUtils.GetName(table);
if (!string.Equals(dataset.Name, tableName))
{
replacements.Add(dataset.Name, tableName);
}
}
return(replacements);
}
public void Configure([NotNull] ITable table,
[NotNull] ITableFields tableFields,
[NotNull] IIssueTableFields fields)
{
Assert.ArgumentNotNull(table, nameof(table));
Assert.ArgumentNotNull(tableFields, nameof(tableFields));
Assert.ArgumentNotNull(fields, nameof(fields));
foreach (KeyValuePair <IssueAttribute, XmlFieldOptions> pair in _fieldOptionsByRole)
{
int fieldIndex = fields.GetIndex(pair.Key, table, optional: true);
if (fieldIndex < 0)
{
_msg.DebugFormat(
"No field with role {0} found in {1}; field configuration ignored",
pair.Key, DatasetUtils.GetName(table));
continue;
}
var fieldInfo = (IFieldInfo3)tableFields.FieldInfo[fieldIndex];
Configure(fieldInfo, pair.Value);
}
foreach (KeyValuePair <string, XmlFieldOptions> pair in _fieldOptionsByName)
{
int fieldIndex = table.FindField(pair.Key);
if (fieldIndex < 0)
{
_msg.DebugFormat("Field not found in {0}: {1}; field configuration ignored",
DatasetUtils.GetName(table),
pair.Key);
continue;
}
var fieldInfo = (IFieldInfo3)tableFields.FieldInfo[fieldIndex];
Configure(fieldInfo, pair.Value);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="QaLengthBase"/> class.
/// </summary>
/// <param name="featureClass">The feature class.</param>
/// <param name="limit">The limit.</param>
/// <param name="is3D">if set to <c>true</c> [is3 D].</param>
/// <param name="perPart">if set to <c>true</c> [per part].</param>
protected QaLengthBase([NotNull] IFeatureClass featureClass,
double limit,
bool is3D,
bool perPart)
: base((ITable)featureClass)
{
Assert.ArgumentNotNull(featureClass, nameof(featureClass));
_limit = limit;
_is3D = is3D;
_perPart = perPart;
_shapeFieldName = featureClass.ShapeFieldName;
IField lengthField = DatasetUtils.GetLengthField(featureClass);
_lengthFieldIndex = lengthField == null
? -1
: featureClass.FindField(lengthField.Name);
_useField = _lengthFieldIndex >= 0 &&
(!is3D || !DatasetUtils.HasZ(featureClass));
}
private ITable CreateTestTable([NotNull] string tableName, out int cvFieldIndex,
out int rangeFieldIndex)
{
IRangeDomain rangeDomain = DomainUtils.CreateRangeDomain(
tableName + "_range",
esriFieldType.esriFieldTypeInteger, 0, 100);
DomainUtils.AddDomain(_testWs, rangeDomain);
ICodedValueDomain cvDomain = DomainUtils.CreateCodedValueDomain(
tableName + "_cv",
esriFieldType.esriFieldTypeInteger, null,
esriSplitPolicyType.esriSPTDuplicate,
esriMergePolicyType.esriMPTDefaultValue,
new CodedValue(1, "Value 1"),
new CodedValue(2, "Value 2"),
new CodedValue(3, "Value 3"));
DomainUtils.AddDomain(_testWs, cvDomain);
IField cvField = FieldUtils.CreateIntegerField("CvField");
((IFieldEdit)cvField).Domain_2 = (IDomain)cvDomain;
IField rangeField = FieldUtils.CreateIntegerField("RangeField");
((IFieldEdit)rangeField).Domain_2 = (IDomain)rangeDomain;
ITable table = DatasetUtils.CreateTable(_testWs,
tableName,
FieldUtils.CreateOIDField(),
cvField,
rangeField);
cvFieldIndex = table.FindField(cvField.Name);
rangeFieldIndex = table.FindField(rangeField.Name);
return(table);
}
public void CanOpenOleDbWorkspaceAccess()
{
string mdbPath = TestData.GetNonGdbAccessDatabase();
string connectionString =
string.Format(
@"Provider=Microsoft.Jet.OLEDB.4.0;Data Source={0};Persist Security Info=False",
mdbPath);
IWorkspace workspace = WorkspaceUtils.OpenOleDbWorkspace(connectionString);
Assert.True(WorkspaceUtils.IsOleDbWorkspace(workspace));
Assert.False(WorkspaceUtils.UsesQualifiedDatasetNames(workspace));
LogWorkspaceProperties(workspace);
foreach (IDatasetName datasetName in DatasetUtils.GetDatasetNames(
workspace, esriDatasetType.esriDTTable))
{
Console.WriteLine(datasetName.Name);
}
}
private IFeatureClass CreateFeatureClass([NotNull] string name,
esriGeometryType geometryType,
params IField[] attributeFields)
{
ISpatialReference sref = SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
true);
SpatialReferenceUtils.SetXYDomain(sref, -10000, -10000, 10000, 10000, 0.0001,
0.001);
var fields = new List <IField>
{
FieldUtils.CreateOIDField(),
FieldUtils.CreateShapeField("Shape", geometryType, sref, 1000)
};
fields.AddRange(attributeFields);
return(DatasetUtils.CreateSimpleFeatureClass(_testWs, name,
FieldUtils.CreateFields(fields)));
}
public override bool IsSatisfied(IDatasetName datasetName, out string reason)
{
string databaseName;
string ownerName;
string tableName;
DatasetUtils.ParseTableName(datasetName,
out databaseName,
out ownerName,
out tableName);
string pattern = GetFirstMatchedPattern(tableName, ownerName, databaseName);
if (pattern == null)
{
reason = "Name does not match any pattern";
return(false);
}
reason = $"Name matches pattern '{pattern}'";
return(true);
}
public static IList <IDomain> GetDomains([NotNull] IObjectClass objectClass)
{
Assert.ArgumentNotNull(objectClass, nameof(objectClass));
var domains = new HashSet <IDomain>();
var subtypes = objectClass as ISubtypes;
IList <Subtype> subtypeValues = DatasetUtils.GetSubtypes(objectClass);
foreach (IField field in DatasetUtils.GetFields(objectClass))
{
IDomain domain = field.Domain;
if (domain != null)
{
domains.Add(domain);
}
if (subtypes == null)
{
continue;
}
string fieldName = field.Name;
foreach (Subtype subtype in subtypeValues)
{
IDomain subtypeDomain = subtypes.Domain[subtype.Code, fieldName];
if (subtypeDomain != null)
{
domains.Add(subtypeDomain);
}
}
}
return(new List <IDomain>(domains));
}
public static IList <double> GetXyTolerances(
[NotNull] IEnumerable <IFeatureClass> featureClasses)
{
Assert.ArgumentNotNull(featureClasses, nameof(featureClasses));
var result = new List <double>();
foreach (IFeatureClass featureClass in featureClasses)
{
double xyTolerance;
if (!DatasetUtils.TryGetXyTolerance(featureClass, out xyTolerance))
{
throw new ArgumentException(
string.Format("{0} has an undefined or invalid XY tolerance",
DatasetUtils.GetName(featureClass)));
}
result.Add(xyTolerance);
}
return(result);
}
public async Task DeleteResourcesForStudySpecificDatasetAsync(Study study, Dataset dataset, CancellationToken cancellationToken = default)
{
_logger.LogInformation($"DeleteResourcesForStudySpecificDatasetAsync - Dataset Id: {dataset.Id}. Resources will be marked ");
try
{
var datasetResourceEntry = DatasetUtils.GetStudySpecificStorageAccountResourceEntry(dataset);
if (datasetResourceEntry != null)
{
await SoftDeleteUtil.MarkAsDeleted(datasetResourceEntry, _userService);
var deleteOperation = await _cloudResourceOperationCreateService.CreateDeleteOperationAsync(datasetResourceEntry.Id, $"Delete dataset related resurces for dataset {dataset.Id}");
await _provisioningQueueService.CreateItemAndEnqueue(deleteOperation);
}
}
catch (Exception ex)
{
throw new Exception($"Failed to delete resources for study specific dataset", ex);
}
}
public void CanCreateStringCodedValueDomainConstraintNotNull()
{
ICodedValueDomain stringCvDomain = DomainUtils.CreateCodedValueDomain(
"CanCreateStringCodedValueDomainConstraintNotNull",
esriFieldType.esriFieldTypeString, null,
esriSplitPolicyType.esriSPTDuplicate,
esriMergePolicyType.esriMPTDefaultValue,
new CodedValue("a", "Value a"),
new CodedValue("b", "Value b"),
new CodedValue("c", "Value c"));
DomainUtils.AddDomain(_testWs, stringCvDomain);
IField textField = FieldUtils.CreateTextField("TextField", 100);
((IFieldEdit)textField).Domain_2 = (IDomain)stringCvDomain;
ITable table = DatasetUtils.CreateTable(_testWs,
"CanCreateStringCodedValueDomainConstraintNotNull",
FieldUtils.CreateOIDField(),
textField);
List <ConstraintNode> constraints =
GdbConstraintUtils.GetGdbConstraints(
table, allowNullForCodedValueDomains: false);
Assert.NotNull(constraints);
foreach (ConstraintNode constraint in constraints)
{
Console.WriteLine(constraint);
}
Assert.AreEqual(2, constraints.Count);
Assert.AreEqual("TextField IN ('a', 'b', 'c')",
constraints[0].Condition);
Assert.AreEqual("OBJECTID >= 0", constraints[1].Condition);
}
public static string GetBaseTableName([NotNull] string gdbDatasetOrQueryClassName)
{
Assert.ArgumentNotNullOrEmpty(gdbDatasetOrQueryClassName,
nameof(gdbDatasetOrQueryClassName));
if (!DatasetUtils.IsQueryLayerClassName(gdbDatasetOrQueryClassName))
{
// not a query class name
return(gdbDatasetOrQueryClassName);
}
string baseTableName;
if (_tableNamesByQueryClassNames.TryGetValue(gdbDatasetOrQueryClassName,
out baseTableName))
{
return(baseTableName);
}
// return name as is
return(gdbDatasetOrQueryClassName);
}
public static IEnumerable <string> GetExpressionFieldNames(
[NotNull] string expression,
[NotNull] ITable table,
[NotNull] string alias)
{
var tableFieldNames = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
foreach (IField field in DatasetUtils.GetFields(table))
{
tableFieldNames.Add(field.Name);
}
var result = new HashSet <string>();
foreach (string token in GetExpressionTokens(expression))
{
string[] tokenParts = token.Split('.');
if (tokenParts.Length != 2)
{
continue;
}
if (!string.Equals(tokenParts[0], alias, StringComparison.OrdinalIgnoreCase))
{
continue;
}
string fieldName = tokenParts[1];
if (!tableFieldNames.Contains(fieldName))
{
continue;
}
result.Add(fieldName);
}
return(result);
}
private static IFeatureClass CreateFeatureClass(
IFeatureWorkspace ws, string fcName)
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryMultiPatch,
SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
true), 1000, true, false));
IFeatureClass fc =
DatasetUtils.CreateSimpleFeatureClass(ws, fcName, fields, null);
// make sure the table is known by the workspace
((IWorkspaceEdit)ws).StartEditing(false);
((IWorkspaceEdit)ws).StopEditing(true);
((IWorkspaceEdit)ws).StartEditing(false);
return(fc);
}
public void CanCreateSpatialFilterWithMultipatch()
{
IFeatureWorkspace ws = OpenTestWorkspace();
IFeatureClass fc = ws.OpenFeatureClass("TOPGIS_TLM.TLM_STRASSE");
ISpatialReference spatialReference = DatasetUtils.GetSpatialReference(fc);
IEnvelope largeEnvelope = GeometryFactory.CreateEnvelope(2600000, 1200000,
2601000, 1201000,
445, spatialReference);
IMultiPatch multiPatch =
GeometryFactory.CreateMultiPatch(GeometryFactory.CreatePolygon(largeEnvelope));
double xyResolution =
SpatialReferenceUtils.GetXyResolution(Assert.NotNull(spatialReference));
// NOTE: Multipatch implements IRelationalOperator since a while!
IGeometry validGeometry;
string message;
Assert.True(GdbQueryUtils.IsValidFilterGeometry(
multiPatch, xyResolution, out validGeometry, out message),
"Multipatch should be valid");
Assert.NotNull(validGeometry);
Assert.True(multiPatch == validGeometry,
"Multipatch should be valid");
Assert.True(GdbQueryUtils.IsValidFilterGeometry(
validGeometry, xyResolution, out validGeometry, out message),
"Corrected geometry should be valid");
IQueryFilter filter = GdbQueryUtils.CreateSpatialFilter(
fc, multiPatch, esriSpatialRelEnum.esriSpatialRelIntersects, false,
spatialReference);
Assert.True(GdbQueryUtils.GetFeatures(fc, filter, true).Any(), "No features found.");
}
public void CanCreateIntegerCodedValueDomainConstraint()
{
ICodedValueDomain integerCvDomain = DomainUtils.CreateCodedValueDomain(
"CanCreateIntegerCodedValueDomainConstraint",
esriFieldType.esriFieldTypeInteger, null,
esriSplitPolicyType.esriSPTDuplicate,
esriMergePolicyType.esriMPTDefaultValue,
new CodedValue(1, "Value 1"),
new CodedValue(2, "Value 2"),
new CodedValue(3, "Value 3"));
DomainUtils.AddDomain(_testWs, integerCvDomain);
IField integerField = FieldUtils.CreateIntegerField("IntegerField");
((IFieldEdit)integerField).Domain_2 = (IDomain)integerCvDomain;
ITable table = DatasetUtils.CreateTable(_testWs,
"CanCreateIntegerCodedValueDomainConstraint",
FieldUtils.CreateOIDField(),
integerField);
List <ConstraintNode> constraints =
GdbConstraintUtils.GetGdbConstraints(table);
Assert.NotNull(constraints);
foreach (ConstraintNode constraint in constraints)
{
Console.WriteLine(constraint);
}
Assert.AreEqual(2, constraints.Count);
Assert.AreEqual("IntegerField IS NULL OR (IntegerField IN (1, 2, 3))",
constraints[0].Condition);
Assert.AreEqual("OBJECTID >= 0", constraints[1].Condition);
}
public static void EnsureUnqualifiedNames([NotNull] IModelElement modelElement,
[NotNull] IDatasetName datasetName)
{
Assert.ArgumentNotNull(modelElement, nameof(modelElement));
Assert.ArgumentNotNull(datasetName, nameof(datasetName));
modelElement.Name = ModelElementNameUtils.GetUnqualifiedName(datasetName.Name);
var featureDatasetElement = modelElement as IFeatureDatasetElement;
if (featureDatasetElement == null)
{
return;
}
IDatasetName featureDatasetName = DatasetUtils.GetFeatureDatasetName(datasetName);
Assert.NotNull(featureDatasetName,
"Unable to determine feature dataset name for {0}",
datasetName.Name);
featureDatasetElement.FeatureDatasetName =
ModelElementNameUtils.GetUnqualifiedName(featureDatasetName.Name);
}
public static IDataView GetHousingRegressionIDataView(MLContext mlContext, out string labelName, out string[] featureNames, bool binaryPrediction = false)
{
// Read the Housing regression dataset
var data = DatasetUtils.LoadHousingRegressionDataset(mlContext);
// Define the label column
var labelColumn = "MedianHomeValue";
if (binaryPrediction)
{
labelColumn = nameof(BinaryOutputRow.AboveAverage);
data = mlContext.Transforms.CustomMappingTransformer(GreaterThanAverage, null).Transform(data);
data = mlContext.Transforms.DropColumns("MedianHomeValue").Fit(data).Transform(data);
}
labelName = labelColumn;
featureNames = data.Schema.AsEnumerable()
.Select(column => column.Name) // Get the column names
.Where(name => name != labelColumn) // Drop the Label
.ToArray();
return(data);
}
public static string GetGdbElementName([NotNull] IModelElement modelElement,
[NotNull] IWorkspace workspace,
[CanBeNull] string databaseName,
[CanBeNull] string schemaOwner)
{
Assert.ArgumentNotNull(modelElement, nameof(modelElement));
Assert.ArgumentNotNull(workspace, nameof(workspace));
if (!WorkspaceUtils.UsesQualifiedDatasetNames(workspace) ||
ModelElementNameUtils.IsQualifiedName(modelElement.Name))
{
return(modelElement.Name);
}
// TODO check if workspace required database name part, and add assertion?
Assert.NotNullOrEmpty(schemaOwner, "Unknown schema owner, cannot qualify name");
return(DatasetUtils.QualifyTableName(workspace,
databaseName,
schemaOwner,
modelElement.Name));
}
public void OrderByGuidFileGdb()
{
IFeatureWorkspace featureWs =
WorkspaceUtils.OpenFileGdbFeatureWorkspace(TestData.GetArealeFileGdbPath());
ITable table = DatasetUtils.OpenTable(featureWs, "TLM_NUTZUNGSAREAL");
IQueryFilter queryFilter = new QueryFilterClass();
var queryFilterDef = (IQueryFilterDefinition)queryFilter;
queryFilterDef.PostfixClause = "ORDER BY UUID";
foreach (IRow row in GdbQueryUtils.GetRows(table, queryFilter, true))
{
object value = row.get_Value(1);
Assert.False(value == DBNull.Value, "Empty UUID field");
var currentGuid = new Guid((string)value);
Console.WriteLine(currentGuid);
}
}
private static IEnumerable <string> GetAllEditableFieldNames([NotNull] ITable table)
{
Assert.ArgumentNotNull(table, nameof(table));
var featureClass = table as IFeatureClass;
string shapeFieldName = featureClass?.ShapeFieldName;
foreach (IField field in DatasetUtils.GetFields(table))
{
if (!field.Editable || !field.IsNullable)
{
continue;
}
if (shapeFieldName != null &&
string.Equals(field.Name, shapeFieldName, StringComparison.OrdinalIgnoreCase))
{
continue;
}
yield return(field.Name);
}
}
public QaEmptyNotNullTextFields(
[Doc(nameof(DocStrings.QaEmptyNotNullTextFields_table))][NotNull]
ITable table,
[Doc(nameof(DocStrings.QaEmptyNotNullTextFields_notNullTextFields))][NotNull]
string[]
notNullTextFields)
: base(table)
{
Assert.ArgumentNotNull(notNullTextFields, nameof(notNullTextFields));
var fieldIndices = new List <int>(notNullTextFields.Length);
foreach (string notNullTextField in notNullTextFields)
{
int fieldIndex = table.FindField(notNullTextField);
Assert.True(fieldIndex >= 0, "field '{0}' not found in table '{1}'",
notNullTextField, DatasetUtils.GetName(table));
fieldIndices.Add(fieldIndex);
}
_notNullTextFieldIndices = fieldIndices;
}
private static IFeatureClass CreateLineClass([NotNull] IFeatureWorkspace ws,
[NotNull] string name,
[CanBeNull] IList <IField> addFields = null)
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
if (addFields != null)
{
foreach (IField addField in addFields)
{
fields.AddField(addField);
}
}
fields.AddField(FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPolyline,
SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
true), 1000, false, false));
return(DatasetUtils.CreateSimpleFeatureClass(ws, name, fields, null));
}
