Migrar desde los comandos de administración de ArcSDE

Utilice las herramientas de geoprocesamiento, los scripts de Python o las herramientas de administración de geodatabase en ArcGIS Desktop para realizar operaciones de administración de geodatabase y de administración de datos que anteriormente realizaba con los comandos de administración de ArcSDE.

Las secciones siguientes enumeran cómo cumplir con tareas frecuentes de administración de geodatabase y de administración de datos para geodatabases corporativas.

Administración de geodatabases

Algunas tareas de administración requieren que se conecte como el administrador de la geodatabase; otras requieren que se conecte como el administrador de la base de datos. En muchos casos, si va a crear scripts para tareas de administración, necesitará crear un archivo de conexión de base de datos (.sde) que se conecte como el usuario requerido. Utilice la herramienta de geoprocesamiento Crear conexión de la base de datos o el cuadro de diálogo Conexión de base de datos en ArcGIS Desktop para crear el archivo.

Crear una geodatabase	Herramienta
Crear una geodatabase en Microsoft SQL Server, Oracle o PostgreSQL.	Herramienta de geoprocesamiento Crear geodatabase corporativa o herramienta de geoprocesamiento Habilitar geodatabase corporativa.
Crear una geodatabase en IBM DB2 o IBM Informix.	Herramienta de geoprocesamiento Habilitar geodatabase corporativa

Controlar la configuración de geodatabase	Herramienta
Agregar palabras clave de configuración y editar parámetros en DBTUNE	Las herramientas de geoprocesamiento Exportar palabras clave de configuración de geodatabase e Importar palabras clave de configuración de geodatabase.
Cambiar la configuración de la tabla de archivos de registro en DB2, Informix u Oracle	Herramienta de geoprocesamientoConfigurar tablas de archivos de registro de geodatabase
Eliminar una geodatabase de esquema de Oracle	Herramienta de geoprocesamiento Eliminar geodatabase de esquema
Actualizar una geodatabase	Herramienta de geoprocesamiento Actualizar geodatabase

Administrar geodatabases con control de versiones	Herramienta
Crear una versión de geodatabase	Herramienta de geoprocesamiento Crear versión o en el cuadro de diálogo Administrador de versiones en ArcGIS Desktop.
Conciliar una versión	Herramienta de geoprocesamiento Conciliar versiones o con la función Conciliar en ArcMap.
Publicar cambios en una versión principal	Herramienta de geoprocesamiento Publicar versión o con la función Publicar en ArcMap.
Comprimir una geodatabase versionada	Herramienta de geoprocesamiento Comprimir o la función Comprimir base de datos en ArcGIS Desktop
Eliminar una versión de la geodatabase	Herramienta de geoprocesamiento Eliminar versión o en el cuadro de diálogo Administrador de versiones en ArcGIS Desktop
Diagnosticar y reparar metadatos de versión y tablas del sistema	Herramientas de geoprocesamiento Diagnosticar metadatos de versión, Reparar metadatos de versión, Diagnosticar tablas de versión y Reparar tablas de versión
Actualizar los índices en las tablas del sistema de versiones	Herramienta de geoprocesamiento Reconstruir índices
Actualizar las estadísticas en las tablas del sistema de versiones	Herramienta de geoprocesamiento Analizar datasets

Administrar conexiones	Herramienta
Conseguir una lista de conexiones actuales de base de datos	En la pestaña Conexiones del cuadro de diálogo Administración de geodatabase en ArcGIS Desktop o la función de Python ListUsers También puede ver los bloqueos por conexiones en la pestaña Bloqueos del cuadro de diálogo Administración de geodatabase.
Eliminar conexiones de la geodatabase	En la pestaña Conexiones del cuadro de diálogo Administración de geodatabase en ArcGIS Desktop o la función de Python DisconnectUser
Bloquear temporalmente las conexiones de geodatabase y volver a habilitar las conexiones	En la pestaña Conexiones del cuadro de diálogo Propiedades de la base de datos en ArcGIS Desktop o la función de Python AcceptConnections

Administración de datos

Al cargar datos en una geodatabase corporativa, el usuario con el que se conecte será propietario de los datos en la geodatabase. Algunas tareas de administración de geodatabase, como la concesión de privilegios o la reconstrucción de índices, solo las puede realizar el propietario de los datos. Asegúrese de crear un archivo de conexión de base de datos (.sde), conectándose como el usuario correcto, antes de realizar estas tareas.

