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 versionnées.

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

# 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 we 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

L'outil Réconcilier les versions peut servir à réconcilier et à réinjecter toutes les versions dans une géodatabase d'entreprise. Cet outil fournit des options permettant de réconcilier toutes les versions dans la géodatabase vers une version cible (ALL_VERSIONS) ou simplement 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, les versions peuvent également être supprimées à l'aide du mot-clé DELETE_VERSION. Dans cet exemple, l'outil est exécuté par l'administrateur de 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 la réconciliation et la réinjection des modifications effectuées, il est important de compresser la géodatabase, afin de supprimer toutes les informations redondantes et d'enregistrer les mises à jour dans les tables métier.

# 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 et ils 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. L'exemple ci-dessus ('*.' + userName + '.*') fonctionne dans le cas de SQL Server, de PostgreSQL ou de DB2. Dans le cas d'Oracle, le caractère générique suivant peut être utilisé : (userName + '.*'). Dans le cas d'Informix, cela peut être : ('*:' + userName + '.*').

Une fois identifiée, la liste de données appartenant à l'utilisateur peut être transmise aux outils Reconstruire des index et Analyser des jeux de données.

En cas de propriétaires multiples, il est nécessaire de générer une liste des données de chaque propriétaire et d'exécuter les outils Reconstruire des index et Analyser des jeux de données en se connectant 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 les versions qui ne sont plus référencées par un réplica

# 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 we reconciled earlier. # We 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 we 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 tous les é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 est vouée à mieux gérer les cas d'erreur. Notez également que certains des commentaires et noms de variables ont changé dans le script suivant.

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 that will be used to hold version names that we want 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 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)
        
        # 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 admin 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. 
        '''
        
        # Using 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.")