Пример #1
0
 public static string GetQualifiedName([CanBeNull] string masterDatabaseName,
                                       [CanBeNull] string schemaOwner,
                                       [NotNull] string modelElementName)
 {
     return(ModelElementNameUtils.GetQualifiedName(masterDatabaseName, schemaOwner,
                                                   modelElementName));
 }
Пример #2
0
        public static T GetDataset <T>([NotNull] string datasetName,
                                       [NotNull] IEnumerable <Dataset> datasets) where T : Dataset
        {
            Assert.ArgumentNotNullOrEmpty(datasetName, nameof(datasetName));
            Assert.ArgumentNotNull(datasets, nameof(datasets));

            foreach (Dataset dataset in datasets)
            {
                var typedDataset = dataset as T;
                if (typedDataset == null)
                {
                    continue;
                }

                string modelDatasetName = dataset.Model.ElementNamesAreQualified
                                                                  ? datasetName // matches only if also qualified
                                                                  : ModelElementNameUtils.GetUnqualifiedName(
                    datasetName);

                if (string.Equals(dataset.Name, modelDatasetName,
                                  StringComparison.OrdinalIgnoreCase))
                {
                    return(typedDataset);
                }
            }

            return(null);
        }
Пример #3
0
        private static string GetModelElementNameFromStoredName(
            [NotNull] string modelElementName,
            [NotNull] Model model)
        {
            if (!ModelElementNameUtils.IsQualifiedName(modelElementName) &&
                model.ElementNamesAreQualified)
            {
                IWorkspace workspace = model.GetMasterDatabaseWorkspace();

                if (workspace == null)
                {
                    return(modelElementName);
                }

                return(DatasetUtils.QualifyTableName(workspace,
                                                     model.DefaultDatabaseName,
                                                     model.DefaultDatabaseSchemaOwner,
                                                     modelElementName));
            }

            if (!model.ElementNamesAreQualified)
            {
                string unqualifiedName;
                if (ModelElementNameUtils.TryUnqualifyName(modelElementName, out unqualifiedName))
                {
                    return(unqualifiedName);
                }
            }

            return(modelElementName);
        }
Пример #4
0
        public static void UpdateName([NotNull] IModelElement modelElement,
                                      [NotNull] IDatasetName datasetName,
                                      bool useQualifiedName)
        {
            Assert.ArgumentNotNull(modelElement, nameof(modelElement));
            Assert.ArgumentNotNull(datasetName, nameof(datasetName));

            UpdateName(modelElement, datasetName.Name, useQualifiedName);

            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 =
                useQualifiedName
                                        ? featureDatasetName.Name
                                        : ModelElementNameUtils.GetUnqualifiedName(featureDatasetName.Name);
        }
Пример #5
0
        public static Dataset GetDatasetFromStoredName([NotNull] string storedDatasetName,
                                                       [NotNull] Model model,
                                                       bool ignoreUnknownDataset)
        {
            Assert.ArgumentNotNullOrEmpty(storedDatasetName, nameof(storedDatasetName));
            Assert.ArgumentNotNull(model, nameof(model));

            string searchName = GetModelElementNameFromStoredName(storedDatasetName, model);

            Dataset dataset = model.GetDatasetByModelName(searchName);

            if (dataset != null)
            {
                return(dataset);
            }

            string unqualifiedName;

            if (ModelElementNameUtils.TryUnqualifyName(storedDatasetName, out unqualifiedName))
            {
                dataset = model.GetDatasetByModelName(unqualifiedName);
                if (dataset != null)
                {
                    return(dataset);
                }
            }

            if (ignoreUnknownDataset)
            {
                return(null);
            }

            throw new ArgumentException(
                      $"No dataset with name '{storedDatasetName}' exists in model '{model.Name}'");
        }
        public void CanUnqualifyName()
        {
            string unqualified;

            Assert.IsTrue(ModelElementNameUtils.TryUnqualifyName("SOMEDB.DBO.SOMETABLE",
                                                                 out unqualified));
            Assert.AreEqual("SOMETABLE", unqualified);
        }
        public void CanUnqualifyNameWithLeadingSeparator()
        {
            string unqualified;

            Assert.IsTrue(ModelElementNameUtils.TryUnqualifyName(".SOMETABLE",
                                                                 out unqualified));
            Assert.AreEqual("SOMETABLE", unqualified);
        }
        public void CanUnqualifySingleCharDatasetName()
        {
            string unqualified;

            Assert.IsTrue(ModelElementNameUtils.TryUnqualifyName("SOMEDB.DBO.T",
                                                                 out unqualified));
            Assert.AreEqual("T", unqualified);
        }
        public void CantUnqualifyUnqualifiedName()
        {
            string unqualified;

            Assert.IsFalse(ModelElementNameUtils.TryUnqualifyName("SOMETABLE",
                                                                  out unqualified));
            Assert.AreEqual("SOMETABLE", unqualified);
        }
