Réorganiser les champs (en permanence) dans la géodatabase fichier à l'aide d'ArcGIS Desktop?

18

À l'aide d'ArcGIS 10.0, est-il possible de réorganiser les champs dans une géodatabase fichier et de conserver l'ordre dans la base de données?

Nous avons envisagé d'exporter vers XML et d'écrire un analyseur pour modifier l'ordre des champs, puis de recréer une nouvelle base de données à partir du XML. Cela semble être un processus laborieux.

Une autre idée est d'importer les définitions de champs existantes dans Excel, de les réorganiser, d'exporter vers CSV, puis d'écrire un script Python pour créer ces champs dans une nouvelle géodatabase. Existe-t-il un script comme celui-ci, avant de l'écrire à partir de zéro?

Malheureusement, ArcGIS Diagrammer ne semble pas prendre en charge la réorganisation des champs.

Existe-t-il des scripts ou des hacks que nous pourrions utiliser pour simplifier ce processus?

arcgis-desktop  arcgis-10.0  esri-geodatabase  arccatalog  schema-architecture 
— Stephen Lead
source
8
J'espère que vous avez voté sur ideas.arcgis.com/ideaView?id=0873000000087wgAAA :-)
— PolyGeo
Vous pouvez réorganiser les champs dans ArcGIS Diagrammer, allez simplement dans la collection de champs et sélectionnez le champ et appuyez sur les flèches haut / bas.
— blah238
@ blah238 si vous pouvez ajouter cela comme réponse, je l'accepterai. Cela fonctionne très bien et est semi-soutenu par Esri depuis qu'un de leurs gars l'a écrit
— Stephen Lead
1
voici la vidéo de démonstration - maps.esri.com/Diagrammer/reorderfields.htm
— Geog

Réponses:

6

Comme mentionné dans les commentaires, vous pouvez réorganiser les champs avec ArcGIS Diagrammer. J'ai posté une étape plus générale dans cette réponse: Comment mettre à jour la propriété length d'un champ de classe d'entités?

— blah238
source
Merci. ArcGIS Diagrammer est un tout petit peu instable - il ne plante pas exactement, mais il semble parfois fait maison. Mais pour modifier le schéma, cela semble être la meilleure option.
— Stephen Lead
Peut maintenant fonctionner après 10.0. Il s'est installé correctement pour moi sur Win7 x64 avec ArcGIS 10.1, mais lors de son exécution, il crache des erreurs de compilation Just In Time et se ferme.
— matt wilkie
1
Il convient de noter qu'ArcGIS Diagrammer ne fonctionne plus avec ArcGIS 10.3 ou version ultérieure.
— Map Man
7

En réponse à une autre question, j'ai dit qu'il était possible d'utiliser des statistiques récapitulatives pour faire l'équivalent de PULLITEMS (ancien parler pour les champs de réorganisation). Cette technique fonctionne bien sur les tables uniquement, mais il existe un autre script maintenant qui indique qu'il fonctionne à la fois sur les classes d'entités et sur la table.

Je recommanderais également les champs Répondre à la réorganisation en permanence à l'aide de l'outil ArcGIS Make Query Table? qui a été inspiré par la réponse de @klewis à celle-ci.

— PolyGeo
source
6

La version gratuite de ET Geowizards fera cela. De base -> Trier les formes. Je viens de le tester sur une géodatabase fichier v10 et cela fonctionne. Il doit cependant créer une nouvelle classe d'entités.

— pgager
source
5

Si vous n'avez pas Visio pour Diagramer - Toutes les autres réponses ici interrompent les jointures. J'ai trouvé que cela fonctionnait bien dans mon cas:

  1. Exportez le schéma pour la base de données entière en utilisant Arccatalog (Export - XML) - Je n'ai pas exporté les données, le schéma uniquement
  2. Utilisez un service Pretty Print en ligne pour formater le xml Ouvrez le fichier XML dans un éditeur de texte et réorganisez les champs comme vous le souhaitez
  3. Réimportez le schéma pour créer une nouvelle base de données
  4. Recharger les données en utilisant la base de données d'origine comme source
— Ozmo
source
J'ai rejeté cela dans la question d'origine comme "un processus laborieux" - mais en fait, quand vous le posez comme ça, cela ne semble pas trop mal;)
— Stephen Lead
4

Vous devez exécuter MakeTableQuery à partir du jeu d'outils Couches et vues de tableau pour réorganiser les champs. Dans la documentation, l'ordre des champs dans la liste des champs indique l'ordre dans lequel les champs apparaîtront dans la couche de sortie ou la vue tabulaire. De plus, si une colonne Forme est ajoutée à la liste des champs, le résultat est un calque; sinon, c'est une vue de table. Ceci est disponible avec n'importe quel niveau de licence.

— klewis
source
Je me demande simplement si vous avez testé cela, car je ne vois pas comment l'outil Créer une table de requêtes peut réorganiser les champs - sa boîte de dialogue semble vous laisser décider si les champs doivent être inclus ou non.
— PolyGeo
Oui, je l'ai testé à partir d'un script Python. L'outil semble être conçu pour combiner ou joindre plusieurs tables. Cependant, je peux créer une nouvelle table ou classe d'entités avec des champs réorganisés en saisissant une seule classe d'entités.
— klewis
Je dois manquer quelque chose, j'ai donc posté une nouvelle question ici gis.stackexchange.com/questions/32310/… - pouvez-vous détailler les étapes pour moi, s'il vous plaît?
— PolyGeo
Je viens de répondre à la nouvelle question en utilisant non seulement MakeQueryTable mais aussi CopyFeatures et quelques modifications mineures du code que j'ai obtenues en utilisant Copier en tant qu'extrait Python dans la fenêtre Python.
— PolyGeo
4

