Migration von ArcSDE-Verwaltungsbefehlen

Vormals mit ArcSDE-Verwaltungsbefehlen verwaltete Geodatabases und Daten können Sie mithilfe von Geoverwaltungswerkzeugen, Python-Skripten oder Geodatabase-Verwaltungswerkzeugen in ArcGIS Desktop verwalten.

In den nachfolgenden Abschnitten wird das Vorgehen bei häufigen Geodatabaseverwaltungs- und Datenmanagement-Tasks für Enterprise-Geodatabases beschrieben.

Geodatabase-Verwaltung

Bei manchen Verwaltungstasks müssen Sie als Geodatabase-Administrator, bei anderen als Datenbankadministrator angemeldet sein. Um Skripte für Verwaltungsaufgaben verfassen zu können, müssen Sie eine Datenbankverbindungsdatei (.sde) erstellen, die eine Verbindung als erforderlicher Benutzer herstellt. Nutzen Sie zum Erstellen der Datei das Geoverarbeitungswerkzeug Datenbankverbindung erstellen oder das Dialogfeld Datenbankverbindung in ArcGIS Desktop.

Eine Geodatabase erstellen	Werkzeug
Erstellen einer Geodatabase in Microsoft SQL Server, Oracle oder PostgreSQL.	Geoverarbeitungswerkzeug Enterprise-Geodatabase erstellen oder Geoverarbeitungswerkzeug Enterprise-Geodatabase aktivieren
Erstellen einer Geodatabase in IBM DB2 oder IBM Informix	Geoverarbeitungswerkzeug Enterprise-Geodatabase aktivieren

Geodatabase-Konfiguration steuern	Werkzeug
Konfigurationsschlüsselwörter hinzufügen und Parameter bearbeiten in DBTUNE	Die Geoverarbeitungswerkzeuge Konfigurationsschlüsselwörter für Geodatabase exportieren und Konfigurationsschlüsselwörter für Geodatabase importieren
Ändern der Konfiguration von Protokolldateitabellen in DB2, Informix oder Oracle	Geoverarbeitungswerkzeug Geodatabase-Protokolldateitabellen konfigurieren
Eine Benutzerschema-Geodatabase aus Oracle löschen	Geoverarbeitungswerkzeug Schema-Geodatabase löschen
Eine Geodatabase aktualisieren	Geoverarbeitungswerkzeug Geodatabase aktualisieren

Versionierte Geodatabases verwalten	Werkzeug
Eine neue Geodatabase-Version erstellen	Geoverarbeitungswerkzeug Version erstellen oder im Dialogfeld Versions-Manager in ArcGIS Desktop
Eine Version abgleichen	Geoverarbeitungswerkzeug Versionen abgleichen oder Verwenden der Funktion Abgleichen in ArcMap
Zurückschreiben von Änderungen in Parent-Version	Geoverarbeitungswerkzeug Version zurückschreiben oder Verwenden der Funktion Zurückschreiben in ArcMap
Komprimieren einer versionierten Geodatabase	Geoverarbeitungswerkzeug Komprimieren oder Funktion Datenbank komprimieren in ArcGIS Desktop
Löschen einer Geodatabase-Version	Geoverarbeitungswerkzeug Version löschen oder im Dialogfeld Versions-Manager in ArcGIS Desktop
Prüfen und Reparieren von Versionsmetadaten und Systemtabellen	Geoverarbeitungswerkzeuge Versions-Metadaten prüfen, Versions-Metadaten reparieren, Versionstabellen prüfen und Versionstabellen reparieren
Aktualisieren von Indizes für Versionssystemtabellen	Geoverarbeitungswerkzeug Indizes neu erstellen
Aktualisieren von Statistiken für Versionssystemtabellen	Geoverarbeitungswerkzeug Datasets analysieren

