Arbeiten mit Geodatabases in Python

Überprüfen von Tabellennamen

In Geodatabases werden die zahlreichen darin enthaltenen Tabellen mit verschiedenen relationalen Datenbankmanagementsystemen (RDBMS) verwaltet. Alle Tabellen in einer Geodatabase müssen einen eindeutigen Namen aufweisen. Daher ist beim Erstellen von Daten in einer Geodatabase ein Verfahren zum Überprüfen der Tabellennamen auf Eindeutigkeit von entscheidender Bedeutung. Stellen Sie sicher, dass ein neuer Tabellenname eindeutig ist, um zu verhindern, dass versehentlich Daten überschrieben werden, wenn das Skript den neuen Ausgabenamen nicht auf Eindeutigkeit überprüft.

Hinweis:

Anhand der Funktion Exists() können Sie überprüfen, ob der Tabellenname für einen bestimmten Workspace eindeutig ist.

Mit der Funktion ValidateTableName() kann ein Skript ermitteln, ob ein bestimmter Name in einem bestimmten Workspace gültig und eindeutig ist. Die Funktion ValidateTableName() überprüft nicht, ob der angegebene Name für den angegebenen Workspace eindeutig ist. Sie gibt nur einen gültigen Tabellennamen für diesen Workspace zurück.

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

ValidateTableName-Funktion

Durch das Angeben des Workspaces 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
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)

Ü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 neuen Feldnamen überprüfen und damit sicherstellen, dass beim Ausführen der Werkzeuge keine Fehler auftreten.

Funktion	Erklärung
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.

ValidateFieldName (Funktion)

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

Vermeiden Sie beim Aktualisieren von Datasets (Feature-Classes oder Tabellen) mit einem Skript Situationen, in denen das jeweilige Dataset gesperrt wird. Wenn eine Personal- oder File-Geodatabase in ArcCatalog geöffnet ist, können Skripte die Geodatabase erst aktualisieren, nachdem die Auswahl der Geodatabase aufgehoben und der entsprechende Ordner aktualisiert oder ArcCatalog geschlossen wurde. Dies gilt auch für Skriptwerkzeuge.

Parsen von Tabellen- und Feldnamen

Skripte müssen mit den Funktionen ParseTableName() und ParseFieldName() den vollständig qualifizierten Namen für ein Dataset oder eine Spalte in einer Tabelle in seine Komponenten aufteilen (Datenbank, Besitzer, Tabelle und Spalte). Für Skripte, die unabhängig vom RDBMS sein müssen, kann nicht angenommen werden, dass der Punkt (.) das Trennzeichen zum Abgrenzen der Komponenten eines vollständig qualifizierten Dataset-Namens ist. In ArcGIS-Anwendungen werden immer vollständig qualifizierte Namen verwendet. Wenn also ein Skript als Quelle eines Skriptwerkzeugs verwendet wird, muss beispielsweise jeder Feature-Class-Name geparst werden, wenn das Skript den Namen der Feature-Class ohne Benutzername und Datenbankname ermitteln muss. Im folgenden Beispiel überprüft das Skript die Eingabe-Feature-Class auf bestimmte Benutzernamen. Das Skript könnte den qualifizierten Namen mit den Parser-Funktionen von Python aufteilen. In diesem Falle würde jedoch von einer bestimmten Syntax ausgegangen werden, die sich ändern kann, wenn ein anderer Datenbanktyp verwendet wird. ParseTableName() gibt eine einzige Zeichenfolge mit dem Namen der Datenbank, dem Namen des Besitzers und dem Namen der Tabelle zurück, die durch Kommas voneinander getrennt sind. ParseFieldName() gibt den Namen der Tabelle und den Feldnamen zurück, die ebenfalls durch Kommas getrennt sind. Die zurückgegebene Zeichenfolge kann anschließend mit einem Skript zuverlässig geparst werden, da diese Funktionen immer Zeichenfolgen im selben Format zurückgeben. Für die Bearbeitung einer Zeichenfolge in Python ist eine Reihe von nativen Methoden verfügbar. In diesem Beispiel wird mit der split-Methode eine Python-Liste erstellt, wobei das Komma als Trennzeichen verwendet wird.

Funktion	Erklärung
ParseFieldName(name, {workspace})	Parst einen vollständig qualifizierten Feldnamen in seine Komponenten (Datenbank, Besitzername, Tabellenname, Feldname), abhängig vom Workspace.
ParseTableName(name, {workspace})	Parst einen Tabellennamen in seine Komponenten (Datenbank, Besitzer, Tabelle), abhängig vom Workspace.

Parsen von Funktionen

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

Eine Python-Liste ist eine geordnete Sammlung eines beliebigen Objekttyps, z. B. von Zeichenfolgen oder Zahlen. Listen sind nullbasiert und können zur effizienten Verwaltung von Werte-Arrays verwendet werden, wenn die Reihenfolge des Listeninhalts bekannt ist.

In Skripten, die als Quelle von Skriptwerkzeugen verwendet werden, können einige Annahmen zu ihren Eingabe-Argumentwerten getroffen werden. Pfade zu Daten werden durch die Geoverarbeitungsumgebung immer vollständig qualifiziert angegeben. Für Skripte, die außerhalb einer ArcGIS-Anwendung ausgeführt werden können, kann diese Annahme nicht getroffen werden.