Überprüfen von Tabellen- und Feldnamen in Python

Überprüfen von Tabellennamen

In Geodatabases werden die zahlreich darin enthaltenen Tabellen mit Hilfe von verschiedenen relationalen Datenbankmanagementsystemen (RDBMS) verwaltet. Alle Tabellen in einer Geodatabase müssen einen gültigen Namen aufweisen. Daher ist beim Erstellen von Daten in einer Geodatabase ein Verfahren zum Überprüfen der Tabellennamen auf Gültigkeit von entscheidender Bedeutung. Mit der Funktion ValidateTableName() kann ein Skript ermitteln, ob ein bestimmter Name in einem bestimmten Workspace gültig ist.

Folgende Fehler in Tabellennamen werden überprüft:

• Der Tabellenname ist ein Wort, das von der Datenquelle reserviert wurde (z. B. Table).
• Die Tabelle enthält ein ungültiges Zeichen.
• Die Tabelle enthält ein ungültiges Anfangszeichen (wenn z. B. eine Zahl als erstes Zeichen verwendet wird).

Hinweis:

Die Funktion ValidateTableName überprüft nicht, ob der angegebene Name für den angegebenen Workspace eindeutig ist. Anhand der Funktion Exists können Sie überprüfen, ob der Tabellenname für einen bestimmten Workspace eindeutig ist.

ValidateTableName-Funktion

Funktion	Erläuterung
ValidateTableName(name, {workspace})	Übernimmt einen Tabellennamen und einen Pfad zu einem Workspace und gibt einen gültigen Tabellennamen für den Workspace zurück.

Durch das Angeben des Workspace als Parameter kann ArcPy alle vorhandenen Tabellennamen überprüfen und ermitteln, ob aufgrund des Ausgabe-Workspaces Benennungseinschränkungen bestehen. Wenn es sich bei dem Ausgabe-Workspace um ein RDBMS handelt, liegen möglicherweise reservierte Ausdrücke vor, die nicht als Tabellenname verwendet werden dürfen. Ferner können ungültige Zeichen vorliegen, die nicht in Tabellen- oder Feldnamen verwendet werden dürfen. Alle ungültigen Zeichen werden durch einen Unterstrich (_) ersetzt. ValidateTableName gibt eine Zeichenfolge zurück, die einen gültigen Tabellennamen darstellt. Diese Zeichenfolge entspricht dem Eingabenamen, sofern dieser gültig ist. Im folgenden Beispiel wird sichergestellt, dass die neue Ausgabe-Feature-Class, die mit dem Werkzeug Features kopieren erstellt wird, einen eindeutigen und in allen Geodatabases gültigen Namen aufweist:

"""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)

Überprüfen von Feldnamen

In jeder Datenbank können Einschränkungen bei der Benennung von Feldern in einer Tabelle bestehen. Objekte wie Feature-Classes oder Beziehungsklassen werden in einem RDBMS als Tabellen gespeichert. Daher betreffen die Einschränkungen nicht nur eigenständige Tabellen. Diese Einschränkungen gelten nur für bestimmte Datenbanksysteme. Daher müssen Skripte sämtliche neue Feldnamen überprüfen und damit sicherstellen, dass beim Ausführen der Werkzeuge keine Fehler auftreten.

Folgende Fehler in Feldnamen werden überprüft:

• Der Feldname ist ein Wort, das von der Datenquelle reserviert wurde (z. B. Table).
• Der Name des Feldes wird von dem zuvor definierten Feld verwendet.
• Das Feld enthält ein ungültiges Zeichen (z. B. *).
• Der Feldname überschreitet die von der Datenquelle festgelegte maximale Länge für Feldnamen.

ValidateFieldName-Funktion

Funktion	Erläuterung
ValidateFieldName(name, {workspace})	Übernimmt eine Zeichenfolge (Feldname) und einen Workspace-Pfad und gibt auf Grundlage von Namenseinschränkungen in der Ausgabe-Geodatabase einen gültigen Feldnamen zurück.

Im folgenden Beispiel wird mit der Funktion ValidateFieldName sichergestellt, dass unabhängig vom Eingabenamen ein Feld hinzugefügt wird:

"""
  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))