Automatiser les opérations de réconciliation et de réinjection pour les données pour lesquelles la synchronisation est activée

Les administrateurs de géodatabase ArcGIS peuvent utiliser la fonction de création de scripts Python pour automatiser de nombreuses tâches généralement effectuées à l'aide de plusieurs outils de géotraitement. Cette rubrique traite du processus qu'un administrateur peut adopter pour exécuter de nuit une réconciliation de versions planifiée, une fois que les employés travaillant sur le terrain ont synchronisé les modifications apportées aux données qui participent au versionnement traditionnel.

Identifier les versions de géodatabases en fonction du nom du service

Commencez par créer une liste des versions de géodatabase à réconcilier.

# Create a list of user names that will be used to find versions.
userList = ['???', '###']
# Get a list of versions for the service named '???' and '###' to pass into the ReconcileVersions tool.
versions = arcpy.da.ListVersions('//connectionLocation/admin.sde')
# Create an empty list that will be used to hold version names that you want to reconcile.
verReconcileList = []
# Loop through the versions list to look for versions with appropriate names.
# if these names are found append them to the verReconcileList.
for user in userList:
    for version in versions:
        if user.lower() in version.name.lower():
            verReconcileList.append(version.name)

Réconcilier par lot les versions et réinjecter les modifications

Vous pouvez utiliser l'outil Réconcilier les versions pour réconcilier et réinjecter toutes les versions traditionnelles dans une géodatabase d'entreprise. Cet outil fournit des options permettant de réconcilier toutes les versions de la géodatabase vers une version cible (ALL_VERSIONS) ou seulement les versions qui empêchent la compression de la version cible (BLOCKING_VERSIONS). Cet outil permet une compression efficace, ainsi que la réconciliation et la réinjection de plusieurs versions en même temps, selon un ordre défini. Après les opérations de réconciliation et de réinjection, vous pouvez supprimer les versions à l'aide du mot-clé DELETE_VERSION.

Dans cet exemple, les versions ne sont pas supprimées (le mot-clé KEEP_VERSION est fourni) et l'outil est exécuté comme administrateur de la géodatabase. Grâce à votre connexion en tant qu'administrateur de géodatabase, vous pouvez réconcilier et réinjecter toutes les versions dans la géodatabase, même celles qui sont privées ou protégées et qui appartiennent à d'autres utilisateurs.

# Get a list of versions to pass into the ReconcileVersions tool. versionList = arcpy.ListVersions('//connectionLocation/admin.sde')
# Execute the ReconcileVersions tool.
arcpy.ReconcileVersions_management('//connectionLocation/admin.sde', "ALL_VERSIONS", "sde.DEFAULT", verReconcileList, "LOCK_ACQUIRED", "NO_ABORT", "BY_OBJECT", "FAVOR_TARGET_VERSION", "POST", "KEEP_VERSION", "c:/temp/reconcilelog.txt")

Compression de la géodatabase

Une fois que la réconciliation et la réinjection des modifications ont été effectuées, il est important de compresser la géodatabase pour supprimer toutes les informations redondantes et déplacer les mises à jour dans les tables de base.

# Run the compress tool. 
arcpy.Compress_management('//connectionLocation/admin.sde')

Recréer les index et mettre à jour les statistiques

Après une opération de compression, il est recommandé de recréer les index et de mettre à jour les statistiques. Ces étapes peuvent être effectuées à l'aide des outils Recréer les index et Analyser les jeux de données. Ces outils vous permettent de saisir une liste de jeux de données en entrée qui exécuteront leurs fonctions simultanément sur l'ensemble des jeux de données. Ces outils mettent également à jour les statistiques et recréent des index pour les tables système appropriées, lorsqu'ils sont exécutés par l'administrateur de géodatabase. La première partie de ce processus consiste à obtenir une liste des données et des utilisateurs qui possèdent ces données. Les index et statistiques peuvent être mis à jour uniquement par le propriétaire des données.

# set the workspace arcpy.env.workspace = '//connectionLocation/dataOwner.sde'
# Get the user name for the workspace
# this assumes you are using database authentication. # OS authentication connection files do not have a 'user' property. userName = arcpy.Describe(arcpy.env.workspace).connectionProperties.user
# Get a list of all the datasets the user has access to. # First, get all the stand-alone tables, feature classes and rasters owned by the current user. oDataList = arcpy.ListTables('*.' + userName + '.*') + arcpy.ListFeatureClasses('*.' + userName + '.*') + arcpy.ListRasters('*.' + userName + '.*')
# Next, for feature datasets owned by the current user
# get all of the featureclasses and add them to the master list. for dataset in arcpy.ListDatasets('*.' + userName + '.*'):
    oDataList += arcpy.ListFeatureClasses(feature_dataset=dataset)