Пример #10
0
 public static string TranslateToMasterDatabaseDatasetName(
     [NotNull] string modelElementName, DdxModel ddxModel)
 {
     return(ModelElementNameUtils.IsQualifiedName(modelElementName)
                                ? modelElementName
                                : ModelElementNameUtils.GetQualifiedName(ddxModel.DefaultDatabaseName,
                                                                         ddxModel.DefaultDatabaseSchemaOwner,
                                                                         modelElementName));
 }
Пример #11
0
        public static void UpdateName([NotNull] IModelElement modelElement,
                                      [NotNull] string gdbDatasetName,
                                      bool useQualifiedName)
        {
            Assert.ArgumentNotNull(modelElement, nameof(modelElement));
            Assert.ArgumentNotNullOrEmpty(gdbDatasetName, nameof(gdbDatasetName));

            modelElement.Name = useQualifiedName
                                                    ? gdbDatasetName
                                                    : ModelElementNameUtils.GetUnqualifiedName(gdbDatasetName);
        }
Пример #12
0
        public static Association CreateAssociation(
            [NotNull] IRelationshipClass relClass,
            [NotNull] IObjectDataset destinationDataset,
            [NotNull] IObjectDataset originDataset,
            [NotNull] Model model)
        {
            bool unqualifyDatasetName = !model.HarvestQualifiedElementNames;

            string relClassName = DatasetUtils.GetName(relClass);

            AssociationCardinality cardinality = GetCardinality(relClass);
            ObjectAttribute        originPK    = GetOriginPK(relClass, originDataset);

            string associationName = !unqualifyDatasetName
                                                         ? relClassName
                                                         : ModelElementNameUtils.GetUnqualifiedName(relClassName);

            if (!relClass.IsAttributed &&
                relClass.Cardinality != esriRelCardinality.esriRelCardinalityManyToMany)
            {
                ObjectAttribute originFK = GetOriginFK(relClass,
                                                       destinationDataset);

                return(new ForeignKeyAssociation(associationName,
                                                 cardinality,
                                                 originFK,
                                                 originPK)
                {
                    Model = model
                });
            }

            ObjectAttribute destinationPK = GetDestinationPK(
                relClass, destinationDataset);

            var           relTable          = (ITable)relClass;
            esriFieldType destinationFKType = DatasetUtils.GetField(
                relTable,
                relClass.DestinationForeignKey).Type;
            esriFieldType originFKType = DatasetUtils.GetField(
                relTable, relClass.OriginForeignKey).Type;

            return(new AttributedAssociation(
                       associationName,
                       cardinality,
                       relClass.DestinationForeignKey, (FieldType)destinationFKType,
                       destinationPK,
                       relClass.OriginForeignKey, (FieldType)originFKType,
                       originPK)
            {
                Model = model
            });
        }
        public void CantUnqualifyNameWithTrailingSeparator()
        {
            string unqualified;

            Assert.IsFalse(ModelElementNameUtils.TryUnqualifyName("SOMETABLE.",
                                                                  out unqualified));
            Assert.AreEqual("SOMETABLE.", unqualified);

            // with trailing blank:
            Assert.IsFalse(ModelElementNameUtils.TryUnqualifyName("SOMETABLE. ",
                                                                  out unqualified));
            Assert.AreEqual("SOMETABLE. ", unqualified);
        }
Пример #14
0
        private static string GetRelationshipClassName([NotNull] IWorkspace masterWorkspace,
                                                       [NotNull] string associationName,
                                                       [NotNull] Model model)
        {
            // TODO: Copy from QaRelationTestFactory:

            if (masterWorkspace.Type != esriWorkspaceType.esriRemoteDatabaseWorkspace)
            {
                // the workspace uses unqualified names

                return(ModelElementNameUtils.IsQualifiedName(associationName)
                                               ? ModelElementNameUtils.GetUnqualifiedName(associationName)
                                               : associationName);
            }

            // the workspace uses qualified names

            if (!ModelElementNameUtils.IsQualifiedName(associationName))
            {
                Assert.NotNullOrEmpty(
                    model.DefaultDatabaseSchemaOwner,
                    "The master database schema owner is not defined, cannot qualify unqualified association name ({0})",
                    associationName);

                return(ModelElementNameUtils.GetQualifiedName(
                           model.DefaultDatabaseName,
                           model.DefaultDatabaseSchemaOwner,
                           ModelElementNameUtils.GetUnqualifiedName(associationName)));
            }

            // the association name is already qualified

            if (StringUtils.IsNotEmpty(model.DefaultDatabaseSchemaOwner))
            {
                return(ModelElementNameUtils.GetQualifiedName(
                           model.DefaultDatabaseName,
                           model.DefaultDatabaseSchemaOwner,
                           ModelElementNameUtils.GetUnqualifiedName(associationName)));
            }

            return(associationName);
        }
Пример #15
0
        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));
        }
