Validation des noms de tables et de champs 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 valide. Il est donc essentiel de disposer d’un mécanisme permettant de vérifier la validité du nom d’une table lors de la création de données dans une géodatabase. Avec la fonction ValidateTableName(), un script peut déterminer si un nom spécifique est valide pour un espace de travail spécifique.

Les erreurs de noms de tables suivantes vont être validées :

• La table partage son nom avec un mot réservé par la source de données (par exemple, Table)
• La table contient un caractère non valide.
• La table a un caractère initial non valide (par exemple, elle utilise un nombre comme premier caractère).

Remarque :

La fonction ValidateTableName ne détermine pas que le nom spécifié est unique pour l’espace de travail spécifié. La fonction Exists permet de vérifier si le nom d’une table est unique pour un espace de travail donné.

ValidateTableName Fonction

Fonction	Explication
ValidateTableName(name, {workspace})	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.

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 non valides qui ne peuvent pas être utilisés dans un nom de table ou de champ. Tous les caractères non valides 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
# Set the workspace. List all of the shapefiles
arcpy.env.workspace = "d:/St_Johns"
fcs = arcpy.ListFeatureClasses("*")
# Set the workspace to SDE for ValidateTableName
arcpy.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.

Les erreurs de noms de champs suivantes vont être validées :

• La champ partage son nom avec un mot réservé par la source de données (par exemple, Table)
• Le champ partage son nom avec un champ défini précédemment.
• Le champ contient un caractère non valide (par exemple, *)
• Le nom de champ dépasse la longueur maximale de la source de données pour les noms de champs.

ValidateFieldName Fonction

Fonction	Explication
ValidateFieldName(name, {workspace})	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.

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 arcpy.ExecuteError:
    print(arcpy.GetMessages(2))