Remarque :

Les jetons de caractères génériques utilisés pour limiter les jeux de données appartenant à l'utilisateur dépendent du système d'exploitation. Dans l'exemple ci-avant, ('*.' + userName + '.*') fonctionne pour les géodatabases dans Microsoft SQL Server, PostgreSQL et IBM Db2. Pour les géodatabases dans Oracle, le caractère générique suivant peut être utilisé : (userName + '.*').

Une fois que la liste de données appartenant à chaque utilisateur a été identifiée, utilisez ces informations dans les outils Reconstruire des index et Analyser des jeux de données.

S'il existe plusieurs propriétaires de données, générez une liste de données pour chacun et exécutez les outils Reconstruire des index et Analyser des jeux de données à l'aide des fichiers de connexion aux bases de données (.sde) qui se connectent à la géodatabase sous chaque nom d'utilisateur.

# Execute rebuild indexes and analyze datasets
# Note: to use the "SYSTEM" option, the user must be an administrator.
workspace = "//connectionLocation/user1.sde"
arcpy.RebuildIndexes_management(workspace, "NO_SYSTEM", oDataList, "ALL")
arcpy.AnalyzeDatasets_management(workspace, "NO_SYSTEM", oDataList, "ANALYZE_BASE", "ANALYZE_DELTA", "ANALYZE_ARCHIVE")

Supprimer des versions réconciliées

L'étape finale du processus consiste à supprimer les versions réconciliées et réinjectées. Vous vous êtes procuré la liste des versions réconciliées lorsque vous avez exécuté l'instruction versionList précédemment. Dans le code ci-après, vous créerez une boucle dans cette liste pour supprimer les versions qui peuvent l'être en toute sécurité.

Remarque :

Si vous utilisez la réplication de géodatabase, il est important d'éviter de supprimer les versions toujours référencées par un réplica. Il s'agit des versions à partir desquelles les réplicas de géodatabase sont créés. Utilisez la fonction ListReplicas pour répertorier les réplicas et le nom de version auquel chacun fait référence. Une tentative de suppression d'une version de réplica devant échouer, il est préférable de l'éviter.

Dans l'exemple qui suit, vous obtiendrez une liste des versions de réplica à l'aide d'une itération à travers tous les réplicas. Supprimez ensuite de la liste des versions toutes les versions de réplica réconciliées. Enfin, créez une boucle dans le reste de la liste des versions réconciliées et supprimez ces versions.

# set the workspace workspace = '//connectionLocation/admin.sde'
# Get a list of all the replica versions in the geodatabase replicaVersions = [replica.version for replica in arcpy.da.ListReplicas(workspace)]
# Loop through this replica version list and remove these version names from the list of versions you reconciled earlier. # You want to remove versions from this list that are still being referenced by a replica for replicaVer in replicaVersions:
  if replicaVer in verReconcileList:
    verReconcileList.remove(replicaVer)
# Loop through the verReconcileList and delete versions. 
# These versions are no longer being referenced by a replica so you can assume it's safe to delete them. if len(versionsList) > 0:
  for version in verReconcileList:
  		arcpy.DeleteVersion_management(workspace, version)

Exemple de code complet

L'exemple de code ci-dessous réunit la plupart des éléments indiqués ci-dessus et porte sur les opérations suivantes :

• Identifier les versions de géodatabases.
• Réconcilier les versions et réinjecter les modifications
• Compresser la géodatabase.
• Recréer les index et mettre à jour les statistiques sur les tables système.
• Recréer les index et mettre à jour les statistiques sur les tables utilisateur.

Remarque :

Le script suivant contient une logique supplémentaire par rapport aux autres exemples de code de cette rubrique. La logique supplémentaire permet de mieux gérer les cas d'erreur. Notez également que certains des commentaires et noms de variable ont changé dans le script.

import arcpy

