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
— 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
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.