¿Reordenando los campos (permanentemente) en la geodatabase de archivos usando ArcGIS Desktop?

18

Usando ArcGIS 10.0, ¿es posible reordenar los campos en una geodatabase de archivos y el pedido persiste en la base de datos?

Consideramos exportar a XML y escribir un analizador para cambiar el orden de los campos, y luego volver a crear una nueva base de datos a partir del XML. Esto parece un proceso laborioso.

Otra idea es importar las definiciones de campo existentes en Excel, reordenarlas, exportarlas a CSV y luego escribir un script de Python para crear estos campos en una nueva Geodatabase. ¿Existe un script como este, antes de que lo escribamos desde cero?

Lamentablemente, ArcGIS Diagrammer no parece admitir el reordenamiento de campo.

¿Hay scripts o hacks que podamos usar para simplificar este proceso?

arcgis-desktop  arcgis-10.0  esri-geodatabase  arccatalog  schema-architecture 
— Stephen Lead
fuente
8
Espero que hayas votado en ideas.arcgis.com/ideaView?id=0873000000087wgAAA :-)
— PolyGeo
Puede reordenar los campos en ArcGIS Diagrammer, simplemente vaya a la colección de campos y seleccione el campo y presione las flechas arriba / abajo.
— blah238
@ blah238 si puedes agregar eso como respuesta, lo aceptaré. Funciona muy bien y cuenta con el apoyo de Esri desde que uno de sus muchachos lo escribió
— Stephen Lead,
1
aquí está la demostración en video - maps.esri.com/Diagrammer/reorderfields.htm
— Geog

Respuestas:

6

Como se menciona en los comentarios, puede reordenar los campos con ArcGIS Diagrammer. Publiqué un paso más general paso a paso en esta respuesta: ¿Cómo actualizar la propiedad de longitud de un campo de clase de entidad?

— blah238
fuente
Gracias. El ArcGIS Diagrammer es un poco inestable: no se bloquea exactamente, pero a veces se siente hecho en casa. Pero para modificar el esquema, parece ser la mejor opción.
— Stephen Lead
Ahora podría funcionar más allá de 10.0. Se instaló bien para mí en Win7 x64 con ArcGIS 10.1, pero cuando se ejecuta arroja errores de compilación Just In Time y se cierra.
— Matt Wilkie
1
Debe ser importante tener en cuenta que ArcGIS Diagrammer ya no funciona con ArcGIS 10.3 o superior.
— Map Man el
7

En respuesta a otra pregunta , dije que es posible usar estadísticas de resumen para hacer el equivalente de PULLITEMS (antiguo habla para reordenar campos). Esa técnica funciona bien solo en Tablas, pero ahora hay otro script disponible que dice que funciona tanto en las clases de entidad como en la tabla.

También recomendaría los campos Respuesta a reordenación de forma permanente utilizando la herramienta Crear tabla de consulta de ArcGIS? que fue inspirado por la respuesta de @klewis a esta.

— PolyGeo
fuente
6

La versión gratuita de ET Geowizards lo hará. Básico -> Ordenar formas. Acabo de probarlo en una geodatabase de archivos v10 y funciona. Sin embargo, tiene que crear una nueva clase de entidad.

— pgager
fuente
5

Si no tiene Visio para Diagramer, todas las otras respuestas aquí rompen cualquier combinación. Encontré que esto funciona bien en mi caso:

  1. Exportar el esquema para toda la base de datos utilizando Arccatalog (Exportar - XML) - No exporté los datos, solo el esquema
  2. Use algún servicio en línea de Pretty Print para formatear el xml Abra el archivo XML en un editor de texto y reordene los campos como desee
  3. Vuelva a importar el esquema para crear una nueva base de datos
  4. Vuelva a cargar los datos utilizando la base de datos original como fuente
— Ozmo
fuente
Descarté eso en la pregunta original como "un proceso laborioso", pero en realidad cuando lo pones así, no suena tan mal;)
— Stephen Lead
4

Debe ejecutar MakeTableQuery desde el conjunto de herramientas Vistas de capas y tablas para reordenar los campos. De la documentación, el orden de los campos en la lista de campos indica el orden en que aparecerán los campos en la capa de salida o en la vista de tabla. Además, si se agrega una columna Forma a la lista de campos, el resultado es una capa; de lo contrario, es una vista de tabla. Esto está disponible con cualquier nivel de licencia.