Пример #16
0
        public static bool ExistsAssociation(
            [NotNull] IEnumerable <IRelationshipClass> relClasses,
            [NotNull] string associationName)
        {
            Assert.ArgumentNotNull(relClasses, nameof(relClasses));
            Assert.ArgumentNotNull(associationName, nameof(associationName));

            bool nameIsQualified = ModelElementNameUtils.IsQualifiedName(associationName);

            foreach (IRelationshipClass relClass in relClasses)
            {
                string relClassName = nameIsQualified
                                                              ? DatasetUtils.GetName(relClass)
                                                              : DatasetUtils.GetUnqualifiedName(relClass);

                if (relClassName.Equals(associationName,
                                        StringComparison.OrdinalIgnoreCase))
                {
                    return(true);
                }
            }

            return(false);
        }
Пример #17
0
        public static Association GetAssociationFromStoredName(
            [NotNull] string storedAssociationName,
            [NotNull] Model model,
            bool ignoreUnknownAssociation)
        {
            Assert.ArgumentNotNullOrEmpty(storedAssociationName, nameof(storedAssociationName));
            Assert.ArgumentNotNull(model, nameof(model));

            string searchName = GetModelElementNameFromStoredName(storedAssociationName, model);

            Association association = model.GetAssociationByModelName(searchName);

            if (association != null)
            {
                return(association);
            }

            string unqualifiedName;

            if (ModelElementNameUtils.TryUnqualifyName(storedAssociationName, out unqualifiedName))
            {
                association = model.GetAssociationByModelName(unqualifiedName);
                if (association != null)
                {
                    return(association);
                }
            }

            if (ignoreUnknownAssociation)
            {
                return(null);
            }

            throw new ArgumentException(
                      $"No association with name '{storedAssociationName}' exists in model '{model.Name}'");
        }
Пример #18
0
        private T GetModelElement <T>(
            [NotNull] string fullName,
            [NotNull] IWorkspaceName workspaceName,
            [NotNull] IDictionary <WorkspaceElement, T> index,
            [NotNull] Func <string, IList <T> > getForName,
            [CanBeNull] Func <string, IWorkspaceName, T> getForCurrentContext)
            where T : class, IModelElement
        {
            Assert.ArgumentNotNullOrEmpty(fullName, nameof(fullName));
            Assert.ArgumentNotNull(workspaceName, nameof(workspaceName));
            Assert.ArgumentNotNull(index, nameof(index));
            Assert.ArgumentNotNull(getForName, nameof(getForName));

            var workspaceElement = new WorkspaceElement(workspaceName, fullName);

            T modelElement;

            if (index.TryGetValue(workspaceElement, out modelElement))
            {
                return(modelElement);
            }

            // model element not yet cached - search for it

            IWorkspace workspace;

            try
            {
                workspace = WorkspaceUtils.OpenWorkspace(workspaceName);
            }
            catch (Exception e)
            {
                throw new InvalidOperationException(
                          $"Error opening workspace name to select model element for name '{fullName}'",
                          e);
            }

            var inaccessibleModels = new List <string>();

            _domainTransactions.UseTransaction(
                delegate
            {
                if (getForCurrentContext != null)
                {
                    modelElement = getForCurrentContext(fullName, workspaceName);
                    if (modelElement != null)
                    {
                        return;
                    }
                }

                IList <T> candidates = getForName(fullName);
                Assert.NotNull(candidates, "no dataset list returned");

                if (!ModelElementNameUtils.IsQualifiedName(fullName))
                {
                    // the gdb element name is unqualified
                    // search as is (in models that allow opening from default db)
                    modelElement = GetCandidateInSameDatabase(
                        candidates, workspace, ModelElementNameType.Any, inaccessibleModels);
                }
                else
                {
                    // the dataset name is qualified
                    // search datasets in models that use qualified names (and that allow opening from default db)
                    modelElement = GetCandidateInSameDatabase(
                        candidates, workspace, ModelElementNameType.Qualified,
                        inaccessibleModels);

                    // not found: unqualify, search in models with unqualified dataset names
                    if (modelElement == null)
                    {
                        candidates =
                            getForName(ModelElementNameUtils.GetUnqualifiedName(fullName));

                        modelElement = GetCandidateInSameDatabase(
                            candidates, workspace, ModelElementNameType.Unqualified,
                            inaccessibleModels);
                    }
                }
            });

            if (modelElement == null && inaccessibleModels.Count > 0)
            {
                // only if no candidate was found: warn if any of the candidates
                // could not be verified because of an invalid workspace reference
                if (inaccessibleModels.Count == 1)
                {
                    string inaccessibleModelName = inaccessibleModels.First();

                    _msg.Warn(
                        $"Workspace for model '{inaccessibleModelName}' containing '{fullName}' cannot be opened.");
                }
                else
                {
                    _msg.Warn(
                        "The master database workspaces for the following models cannot be opened:");
                    using (_msg.IncrementIndentation())
                    {
                        foreach (string inaccessibleModelName in inaccessibleModels)
                        {
                            _msg.Warn($"{inaccessibleModelName}");
                        }
                    }
                }
            }

            // add element even if null (to not search again for unregistered element)
            index.Add(workspaceElement, modelElement);

            return(modelElement);
        }
Пример #19
0
 public string GetNameWithoutCatalog()
 {
     return(ModelElementNameUtils.GetNameWithoutCatalogPart(_name));
 }