Riordinare i campi (in modo permanente) nel file geodatabase usando ArcGIS Desktop?

18

Utilizzando ArcGIS 10.0, è possibile riordinare i campi in un geodatabase di file e l'ordine è persistito nel database?

Abbiamo preso in considerazione l'esportazione in XML e la scrittura di un parser per modificare l'ordine dei campi, quindi ricreare un nuovo database dall'XML. Sembra un processo laborioso.

Un'altra idea è importare le definizioni dei campi esistenti in Excel, riordinarle, esportarle in CSV, quindi scrivere uno script Python per creare questi campi in un nuovo Geodatabase. Esiste una sceneggiatura come questa, prima di scriverla da zero?

Purtroppo il Diagrammer ArcGIS non sembra supportare il riordino sul campo.

Ci sono script o hack che potremmo usare per semplificare questo processo?

arcgis-desktop  arcgis-10.0  esri-geodatabase  arccatalog  schema-architecture 
— Stephen Lead
fonte
8
Spero che tu abbia votato a ideas.arcgis.com/ideaView?id=0873000000087wgAAA :-)
— PolyGeo
Puoi riordinare i campi in ArcGIS Diagrammer, basta andare nella raccolta dei campi e selezionare il campo e premere le frecce su / giù.
— blah238,
@ blah238 se puoi aggiungerlo come risposta, lo accetterò. Funziona molto bene ed è semi supportato da Esri da quando uno dei loro ragazzi lo ha scritto
— Stephen Lead,
1
ecco la dimostrazione video - maps.esri.com/Diagrammer/reorderfields.htm
— Geog

Risposte:

6

Come menzionato nei commenti, è possibile riordinare i campi con ArcGIS Diagrammer. In questa risposta ho pubblicato un passaggio più generale: Come aggiornare la proprietà della lunghezza di un campo della classe di caratteristiche?

— blah238
fonte
Grazie. ArcGIS Diagrammer è un po 'instabile: non si blocca esattamente, ma a volte sembra fatto in casa. Ma per modificare lo schema, sembra l'opzione migliore.
— Stephen Lead,
Ora potrebbe funzionare oltre la 10.0. È stato installato correttamente per me su Win7 x64 con ArcGIS 10.1, ma quando viene eseguito rivela errori di compilazione Just In Time ed esce.
— matt wilkie,
1
Dovrebbe essere importante notare che ArcGIS Diagrammer non funziona più con ArcGIS 10.3 o versioni successive.
— Map Man
7

In risposta a un'altra domanda, ho detto che è possibile utilizzare le statistiche riassuntive per fare l'equivalente di PULLITEMS (vecchio parlare per riordinare i campi). Quella tecnica funziona bene solo su Tabelle ma c'è un altro script disponibile che dice che funziona sia su classi di funzionalità che su tabella.

Vorrei anche raccomandare la risposta al riordino permanente dei campi usando lo strumento ArcGIS Make Query Table? che è stato ispirato dalla risposta di @klewis a questo.

— PolyGeo
fonte
6

La versione gratuita di ET Geowizards farà questo. Base -> Ordina forme. L'ho appena testato su un file geodatabase v10 e funziona. Tuttavia, deve creare una nuova classe di funzionalità.

— pgager
fonte
5

Se non si dispone di Visio per Diagramer, tutte le altre risposte qui interrompono qualsiasi join. Ho trovato che funziona bene nel mio caso:

  1. Esporta lo schema per l'intero db usando Arccatalog (Export - XML) - Non ho esportato i dati, solo schema
  2. Utilizza un servizio Pretty Print online per formattare l'xml Apri il file XML in un editor di testo e riordina i campi come preferisci
  3. Reimportare lo schema per creare un nuovo database
  4. Ricarica i dati utilizzando il database originale come origine
— Ozmo
fonte
L'ho scartato nella domanda originale come "un processo laborioso" - ma in realtà quando lo metti così, non suona troppo male;)
— Stephen Lead,
4

È necessario eseguire MakeTableQuery dal set di strumenti Livelli e Viste tabella per riordinare i campi. Dalla documentazione, L'ordine dei campi nell'elenco dei campi indica l'ordine in cui i campi appariranno nel layer di output o nella vista tabella. Inoltre, se una colonna Forma viene aggiunta all'elenco dei campi, il risultato è un livello; in caso contrario, è una vista tabella. Questo è disponibile con qualsiasi livello di licenza.

— klewis
fonte
Mi chiedo solo se hai provato questo perché non riesco a vedere un modo per riordinare i campi con lo strumento Crea tabella query: la sua finestra di dialogo sembra che ti permetta di decidere se includere o meno i campi.
— PolyGeo
Sì, l'ho provato da uno script Python. Lo strumento sembra essere progettato per combinare o unire più tabelle. Tuttavia, sono in grado di creare una nuova tabella o classe di caratteristiche con campi riordinati inserendo una singola classe di caratteristiche.
— Klewis,
Devo mancare qualcosa, quindi ho pubblicato una nuova domanda qui gis.stackexchange.com/questions/32310/… - puoi forse dettagliare i passaggi lì per me, per favore?
— PolyGeo
Ho appena risposto alla nuova domanda utilizzando non solo MakeQueryTable ma anche CopyFeatures e alcune modifiche minori del codice che ho ottenuto usando Copia come frammento Python nella finestra di Python.
— PolyGeo
4