— klewis
fuente
Solo me pregunto si ha probado esto porque no puedo ver una forma en que la herramienta Crear tabla de consulta reordene los campos; su diálogo de herramientas parece simplemente permitirle decidir si los campos se incluirán o no.
— PolyGeo
Sí, he probado esto desde un script de Python. La herramienta parece estar diseñada para combinar o unir varias tablas. Sin embargo, puedo crear una nueva tabla o clase de entidad con campos reordenados ingresando una sola clase de entidad.
— klewis
Debo estar perdiendo algo, así que he publicado una nueva pregunta aquí gis.stackexchange.com/questions/32310/… . ¿ Podrían detallarme los pasos allí, por favor?
— PolyGeo
Acabo de responder la nueva pregunta usando no solo MakeQueryTable sino también CopyFeatures y alguna edición menor del código que obtuve usando Copiar como fragmento de Python en la ventana de Python.
— PolyGeo
4

Con la herramienta de combinación , puede reordenar fácilmente los campos de forma permanente. Funciona con tablas y clases de entidad. El reordenamiento se puede hacer a través de la secuencia de comandos de Python e incluso con el cuadro de diálogo Herramienta (al eliminar un campo y volver a agregarlo en el cuadro de diálogo). Aunque reordenar a través del diálogo no es un enfoque perfecto.

Se recomienda usar la herramienta Fusionar una vez y luego usar Copiar como fragmento de Python y luego cambiar manualmente el orden de los campos y luego pegar el código de Python en las ventanas de Python.

Aquí hay una secuencia de comandos de Python que usa la herramienta de combinación para reordenar los campos (copiado de aquí )

import arcpy

def reorder_fields(table, out_table, field_order, add_missing=True):
    """ 
    Reorders fields in input featureclass/table
    :table:         input table (fc, table, layer, etc)
    :out_table:     output table (fc, table, layer, etc)
    :field_order:   order of fields (objectid, shape not necessary)
    :add_missing:   add missing fields to end if True (leave out if False)
    -> path to output table
    """
    existing_fields = arcpy.ListFields(table)
    existing_field_names = [field.name for field in existing_fields]

    existing_mapping = arcpy.FieldMappings()
    existing_mapping.addTable(table)

    new_mapping = arcpy.FieldMappings()

    def add_mapping(field_name):
        mapping_index = existing_mapping.findFieldMapIndex(field_name)

        # required fields (OBJECTID, etc) will not be in existing mappings
        # they are added automatically
        if mapping_index != -1:
            field_map = existing_mapping.fieldMappings[mapping_index]
            new_mapping.addFieldMap(field_map)

    # add user fields from field_order
    for field_name in field_order:
        if field_name not in existing_field_names:
            raise Exception("Field: {0} not in {1}".format(field_name, table))

        add_mapping(field_name)

    # add missing fields at end
    if add_missing:
        missing_fields = [f for f in existing_field_names if f not in field_order]
        for field_name in missing_fields:
            add_mapping(field_name)

    # use merge with single input just to use new field_mappings
    arcpy.Merge_management(table, out_table, new_mapping)
    return out_table

USO:

new_field_order = ["field2", "field3", "field1"]
reorder_fields(in_fc, out_fc, new_field_order)
— Farid Cheraghi
fuente
Eso parece funcionar bien desde el cuadro de diálogo de la herramienta donde eliminé por primera vez un campo que quería mover para ser el último, agregué un nuevo campo y luego agregué Agregar campo de entrada. Sin embargo, como dijiste, usarlo en Python es más fácil que a través de la herramienta cuando se necesita un reordenamiento más complejo.
— PolyGeo
3

Hay una extensión gratuita de Esri llamada X-Ray que contiene una herramienta hecha para reordenar campos. Nos ha funcionado muy bien y es fácil de usar.

El complemento X-Ray para ArcCatalog se puede usar para desarrollar, refinar y documentar sus diseños de geodatabase

— marca
fuente
bienvenido a GIS Stack Exchange, y gracias por el consejo. Cambié el formato de su respuesta para que esté más en línea con los estándares de Stack Exchange: incluí un enlace y una cita sobre el producto, y eliminé información extraña.
— Stephen Lead
2