Verbindungen verwalten	Werkzeug
Eine Liste der aktuellen Geodatabase-Verbindungen abrufen	In der Registerkarte Verbindungen des Dialogfelds Geodatabase-Verwaltung in ArcGIS Desktop oder mit der ListUsers Python-Funktion Unter der Registerkarte Sperren im Dialogfeld Geodatabase-Verwaltung können Sie außerdem von Verbindungen verwendete Sperren sehen.
Trennen von Verbindungen aus der Geodatabase	In der Registerkarte Verbindungen des Dialogfelds Geodatabase-Verwaltung in ArcGIS Desktop oder mit der Python-Funktion DisconnectUser
Geodatabase-Verbindungen zeitweilig sperren und erneut aktivieren	In der Registerkarte Verbindungen des Dialogfelds Eigenschaften: Datenbank in ArcGIS Desktop oder mit der Python-Funktion AcceptConnections

Datenmanagement

Beim Laden von Daten in eine Enterprise-Geodatabase gehören die Daten in der Geodatabase dem Benutzer, über den die Verbindung hergestellt wurde. Manche Tasks der Geodatabase-Verwaltung, darunter Gewähren von Berechtigungen oder Neuerstellung von Indizes, können nur durch den Besitzer des Daten ausgeführt werden. Achten Sie darauf, vor Ausführung dieser Tasks eine Datenbankverbindungsdatei (.sde) zu erstellen, mit der Sie sich als der richtige Benutzer anmelden.

Meist wurden ArcSDE-Verwaltungsbefehle zur Skripterstellung für das Laden oder Verwalten von Daten verwendet, weshalb die in den nachfolgenden Abschnitten aufgeführten Datenmanagement-Tasks Beispielskripte enthalten.

Verwenden Sie CreateDatabaseConnection_management, wenn Sie die Datenbankverbindungsdatei als Teil jedes Skripts generieren wollen.

Exportieren von Geodatabase-Inhalten in eine übertragbare Datei

Beschreibung: Exportieren Sie das Geodatabase-Schema, dessen Beziehungen, Verhalten und Daten in ein XML-Workspace-Dokument, um es für andere freizugeben. Sie können Geodatabase-Inhalte auch als Teilmenge in ein XML-Workspace-Dokument exportieren.

Werkzeug dafür: XML-Workspace-Dokument exportieren

Beispielskript:

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

Importieren neuer Geodatabase-Inhalte

Beschreibung: XML-Workspace-Dokumente beinhalten das Geodatabase-Schema, Beziehungen und Verhalten. Es können auch Daten enthalten sein. Sie könnten ein XML-Workspace-Dokument importieren, das lediglich das Geodatabase-Schema enthält, und danach Ihre eigenen Daten in das Schema laden. Oder Sie könnten eine Geodatabase-Vorlage erstellen, das darin definierte Schema und dessen Beziehungen in ein XML-Workspace-Dokument exportieren und dieses Dokument in eine neue Geodatabase importieren.

Werkzeug dafür: XML-Workspace-Dokument importieren

Beispielskript:

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

Inhalte zum Überschreiben alter Inhalte importieren

Beschreibung: XML-Workspace-Dokumente beinhalten das Geodatabase-Schema, Beziehungen und Verhalten. Es können auch Daten enthalten sein. Sie können ein XML-Workspace-Dokument mitsamt Schema, Beziehungen, Verhalten und Daten importieren und damit die Inhalte einer vorhandenen Geodatabase überschreiben. Dies bietet sich an, wenn Sie von einer anderen Agentur oder einem Subunternehmen Projektaktualisierungen erhalten und Sie die gesamten aktuellen Daten und Definitionen benötigen.

Werkzeuge dafür: Löschen sowie XML-Workspace-Dokument importieren

Beispielskript:

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

Einzelnen Shapefile oder einzelne Coverage importieren und Felder zuordnen

Beschreibung: Geben Sie an, welche der zu importierenden Felder aus dem Shapefile oder der Coverage welchen Feldern in der resultierenden Feature-Class in der Geodatabase entsprechen.

Werkzeuge dafür: ListFields plus FeatureClassToFeatureClass_conversion plus FieldMappings

Beispielskript:

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)

Mehrere Shapefiles oder Coverages auf einmal importieren

Beschreibung: Es werden mehrere Shapefiles oder Coverages zusammen importiert.