Con lo strumento Unisci , puoi facilmente riordinare i campi in modo permanente. Funziona con tabelle e classi di caratteristiche. Il riordino può essere effettuato tramite script Python e persino con la finestra di dialogo Strumento (Rimuovendo un campo e aggiungendolo nuovamente nella finestra di dialogo). Sebbene il riordino tramite la finestra di dialogo non sia un approccio perfetto.

Si consiglia di utilizzare lo strumento Unisci una volta e quindi utilizzare Copia come frammento Python, quindi modificare manualmente gli ordini dei campi e quindi incollare il codice Python in Windows Python.

Ecco uno script Python che utilizza lo strumento Unisci per riordinare i campi (copiato da qui )

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
Sembra funzionare bene dalla finestra di dialogo dello strumento in cui ho prima eliminato un campo che volevo spostare per ultimo, ho aggiunto un nuovo campo e poi ho aggiunto il campo di input. Tuttavia, come hai detto, usarlo in Python è più facile che tramite lo strumento quando è necessario un riordino più complesso.
— PolyGeo
3

Esri un'estensione gratuita di Esri chiamata X-Ray che contiene uno strumento creato per riordinare i campi. Ha funzionato benissimo per noi ed è facile da usare.

Il componente aggiuntivo X-Ray per ArcCatalog può essere utilizzato per sviluppare, perfezionare e documentare i progetti di geodatabase

— marchio
fonte
benvenuto in GIS Stack Exchange e grazie per il suggerimento. Ho riformattato la tua risposta per renderla più in linea con gli standard di Stack Exchange: ho incluso un link e un preventivo sul prodotto e rimosso informazioni estranee.
— Stephen Lead,
2

Finora il metodo più efficace che ho trovato per rinominare i campi, cambiare il loro ordine predefinito e una serie di altre cose è usare Microsoft Access:

  1. Crea un nuovo geodatabase personale
  2. Trascina e rilascia la classe caratteristica o la tabella in p-gdb
  3. Apri in Access e:
    • Ignorando l'inizio di tutte le tabelle GDB_, aprire le tabelle in modalità progettazione tabella
    • rinominare, cambiare ordine, aggiungere nuovo, ecc.
  4. Trascina e rilascia indietro sul tuo vero gdb operativo

Appunti:

Avere sempre un backup corrente. Stai scherzando direttamente con la struttura GDB interna e potresti facilmente eliminare i tuoi dati modificando il DB al punto che ArcGIS non sa più come leggerli.

Esistono alcune parole chiave riservate sul lato ArcGIS che non possono essere utilizzate per i nomi dei campi. Access creerà o rinominerà felicemente i campi con queste parole chiave, ma quando le ripristini avranno automaticamente un carattere di sottolineatura aggiunto. Così Currentdiventa Current_. Inoltre, si notano le parole chiave riservate di Access parzialmente sovrapposte .

Il GDB personale ha un limite di dimensioni del file di 2 GB, quindi la dimensione totale di tutte le tabelle e le classi di caratteristiche all'interno del GDB non può superare quella.

Potrebbe essere allettante utilizzare sempre GDB personali per piccoli progetti (<2 GB). Non farlo. Le prestazioni sono spaventose e ci sono sottili differenze nella sintassi SQL di Access che rendono le espressioni delle etichette, le query di definizione e così via non portatili.

— Wilkie opaco
fonte
ovviamente, questo metodo non è ufficialmente sanzionato, e se qualcosa va storto non sarai in grado di chiamare il supporto tecnico;)
— Stephen Lead
2

Questo script Python è una specie di metodo "a nastro" per farlo. È limitato a 20 campi ma potrebbe essere facilmente aggiunto per consentirne l'esecuzione per tutti i campi dei dati.

Lo script è progettato per essere eseguito come uno strumento di script, quindi è necessario impostare i parametri in ArcCatalog.

I parametri dovrebbero essere i seguenti:

  • InputFC - Classe di caratteristiche
  • Posizione di output - Area di lavoro
  • Nome output - String
  • Field1 - Field
  • Field2 - Field
  • Fino a Field20

Codice:

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

Mi rendo conto che questo non è il modo più carino o più efficiente per farlo, ma in realtà funziona abbastanza bene e ci è voluta solo mezz'ora per scrivere. Lo uso sempre quando devo riordinare i campi e non richiede Diagrammer o Microsoft Access. Naturalmente il numero massimo di campi può essere un problema, ma può essere personalizzato nuovamente all'interno dello script.

— GeoJohn
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.