Utilisation de géodatabases dans Python

Validation des noms de tables

Les géodatabases utilisent différents systèmes de gestion de bases de données relationnelles (SGBDR) pour gérer les nombreuses tables contenues dans une géodatabase. Toutes les tables d'une géodatabase doivent avoir un nom unique. Il est donc essentiel de disposer d'un mécanisme permettant de vérifier si le nom d'une table est unique lors de la création de données dans une géodatabase. La vérification d'unicité d'un nouveau nom de table est essentielle pour éviter d'écraser des données par erreur si le script ne garantit pas que le nouveau nom en sortie est unique.

Remarque :

La fonction Exists() permet de vérifier si le nom d'une table est unique pour un espace de travail donné.

Avec la fonction ValidateTableName(), un script peut déterminer si un nom spécifique est valide et unique pour un espace de travail spécifique. La fonction ValidateTableName () ne détermine pas que le nom spécifié est unique pour l'espace de travail spécifié. Elle retourne uniquement un nom de table valide pour cet espace de travail.

Fonction	Explication
ValidateTableName(nom, {espace_de_travail})	Accepte un nom de table et un chemin d'accès d'espace de travail et retourne un nom de table valide pour l'espace de travail.

Fonction ValidateTableName

La spécification de l'espace de travail en tant que paramètre permet à ArcPy de vérifier tous les noms des tables existantes et de déterminer si l'espace de travail en sortie applique des règles de dénomination. Si l'espace de travail en sortie est un SGBDR, il peut présenter des mots réservés qui ne peuvent pas être utilisés dans un nom de table. Il peut également contenir des caractères invalides qui ne peuvent pas être utilisés dans un nom de table ou de champ. Tous les caractères invalides sont remplacés par un trait de soulignement (_). La fonction ValidateTableName() renvoie une chaîne représentant un nom de table valide pouvant être identique au nom en entrée s'il est valide. L'exemple ci-dessous garantit que la nouvelle classe d'entités en sortie créée par l'outil Copier des entités porte un nom unique valide dans toute géodatabase :

# Move all shapefiles from a folder into a geodatabase
#
import arcpy
from arcpy import env

# Set the workspace. List all of the shapefiles
#
env.workspace = "D:/St_Johns"
fcs = arcpy.ListFeatureClasses("*")

# Set the workspace to SDE for ValidateTableName
#
env.workspace = "Database Connections/Bluestar.sde"

# For each feature class name
#
for fc in fcs: 
    # Validate the output name so it is valid
    #
    outfc = arcpy.ValidateTableName(fc)

    # Copy the features from the workspace to a geodatabase
    #
    arcpy.CopyFeatures_management(fc, outfc)

Validation des noms de champs

Chaque base de données peut comporter des restrictions de nomenclature concernant les noms des champs d'une table. Les objets tels que les classes d'entités ou les classes de relations sont stockés sous forme de tables dans un SGBDR, si bien que ces restrictions n'affectent pas uniquement les tables autonomes. Ces restrictions peuvent être communes ou non à différents systèmes de base de données. Les scripts doivent donc vérifier tous les noms de champs pour s'assurer qu'un outil n'échoue par lors de l'exécution.

Fonction	Explication
ValidateFieldName(nom, {espace_de_travail})	Renvoie, à partir d'une chaîne (nom de champ) et d'un chemin d'accès à un espace de travail, un nom de champ valide en fonction des règles de dénomination dans la géodatabase en sortie.

Fonction ValidateFieldName

L'exemple ci-dessous garantit l'ajout d'un champ quel que soit le nom en entrée à l'aide de la fonction ValidateFieldName :

# Create a new numeric field containing the ratio of polygon area to
#   polygon perimeter. Two arguments, a feature class and field name,
#   are expected.

# Define a pair of simple exceptions for error handling
#
class ShapeError(Exception):
    pass
class FieldError(Exception):
    pass

import arcpy
import os

try:
    # Get the input feature class and make sure it contains polygons
    #
    input = arcpy.GetParameterAsText(0)
    desc = arcpy.Describe(input)
    if desc.shapeType.lower() != "polygon":
        raise ShapeError

    # Get the new field name and validate it
    #
    fieldname = arcpy.GetParameterAsText(1)
    fieldname = arcpy.ValidateFieldName(fieldname, os.path.dirname(input))

    # Make sure shape_length and shape_area fields exist
    #
    if len(arcpy.ListFields(input,"Shape_area")) > 0 and \
        len(arcpy.ListFields(input,"Shape_length")) > 0:

        # Add the new field and calculate the value
        #
        arcpy.AddField_management(input, fieldname, "double")
        arcpy.CalculateField_management(input,fieldname,
                                        "[Shape_area] / [Shape_length]")
    else:
        raise FieldError

