Reordenando campos (permanentemente) no geodatabase do arquivo usando o ArcGIS Desktop?

18

Usando o ArcGIS 10.0, é possível reordenar os campos em um geodatabase de arquivo e a ordem persistiu no banco de dados?

Consideramos exportar para XML e escrever um analisador para alterar a ordem dos campos e, em seguida, recriar um novo banco de dados a partir do XML. Parece um processo trabalhoso.

Outra idéia é importar as definições de campo existentes para o Excel, reordená-las, exportar para CSV e, em seguida, escrever um script Python para criar esses campos em um novo Geodatabase. Existe um script como esse antes de escrevê-lo do zero?

Infelizmente, o ArcGIS Diagrammer parece não suportar o pedido em campo.

Existem scripts ou hacks que poderíamos usar para simplificar esse processo?

arcgis-desktop  arcgis-10.0  esri-geodatabase  arccatalog  schema-architecture 
— Stephen Lead
fonte
8
Espero que você tenha votado em ideas.arcgis.com/ideaView?id=0873000000087wgAAA :-)
— PolyGeo
Você pode reordenar os campos no ArcGIS Diagrammer, basta acessar a coleção de campos, selecionar o campo e pressionar as setas para cima / para baixo.
— precisa saber é
@ blah238 se você puder adicionar isso como resposta, eu aceito. Funciona muito bem e é semi-suportado pela Esri desde que um deles escreveu
— Stephen Lead
1
aqui está a demonstração em vídeo - maps.esri.com/Diagrammer/reorderfields.htm
— Geog

Respostas:

6

Conforme mencionado nos comentários, você pode reordenar os campos com o ArcGIS Diagrammer. Publiquei um passo a passo mais geral nesta resposta: Como atualizar a propriedade length de um campo de classe de recurso?

— blah238
fonte
Obrigado. O ArcGIS Diagrammer é um pouco instável - ele não falha exatamente, mas às vezes parece caseiro. Mas, para modificar o esquema, parece ser a melhor opção.
— Stephen Chumbo
Agora pode funcionar além de 10.0. Ele instalou bem para mim no Win7 x64 com ArcGIS 10.1, mas quando executado, gera erros de compilação Just In Time e é encerrado.
— 23413 Mattel
1
É importante notar que o ArcGIS Diagrammer não funciona mais com o ArcGIS 10.3 ou superior.
— Map Man
6

A versão gratuita do ET Geowizards fará isso. Básico -> Classificar formas. Acabei de testar em um geodatabase de arquivo v10 e funciona. Ele precisa criar uma nova classe de recurso.

— pgager
fonte
5

Se você não possui o Visio for Diagramer - Todas as outras respostas aqui quebram as associações. Eu achei que isso funcionava bem no meu caso:

  1. Exportar o esquema para o banco de dados inteiro usando Arccatalog (Export - XML) - Não exportei os dados, apenas esquema
  2. Use algum serviço online Pretty Print para formatar o xml Abra o arquivo XML em um editor de texto e reordene os campos como desejar
  3. Reimporte o esquema para criar um novo banco de dados
  4. Recarregue os dados usando o banco de dados original como fonte
— Ozmo
fonte
Eu demiti que na pergunta original como "um processo trabalhoso" - mas, na verdade, quando você colocá-lo assim, não soa muito ruim;)
— Stephen chumbo
4

Você precisa executar MakeTableQuery no conjunto de ferramentas Layers e Table Views para reordenar os campos. Na documentação, A ordem dos campos na lista de campos indica a ordem em que os campos aparecerão na camada de saída ou na exibição da tabela. Além disso, se uma coluna Shape for adicionada à lista de campos, o resultado será uma camada; caso contrário, é uma exibição de tabela. Está disponível com qualquer nível de licença.

— klewis
fonte
Estou imaginando se você testou isso porque não consigo encontrar uma maneira de a ferramenta Criar tabela de consulta reordenar os campos - o diálogo da ferramenta parece apenas permitir que você decida se os campos devem ser incluídos ou não.
— PolyGeo
Sim, eu testei isso a partir de um script Python. A ferramenta parece ter sido projetada para combinar ou unir várias tabelas. No entanto, sou capaz de criar uma nova tabela ou classe de recurso com campos reordenados inserindo uma única classe de recurso.
— precisa saber é
Devo estar faltando alguma coisa, por isso postei uma nova pergunta aqui gis.stackexchange.com/questions/32310/… - você talvez possa detalhar as etapas para mim, por favor?
— PolyGeo
Acabei de responder à nova pergunta usando não apenas MakeQueryTable, mas também CopyFeatures e algumas pequenas edições de código que obtive usando o Copy As Python Snippet na janela Python.
— PolyGeo
4