En la mayoría de los casos, los comandos de administración de ArcSDE se utilizaron para realizar scripts de carga o de administración de datos; por lo tanto, las tareas de administración de datos que se enumeran en las secciones siguientes incluyen scripts de muestra.

Si desea crear el archivo de conexión de base de datos como parte de cada script, utilice CreateDatabaseConnection_management.

Exportar contenido de la geodatabase a un archivo portátil

Descripción: exportar el esquema de geodatabase, las relaciones, el comportamiento y los datos a documentos de espacio de trabajo XML para compartirlos con otros. También puede exportar un subconjunto del contenido de la geodatabase a un documento de espacio de trabajo XML.

Herramienta que se debe utilizar: Exportar documento XML del espacio de trabajo

Script de muestra:

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

Importar nuevo contenido de geodatabase

Descripción: los documentos de espacio de trabajo XML incluyen el esquema de geodatabase, las relaciones y el comportamiento, y también pueden contener datos. Puede importar un documento de espacio de trabajo XML que contenga solo el esquema de geodatabase y, a continuación, cargar sus propios datos en el esquema. O también puede crear una plantilla de esquema de geodatabase, exportar el esquema y las relaciones definidas en esa geodatabase a un documento de espacio de trabajo XML, e importar ese documento a una nueva geodatabase.

Herramienta que se debe utilizar: Importar documento XML del espacio de trabajo

Script de muestra:

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

Importar contenido para sobrescribir contenido antiguo

Descripción: los documentos de espacio de trabajo XML incluyen el esquema de geodatabase, las relaciones y el comportamiento, y también pueden contener datos. Puede importar un documento de espacio de trabajo XML que contenga el esquema, las relaciones, el comportamiento y los datos, así como sobrescribir el contenido de una geodatabase existente. Puede hacer esto si recibe actualizaciones de proyecto de otra agencia o de otro contratista y desea tener los datos y las definiciones más recientes.

Herramientas que se deben utilizar: Eliminar más Importar documento del espacio de trabajo XML

Script de muestra:

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

Importar un shapefile o una cobertura únicos y campos de esquema

Descripción: especificar qué campos del shapefile o de la cobertura que importe se asignan a qué campos de la clase de entidad resultante en la geodatabase.

Herramientas que se deben utilizar: ListFields más FeatureClassToFeatureClass_conversion más FieldMappings

Script de muestra:

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)

Importar varios shapefiles o varias coberturas de una sola vez

Descripción: importar varios shapefiles o varias coberturas de una sola vez.

Herramienta que se debe utilizar: De clase de entidad a geodatabase

Script de muestra:

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

Importar varios shapefiles o varias coberturas y conceder privilegios sobre nuevas clases de entidad a grupos de bases de datos existentes.

Descripción: importar varios shapefiles o varias coberturas de una sola vez y conceder privilegios sobre las clases de entidad resultantes a grupos de bases de datos existentes para que los miembros de los grupos tengan acceso a las nuevas clases de entidad.

Herramientas que se deben utilizar: De clase de entidad a geodatabase más Cambiar privilegios

Script de muestra:

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

Combinar varios shapefiles en una única clase de entidad

Descripción: si tiene shapefiles que contienen el mismo tipo de datos puede combinarlos en una clase de entidad en su geodatabase. Por ejemplo, si obtiene shapefiles de punto que representan escuelas de varios distritos escolares, podría importar esos shapefiles a una única clase de entidad de escuelas en su geodatabase.

Herramientas que se deben utilizar: Incorporar más Fusionar

Script de muestra:

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

Importar varias tablas

Descripción: puede importar varias tablas de dBASE, INFO, VPF, OLE DB o geodatabases a su geodatabase corporativa al mismo tiempo.

Herramienta que se debe utilizar: De tabla a geodatabase

Script de muestra:

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

Truncar una tabla o una clase de entidad, e incorporar registros

Descripción: si recibe actualizaciones de datos de otra agencia o de un tercero, puede conservar su tabla existente y, por lo tanto, los privilegios definidos para la tabla; para ello, debe truncar la tabla e incorporar las actualizaciones de los datos.

Herramientas que se deben utilizar: Truncar tabla más Incorporar

Script de muestra:

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

Truncar una tabla o una clase de entidad, incorporar registros y actualizar las estadísticas de base de datos