Werkzeug dafür: Feature-Class in Geodatabase

Beispielskript:

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

Importieren Sie mehrere Shapefiles oder Coverages und statten Sie vorhandene Datenbankgruppen mit Berechtigungen für neue Feature-Classes aus.

Beschreibung: Importieren Sie mehrere Shapefiles oder Coverages gleichzeitig und statten Sie vorhandene Datenbankgruppen mit Berechtigungen für die resultierenden Feature-Classes aus, damit die Mitglieder der Gruppen auf die neuen Feature-Classes zugreifen können.

Werkzeuge dafür: Feature-Class zu Geodatabase sowie Berechtigungen ändern

Beispielskript:

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

Mehrere Shapefiles in einer Feature-Class kombinieren

Beschreibung: Wenn Ihre Shapefiles denselben Datentyp aufweisen, können Sie sie in Ihrer Geodatabase in einer Feature-Class zusammenfassen. Wenn Sie beispielsweise Punkt-Shapefiles erhalten, die Schulen aus mehreren Schulbezirken darstellen, könnten Sie diese Shapefiles in eine einzelne Schulen-Feature-Class in Ihrer Geodatabase importieren.

Werkzeuge dafür: Anhängen sowie Zusammenführen

Beispielskript:

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

Mehrere Tabellen importieren

Beschreibung: Sie können mehrere Tabellen vom Typ dBASE, INFO, VPF, OLE DB oder Geodatabase gleichzeitig in Ihre Enterprise-Geodatabase importieren.

Werkzeug dafür: Tabelle in Geodatabase

Beispielskript:

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

Eine Tabelle oder Feature-Class kürzen und Datensätze anhängen

Beschreibung: Wenn Sie Datenaktualisierungen von einer anderen Agentur oder Dritten erhalten, können Sie Ihre bestehende Tabelle und somit die dafür definierten Berechtigungen beibehalten, indem Sie die Tabelle abschneiden und die Datenaktualisierungen anhängen.

Werkzeuge dafür: Tabelle kürzen sowie Anhängen

Beispielskript:

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

Eine Tabelle oder Feature-Class kürzen, Datensätze anhängen und Datenbankstatistiken aktualisieren

Beschreibung: Wenn Sie Datenaktualisierungen von einer anderen Agentur oder Dritten erhalten, können Sie Ihre bestehende Tabelle und somit die dafür definierten Berechtigungen beibehalten, indem Sie die Tabelle abschneiden und die Datenaktualisierungen anhängen. Wenn die Tabelle eine große Anzahl an Datensätzen enthält, bietet sich eine Aktualisierung der Datenbankstatistiken zu der frisch aktualisierten Tabelle an.

Werkzeuge dafür: Tabelle kürzen plus Anhängen plus Datasets analysieren

Beispielskript:

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

Erstellen einer nicht räumlichen Datenbanksicht

Beschreibung: In einer Datenbanksicht lassen sich Daten aus mehreren Tabellen kombinieren und die von Quelltabellen zurückgelieferten Attribute einschränken.

Werkzeug dafür: Datenbanksicht erstellen

Beispielskript:

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

Erstellen einer Datenbanksicht mit Spalte "SQL-Geometrietyp"

Beschreibung: In einer Datenbanksicht lassen sich Daten aus mehreren Tabellen kombinieren und die von den Quelltabellen zurückgelieferten Attribute einschränken. Sie können der Sicht eine einzelne Spalte "SQL-Geometrietyp" hinzufügen. Deren räumliche Daten können in ArcGIS angezeigt werden.

Werkzeug dafür: Datenbanksicht erstellen

Beispielskript:

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

Erstellen einer Sicht mit Spalte "SQL-Geometrietyp" und Registrieren der Sicht in der Geodatabase

Beschreibung: Mit der Registrierung einer räumlichen Sicht bei der Geodatabase können Sie Informationen über die Ausdehnung der räumlichen Daten, den Geometrietyp und das Koordinatenbezugssystem speichern. Durch die Speicherung dieser Informationen in den Geodatabase-Systemtabellen wird die für das Rendern der Features erforderliche Zeit reduziert, wenn Sie die Sicht erstmals zur Karte hinzufügen. Fügen Sie der Sicht eine einzelne Spalte "SQL-Geometrietyp" und eine einzelne Spalte "ObjectID" hinzu.