Hasta ahora, el método más eficiente que he encontrado para cambiar el nombre de los campos, cambiar su orden predeterminado y otras cosas es usar Microsoft Access:

  1. Crear nueva geodatabase personal
  2. Arrastre y suelte la clase de entidad o tabla en el p-gdb
  3. Abrir en Access y:
    • Ignorando todas las tablas que comienzan GDB_, tablas abiertas en modo de diseño de tabla
    • cambiar el nombre, cambiar el orden, agregar nuevo, etc.
  4. Arrastra y suelta de nuevo a tu gdb operacional real

Notas:

Siempre tenga una copia de seguridad actual. Estás jugando directamente con la estructura interna de GDB y podrías eliminar fácilmente tus datos alterando la base de datos hasta el punto en que ArcGIS ya no sepa cómo leerla.

Hay algunas palabras clave reservadas en el lado de ArcGIS que no se pueden usar para los nombres de campo. Access creará o cambiará el nombre de los campos con estas palabras clave, pero cuando las recupere, automáticamente se agregará un guión bajo. Así se Currentconvierte Current_. También tenga en cuenta las palabras clave reservadas de acceso parcialmente superpuestas .

El GDB personal tiene un límite de tamaño de archivo de 2GB, por lo que el tamaño total de todas las tablas y clases de entidad dentro del GDB no puede exceder eso.

Puede ser tentador usar siempre GDB personales para proyectos pequeños (<2GB). No lo hagas El rendimiento es abismal y existen diferencias sutiles en la sintaxis SQL de Access que hacen que las expresiones de etiqueta, las consultas de definición, etc., no sean portátiles.

— wilkie mate
fuente
por supuesto, este método no está oficialmente sancionado, y si algo sale mal, no podrá llamar al Soporte Técnico;)
— Stephen Lead el
2

Este Python Script es una especie de método de "cinta adhesiva" para hacer esto. Está limitado a 20 campos, pero podría agregarse fácilmente para permitir que se ejecute para todos los campos que tengan sus datos.

El script está diseñado para ejecutarse como una herramienta de script, por lo que deberá configurar los parámetros dentro de ArcCatalog.

Los parámetros deben ser los siguientes:

  • InputFC - Clase de entidad
  • Ubicación de salida - Espacio de trabajo
  • Nombre de salida: cadena
  • Campo1 - Campo
  • Field2 - Campo
  • Todo el camino a Field20

Código:

import arcpy, os, sys
from arcpy import env

arcpy.env.overwriteOutput = True

inFC = arcpy.GetParameterAsText(0)
outLoc = arcpy.GetParameterAsText(1)
outName = arcpy.GetParameterAsText(2)
field1 = arcpy.GetParameterAsText(3)
field2 = arcpy.GetParameterAsText(4)
field3 = arcpy.GetParameterAsText(5)
field4 = arcpy.GetParameterAsText(6)
field5 = arcpy.GetParameterAsText(7)
field6 = arcpy.GetParameterAsText(8)
field7 = arcpy.GetParameterAsText(9)
field8 = arcpy.GetParameterAsText(10)
field9 = arcpy.GetParameterAsText(11)
field10 = arcpy.GetParameterAsText(12)
field11 = arcpy.GetParameterAsText(13)
field12 = arcpy.GetParameterAsText(14)
field13 = arcpy.GetParameterAsText(15)
field14 = arcpy.GetParameterAsText(16)
field15 = arcpy.GetParameterAsText(17)
field16 = arcpy.GetParameterAsText(18)
field17 = arcpy.GetParameterAsText(19)
field18 = arcpy.GetParameterAsText(20)
field19 = arcpy.GetParameterAsText(21)
field20 = arcpy.GetParameterAsText(22)

fieldList = ["SHAPE@"]

arcpy.AddMessage(" ")

arcpy.AddMessage("Appending field choices to new List ")

arcpy.AddMessage(" ")

if (field1 != ""):
    fieldList.append(field1)
if (field2 != ""):
    fieldList.append(field2)
if (field3 != ""):
    fieldList.append(field3)
if (field4 != ""):
    fieldList.append(field4)
if (field5 != ""):
    fieldList.append(field5)
if (field6 != ""):
    fieldList.append(field6)