Descripción: si recibe actualizaciones de datos de otra agencia o de un tercero, puede conservar su tabla existente y, por lo tanto, los privilegios definidos para la tabla; para ello, debe truncar la tabla e incorporar las actualizaciones de los datos. Si la tabla contiene numerosos registros, es probable que desee actualizar las estadísticas de base de datos en la tabla recién actualizada.

Herramientas que se deben utilizar: Truncar tabla más Incorporar más Analizar datasets

Script de muestra:

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

Crear una vista no espacial de base de datos

Descripción: una vista de base de datos puede combinar datos de varias tablas y restringir los atributos que se devuelven de las tablas de origen.

Herramienta que se debe utilizar: Crear vista de base de datos

Script de muestra:

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

Crear una vista de base de datos que contenga una columna de tipo de geometría SQL

Descripción: una vista de base de datos puede combinar datos de varias tablas y restringir los atributos que se devuelven de las tablas de origen. Puede incluir una única columna de tipo de geometría SQL en la vista y los datos espaciales se pueden mostrar en ArcGIS.

Herramienta que se debe utilizar: Crear vista de base de datos

Script de muestra:

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

Crear una vista que contenga una columna de tipo de geometría SQL y registrar la vista con la geodatabase

Descripción: registrar una vista espacial con la geodatabase le permite almacenar información sobre la extensión, el tipo de geometría y el sistema de referencia de coordenadas de los datos espaciales. Si esta información está almacenada en las tablas de sistema de la geodatabase, se reduce el tiempo que tardan en representarse las entidades al agregar la vista por primera vez al mapa. Incluya una única columna de tipo de geometría SQL en la vista y una columna ObjectID.

Herramientas que se deben utilizar: Crear vista de base de datos y Registrar con geodatabase

Script de muestra:

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

Eliminar tablas

Descripción: puede eliminar varias tablas de la geodatabase al mismo tiempo. Esto puede resultar útil en flujos de trabajo en los que los datos sean temporales, como datos de proyectos específicos, o en flujos de trabajo en los que reciba datos de reemplazo de un tercero.

Herramienta que se debe utilizar: Eliminar

Script de muestra:

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

Eliminar clases de entidad

Descripción: puede eliminar varias clases de entidad de la geodatabase al mismo tiempo. Esto puede resultar útil en flujos de trabajo en los que los datos sean temporales, como datos de proyectos específicos, o en flujos de trabajo en los que reciba datos de reemplazo de un tercero.

Herramienta que se debe utilizar: Eliminar

Script de muestra:

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

Exportar datos a un shapefile

Descripción: exportar una clase de entidad a un shapefile.

Herramienta que se debe utilizar: De clase de entidad a shapefile

Script de muestra:

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

Conciliar, publicar y comprimir una geodatabase versionada

Descripción: usted versiona datos y geodatabases para facilitar la edición de flujos de trabajo que requieran que varias personas editen los datos al mismo tiempo durante periodos prolongados. Para permitir esto, se requieren determinadas operaciones de mantenimiento en la geodatabase. Estas incluyen conciliar los datos versionados con una versión anterior para introducir los cambios realizados en la versión anterior, publicar las ediciones de la versión secundaria a la versión anterior y comprimir la geodatabase para eliminar estados de versión innecesarios.

Herramientas que se deben utilizar: Conciliar versiones más Comprimir

Script de muestra:

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

Consulte también Utilizar un script de Python para conciliar y publicar versiones por lotes.

Versionar tablas o clases de entidad, agregar Id. globales a las mismas y crear una réplica

Descripción: las tablas o las clases de entidad deben estar registradas como versionadas y contener una columna de Id. global antes de que pueda replicarlas.

Herramientas que se deben utilizar: Registrar como versionada, Agregar Id. globales y Crear réplica

Script de muestra:

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

Registrar una tabla de terceros con la geodatabase

Descripción: si utiliza aplicaciones de terceros o SQL para crear tablas (tanto espaciales como no espaciales) en la base de datos en la que está almacenada su geodatabase, puede registrar las tablas con la geodatabase. Esto agrega información sobre las tablas a las tablas del sistema de geodatabase, tras lo cual, las tablas pueden participar en la funcionalidad de la geodatabase.

Herramienta que se debe utilizar: Registrar con geodatabase

Script de muestra:

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