Zmieniać kolejność pól (na stałe) w geobazie pliku za pomocą ArcGIS Desktop?

18

Czy za pomocą ArcGIS 10.0 można zmienić kolejność pól w geobazie pliku i zlecenie utrwalone w bazie danych?

Rozważaliśmy eksport do XML i napisanie parsera, aby zmienić kolejność pól, a następnie odtworzenie nowej bazy danych z XML. To wydaje się żmudnym procesem.

Innym pomysłem jest zaimportowanie istniejących definicji pól do Excela, zmiana ich kolejności, eksportowanie do CSV, a następnie napisanie skryptu Python, aby utworzyć te pola w nowej Geodatabase. Czy taki skrypt istnieje przed napisaniem go od zera?

Niestety ArcGIS Diagrammer nie obsługuje ponownego zamawiania w terenie.

Czy są jakieś skrypty lub hacki, których moglibyśmy użyć, aby uprościć ten proces?

arcgis-desktop arcgis-10.0 esri-geodatabase arccatalog schema-architecture Stephen Lead
źródło
8
Mam nadzieję, że głosowałeś na ideas.arcgis.com/ideaView?id=0873000000087wgAAA :-)
PolyGeo
Możesz zmienić kolejność pól w ArcGIS Diagrammer, po prostu przejdź do kolekcji pól i wybierz pole i naciśnij strzałki w górę / w dół.
blah238,
@ blah238, jeśli możesz dodać to jako odpowiedź, zaakceptuję. Działa bardzo dobrze i jest częściowo wspierany przez Esri, odkąd napisał go jeden z nich
Stephen Lead
1
oto demonstracja wideo - maps.esri.com/Diagrammer/reorderfields.htm
Dror Har Gil

Odpowiedzi:

6

Jak wspomniano w komentarzach, można zmieniać kolejność pól za pomocą ArcGIS Diagrammer. W tej odpowiedzi zamieściłem bardziej ogólny krok: Jak zaktualizować właściwość length pola klasy obiektów?

blah238
źródło
Dzięki. ArcGIS Diagrammer jest trochę niestabilny - nie ulega awarii, ale czasami sprawia wrażenie domowej roboty. Ale do modyfikacji schematu wydaje się to najlepsza opcja.
Stephen Lead
Może teraz działać po 10,0. Zainstalowałem dla mnie ok na Win7 x64 z ArcGIS 10.1, ale po uruchomieniu wyrzuca błędy kompilacji Just In Time i kończy pracę.
matt wilkie
1
Należy zauważyć, że ArcGIS Diagrammer nie działa już z ArcGIS 10.3 lub nowszym.
Map Man
7

W odpowiedzi na inne pytanie powiedziałem, że można użyć statystyk podsumowujących, aby wykonać odpowiednik PULLITEMS (stary mówi o polach zmiany kolejności). Ta technika działa dobrze tylko na tabelach, ale dostępny jest teraz inny skrypt, który mówi, że działa zarówno na klasach elementów, jak i na tabelach.

Poleciłbym również odpowiedź na pytania dotyczące ponownego zamawiania pól na stałe za pomocą narzędzia ArcGIS Make Query Table? który został zainspirowany odpowiedzią @klewis na ten temat.

PolyGeo
źródło
6

To zrobi bezpłatna wersja ET Geowizards. Podstawowe -> Sortuj kształty. Właśnie przetestowałem go na Geobazie Pliku v10 i działa. Musi jednak stworzyć nową klasę funkcji.

pgager
źródło
5

Jeśli nie masz programu Visio dla programu Diagramer - wszystkie pozostałe odpowiedzi tutaj przerywają wszelkie połączenia. Uważam, że to działa dobrze w moim przypadku:

  1. Eksportuj schemat dla całej bazy danych za pomocą Arccatalog (Export - XML) - Nie eksportowałem danych, tylko schemat
  2. Skorzystaj z internetowej usługi Pretty Print, aby sformatować plik xml Otwórz plik XML w edytorze tekstu i zmień kolejność pól według własnego uznania
  3. Ponownie zaimportuj schemat, aby utworzyć nową bazę danych
  4. Załaduj ponownie dane, używając oryginalnej bazy danych jako źródła
Ozmo
źródło
Odrzuciłem to w pierwotnym pytaniu jako „pracochłonny proces” - ale w rzeczywistości, kiedy to ujmujesz, nie brzmi to tak źle;)
Stephen Lead
4

Aby zmienić kolejność pól, musisz uruchomić MakeTableQuery z zestawu narzędzi Warstwy i Widoki tabel. Z dokumentacji kolejność pól na liście pól wskazuje kolejność pól w widoku warstwy wyjściowej lub widoku tabeli. Ponadto, jeśli kolumna Kształt zostanie dodana do listy pól, wynikiem jest warstwa; w przeciwnym razie jest to widok tabeli. Jest to dostępne na każdym poziomie licencji.

Klewis
źródło
Zastanawiam się, czy to przetestowałeś, ponieważ nie widzę sposobu, aby narzędzie Utwórz tabelę zapytań zmieniło kolejność pól - okno dialogowe tego narzędzia wydaje się po prostu pozwalać ci zdecydować, czy pola mają zostać uwzględnione, czy nie.
PolyGeo
Tak, przetestowałem to ze skryptu Python. Wydaje się, że narzędzie zostało zaprojektowane do łączenia lub łączenia wielu tabel. Jestem jednak w stanie utworzyć nową tabelę lub klasę elementów z zmienionymi polami, wprowadzając pojedynczą klasę elementów.
klewis
Muszę coś przeoczyć, więc opublikowałem tutaj nowe pytanie gis.stackexchange.com/questions/32310/... - czy możesz podać mi szczegółowe kroki, które mam dla Ciebie?
PolyGeo
Właśnie odpowiedziałem na nowe pytanie, używając nie tylko MakeQueryTable, ale także CopyFeatures i niewielkiej edycji kodu, który otrzymałem za pomocą opcji Kopiuj jako fragment kodu Pythona w oknie Pythona.
PolyGeo
4

