private static IEnumerable <IRow> GetReferencingRows( [NotNull] ReferencedTableInfo referencedTableInfo, [NotNull] ReferencingTableInfo referencingTableInfo) { const bool recycle = true; const int maxKeyCount = 20; if (referencedTableInfo.KeySet.Count <= maxKeyCount) { return(GdbQueryUtils.GetRowsInList( referencingTableInfo.Table, referencingTableInfo.ForeignKeyFieldName, referencedTableInfo.KeySet, recycle, referencingTableInfo.Filter)); } var queryFilter = new QueryFilterClass { WhereClause = string.Format("{0} IS NOT NULL", referencingTableInfo.ForeignKeyFieldName) }; return(GdbQueryUtils.GetRows(referencingTableInfo.Table, queryFilter, recycle)); }
private static IDictionary <Guid, QualityConditionExceptions> ReadTargetExceptions( [NotNull] IList <IObjectClass> targetExceptionClasses, [NotNull] IIssueTableFields fields) { Assert.ArgumentNotNull(targetExceptionClasses, nameof(targetExceptionClasses)); Assert.ArgumentCondition(targetExceptionClasses.Count > 0, "no exception classes"); var result = new Dictionary <Guid, QualityConditionExceptions>(); foreach (ITable targetTable in targetExceptionClasses.Cast <ITable>()) { var factory = new ExceptionObjectFactory( targetTable, fields, defaultStatus: ExceptionObjectStatus.Inactive, includeManagedExceptionAttributes: true); foreach (IRow row in GdbQueryUtils.GetRows(targetTable, recycle: true)) { ExceptionObject exceptionObject = factory.CreateExceptionObject(row); Guid qconVersionUuid = exceptionObject.QualityConditionVersionUuid; QualityConditionExceptions exceptions; if (!result.TryGetValue(qconVersionUuid, out exceptions)) { exceptions = new QualityConditionExceptions(qconVersionUuid, null); result.Add(qconVersionUuid, exceptions); } exceptions.Add(exceptionObject); } } return(result); }
private static IList <ConstraintNode> GetConstraints( [NotNull] ITable constraintsTable, [CanBeNull] string filterExpression, [NotNull] string constraintField, [CanBeNull] string constraintDescriptionField, bool invertCondition) { var result = new List <ConstraintNode>(); int constraintIndex = constraintsTable.FindField(constraintField); Assert.True(constraintIndex >= 0, "Field {0} not found in table {1}", constraintField, DatasetUtils.GetName(constraintsTable)); int descriptionIndex = -1; if (StringUtils.IsNotEmpty(constraintDescriptionField)) { descriptionIndex = constraintsTable.FindField(constraintDescriptionField); Assert.True(descriptionIndex >= 0, "Field {0} not found in table {1}", constraintDescriptionField, DatasetUtils.GetName(constraintsTable)); } IQueryFilter filter = CreateQueryFilter(filterExpression, constraintField, constraintDescriptionField); const bool recycling = true; foreach (IRow row in GdbQueryUtils.GetRows(constraintsTable, filter, recycling)) { var constraint = row.Value[constraintIndex] as string; if (constraint == null || constraint.Trim().Length == 0) { continue; } string constraintDescription = descriptionIndex >= 0 ? row.Value[descriptionIndex] as string : null; result.Add( CreateConstraintNode(constraint, constraintDescription, invertCondition)); } return(result); }
private static ExceptionUpdateDetector GetUpdateDetector( [NotNull] ITable targetTable, [NotNull] ManagedExceptionVersionFactory targetExceptionVersionFactory, [NotNull] IEnumerable <IssueAttribute> editableAttributes) { var result = new ExceptionUpdateDetector(editableAttributes); foreach (IRow targetRow in GdbQueryUtils.GetRows(targetTable, recycle: true)) { result.AddExistingException( targetExceptionVersionFactory.CreateExceptionVersion(targetRow)); } return(result); }
private static Dictionary <int, IRow> GetFirstNRows(ITable table, int count) { var dic = new Dictionary <int, IRow>(count); foreach (IRow row in GdbQueryUtils.GetRows(table, false)) { dic.Add(row.OID, row); if (dic.Count >= count) { break; } } return(dic); }
protected virtual IEnumerable <Row> GetRowsCore([NotNull] ISourceClass sourceClass, [CanBeNull] QueryFilter filter, bool recycle) { Table table = OpenFeatureClass(sourceClass); if (table == null) { yield break; } // Todo daro: check recycle foreach (Feature feature in GdbQueryUtils.GetRows <Feature>( table, filter, recycle)) { yield return(feature); } }
/// <summary> /// Ensures that the list of reserved names is ready. /// </summary> private void EnsureReservedNames() { if (_reservedNames != null) { return; } int nameFieldIndex; int reasonFieldIndex; int validNameFieldIndex; string subFields = GetLookupSubFields(out nameFieldIndex, out reasonFieldIndex, out validNameFieldIndex); var queryFilter = new QueryFilterClass { SubFields = subFields, WhereClause = GetConstraint(_reservedNamesTable) }; _reservedNames = new List <ReservedName>(); const bool recycle = true; foreach ( IRow row in GdbQueryUtils.GetRows(_reservedNamesTable, queryFilter, recycle)) { var name = row.get_Value(nameFieldIndex) as string; if (string.IsNullOrEmpty(name)) { continue; } string reason = reasonFieldIndex >= 0 ? row.get_Value(reasonFieldIndex) as string : null; string validName = validNameFieldIndex >= 0 ? row.get_Value(validNameFieldIndex) as string : null; _reservedNames.Add(new ReservedName(name, reason, validName)); } }
private IEnumerable <FieldSpecification> ReadFieldSpecifications( [NotNull] ITable table) { int nameFieldIndex = table.FindField("ATTRIBUTE"); int typeStringFieldIndex = table.FindField("FIELDTYPE_ARCGIS"); int aliasFieldIndex = table.FindField("ALIAS"); int accessTypeFieldIndex = table.FindField("FIELDTYPE_ACCESS"); const bool recycle = true; foreach (IRow row in GdbQueryUtils.GetRows(table, GetQueryFilter(), recycle)) { var name = row.Value[nameFieldIndex] as string; Console.WriteLine(name); if (string.IsNullOrEmpty(name)) { continue; } object type = row.Value[typeStringFieldIndex]; var typeString = type as string; if (string.IsNullOrEmpty(typeString)) { throw new InvalidConfigurationException( string.Format("Expected type is undefined: '{0}'", type)); } var alias = row.Value[aliasFieldIndex] as string; esriFieldType expectedType = GetFieldType(typeString); var accessTypeString = row.Value[accessTypeFieldIndex] as string; int length = expectedType == esriFieldType.esriFieldTypeString ? GetTextLength(accessTypeString) : -1; yield return (new FieldSpecification(name, expectedType, length, alias, null, true)); } }
public void CanGetRelated() { IFeatureWorkspace ws = OpenTestWorkspace(); IRelationshipClass rc = ws.OpenRelationshipClass("TOPGIS_TLM.TLM_STRASSE_NAME"); NUnit.Framework.Assert.AreEqual(rc.Cardinality, esriRelCardinality.esriRelCardinalityOneToMany); int count = 0; foreach (IRow row in GdbQueryUtils.GetRows((ITable)rc.OriginClass, false)) { var obj = (IObject)row; IList <IObject> features = GdbQueryUtils.GetRelatedObjectList(obj, new[] { rc }); count += features.Count; } NUnit.Framework.Assert.Greater(count, 0); }
private int ExecuteGeometry([CanBeNull] IGeometry geometry) { EnsureKeySet(); if (!(_table is IFeatureClass)) { geometry = null; } IQueryFilter filter = TestUtils.CreateFilter(geometry, AreaOfInterest, GetConstraint(0), _table, null); const bool recycle = true; int errorCount = 0; foreach (IRow row in GdbQueryUtils.GetRows(_table, filter, recycle)) { errorCount += VerifyRow(row); } return(errorCount); }
public void Can_instantiate_IssueItem() { var definition = _geodatabase.GetDefinition <FeatureClassDefinition>(_issuePointsFeatureClassName); var reader = new AttributeReader(definition, Attributes.IssueCode, Attributes.IssueCodeDescription, Attributes.InvolvedObjects, Attributes.QualityConditionName, Attributes.TestName, Attributes.TestDescription, Attributes.TestType, Attributes.IssueSeverity, Attributes.IsStopCondition, Attributes.Category, Attributes.AffectedComponent, Attributes.Url, Attributes.DoubleValue1, Attributes.DoubleValue2, Attributes.TextValue, Attributes.IssueAssignment, Attributes.QualityConditionUuid, Attributes.QualityConditionVersionUuid, Attributes.ExceptionStatus, Attributes.ExceptionNotes, Attributes.ExceptionCategory, Attributes.ExceptionOrigin, Attributes.ExceptionDefinedDate, Attributes.ExceptionLastRevisionDate, Attributes.ExceptionRetirementDate, Attributes.ExceptionShapeMatchCriterion); foreach (Feature feature in GdbQueryUtils.GetRows <Feature>(_issuePoints)) { var item = new IssueItem(0, feature); break; } }
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); } }
public static void Import( [CanBeNull] string importWhereClause, [NotNull] IList <IObjectClass> targetExceptionClasses, [NotNull] IList <IObjectClass> importExceptionClasses, [NotNull] string importOriginValue, DateTime importDate) { IIssueTableFields importFields = GetImportFields(importExceptionClasses); IIssueTableFields targetFields = GetTargetFields(targetExceptionClasses); IDictionary <Guid, QualityConditionExceptions> targetExceptionsByConditionVersion; using (_msg.IncrementIndentation( "Reading existing exceptions in target workspace")) { targetExceptionsByConditionVersion = ReadTargetExceptions(targetExceptionClasses, targetFields); } var replacedExceptionObjects = new Dictionary <esriGeometryType, HashSet <int> >(); using (_msg.IncrementIndentation("Importing new exceptions from issue datasets...") ) { foreach (ITable importTable in importExceptionClasses.Cast <ITable>()) { using (_msg.IncrementIndentation("from {0}...", DatasetUtils.GetName(importTable))) { ITable targetTable = GetTargetTable(importTable, targetExceptionClasses); if (targetTable == null) { _msg.Warn( "No matching table in target workspace, ignoring import table"); continue; } var factory = new ExceptionObjectFactory( importTable, importFields, defaultStatus: ExceptionObjectStatus.Inactive); var newCount = 0; var updateCount = 0; var ignoredCount = 0; using (var writer = new ExceptionWriter(importTable, importFields, targetTable, targetFields)) { foreach (IRow row in GdbQueryUtils.GetRows(importTable, GetQueryFilter( importWhereClause), recycle: true)) { int matchCount; bool added = ImportException(row, importOriginValue, importDate, factory, targetExceptionsByConditionVersion, replacedExceptionObjects, writer, out matchCount); if (!added) { ignoredCount++; } else if (matchCount == 0) { newCount++; } else { updateCount++; } } } _msg.InfoFormat("{0:N0} exception(s) imported as new", newCount); _msg.InfoFormat("{0:N0} exception(s) imported as updates", updateCount); if (ignoredCount > 0) { _msg.InfoFormat("{0:N0} exception(s) ignored", ignoredCount); } } } } using (_msg.IncrementIndentation("Processing replaced exceptions...")) { foreach (ITable targetTable in targetExceptionClasses.Cast <ITable>()) { using (_msg.IncrementIndentation("Target table {0}...", DatasetUtils.GetName(targetTable))) { int fixedStatusCount; int updateCount = ProcessReplacedExceptions(targetTable, targetFields, replacedExceptionObjects, importDate, out fixedStatusCount); _msg.InfoFormat("{0:N0} replaced exception(s) updated", updateCount); if (fixedStatusCount > 0) { _msg.InfoFormat("Status value of {0:N0} old exception version(s) fixed", fixedStatusCount); } } } } }
public static void Update( [CanBeNull] string whereClause, [NotNull] IList <IObjectClass> targetExceptionClasses, [NotNull] IList <IObjectClass> updateExceptionClasses, [NotNull] string updateOriginValue, DateTime updateDate, bool requireOriginalVersionExists = true) { IIssueTableFields updateFields = GetUpdateFields(updateExceptionClasses); IIssueTableFields targetFields = GetTargetFields(targetExceptionClasses); var editableAttributes = new[] { IssueAttribute.ExceptionStatus, IssueAttribute.ExceptionCategory, IssueAttribute.ExceptionNotes, IssueAttribute.ExceptionOrigin, IssueAttribute.ExceptionDefinitionDate, IssueAttribute.ExceptionLastRevisionDate, IssueAttribute.ExceptionRetirementDate, IssueAttribute.IssueAssignment }; using (_msg.IncrementIndentation( "Updating exceptions based on exported exception datasets...")) { foreach (ITable updateTable in updateExceptionClasses.Cast <ITable>()) { using (_msg.IncrementIndentation("from {0}...", DatasetUtils.GetName(updateTable))) { ITable targetTable = GetTargetTable(updateTable, targetExceptionClasses); if (targetTable == null) { _msg.Warn( "No matching table in target workspace, ignoring import table"); continue; } var targetExceptionFactory = new ManagedExceptionVersionFactory( targetTable, targetFields, editableAttributes); var updateExceptionFactory = new ManagedExceptionVersionFactory( updateTable, updateFields, editableAttributes); ExceptionUpdateDetector updateDetector = GetUpdateDetector( targetTable, targetExceptionFactory, editableAttributes); var replacedOids = new HashSet <int>(); var updatedRowsCount = 0; var rowsWithConflictsCount = 0; using (var exceptionWriter = new ExceptionWriter(updateTable, updateFields, targetTable, targetFields)) { foreach (IRow updateRow in GdbQueryUtils.GetRows( updateTable, GetQueryFilter(whereClause), recycle: true)) { ManagedExceptionVersion updateExceptionVersion = updateExceptionFactory.CreateExceptionVersion(updateRow); ManagedExceptionVersion mergedException; ManagedExceptionVersion replacedExceptionVersion; IList <ExceptionAttributeConflict> conflicts; if (updateDetector.HasChange(updateExceptionVersion, out mergedException, out replacedExceptionVersion, out conflicts)) { if (replacedExceptionVersion == null) { string message = string.Format( "Exception version {0} not found in lineage {1} (target table: {2})", ExceptionObjectUtils.FormatGuid( updateExceptionVersion.VersionUuid), ExceptionObjectUtils.FormatGuid( updateExceptionVersion.LineageUuid), DatasetUtils.GetName(targetTable)); if (requireOriginalVersionExists) { throw new InvalidDataException(message); } _msg.WarnFormat( "{0}. Creating new version with attributes from update row.", message); } updatedRowsCount++; string versionImportStatus; if (conflicts.Count == 0) { versionImportStatus = null; } else { versionImportStatus = FormatConflicts(conflicts, targetFields); rowsWithConflictsCount++; LogConflicts(conflicts, targetFields); } exceptionWriter.Write(updateRow, updateDate, mergedException, FormatOriginValue(updateOriginValue, replacedExceptionVersion), updateOriginValue, versionImportStatus); if (replacedExceptionVersion != null) { replacedOids.Add(replacedExceptionVersion.ObjectID); } } } } _msg.InfoFormat("{0:N0} exception(s) updated", updatedRowsCount); if (rowsWithConflictsCount > 0) { _msg.WarnFormat("{0:N0} exception(s) with conflicts", rowsWithConflictsCount); } if (replacedOids.Count > 0) { int fixedStatusCount; int updateCount = ProcessReplacedExceptions(targetTable, targetFields, updateDate, replacedOids, out fixedStatusCount); _msg.DebugFormat("{0:N0} replaced exception version(s) updated", updateCount); if (fixedStatusCount > 0) { _msg.WarnFormat( "Status value of {0:N0} old exception version(s) fixed", fixedStatusCount); } } } } } }
internal static IKeySet ReadKeySet([NotNull] ITable table, [NotNull] string keyField, [CanBeNull] string whereClause, esriFieldType keyFieldType, int keyFieldIndex) { Assert.ArgumentNotNull(table, nameof(table)); Assert.ArgumentNotNullOrEmpty(keyField, nameof(keyField)); Stopwatch watch = null; MemoryUsageInfo memoryUsage = null; if (_msg.IsVerboseDebugEnabled) { watch = _msg.DebugStartTiming(); memoryUsage = new MemoryUsageInfo(); memoryUsage.Refresh(); } IKeySet result = CreateKeySet(keyFieldType); var queryFilter = new QueryFilterClass { SubFields = keyField, WhereClause = whereClause }; string tableName = DatasetUtils.GetName(table); const bool recycle = true; foreach (IRow row in GdbQueryUtils.GetRows(table, queryFilter, recycle)) { object key = row.Value[keyFieldIndex]; if (key == DBNull.Value || key == null) { continue; } // TODO handle errors (e.g. invalid guid strings) bool added = result.Add(key); if (!added) { _msg.VerboseDebugFormat( "Ignored duplicate key found in field '{0}' in table '{1}': {2}", keyField, tableName, key); } } if (watch != null) { _msg.DebugStopTiming(watch, "Reading {0:N0} {1} keys from field '{2}' in table '{3}'", result.Count, keyFieldType, keyField, DatasetUtils.GetName(table)); _msg.DebugFormat("Memory usage of keys: {0}", memoryUsage); } return(result); }
internal static ITupleKeySet ReadTupleKeySet( [NotNull] ITable table, [NotNull] ICollection <string> keyFields, [CanBeNull] string whereClause, [NotNull] IList <esriFieldType> keyFieldTypes, [NotNull] IList <int> keyFieldIndices) { Assert.ArgumentNotNull(table, nameof(table)); Assert.ArgumentNotNull(keyFields, nameof(keyFields)); Assert.ArgumentNotNull(keyFieldTypes, nameof(keyFieldTypes)); Assert.ArgumentNotNull(keyFieldIndices, nameof(keyFieldIndices)); Stopwatch watch = null; MemoryUsageInfo memoryUsage = null; if (_msg.IsVerboseDebugEnabled) { watch = _msg.DebugStartTiming(); memoryUsage = new MemoryUsageInfo(); memoryUsage.Refresh(); } var fieldIndices = new List <int>(); foreach (string keyField in keyFields) { int fieldIndex = table.FindField(keyField); Assert.True(fieldIndex >= 0, "field '{0}' not found in table {1}", keyField, DatasetUtils.GetName(table)); fieldIndices.Add(fieldIndex); } ITupleKeySet result = new TupleKeySet(); IQueryFilter queryFilter = GetQueryFilter(keyFields, whereClause); string keyFieldsString = StringUtils.Concatenate(keyFields, ","); string tableName = DatasetUtils.GetName(table); const bool recycle = true; foreach (IRow row in GdbQueryUtils.GetRows(table, queryFilter, recycle)) { Tuple tuple = ReadTuple(row, fieldIndices); bool added = result.Add(tuple); if (!added) { _msg.DebugFormat( "Ignored duplicate value combination found in fields '{0}' in table '{1}': {2}", keyFieldsString, tableName, tuple); } } if (watch != null) { _msg.DebugStopTiming(watch, "Reading {0:N0} keys from fields '{1}' in table '{2}'", result.Count, queryFilter.SubFields, DatasetUtils.GetName(table)); _msg.DebugFormat("Memory usage of keys: {0}", memoryUsage); } return(result); }
public void CanCreateGdbFeatureClassWithBackingDataset() { IWorkspace ws = TestUtils.OpenUserWorkspaceOracle(); const string tlmStrasse = "TOPGIS_TLM.TLM_STRASSE"; IFeatureClass realFeatureClass = DatasetUtils.OpenFeatureClass(ws, tlmStrasse); var rowCache = GdbQueryUtils.GetRows((ITable)realFeatureClass, false) .Take(100) .ToList(); Assert.AreEqual(100, rowCache.Count); GdbTable tableWithBackingData = new GdbFeatureClass(41, "TESTABLE", esriGeometryType.esriGeometryPoint, "Test table", table => new InMemoryDataset(table, rowCache)); IFeatureClass featureClassWithBackingData = (IFeatureClass)tableWithBackingData; Assert.AreEqual(41, featureClassWithBackingData.ObjectClassID); Assert.AreEqual("TESTABLE", DatasetUtils.GetName(featureClassWithBackingData)); Assert.AreEqual("Test table", DatasetUtils.GetAliasName(featureClassWithBackingData)); Assert.AreEqual(esriGeometryType.esriGeometryPoint, featureClassWithBackingData.ShapeType); Assert.False(featureClassWithBackingData.HasOID); Assert.Null(featureClassWithBackingData.OIDFieldName); for (int i = 0; i < realFeatureClass.Fields.FieldCount; i++) { featureClassWithBackingData.AddField(realFeatureClass.Fields.Field[i]); } Assert.AreEqual("OBJECTID", featureClassWithBackingData.OIDFieldName); Assert.AreEqual("SHAPE", featureClassWithBackingData.ShapeFieldName); Assert.AreEqual(100, GdbQueryUtils.Count(featureClassWithBackingData, "")); IQueryFilter queryFilter = GdbQueryUtils.CreateQueryFilter("OBJECTID"); queryFilter.WhereClause = "OBJECTID < 0"; Assert.AreEqual(0, GdbQueryUtils.Count(featureClassWithBackingData, queryFilter)); var backingDataset = tableWithBackingData.BackingDataset as InMemoryDataset; Assert.NotNull(backingDataset); backingDataset.AllRows.Add(new GdbRow(1, tableWithBackingData)); Assert.AreEqual(0, GdbQueryUtils.Count(featureClassWithBackingData, queryFilter)); queryFilter.WhereClause = "OBJECTID >= 0"; Assert.AreEqual(101, GdbQueryUtils.Count(featureClassWithBackingData, queryFilter)); }
public static IEnumerable <AllowedError> GetAllowedErrors( [NotNull] IssueDatasetWriter issueWriter, [CanBeNull] IGeometry areaOfInterest, [NotNull] ISpatialFilter spatialFilter, [NotNull] AllowedErrorFactory allowedErrorFactory) { Assert.ArgumentNotNull(issueWriter, nameof(issueWriter)); Assert.ArgumentNotNull(spatialFilter, nameof(spatialFilter)); Assert.ArgumentNotNull(allowedErrorFactory, nameof(allowedErrorFactory)); Stopwatch watch = _msg.DebugStartTiming(); ITable errorTable = issueWriter.Table; IQueryFilter filter; var errorFeatureClass = errorTable as IFeatureClass; if (errorFeatureClass != null) { if (areaOfInterest != null) { spatialFilter.Geometry = areaOfInterest; spatialFilter.GeometryField = errorFeatureClass.ShapeFieldName; spatialFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects; } filter = spatialFilter; } else { filter = new QueryFilterClass { WhereClause = spatialFilter.WhereClause, SubFields = spatialFilter.SubFields }; } var addedAllowedErrorsCount = 0; var readRowCount = 0; const bool recycling = true; foreach (IRow row in GdbQueryUtils.GetRows(errorTable, filter, recycling)) { readRowCount++; AllowedError allowedError = allowedErrorFactory.CreateAllowedError(issueWriter, row); if (allowedError == null) { continue; } addedAllowedErrorsCount++; yield return(allowedError); } _msg.DebugStopTiming(watch, "Collected {0} allowed error(s) based on {1} row(s) read from {2}", addedAllowedErrorsCount, readRowCount, issueWriter.DatasetName); }