except ShapeError:
    print "Input does not contain polygons"

except FieldError:
    print "Input does not contain shape area and length fields"

except:
    print arcpy.GetMessages(2)

Lorsqu'un script met à jour un jeu de données, tel qu'une classe d'entités ou une table, évitez les situations dans lesquelles le jeu de données est verrouillé. Si vous avez ouvert une géodatabase fichier ou personnelle dans ArcCatalog, les scripts ne peuvent mettre à jour le contenu de la géodatabase que lorsqu'il est désélectionné et que le dossier est actualisé ou lorsque ArcCatalog est fermé. Cette opération s'applique également aux outils de script.

Analyse des noms de tables et de champs

Les scripts doivent utiliser les fonctions ParseTableName() et ParseFieldName() pour fractionner les noms complets d'un jeu de données ou d'une colonne dans une table selon ses composants (base de données, propriétaire, table et colonne). Les scripts qui doivent être indépendants du SGBDR ne doivent pas considérer le point (.) comme délimiteur permettant de séparer les composants du nom complet d'un jeu de données. Les applications ArcGIS utilisent toujours des noms complets. Ainsi, si votre script sert de source à un outil de script, tout nom de classe d'entités, par exemple, doit être analysé si le script doit déterminer le nom de la classe d'entités sans les noms d'utilisateur et de base de données. Dans l'exemple ci-dessous, le script recherche des noms d'utilisateurs spécifiques dans la classe d'entités en entrée. Le script peut utiliser les fonctions d'analyse de Python pour fractionner le nom qualifié, mais il prend alors en compte une syntaxe spécifique qui peut être modifiée si un autre type de base e données est utilisé. La fonction ParseTableName() renvoie une chaîne unique contenant les noms de la base de donnée, du propriétaire et de la table, séparés par des virgules. La fonction ParseFieldName() renvoie les noms de la table et du champ, également séparés par des virgules. Un script peut alors analyser correctement la chaîne renvoyée car ces méthodes retournent toujours la même chaîne formatée. Une chaîne dans Python contient plusieurs méthodes natives de gestion. Dans cet exemple, la méthode de fractionnement sert à créer une liste Python, en utilisant la virgule comme délimiteur.

Fonction	Explication
ParseFieldName(nom, {espace_de_travail})	Analyse un nom de champ complet selon ses composants (base de données, nom du propriétaire, nom de table, nom de champ) en fonction de l'espace de travail.
ParseTableName(nom, {espace_de_travail})	Analyse un nom de table selon ses composants (base de données, propriétaire, table) en fonction de l'espace de travail

Fonctions d'analyse

# Append input feature class to another feature class and update field
#
import arcpy
from arcpy import env
import sys

# Get the name of the input feature class and parse it.
#
env.workspace = os.path.dirname(arcpy.GetParameterAsText(0))

# Split ParseTableName's returned value to determine database, owner, and
#  featureclass
#
fullname = arcpy.ParseTableName(os.path.basename(arcpy.GetParameterAsText(0)))
database, owner, featureclass = fullname.split(",")

# Validate the name of the feature class that will be appended to and set 
#   the workspace using the administrator's connection
#
env.workspace = "Database Connections/Trans_admin.sde"
appendFC = arcpy.ValidateTableName("common", "roads")

try:
   if owner == "TJohnson":
       arcpy.CalculateField_management(fullname, "AppendedBy", owner)
       arcpy.Append_management(fullname, appendFC)
   elif owner == "RSmith":
       arcpy.CalculateField_management(fullname, "AppendedBy", owner)
       arcpy.Append_management(fullname, appendFC)
   else:
       arcpy.AddError("Unknown user of input feature class")
except:
    arcpy.AddError(arcpy.GetMessages(2))

Une liste Python représente un ensemble ordonné de tout type d'objet, tel que des chaînes ou des nombres. Les listes sont basées sur zéro et peuvent servir à gérer de façon efficace des tableaux de valeurs lorsque l'ordre des éléments de la liste est connu.

Les scripts utilisés comme source des outils de script peuvent émettre des hypothèses quant aux valeurs d'un argument en entrée. Les chemins d'accès aux données sont toujours qualifiés par la structure de géotraitement. Les scripts qui peuvent être exécutés à l'extérieur d'une application ArcGIS ne doivent pas émettre la même hypothèse.