Utilisez les outils de géotraitement, les scripts Python ou les outils d'administration de géodatabase dans ArcGIS for Desktop pour réaliser les tâches d'administration des géodatabases et de gestion des données qui s'effectuaient auparavant avec les commandes d'administration ArcSDE.
Les sections suivantes expliquent comment réaliser les tâches courantes d'administration des géodatabases et de gestion des données pour les géodatabases d'entreprise :
Administration de géodatabase
Pour certaines tâches d'administration, vous devez être connecté en tant qu'administrateur de géodatabase et pour d'autres, vous devez vous connecter comme administrateur de base de données. Dans de nombreux cas, si vous envisagez d'écrire des scripts pour les tâches d'administration, vous devez créer un fichier de connexion à une base de données (.sde) qui établit la connexion en tant qu'utilisateur requis. Utilisez l'outil de géotraitement Créer une connexion à une base de données ou la boîte de dialogue Connexion à la base de données dans ArcGIS for Desktop pour créer le fichier.
| Créer une géodatabase | Outil |
|---|---|
Créer une géodatabase dans Microsoft SQL Server, Oracle ou PostgreSQL | Outil de géotraitement Créer une géodatabase d'entreprise ou outil de géotraitement Activer une géodatabase d’entreprise |
Créer une géodatabase dans IBM DB2 ou IBM Informix | Outil de géotraitement Activer une géodatabase d'entreprise |
| Contrôler la configuration d'une géodatabase | Outil |
|---|---|
Ajouter des mots-clés de configuration et modifier des paramètres dans DBTUNE | Les outils de géotraitement Exporter les mots-clés de configuration de la géodatabase et Importer les mots-clés de configuration de la géodatabase |
Modifier la configuration des tables de fichiers journaux | Outil de géotraitement Configurer les tables de fichiers journaux de la géodatabase |
Supprimer une géodatabase de structure depuis Oracle | Outil de géotraitement Supprimer une géodatabase de structure |
Mettre à niveau une géodatabase | Outil de géotraitement Mettre à niveau la géodatabase |
| Gérer les géodatabases versionnées | Outil |
|---|---|
Créer une version de la géodatabase | Outil de géotraitement Créer une version ou boîte de dialogue Gestionnaire de versions dans ArcGIS for Desktop |
réconciliez une version. | Outil de géotraitement Réconcilier des versions ou à l'aide de la fonction Réconcilier d'ArcMap |
Réinjecter les modifications dans une version parent | Outil de géotraitement Réinjecter la version ou à l'aide de la fonction Réinjecter d'ArcMap |
Compresser une géodatabase versionnée | Outil de géotraitement Compresser ou fonction Compresser une base de données dans ArcGIS for Desktop |
Supprimer une version de géodatabase | Outil de géotraitement Supprimer une version ou boîte de dialogue Gestionnaire de versions dans ArcGIS for Desktop |
Diagnostiquer et réparer les tables système et les métadonnées de version | Outils de géotraitement Diagnostiquer les métadonnées de version, Réparer les métadonnées de version, Diagnostiquer des tables de version et Réparer des tables de version |
Mettre à jour les index sur les tables système de version | Outil de géotraitement Recréer les index |
Mettre à jour les statistiques sur les tables système de version | Outil de géotraitement Analyser des jeux de données |
| Gérer les connexions | Outil |
|---|---|
Obtenir une liste des connexions à des géodatabases actuelles | Dans l'onglet Connexions de la boîte de dialogue Administration de géodatabase dans ArcGIS for Desktop ou la fonction Python ListUser Vous pouvez également voir les verrouillages détenus par les connexions dans l'onglet Verrous de la boîte de dialogue Administration de la géodatabase. |
Supprimer les connexions de la géodatabase | Dans l'onglet Connexions de la boîte de dialogue Administration de géodatabase dans ArcGIS for Desktop ou la fonction Python DisconnectUser |
Bloquer temporairement les connexions aux géodatabases et réactiver les connexions | Dans l'onglet Connexions de la boîte de dialogue Propriétés de la base de données dans ArcGIS for Desktop ou la fonction Python AcceptConnections |
Gestion des données
Lors du chargement des données dans une géodatabase d'entreprise, l'utilisateur sous le nom duquel vous vous connectez possède les données de la géodatabase. Certaines tâches de gestion des géodatabases, telles que l'octroi de privilèges ou la reconstitution d'index, peuvent uniquement être effectuées par le propriétaire des données. N'oubliez pas de créer un fichier de connexion à la base de données (.sde) en vous connectant avec un compte approprié avant d'effectuer ces tâches.
Dans la plupart des cas, les commandes d'administration ArcSDE étaient utilisées pour écrire des scripts de chargement ou de gestion des données. Par conséquent, les tâches de gestion des données répertoriées dans les sections suivantes intègrent des exemples de scripts.
Si vous souhaitez créer le fichier de connexion à une base de données dans le cadre de chaque script, utilisez CreateDatabaseConnection_management.
Exporter le contenu d'une géodatabase dans un fichier portable
Description : exportez la structure, les relations, le comportement et les données de la géodatabase dans des documents d'espace de travail XML pour les partager avec d'autres. Vous pouvez également exporter un sous-ensemble du contenu de la géodatabase dans un document d'espace de travail XML.
Outil à utiliser : Exporter un document d'espace de travail XML
Exemple de script :
""" Export geodatabase contents to a portable file """
import arcpy
import sys
def ExportXMLWorkspaceDocument(in_data, out_file, export_type=None, storage_type=None, export_metadata=None):
""" Export geodatabase contents to a portable file """
try:
arcpy.ExportXMLWorkspaceDocument_management(in_data,
out_file,
export_type,
storage_type,
export_metadata)
except arcpy.ExecuteError:
print(arcpy.GetMessages(2))
if __name__ == "__main__":
arguments = sys.argv[1:]
ExportXMLWorkspaceDocument(*arguments)
Importer le contenu d'une nouvelle géodatabase
Description : les documents d'espace de travail XML incluent la structure, les relations et le comportement de la géodatabase et peuvent contenir des données également. Vous pouvez importer un document d'espace de travail XML contenant uniquement la structure de la géodatabase, puis charger vos propres données dans la structure. Vous pouvez également créer une géodatabase modèle, exporter la structure et les relations définies dans cette géodatabase vers un document d'espace de travail XML, puis importer ce document dans une nouvelle géodatabase.
Outil à utiliser : Importer un document d'espace de travail XML
Exemple de script :
""" Import new gdb contents """
import arcpy
import sys
def ImportXMLWorkspaceDocument(target_geodatabase, in_file, import_type=None, config_keywords=None):
""" Import new gdb contents """
try:
arcpy.ImportXMLWorkspaceDocument_management(target_geodatabase,
in_file,
import_type,
config_keywords)
except arcpy.ExecuteError:
print(arcpy.GetMessages(2))
if __name__ == "__main__":
arguments = sys.argv[1:]
ImportXMLWorkspaceDocument(*arguments)
Importer le contenu pour remplacer le contenu existant
Description : les documents d'espace de travail XML incluent la structure, les relations et le comportement de la géodatabase et peuvent contenir des données également. Vous pouvez importer un document d'espace de travail XML contenant la structure, les relations, le comportement et les données, puis remplacer le contenu d'une géodatabase existante. Ceci peut être utile si vous recevez la mise à jour d'un projet d'une autre agence ou d'un autre prestataire et que vous voulez intégrer les données et définitions les plus récentes.
Outil à utiliser : Supprimer plus Importer un document d’espace de travail XML
Exemple de script :
""" Imports contents to overwrite old contents """
import arcpy
import sys
from xml.etree import ElementTree
import re
def FindDatasets(xml_file):
""" Open xml file and identify datasets """
xmldoc = ElementTree.ElementTree()
xmldoc.parse(xml_file)
root = xmldoc.getroot()
contents = []
for i in root.findall('WorkspaceDefinition/DatasetDefinitions/DataElement'):
contents.append(i.findtext('Name'))
for j in i.findall('./Children/DataElement/CatalogPath'):
contents.append('/'.join(re.split(r'/[a-z|A-Z]*=', j.text)[1:]))
contents.reverse()
return contents
def DeleteDatasets(database, datasets):
""" Delete dataset in database """
for ds in datasets:
try:
arcpy.Delete_management(os.path.join(database, datasets))
except:
print('Unable to delete {}'.format(ds))
def ImportXML(database, xml_file):
""" Import XML workspace document """
arcpy.ImportXMLWorkspaceDocument_management(database, xml_file)
if __name__ == "__main__":
xml_file = sys.argv[1]
database = sys.argv[2]
datasets = FindDatasets(xml_file)
DeleteDatasets(database, datasets)
ImportXML(database, xml_file)
arcpy.ImportXMLWorkspaceDocument_management(database, xml_file)
Importer un fichier de formes ou une couverture unique et apparier les champs
Description : désignez quels champs du fichier de formes ou de la couverture que vous importez apparier à quels champs de la classe d'entités obtenue dans la géodatabase.
Outils à utiliser : ListFields plus FeatureClassToFeatureClass_conversion plus FieldMappings
Exemple de script :
import arcpy
import os
arcpy.env.overwriteOutput = True
input_features = r'C:\Users\davi4075\Documents\ArcGIS\lakes.shp'
out_fc = r'C:\Users\davi4075\Documents\ArcGIS\mexico.gdb\out_lakes'
fms = arcpy.FieldMappings()
fms.fieldValidationWorkspace = os.path.dirname(out_fc)
# Cycle through input field to transfer
for field in arcpy.ListFields(input_features):
# Exclude geometry and objectid fields
if field.type not in ['Geometry', 'OID']:
fm = arcpy.FieldMap()
fm.addInputField(input_features, field.name)
# if altering field properties, need to push updated field back
# to FieldMap
field.name = field.name.upper()
fm.outputField = field
# Insert FieldMap into FieldMappings
fms.addFieldMap(fm)
arcpy.FeatureClassToFeatureClass_conversion(
input_features, os.path.dirname(out_fc), os.path.basename(out_fc),
field_mapping=fms)
Importer plusieurs fichiers de formes ou couvertures simultanément
Description : importez plusieurs fichiers de formes ou couvertures en même temps.
Outil à utiliser : Classe d'entités vers géodatabase
Exemple de script :
""" Import multiple shapefiles or coverages at one time """
import arcpy
import sys
def ImportMultiple(input_features, output_database):
"""
Import multiple shapefiles or coverages at one time
input_features -- semi-colon delimited string of shapefiles and/or coverages
"""
try:
arcpy.FeatureClassToGeodatabase_conversion(input_features, output_database)
except arcpy.ExecuteError:
print(arcpy.GetMessages(2))
if __name__ == "__main__":
arguments = sys.argv[1:]
ImportMultiple(*arguments)
Importer plusieurs fichiers de formes ou couvertures et accorder des privilèges sur de nouvelles classes d'entités aux groupes de bases de données existants
Description : importez plusieurs fichiers de formes ou couvertures en même temps et accordez des privilèges sur les classes d'entités obtenues aux groupes de bases de données existants afin que les membres des groupes aient accès aux nouvelles classes d'entités.
Outils à utiliser : Classe d'entités vers géodatabase plus Modifier les privilèges
Exemple de script :
"""
Import multiple shapefiles or coverages and grant privileges on new feature
classes to existing groups or users
"""
import arcpy
import sys
def ImportMultipleAndGrantPrivileges(input_features, output_database, user, view=None, edit=None):
"""
Import multiple shapefiles or coverages and grant privileges on new feature
classes to existing groups or users
"""
try:
feature_classes = input_features.split(';')
for fc in feature_classes:
out_fc = arcpy.CreateUniqueName(fc, output_database)
arcpy.FeatureClassToFeatureClass_conversion(fc, out_fc)
arcpy.ChangePrivileges_management(out_fc, user, view, edit)
except arcpy.ExecuteError:
print(arcpy.GetMessages(2))
if __name__ == "__main__":
arguments = sys.argv[1:]
ImportMultipleAndGrantPrivileges(*arguments)
Combiner plusieurs fichiers de formes en une classe d'entités
Description : si vous possédez des fichiers de formes qui contiennent le même type de données, vous pouvez les combiner en une classe d'entités dans votre géodatabase. Par exemple, si vous obtenez des fichiers de formes ponctuels représentant des écoles de plusieurs arrondissements scolaires, vous pouvez importer ces fichiers de formes dans une seule classe d'entités écoles dans votre géodatabase.
Outils à utiliser : Ajouter plus Fusionner
Exemple de script :
""" Combine multiple shapefiles into one feature class """
import arcpy
import sys
def CombineMultipleFeatureClasses(input_features, output_or_target):
""" Combine multiple shapefiles into one feature class """
try:
feature_classes = input_features.split(';')
if arcpy.Exists(output_or_target):
arcpy.Append_management(feature_classes, output_or_target)
else:
arcpy.Merge_management(feature_classes, output_or_target)
except arcpy.ExecuteError:
print(arcpy.GetMessages(2))
if __name__ == "__main__":
arguments = sys.argv[1:]
CombineMultipleFeatureClasses(*arguments)
Importer plusieurs tables
Description : vous pouvez importer plusieurs tables dBASE, INFO, VPF, OLE DB ou de géodatabase dans votre géodatabase d'entreprise à la fois.
Outil à utiliser : Table vers géodatabase
Exemple de script :
""" Import multiple nonspatial tables """
import arcpy
import sys
def ImportTables(in_tables, target_database):
"""
Export data to a shapefile
in_tables -- semi-colon delimited string of tables
target_database -- the database were tables will be added
"""
try:
tables = in_tables.split(";")
arcpy.TableToGeodatabase_conversion(tables, target_database)
except arcpy.ExecuteError:
print(arcpy.GetMessages(2))
if __name__ == "__main__":
arguments = sys.argv[1:]
ImportTables(*arguments)
Tronquer une table ou une classe d'entités et ajouter des enregistrements
Description : si vous recevez des mises à jour de données d'une autre agence ou d'un tiers, vous pouvez préserver votre table existante et, par conséquent, les privilèges définis pour la table en tronquant cette dernière et en ajoutant les mises à jour de données.
Outils à utiliser : Tronquer une table plus Ajouter
Exemple de script :
""" Truncate table or feature class and append records """
import arcpy
import sys
def TruncateTableOrFeatureClass(in_table, target_table):
""" Truncate table or feature class and append records """
try:
arcpy.TruncateTable_management(target_table)
arcpy.Append_management(in_table, target_table, schema_type="NO_TEST")
except arcpy.ExecuteError:
print(arcpy.GetMessages(2))
if __name__ == "__main__":
arguments = sys.argv[1:]
TruncateTableOrFeatureClass(*arguments)
Tronquer une table ou une classe d'entités, ajouter des enregistrements et mettre à jour des statistiques de base de données
Description : si vous recevez des mises à jour de données d'une autre agence ou d'un tiers, vous pouvez préserver votre table existante et, par conséquent, les privilèges définis pour la table en tronquant cette dernière et en ajoutant les mises à jour de données. Si la table contient un grand nombre d'enregistrement, vous pouvez mettre à jour les statistiques de base de données dans la table récemment mise à jour.
Outils à utiliser : Tronquer une table plus Ajouter plus Analyser des jeux de données
Exemple de script :
"""
Truncate table or feature class, append records, and update
database statistics
"""
import arcpy
import sys
import os
def TruncateTableOrFeatureClass(in_table, target_table):
"""
Truncate table or feature class, append records, and update
database statistics
"""
try:
arcpy.TruncateTable_management(target_table)
arcpy.Append_management(in_table, target_table)
descr = arcpy.Describe(os.path.dirname(target_table))
if getattr(descr, 'connectionProperties', None):
conn = os.path.dirname(target_table)
else:
conn = os.path.dirname(os.path.dirname(target_table))
arcpy.AnalyzeDatasets_management(conn)
except arcpy.ExecuteError:
print(arcpy.GetMessages(2))
if __name__ == "__main__":
arguments = sys.argv[1:]
TruncateTableOrFeatureClass(*arguments)
Créer une vue de base de données non spatiales
Description : une vue de base de données peut allier des données provenant de plusieurs tables et limiter les attributs qui sont renvoyés des tables source.
Outil à utiliser : Créer une vue de base de données
Exemple de script :
""" Create nonspatial view """
import arcpy
import sys
def CreateNonspatialView(input_database, view_name, view_definition):
""" Create nonspatial view """
try:
arcpy.CreateDatabaseView_management(input_database, view_name, view_definition)
except arcpy.ExecuteError:
print(arcpy.GetMessages(2))
if __name__ == "__main__":
arguments = sys.argv[1:]
CreateNonspatialView(*arguments)
Créer une vue de base de données contenant une colonne de type de géométrie SQL
Description : une vue de base de données peut allier des données provenant de plusieurs tables ou classes d'entités et limiter les attributs qui sont renvoyés des tables source ou classes d'entités. Vous pouvez inclure une seule colonne de type de géométrie SQL dans la vue, et les données spatiales peuvent s'afficher dans ArcGIS.
Outil à utiliser : Créer une vue de base de données
Exemple de script :
""" Create view containing SQL geometry type column """
import arcpy
import sys
def CreateSpatialView(input_database, view_name, view_definition):
""" Create view containing SQL geometry type column """
try:
arcpy.CreateDatabaseView_management(input_database, view_name, view_definition)
except arcpy.ExecuteError:
print(arcpy.GetMessages(2))
if __name__ == "__main__":
arguments = sys.argv[1:]
CreateSpatialView(*arguments)
Supprimer des tables
Description : vous pouvez supprimer plusieurs tables de la géodatabase en même temps. Ceci peut être utile dans les workflows où les données sont temporaires, par exemple des données spécifiques à un projet, ou dans les workflows dans lesquels vous recevez des données de remplacement de la part d'un tiers.
Outil à utiliser : Supprimer
Exemple de script :
""" Delete nonspatial tables """
import arcpy
import sys
def DeleteNonspatialTables(in_data):
"""
Delete nonspatial tables
in_data -- semi-colon delimited string of tables
"""
try:
tables = in_data.split(';')
for table in tables:
arcpy.Delete_management(table)
except arcpy.ExecuteError:
print(arcpy.GetMessages(2))
if __name__ == "__main__":
DeleteNonspatialTables(sys.argv[1])
Supprimer des classes d'entités
Description : vous pouvez supprimer plusieurs classes d'entités de la géodatabase en même temps. Ceci peut être utile dans les workflows où les données sont temporaires, par exemple des données spécifiques à un projet, ou dans les workflows dans lesquels vous recevez des données de remplacement de la part d'un tiers.
Outil à utiliser : Supprimer
Exemple de script :
""" Delete feature classes """
import arcpy
import sys
def DeleteFeatureClasses(in_data):
"""
Delete feature classes
in_data -- semi-colon delimited string of feature classes
"""
try:
feature_classes = in_data.split(';')
for fc in feature_classes:
arcpy.Delete_management(fc)
except arcpy.ExecuteError:
print(arcpy.GetMessages(2))
if __name__ == "__main__":
DeleteFeatureClasses(sys.argv[1])
Exporter des données vers un fichier de formes
Description : exportez une classe d'entités vers un fichier de formes.
Outil à utiliser : Classe d'entités vers fichier de formes
Exemple de script :
""" Export data to a shapefile """
import arcpy
import sys
def ExportToAShapefile(in_table, target_shp):
""" Export data to a shapefile """
try:
if arcpy.Exists(target_shp):
arcpy.Append_management(in_table, target_shp, schema_type="NO_TEST")
else:
arcpy.CopyRows_management(in_table, target_shp)
except arcpy.ExecuteError:
print(arcpy.GetMessages(2))
if __name__ == "__main__":
arguments = sys.argv[1:]
ExportToAShapefile(*arguments)
Réconcilier, réinjecter et compresser une géodatabase versionnée
Description : vous versionnez les données et votre géodatabase pour faciliter les workflows qui nécessitent la mise à jour de données par plusieurs personnes en même temps sur de longues périodes. Pour ce faire, la géodatabase doit subir certaines tâches de maintenance. Ces tâches sont notamment la réconciliation des données versionnées avec une version ascendant afin d'intégrer les changements apportés à la version ascendant, la réinjection des mises à jour depuis la version enfant vers la version ascendant, puis la compression de la géodatabase en vue de supprimer les états de version superflus.
Outils à utiliser : Réconcilier des versions plus Compresser
Exemple de script :
""" Reconcile, post, and compress versioned geodatabase """
import arcpy
import sys
def ReconcilePostAndCompress(input_database, reconcile_mode):
"""
Reconcile, post, and compress versioned geodatabase
"""
try:
arcpy.ReconcileVersions_management(input_database, reconcile_mode)
arcpy.Compress_management(input_database)
except arcpy.ExecuteError:
print(arcpy.GetMessages(2))
if __name__ == "__main__":
arguments = sys.argv[1:]
ReconcilePostAndCompress(*arguments)
Consultez également Utilisation de la fonction de création de scripts Python pour la réconciliation par lots et la réinjection des versions.
Versionner des tables ou classes d'entités, leur ajouter des ID globaux et créer un réplica
Description : les tables ou classes d'entités doivent être inscrites comme versionnées et contenir une colonne ID global avant de pouvoir les répliquer.
Outils à utiliser : Inscrire comme versionné plus Ajouter les ID globaux plus Créer un réplica
Exemple de script :
""" Version tables, add global IDs to tables, and create a replica """
import arcpy
import sys
def VersionTablesEtc(in_tables, in_type=None, out_geodatabase=None, out_name=None):
""" Version tables, add global IDs to tables, and create a replica """
try:
tables = in_tables.split(';')
for table in tables:
arcpy.RegisterAsVersioned_management(table)
arcpy.AddGlobalIDs_management(tables)
if 'CreateReplica' in dir(arcpy.management):
arcpy.CreateReplica_management(tables, in_type, out_geodatabase, out_name)
except arcpy.ExecuteError:
print(arcpy.GetMessages(2))
if __name__ == "__main__":
arguments = sys.argv[1:]
VersionTablesEtc(*arguments)
Inscrire une table tierce auprès de la géodatabase
Description : si vous utilisez des applications tierces ou SQL pour créer des tables (spatiales et non spatiales) dans la base de données où votre géodatabase est stockée, vous pouvez inscrire les tables auprès de la géodatabase. Ceci ajoute des informations concernant les tables dans les tables système de la géodatabase, ce qui permet aux tables de participer aux fonctionnalités de la géodatabase.
Outil à utiliser : Inscrire dans une géodatabase
Exemple de script :
""" Register third-party tables with the geodatabase """
import arcpy
import sys
def RegisterThirdPartyTables(in_tables):
"""
Register third-party tables with the geodatabase
in_tables -- semi-colon delimited string of tables
"""
try:
tables = in_tables.split(';')
for table in tables:
arcpy.RegisterWithGeodatabase_management(table)
except arcpy.ExecuteError:
print(arcpy.GetMessages(2))
if __name__ == "__main__":
RegisterThirdPartyTables(sys.argv[1])