Werkzeuge dafür: Datenbanksicht erstellen und In Geodatabase registrieren

Beispielskript:

""" Create view containing SQL geometry type column """
""" Register view with the geodatabase """

import arcpy
import sys


def CreateSpatialViewAndRegisterWithGeodatabase(input_database, view_name, view_definition):
    """ Create view containing SQL geometry type column and then register with the geodatabase """
    try:
        arcpy.CreateDatabaseView_management(input_database, view_name, view_definition)
        arcpy.RegisterWithGeodatabase_management(view_name)
    except arcpy.ExecuteError:
        print(arcpy.GetMessages(2))

if __name__ == "__main__":
    arguments = sys.argv[1:]
    CreateSpatialViewAndRegisterWithGeodatabase(*arguments)

Löschen von Tabellen

Beschreibung: Sie können gleichzeitig mehrere Tabellen aus der Geodatabase löschen. Dies bietet sich an für Workflows, die temporäre Daten enthalten, welche beispielsweise nur für ein Projekt gelten, oder für Workflows, in denen Sie Ersetzungsdaten von Dritten erhalten.

Werkzeug dafür: Löschen

Beispielskript:

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

Feature-Classes löschen

Beschreibung: Sie können gleichzeitig mehrere Feature-Classes aus der Geodatabase löschen. Dies bietet sich an für Workflows, die temporäre Daten enthalten, welche beispielsweise nur für ein Projekt gelten, oder für Workflows, in denen Sie Ersetzungsdaten von Dritten erhalten.

Werkzeug dafür: Löschen

Beispielskript:

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

Daten in ein Shapefile exportieren

Beschreibung: Exportiert eine Feature-Class in ein Shapefile.

Werkzeug dafür: Feature-Class in Shapefile

Beispielskript:

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

Abgleichen, Veröffentlichen und Komprimieren einer versionierten Geodatabase

Beschreibung: Durch das Versionieren von Daten und Ihrer Geodatabase ermöglichen Sie die Bearbeitung von Workflows, bei denen mehrere Benutzer über längere Zeiträume hinweg gleichzeitig Daten eingeben müssen. Hierfür ist eine gewisse Pflege der Geodatabase erforderlich. Dazu gehören der Abgleich versionierter Daten mit einer Vorgängerversion, um an der Vorgängerversion vorgenommene Änderungen zu übertragen, das Zurückschreiben von Änderungen an der Child-Version in die Vorgängerversion sowie die Komprimierung der Geodatabase, um nicht benötigte Versionszustände zu entfernen.

Werkzeuge hierfür: Versionen abgleichen sowie Komprimieren

Beispielskript:

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

Siehe auch Verwenden der Python-Skripterstellung zum Batch-Abgleich und Zurückschreiben von Versionen.

Versionieren von Tabellen und Feature-Classes, Hinzufügen globaler IDs und Erstellen eines Replikats

Beschreibung: Tabellen oder Feature-Classes müssen als versioniert registriert sein und eine Spalte "Globale ID" enthalten, bevor diese repliziert werden können.

Werkzeuge hierfür: Als versioniert registrieren plus Global-IDs hinzufügen plus Replikat erstellen

Beispielskript:

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

Registrieren einer Tabelle eines Drittanbieters in der Geodatabase

Beschreibung: Wenn Sie mithilfe einer Drittanbieteranwendung oder von SQL (räumliche oder nicht räumliche) Tabellen in der Datenbank erstellen, in der Ihre Geodatabase gespeichert ist, können Sie die Tabellen in der Geodatabase registrieren. Hierdurch werden Informationen über die Tabellen zu den Systemtabellen der Geodatabase hinzugefügt, und die Tabellen werden daraufhin für die Geodatabasefunktionen nutzbar.

Werkzeug dafür: In Geodatabase registrieren

Beispielskript:

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