Avec l' outil de fusion , vous pouvez facilement réorganiser les champs de façon permanente. Il fonctionne avec des tables et des classes d'entités. La réorganisation peut être effectuée via un script python et même avec la boîte de dialogue Outil (en supprimant un champ et en l'ajoutant à nouveau dans la boîte de dialogue). Bien que la réorganisation via la boîte de dialogue ne soit pas une approche parfaite.

Il est recommandé d'utiliser l'outil de fusion une fois, puis d'utiliser Copier comme extrait de code Python , puis de modifier manuellement l'ordre des champs, puis de coller le code Python dans les fenêtres Python.

Voici un script python qui utilise l'outil de fusion pour réorganiser les champs (copié à partir d' ici )

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

USAGE:

new_field_order = ["field2", "field3", "field1"]
reorder_fields(in_fc, out_fc, new_field_order)
— Farid Cheraghi
source
Cela semble bien fonctionner dans la boîte de dialogue de l'outil où j'ai d'abord supprimé un champ que je voulais déplacer pour être le dernier, j'ai ajouté un nouveau champ, puis j'ai ajouté un champ de saisie. Cependant, comme vous l'avez dit, son utilisation en Python est plus facile que via l'outil lorsqu'une réorganisation plus complexe est nécessaire.
— PolyGeo
3

Il existe une extension gratuite d'Esri appelée X-Ray qui contient un outil conçu pour réorganiser les champs. A fonctionné très bien pour nous et est facile à utiliser.

Le complément X-Ray pour ArcCatalog peut être utilisé pour développer, affiner et documenter vos conceptions de géodatabase

— marque
source
bienvenue à GIS Stack Exchange, et merci pour l'astuce. J'ai reformaté votre réponse pour qu'elle soit plus conforme aux normes Stack Exchange - j'ai inclus un lien et un devis sur le produit et supprimé les informations superflues.
— Stephen Lead
2

Jusqu'à présent, la méthode la plus efficace que j'ai trouvée pour renommer les champs, modifier leur ordre par défaut et un certain nombre d'autres choses consiste à utiliser Microsoft Access:

  1. Créer une nouvelle géodatabase personnelle
  2. Faites glisser et déposez la classe d'entités ou la table dans le p-gdb
  3. Ouvert dans Access et:
    • Ignorer toutes les tables commençant GDB_, ouvrez les tables en mode de conception de table
    • renommer, modifier l'ordre, ajouter un nouveau, etc.
  4. Glissez-déposez vers votre véritable gdb opérationnel

Remarques:

Ayez toujours une sauvegarde de courant. Vous jouez directement avec la structure GDB interne et vous pouvez facilement mettre vos données à la poubelle en modifiant la base de données au point qu'ArcGIS ne sait plus comment la lire.

Certains mots clés réservés du côté ArcGIS ne peuvent pas être utilisés pour les noms de champ. Access se fera un plaisir de créer ou de renommer des champs avec ces mots-clés, mais lorsque vous les ramenez, un trait de soulignement est automatiquement ajouté. Ainsi Currentdevient Current_. Notez également les mots-clés réservés Access qui se chevauchent partiellement .

Les GDB personnels ont une limite de taille de fichier de 2 Go, donc la taille totale de toutes les tables et classes d'entités au sein de la GDB ne peut pas dépasser cela.

Il peut être tentant de toujours utiliser des GDB personnels pour les petits projets (<2 Go). Non. Les performances sont abyssales et il existe de subtiles différences dans la syntaxe SQL d'Access qui rendent les expressions d'étiquette, les requêtes de définition, etc. non portables.

— Matt Wilkie
source
bien sûr, cette méthode n'est pas officiellement sanctionnée, et si quelque chose ne va pas, vous ne pourrez pas appeler le support technique;)
— Stephen Lead
2

Ce script Python est une sorte de méthode "ruban adhésif" pour ce faire. Il est limité à 20 champs mais pourrait facilement être ajouté afin de lui permettre de s'exécuter pour autant de champs que vos données.

Le script est conçu pour être exécuté comme un outil de script, vous devez donc configurer les paramètres dans ArcCatalog.

Les paramètres doivent être les suivants:

  • InputFC - Classe d'entités
  • Emplacement de sortie - Espace de travail
  • Nom de sortie - chaîne
  • Field1 - Field
  • Field2 - Field
  • Jusqu'au Field20

Code:

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

Je me rends compte que ce n'est pas la façon la plus jolie ou la plus efficace de le faire, mais cela fonctionne plutôt bien et n'a pris qu'une demi-heure à écrire. Je l'utilise tout le temps lorsque j'ai besoin de réorganiser des champs, et cela ne nécessite pas Diagrammer ou Microsoft Access. Bien sûr, le nombre maximum de champs peut être un problème, mais encore une fois, il peut être personnalisé dans le script.

— GeoJohn
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.