if (field7 != ""):
    fieldList.append(field7)
if (field8 != ""):
    fieldList.append(field8)
if (field9 != ""):
    fieldList.append(field9)
if (field10 != ""):
    fieldList.append(field10)
if (field11 != ""):
    fieldList.append(field1)
if (field12 != ""):
    fieldList.append(field12)
if (field13 != ""):
    fieldList.append(field13)
if (field14 != ""):
    fieldList.append(field14)
if (field15 != ""):
    fieldList.append(field15)
if (field16 != ""):
    fieldList.append(field16)
if (field17 != ""):
    fieldList.append(field17)
if (field18 != ""):
    fieldList.append(field18)
if (field19 != ""):
    fieldList.append(field19)
if (field20 != ""):
    fieldList.append(field20)

arcpy.AddMessage(" ")

#arcpy.AddMessage(fieldList)

oldFieldList = arcpy.ListFields(inFC)

fieldTypes = []

numOfFields = len(fieldList)

fieldIndex = 1

reorderedFields = []

for fld in fieldList:
    for f in oldFieldList:
        if f.name == fld:
            arcpy.AddMessage(f.name)
            reorderedFields.append(f)
            break

arcpy.AddMessage(" ")

arcpy.AddMessage(reorderedFields)

desc = arcpy.Describe(inFC)
geoType = desc.shapeType.upper()
spatRef = arcpy.Describe(inFC).spatialReference

arcpy.CreateFeatureclass_management(outLoc, outName, geoType, "", "", "", spatRef)
newFeat = os.path.join(outLoc, outName)

for flds in reorderedFields:
    if (flds.type == "String"):
        fLength = flds.length
        arcpy.AddField_management(newFeat, flds.name, flds.type, "", "", str(fLength))
    else:
        arcpy.AddField_management(newFeat, flds.name, flds.type)

arcpy.AddMessage(" ")

arcpy.AddMessage(fieldList)

arcpy.AddMessage(" ")

arcpy.AddMessage("Features will be copied with new Schema...")

count = 0