try:
    # Set the workspace 
    arcpy.env.workspace = 'Database Connections/admin.sde'
    
    # Set variables
    workspace = arcpy.env.workspace
    arcpy.env.overwriteOutput = True
    targetVersion = 'sde.DEFAULT'
    
    # Create a list of user names that will be used to find versions.
    userList = ['???', '###']
    
    # Get a list of versions for the service named '???' and '###' to pass into the ReconcileVersions tool.
    versions = arcpy.da.ListVersions(workspace)
    
    # Create an empty list to hold version names to reconcile.
    verReconcileList = []
    
    # Loop through the list to look for versions with our user names in their name where the parent version is the target version.
    # if these names are found, append them to the verReconcileList.
    for user in userList:
        for version in versions:
            if user.lower() in version.name.lower():
                if version.parentVersionName.lower() == targetVersion.lower():
                    verReconcileList.append(version.name)
    
    # Perform maintenance if versions are found; otherwise, there is no maintenance to perform.
    if len(verReconcileList)>0:
        
        # Execute the ReconcileVersions tool.
        arcpy.ReconcileVersions_management(workspace, "ALL_VERSIONS", targetVersion, verReconcileList, "LOCK_ACQUIRED", "NO_ABORT", "BY_OBJECT", "FAVOR_TARGET_VERSION", "POST", "KEEP_VERSION", "c:/temp/reconcilelog.txt")
        
        # Run the compress tool. 
        arcpy.Compress_management(workspace)
        
        # Rebuild indexes and analyze the states and states_lineages system tables
        arcpy.RebuildIndexes_management(workspace, "SYSTEM", "", "ALL")
        
        arcpy.AnalyzeDatasets_management(workspace, "SYSTEM", "", "ANALYZE_BASE", "ANALYZE_DELTA", "ANALYZE_ARCHIVE")
        
        
        '''
        *********************
        Data Owner(s) Section
        *********************
        '''
        # Get a list of datasets owned by the data owner user (requires second connection file)
        
        # Set the workspace 
        arcpy.env.workspace = 'Database Connections/dataOwner.sde'
        
        # Set a variable for the workspace
        workspace = arcpy.env.workspace
        
        # Get the user name for the workspace
        # this assumes you are using database authentication.
        # OS authentication connection files do not have a 'user' property.
        userName = arcpy.Describe(arcpy.env.workspace).connectionProperties.user
        
        # Get a list of all the datasets the user has access to.
        # First, get all the stand alone tables, feature classes and raster datasets owned by the current user.
        oDataList = arcpy.ListTables('*.' + userName + '.*') + arcpy.ListFeatureClasses('*.' + userName + '.*') + arcpy.ListRasters('*.' + userName + '.*')
        
        # Next, for feature datasets owned by the current user
        # get all of the feature classes and add them to the master list.
        for dataset in arcpy.ListDatasets('*.' + userName + '.*'):
            oDataList += arcpy.ListFeatureClasses(feature_dataset=dataset)
        
        # Rebuild indexes and analyze the data owner tables
        arcpy.RebuildIndexes_management(workspace, "NO_SYSTEM", oDataList, "ALL")
        
        arcpy.AnalyzeDatasets_management(workspace, "NO_SYSTEM", oDataList, "ANALYZE_BASE", "ANALYZE_DELTA", "ANALYZE_ARCHIVE")
        
        '''
        *************************
        End Data Owner(s) Section
        *************************
        '''
        
        # set the workspace back to the geodatabase administrator workspace
        workspace = 'Database Connections/admin.sde'
        
        # Get a list of all the replica versions in the geodatabase
        replicaVersions = [replica.version for replica in arcpy.da.ListReplicas(workspace)]
        
        '''
        - We now have a list of versions that were created by taking a map offline (verReconcileList)
        - We also have a list of replica versions (replicaVersions)
        - The versions that we were reconciling are ready to be deleted if they are not currently pointing to a version
        - We are going to loop through the reconcile versions list and remove any versions that are still pointing to a replica
        - The versions remaining in the reconcile list are ready to be cleaned (deleted) up because there are no maps/replicas pointing to them. 
        '''
        
        # Use the list of versions associated with users/maps that we reconciled earlier. Remove any versions from the list that are still being used by a replica. 
        for replicaVer in replicaVersions:
            if replicaVer in verReconcileList:
                verReconcileList.remove(replicaVer)
        
        # Loop through the versionsList and delete versions that are no longer being referenced by a replica. 
        # Since these versions are no longer being referenced by a replica, we can assume it's safe to delete them.
        if len(verReconcileList) > 0:     #check to see that the list is not empty
            for version in verReconcileList:
                try:
                    arcpy.DeleteVersion_management(workspace, version)
                except:
                    print("Failed to delete version.")
                    print(arcpy.GetMessages(2))
        else:
            print("No versions to delete.")
    
    else:
        print("No versions to reconcile, aborting version maintenance routine.")

except:
    print(arcpy.GetMessages(2))
    
print("Done.")