Com a ferramenta Mesclar , você pode reordenar facilmente os campos permanentemente. Funciona com tabelas e classes de recursos. A reordenação pode ser feita por meio de script python e até com a caixa de diálogo Ferramenta (removendo um campo e recolocando-o na caixa de diálogo). Embora reordenar por meio do diálogo não seja uma abordagem perfeita.

Recomenda-se usar a ferramenta Mesclar uma vez e, em seguida, usar Copiar como snippet Python e, em seguida, alterar manualmente as ordens dos campos e colar o código python nas janelas python.

Aqui está um script python que usa a Merge Tool para reordenar campos (copiado daqui )

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
fonte
Isso parece funcionar bem na caixa de diálogo da ferramenta em que eu excluí pela primeira vez um campo que queria mover para o último, adicionei um novo campo e adicionamos Campo de entrada. No entanto, como você disse, usá-lo no Python é mais fácil do que através da ferramenta quando é necessário um reordenamento mais complexo.
— PolyGeo
3

Existe uma extensão gratuita da Esri chamada X-Ray, que contém uma ferramenta feita para reordenar campos. Funcionou muito bem para nós e é fácil de usar.

O suplemento X-Ray para ArcCatalog pode ser usado para desenvolver, refinar e documentar seus projetos de geodatabase

— Marca
fonte
bem-vindo ao GIS Stack Exchange e obrigado pela dica. Re-formatei sua resposta para estar mais de acordo com os padrões do Stack Exchange - incluí um link e uma citação sobre o produto e removi informações estranhas.
— Stephen Lead
2

Até agora, o método mais eficiente que encontrei para renomear campos, alterar sua ordem padrão e várias outras coisas é usar o Microsoft Access:

  1. Criar novo banco de dados geográfico pessoal
  2. Arraste e solte a classe ou a tabela de recursos no p-gdb
  3. Abra no Access e:
    • Ignorando todas as tabelas iniciadas GDB_, abra tabelas no modo de design de tabela
    • renomear, alterar ordem, adicionar novo etc.
  4. Arraste e solte de volta ao seu gdb operacional real

Notas:

Sempre tenha um backup atual. Você está mexendo diretamente com a estrutura interna do GDB e pode facilmente descartar seus dados alterando o banco de dados ao ponto em que o ArcGIS não sabe mais lê-lo.

Existem algumas palavras - chave reservadas no lado do ArcGIS que não podem ser usadas para nomes de campos. O Access criará ou renomeará os campos com essas palavras-chave, mas quando você os devolver, eles terão um sublinhado automaticamente anexado. Então Currentse torna Current_. Observe também as palavras-chave reservadas do Access parcialmente sobrepostas .

O GDB pessoal tem um limite de tamanho de arquivo de 2 GB, portanto o tamanho total de todas as tabelas e classes de recursos no GDB não pode exceder isso.

Pode ser tentador usar sempre GDBs pessoais para pequenos projetos (<2GB). Não. O desempenho é péssimo e há diferenças sutis na sintaxe SQL do Access que tornam Expressões de rótulo, Consultas de definição e assim por diante não portáteis.

— Matt Wilson
fonte
Claro, este método não é oficialmente sancionada, e se algo der errado, você não será capaz de chamar o suporte técnico;)
— Stephen Chumbo
2

Esse script Python é uma espécie de método de "fita adesiva" para fazer isso. Ele é limitado a 20 campos, mas pode ser facilmente adicionado a fim de permitir a execução para quantos campos seus dados tiverem.

O script foi projetado para ser executado como uma ferramenta de script, portanto, você precisará configurar parâmetros no ArcCatalog.

Os parâmetros devem ser os seguintes:

  • InputFC - Classe de recurso
  • Local de saída - área de trabalho
  • Nome da saída - String
  • Campo1 - Campo
  • Campo2 - Campo
  • Todo o caminho para 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

Sei que essa não é a maneira mais bonita ou eficiente de fazer isso, mas na verdade funciona muito bem e levou apenas meia hora para escrever. Eu uso isso o tempo todo quando preciso reordenar os campos e não requer o Diagrammer ou o Microsoft Access. Obviamente, o número máximo de campos pode ser um problema, mas novamente pode ser personalizado dentro do script.

— GeoJohn
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.