with arcpy.da.SearchCursor(inFC, fieldList) as cursor:
    for row in cursor:
        insertCursor = arcpy.da.InsertCursor(newFeat, (fieldList))
        if (numOfFields == 21):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10], row[11], row[12], row[13], row[14], row[15], row[16], row[17], row[18], row[19], row[20]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]) + ', ' + str(row[6]) + ', ' + str(row[7]) + ', ' + str(row[8]) + ', ' + str(row[9]) + ', ' + str(row[10]) + ', ' + str(row[11]) + ', ' + str(row[12]) + ', ' + str(row[13]) + ', ' + str(row[14]) + ', ' + str(row[15]) + ', ' + str(row[16]) + ', ' + str(row[17]) + ', ' + str(row[18]) + ', ' + str(row[19]) + ', ' + str(row[20]))
            count += 1
        elif (numOfFields == 20):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10], row[11], row[12], row[13], row[14], row[15], row[16], row[17], row[18], row[19]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]) + ', ' + str(row[6]) + ', ' + str(row[7]) + ', ' + str(row[8]) + ', ' + str(row[9]) + ', ' + str(row[10]) + ', ' + str(row[11]) + ', ' + str(row[12]) + ', ' + str(row[13]) + ', ' + str(row[14]) + ', ' + str(row[15]) + ', ' + str(row[16]) + ', ' + str(row[17]) + ', ' + str(row[18]) + ', ' + str(row[19]))
            count += 1
        elif (numOfFields == 19):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10], row[11], row[12], row[13], row[14], row[15], row[16], row[17], row[18]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]) + ', ' + str(row[6]) + ', ' + str(row[7]) + ', ' + str(row[8]) + ', ' + str(row[9]) + ', ' + str(row[10]) + ', ' + str(row[11]) + ', ' + str(row[12]) + ', ' + str(row[13]) + ', ' + str(row[14]) + ', ' + str(row[15]) + ', ' + str(row[16]) + ', ' + str(row[17]) + ', ' + str(row[18]))
            count += 1
        elif (numOfFields == 18):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10], row[11], row[12], row[13], row[14], row[15], row[16], row[17]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]) + ', ' + str(row[6]) + ', ' + str(row[7]) + ', ' + str(row[8]) + ', ' + str(row[9]) + ', ' + str(row[10]) + ', ' + str(row[11]) + ', ' + str(row[12]) + ', ' + str(row[13]) + ', ' + str(row[14]) + ', ' + str(row[15]) + ', ' + str(row[16]) + ', ' + str(row[17]))
            count += 1
        elif (numOfFields == 17):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10], row[11], row[12], row[13], row[14], row[15], row[16]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]) + ', ' + str(row[6]) + ', ' + str(row[7]) + ', ' + str(row[8]) + ', ' + str(row[9]) + ', ' + str(row[10]) + ', ' + str(row[11]) + ', ' + str(row[12]) + ', ' + str(row[13]) + ', ' + str(row[14]) + ', ' + str(row[15]) + ', ' + str(row[16]))
            count += 1
        elif (numOfFields == 16):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10], row[11], row[12], row[13], row[14], row[15]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]) + ', ' + str(row[6]) + ', ' + str(row[7]) + ', ' + str(row[8]) + ', ' + str(row[9]) + ', ' + str(row[10]) + ', ' + str(row[11]) + ', ' + str(row[12]) + ', ' + str(row[13]) + ', ' + str(row[14]) + ', ' + str(row[15]))
            count += 1
        elif (numOfFields == 15):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10], row[11], row[12], row[13], row[14]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]) + ', ' + str(row[6]) + ', ' + str(row[7]) + ', ' + str(row[8]) + ', ' + str(row[9]) + ', ' + str(row[10]) + ', ' + str(row[11]) + ', ' + str(row[12]) + ', ' + str(row[13]) + ', ' + str(row[14]))
            count += 1
        elif (numOfFields == 14):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10], row[11], row[12], row[13]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]) + ', ' + str(row[6]) + ', ' + str(row[7]) + ', ' + str(row[8]) + ', ' + str(row[9]) + ', ' + str(row[10]) + ', ' + str(row[11]) + ', ' + str(row[12]) + ', ' + str(row[13]))
            count += 1
        elif (numOfFields == 13):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10], row[11], row[12]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]) + ', ' + str(row[6]) + ', ' + str(row[7]) + ', ' + str(row[8]) + ', ' + str(row[9]) + ', ' + str(row[10]) + ', ' + str(row[11]) + ', ' + str(row[12]))
            count += 1
        elif (numOfFields == 12):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10], row[11]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]) + ', ' + str(row[6]) + ', ' + str(row[7]) + ', ' + str(row[8]) + ', ' + str(row[9]) + ', ' + str(row[10]) + ', ' + str(row[11]))
            count += 1
        elif (numOfFields == 11):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]) + ', ' + str(row[6]) + ', ' + str(row[7]) + ', ' + str(row[8]) + ', ' + str(row[9]) + ', ' + str(row[10]))
            count += 1
        elif (numOfFields == 10):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]) + ', ' + str(row[6]) + ', ' + str(row[7]) + ', ' + str(row[8]) + ', ' + str(row[9]))
            count += 1
        elif (numOfFields == 9):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]) + ', ' + str(row[6]) + ', ' + str(row[7]) + ', ' + str(row[8]))
            count += 1
        elif (numOfFields == 8):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]) + ', ' + str(row[6]) + ', ' + str(row[7]))
            count += 1
        elif (numOfFields == 7):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5], row[6]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]) + ', ' + str(row[6]))
            count += 1
        elif (numOfFields == 6):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]))
            count += 1
        elif (numOfFields == 5):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]))
            count += 1
        elif (numOfFields == 4):
            insertCursor.insertRow((row[0], row[1], row[2], row[3]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]))
            count += 1
        elif (numOfFields == 3):
            insertCursor.insertRow((row[0], row[1], row[2]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]))
            count += 1
        elif (numOfFields == 2):
            insertCursor.insertRow((row[0], row[1]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]))
            count += 1

Me doy cuenta de que esta no es la forma más bonita o más eficiente de hacer esto, pero en realidad funciona bastante bien y solo tardó aproximadamente media hora en escribir. Lo uso todo el tiempo cuando necesito reordenar campos, y no requiere Diagrammer o Microsoft Access. Por supuesto, el número máximo de campos puede ser un problema, pero nuevamente puede personalizarse dentro del script.

— GeoJohn
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.