Dzięki narzędziu Scalanie możesz z łatwością na stałe porządkować pola na stałe. Działa z tabelami i klasami funkcji. Zmiana kolejności może odbywać się za pomocą skryptu Python, a nawet za pomocą okna dialogowego Narzędzia (poprzez usunięcie pola i ponowne dodanie go w oknie dialogowym). Chociaż ponowne zamówienie za pośrednictwem okna dialogowego nie jest idealnym podejściem.

Zaleca się jednorazowe użycie narzędzia Scal, a następnie użycie opcji Kopiuj jako fragment kodu w Pythonie, a następnie ręczną zmianę kolejności pól, a następnie wklejenie kodu Pythona w oknach Pythona.

Oto skrypt w języku Python, który używa narzędzia korespondencji seryjnej do zmiany kolejności pól (skopiowane stąd )

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

STOSOWANIE:

new_field_order = ["field2", "field3", "field1"]
reorder_fields(in_fc, out_fc, new_field_order)
Farid Cheraghi
źródło
Wydaje się, że działa to dobrze w oknie narzędzi, w którym najpierw usunąłem pole, które chciałem przesunąć, aby było ostatnim, dodałem nowe pole, a następnie dodałem pole wprowadzania. Jednak, jak powiedziałeś, użycie go w Pythonie jest łatwiejsze niż za pomocą narzędzia, gdy potrzebne jest bardziej złożone ponowne zamówienie.
PolyGeo
3

Istnieje bezpłatne rozszerzenie Esri o nazwie X-Ray, które zawiera narzędzie wykonane w polach Reorder. Sprawdził się doskonale dla nas i jest łatwy w użyciu.

Dodatek rentgenowski do ArcCatalog może służyć do opracowywania, udoskonalania i dokumentowania projektów geobazy

znak
źródło
witamy w GIS Stack Exchange i dziękujemy za podpowiedź. Ponownie sformatowałem twoją odpowiedź, aby była bardziej zgodna ze standardami Stack Exchange - zamieściłem link i cytat na temat produktu oraz usunąłem zbędne informacje.
Stephen Lead
2

Jak dotąd najskuteczniejszą metodą, jaką znalazłem, jest zmiana nazwy pól, zmiana ich domyślnej kolejności, a szereg innych rzeczy to użycie Microsoft Access:

  1. Utwórz nową osobistą geobazę
  2. Przeciągnij i upuść klasę elementów lub tabelę do p-gdb
  3. Otwórz w Access i:
    • Ignorując wszystkie tabele na początku GDB_, otwórz tabele w trybie projektowania tabel
    • zmień nazwę, zmień kolejność, dodaj nowy itp.
  4. Przeciągnij i upuść z powrotem do swojego prawdziwego operacyjnego gdb

Uwagi:

Zawsze miej kopię zapasową prądu. Bałaganisz bezpośrednio wewnętrzną strukturą GDB i możesz z łatwością wyrzucić swoje dane, zmieniając bazę danych do tego stopnia, że ​​ArcGIS nie wie już, jak ją odczytać.

Istnieją pewne zastrzeżone słowa kluczowe po stronie ArcGIS, których nie można używać w nazwach pól. Access z przyjemnością utworzy lub zmieni nazwy pól za pomocą tych słów kluczowych, ale kiedy je przywrócisz, automatycznie dodają podkreślenie. Tak się Currentstaje Current_. Należy również zauważyć częściowo pokrywające się słowa kluczowe zastrzeżone dla programu Access .

Osobisty GDB ma limit wielkości 2 GB, więc całkowity rozmiar wszystkich tabel i klas funkcji w GDB nie może go przekroczyć.

Może być kuszące, aby zawsze używać osobistych GDB do małych projektów (<2 GB). Nie rób Wydajność jest fatalna i istnieją subtelne różnice w składni SQL programu Access, które powodują, że wyrażenia etykiet, zapytania definicji itp. Są nieprzenośne.

matowe wilkie
źródło
oczywiście ta metoda nie jest oficjalnie usankcjonowana, a jeśli coś pójdzie nie tak, nie będziesz mógł zadzwonić do pomocy technicznej;)
Stephen Lead
2

Ten skrypt w Pythonie jest swego rodzaju metodą „taśmy izolacyjnej”. Jest ograniczony do 20 pól, ale można go łatwo dodać, aby umożliwić działanie dla dowolnej liczby pól w danych.

Skrypt został zaprojektowany do uruchamiania jako narzędzie skryptowe, dlatego należy ustawić parametry w ArcCatalog.

Parametry powinny być następujące:

  • InputFC - klasa funkcji
  • Lokalizacja wyjściowa - przestrzeń robocza
  • Nazwa wyjściowa - ciąg
  • Field1 - Field
  • Field2 - Field
  • Aż do Field20

Kod:

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

Zdaję sobie sprawę, że nie jest to najładniejszy ani najwydajniejszy sposób na zrobienie tego, ale tak naprawdę działa całkiem nieźle i napisanie go zajęło około pół godziny. Używam tego cały czas, gdy muszę zmienić kolejność pól i nie wymaga to programu Diagrammer ani Microsoft Access. Oczywiście maksymalna liczba pól może być problemem, ale znowu można ją dostosować w skrypcie.

GeoJohn
źródło