Suite

Comment charger le style de couche de Postgresql avec Python ?

Comment charger le style de couche de Postgresql avec Python ?


Je voudrais écrire une macro python qui, lors de l'ouverture de mon fichier de projet QGIS, rechargera le style par défaut pour chaque couche à partir de la table postgres 'layer_style'. J'ai jeté un œil à la documentation et je ne peux comprendre comment cela se fait qu'à partir d'un fichier sqlite db ou .qml.

Tous les pointeurs seraient appréciés.


Ressusciter le sujet avec QGIS 3.0 :). En regardant leQgsVectorLayerDocumentation API au lieu deQgsMapLayerAPI, vous avez la réponse. Vous pouvez utiliser la méthode saveStyleToDatabase

Il existe des recettes associées pour manipuler les styles dans la base de données PostgreSQL à partir des tests Python de QGIS, notammentsaveStyleToDatabasecas à https://github.com/qgis/QGIS/blob/master/tests/src/python/test_provider_postgres.py#L1553


Comment charger le style de couche de Postgresql avec Python ? - Systèmes d'information géographique

Un chargeur de données géographiques en GML et KML

(qui nécessite une certaine préparation avant le chargement via ogr2ogr)

Auteur : Astun Technology Ltd.

Contact : support [at] astuntechnology.com

Un chargeur GML et KML écrit en Python qui utilise OGR 1.9. Les données sources peuvent être au format GML ou KML (y compris les fichiers compressés au format GZ ou ZIP) et peuvent être sorties dans l'un des formats pris en charge par OGR. Les données source peuvent être préparées à l'aide d'un simple Python pour les rendre adaptées au chargement avec OGR (utile avec des types de fonctionnalités complexes) ou pour ajouter de la valeur en dérivant des attributs.

Le chargeur a été initialement écrit pour charger les données de la couche topographique MasterMap du système d'exploitation Ordnance Survey au format GML/GZ, mais a depuis été utilisé pour charger d'autres données GML et KML.

  • Python 2.6 ou supérieur (y compris 3) est requis. Le plus moderne Linux les systèmes d'exploitation auront déjà la version 2.6 ou supérieure.
  • Module Python lxml pour l'analyse et la manipulation de XML

Les détails de l'installation sont disponibles sur le wiki du projet

Configurez d'abord Loader en modifiant loader.config en spécifiant :

  • src_dir
    • Le répertoire contenant vos fichiers sources ou un fichier individuel. Tous les fichiers pris en charge dans le répertoire spécifié et ses descendants seront chargés.
    • Le répertoire utilisé pour stocker les données traduites si vous écrivez dans un format basé sur un fichier tel que ESRI Shape, MapInfo TAB, etc.
    • Le répertoire utilisé pour stocker les fichiers de travail temporaires pendant le chargement.
    • La commande ogr2ogr qui sera utilisée pour charger les données. Ici, vous pouvez spécifier le format de destination et tous les paramètres associés (par exemple, les détails de connexion à la base de données si vous écrivez sur PostGIS).
    • La commande utilisée pour préparer les données source afin qu'elles conviennent au chargement avec OGR, choisissez-en une qui convient à vos données source, telle que prep_osgml.prep_osmm_topo pour OS MasterMap Topo.
    • Le fichier OGR .gfs utilisé pour définir les attributs d'entité et le type de géométrie des entités lues à partir du GML, choisissez à nouveau un fichier gfs approprié pour vos données source, tel que ../gfs/osmm_topo_postgres.gfs pour charger OS MasterMap Topo dans PostgreSQL.

    Voir python/loader.config pour plus d'explications et de détails sur les jetons disponibles. Les variables d'environnement peuvent être utilisées avec n'importe laquelle des options en utilisant un jeton de la forme : $HOME , $ ou %TEMP% (Windows uniquement)

    Exécutez ensuite à partir de la ligne de commande :

    Des arguments supplémentaires peuvent être passés pour remplacer les valeurs dans le fichier de configuration (utile lors de l'exécution de plusieurs instances du chargeur) par exemple pour spécifier un répertoire source différent ( src_dir ):

    Quelques exemples de configuration sont disponibles sur le wiki du projet

    OS Couche réseau d'eau OSMM

    • Améliorer la prise en charge des éléments qui nécessitent une liste de codes externe en récupérant la liste de codes lorsqu'elle est disponible
    • Prise en charge des attributs nil tels que : <net:inNetwork nilReason="missing" xsi:nil="true" /> , <hy-n:length xsi:nil="true" uom="m" nilReason="missing" />, <water:level xsi:nil="true" nilReason="missing" />`
    • Ajouter un exemple au wiki
    • Spécifiez le fichier gfs via la ligne de commande en utilisant GML_GFS_TEMPLATE path_to_template.gfs
    • Ajouter une exception et un message lorsque les données source sont introuvables
    • Identifiez les erreurs avec les appels de sous-processus et relancez
    • Utiliser la journalisation standard au lieu de l'impression
    • Traitement parallèle, soit :
      • Exécutez les instances loader.py en parallèle, une par cœur, chacune traitant un seul fichier d'entrée
      • Un seul processus loader.py qui génère un processus par type de fonctionnalité
        • Permettrait d'utiliser --config GML_READ_MODE SEQUENTIAL_LAYERS car chaque instance ogr2ogr ne chargerait qu'un seul type de fonctionnalité
        • Lors du chargement, les fonctionnalités de PostgreSQL peuvent potentiellement être redirigées : prepgml4ogr | ogr2ogr | psql

        Améliorations potentielles dues aux modifications de l'OGR

        • Utilisez --config GML_GFS_TEMPLATE path/to/file.gfs pour spécifier le modèle au lieu de copier le fichier modèle pour chaque fichier source (nécessite GDAL 1.9.0)
        • Utilisez --config GML_READ_MODE SEQUENTIAL_LAYERS avec des fichiers GML qui incluent plusieurs types de fonctionnalités qui apparaissent séquentiellement pour éviter que le GML soit analysé plusieurs fois (nécessite GDAL 1.9.0)
        • Utiliser la possibilité d'utiliser les attributs GML comme attributs de fonctionnalité en utilisant la syntaxe [email protected] dans le fichier GFS (et supprimer la logique de préparation pertinente qui crée un élément pour contenir les valeurs d'attribut) (nécessite GDAL 1.11.0)
        • Utilisez /vsigzip/ pour lire directement gz

        MIT, Copyright (c) 2017 Astun Technology Ltd. (http://astuntechnology.com). Voir LICENSE.txt pour les conditions complètes.

        La logique pour appliquer les valeurs style_code et style_description aux données de la couche topographique OSMM est dérivée du projet ESRI UK OSMM-Styling sous licence Apache-2.0.


        Comment améliorer les performances de django bulk_create pour les grands ensembles de données ? (PostgreSQL)

        J'ai de gros fichiers csv avec environ 164 colonnes x 50000 lignes et j'aimerais importer ces fichiers dans une base de données PostgreSQl (12.2).

        En utilisant Django 3.0.7 et Python 3.6.8, j'ai créé un modèle DataRow qui a un champ pour chaque colonne. Lors de l'importation d'un fichier, je le valide d'abord en vérifiant les valeurs manquantes et ainsi de suite. Ensuite, je crée un objet DataRow pour chaque ligne et essaie de tout charger dans la base de données à l'aide de bulk_create . Voici un stylisé version courte de mon code :

        Jusqu'ici ça marche. La validation et l'ajout de tous les objets à data_row_objects prennent environ 8 secondes, ce qui est correct. Cependant, l'instruction bulk_create prend environ 3 minutes, ce qui n'est pas acceptable.

        Alors, comment puis-je améliorer les performances ici ? J'ai déjà essayé d'augmenter/diminuer le batch_size mais 3000 semble être la taille la plus stable jusqu'à présent.

        J'ai également lu sur certains articles ici sur stackoverflow que l'importation d'un fichier csv directement dans la base de données est beaucoup plus rapide. Cependant, je préférerais utiliser uniquement django pur car à mon avis c'est l'un des objectifs exacts de django : éviter la communication directe avec les bases de données.

        Ou dois-je modifier les paramètres de mon PostgreSQL ? C'est peut-être plus lent puisque django et PostgreSQL sont tous deux dans un conteneur docker séparé.

        Pour être honnête il m'est assez difficile de distinguer le goulot d'étranglement de la performance ici car je suis encore un débutant en termes de django et de bases de données. Mais je pense qu'il doit y avoir un moyen rapide et élégant car mes ensembles de données ne sont pas du tout volumineux et l'importation de tels fichiers devrait être une tâche assez courante.


        1 réponse 1

        Le problème dans ce cas était avec mon utilisation de TileMill.

        Lorsqu'une nouvelle couche est créée, le paramètre par défaut de son étendue est de pré-calculer en fonction de la table de base de données utilisée comme entrée. Cela signifie que la couche n'aura jamais que la taille du jeu de données avec lequel elle a été initialement créée.

        Dans ce cas, j'avais itéré sur un sous-ensemble de mes données comme test de mon code et les étendues ont été calculées en fonction des résultats. Lorsque j'ai itéré sur l'ensemble des données, le code a itéré sur l'ensemble de la base de données mais n'affichait que les résultats dans les contraintes calculées précédemment.

        La solution consiste à créer un nouveau calque ou à définir le paramètre d'étendue du calque sur « dynamique » plutôt que sur « pré-calculer »


        Configurer votre projet

        Maintenant que vous avez une base de données spatiale configurée et prête, vous pouvez continuer et configurer votre projet Django. Dans cette section, vous utilisez venv pour créer un environnement virtuel isolé pour votre projet et installer tous les packages requis tels que Django.

        Création d'un environnement virtuel

        Un environnement virtuel vous permet de créer un environnement isolé pour les dépendances de votre projet en cours. Cela vous permettra d'éviter les conflits entre les mêmes packages qui ont des versions différentes.

        Dans Python 3, vous pouvez créer des environnements virtuels à l'aide de virtualenv ou du module venv.

        Pour plus d'informations sur les environnements virtuels Python, consultez Python Virtual Environments : A Primer.

        Maintenant, rendez-vous sur votre terminal et exécutez la commande suivante pour créer un environnement virtuel basé sur Python 3 :

        Ensuite, vous devez activer la commande suivante :

        C'est tout. Votre environnement virtuel est maintenant activé et vous pouvez installer les packages pour votre projet.

        Installation de Django

        La première étape après la création et l'activation d'un environnement virtuel consiste à installer Django. Le package Django est disponible à partir du Python Package Index (PyPI), vous pouvez donc simplement utiliser pip pour l'installer en exécutant la commande suivante dans votre terminal :

        Création d'un projet Django

        Le projet que vous créez est une application web qui répertorie les commerces triés par distance afin que vos utilisateurs puissent découvrir les commerces proches de leur emplacement.

        L'application Web utilise GeoDjango pour mettre en œuvre facilement les exigences de localisation, telles que le calcul des distances des magasins par rapport à l'emplacement de l'utilisateur et la commande des magasins par distance.

        En utilisant GeoDjango, vous pouvez obtenir et afficher les magasins les plus proches qui sont stockés dans une base de données PostgreSQL configurée avec l'extension PostGIS pour permettre les opérations spatiales.

        Maintenant, vous êtes prêt à créer un projet Django en utilisant le script django-admin.py. Exécutez simplement la commande suivante :

        Cela créera un projet nommé nearshops .

        Configuration de la base de données PostgreSQL

        Maintenant que vous avez créé un projet, continuons en configurant la connexion à la base de données spatiale PostgreSQL et PostGIS. Ouvrez le fichier settings.py et ajoutez django.contrib.gis.db.backends.postgis comme moteur avec les informations d'identification pour la base de données PostGIS que vous avez configurée précédemment :

        Noter: Vous devez modifier les informations d'identification de la base de données en conséquence si vous n'avez pas spécifié les mêmes informations d'identification lors de l'exécution du conteneur Docker.

        Si vous essayez d'exécuter votre serveur Django à ce stade, vous obtenez l'erreur ImportError: No module named 'psycopg2' liée à psycopg2 , qui est l'adaptateur PostgreSQL le plus populaire pour Python. Pour résoudre l'erreur, il vous suffit d'installer le psycopg2-binary dans votre environnement virtuel en utilisant les éléments suivants :

        Ajout de GeoDjango

        GeoDjango est un framework qui permet de créer aussi facilement que possible des applications Web SIG et géolocalisées. Vous pouvez l'ajouter en incluant simplement le module gis contrib dans la liste des applications installées.

        Ouvrez le fichier settings.py et localisez le tableau INSTALLED_APPS. Ajoutez ensuite le module 'django.contrib.gis' :


        Comment charger le style de couche de Postgresql avec Python ? - Systèmes d'information géographique

        Visualiseur géographique Python (GeoVis)

        Version : 0.2.0

        Python Geographic Visualizer (GeoVis) est un module de visualisation géographique autonome pour le langage de programmation Python destiné à une utilisation quotidienne facile par les novices et les programmeurs expérimentés. Il a des lignes simples pour visualiser rapidement un fichier de formes, créer et styliser des cartes de base avec plusieurs couches de fichiers de formes et/ou enregistrer dans des fichiers image. Utilise le Tkinter intégré ou d'autres modules de rendu tiers pour faire son travail principal. La version actuelle est fonctionnelle, mais doit être considérée comme un travail en cours avec des bogues potentiels, alors utilisez-la avec précaution. Pour l'instant, ne visualise que les fichiers de formes qui sont dans le système de coordonnées lat/long non projeté.

        • 15 avril 2014 : Publication de la nouvelle v0.2.0, mise à jour majeure.
          • Nouvelles fonctionnalités:
            • Symboliser les fichiers de formes en fonction de leurs attributs et ajouter une légende (catégorique, classes égales, intervalle égal, ruptures naturelles)
            • Choisissez entre plusieurs icônes de symbolisation : cercle, carré, pyramide
            • Zoomez la carte sur une région d'intérêt
            • Dessinez manuellement des géométries de base et écrivez du texte sur la carte
            • Fonctions qui permettent des entrées utilisateur interactives en milieu de script
            • Prise en charge de la version Pillow de PIL et amélioration de la qualité PIL en utilisant l'anticrénelage
            • Modification de la licence MIT pour être plus conviviale pour les contributeurs
            • Créez et stylisez un calque, puis ajoutez-le à la carte, au lieu d'ajouter à la carte directement à partir du fichier
            • La couleur doit maintenant être explicitement définie et n'est plus aléatoire par défaut
            • La prise en charge de PyCairo a été temporairement interrompue en raison de certaines difficultés, il est donc probable qu'il y ait des erreurs
            • Correction d'une erreur avec l'enregistrement interactif de l'image à partir de la fenêtre de visualisation en mode PIL.
            • Découverte et correction d'une erreur d'importation cruciale. - A également étendu le fichier README et l'a converti en démarques, et ajouté une documentation Wiki générée automatiquement.
            • Fonctionnalité de base
            • Une doublure pour la visualisation des fichiers de formes et l'enregistrement de la carte
            • Création de carte personnalisée à plusieurs couches
            • Personnalisez chaque fichier de formes avec les couleurs et la taille de remplissage

            Techniquement parlant, GeoVis n'a pas de dépendances externes, mais il est fortement recommandé d'installer les bibliothèques de rendu Aggdraw, PIL ou PyCairo pour faire le rendu. GeoVis détecte automatiquement le module de rendu dont vous disposez et utilise le premier qu'il trouve dans l'ordre suivant (aggdraw, PIL, pycairo). Si vous souhaitez choisir manuellement un moteur de rendu différent, cela doit être spécifié pour chaque session. Si aucun de ces éléments n'est disponible, GeoVis utilisera par défaut le Tkinter Canvas intégré comme moteur de rendu, mais en raison de limitations majeures, cela n'est pas recommandé pour afficher des fichiers de formes plus volumineux.

            Devrait fonctionner sur Python version 2.x et Windows. N'a pas encore été testé sur Python 3.x ou d'autres systèmes d'exploitation.

            Les contributeurs sont recherchés et nécessaires, donc ce code est libre de partager, d'utiliser, de réutiliser et de modifier selon la licence MIT, voir license.txt

            1. Téléchargez GeoVis, depuis a ou b :
            • a) La version stable la plus récente de la page des versions (recommandé).
            • b) La version "bleeding edge" en utilisant le bouton "download zip" à droite du dossier principal du référentiel.
            1. Installez-le en utilisant a ou b :
            • a) Placez le dossier geovis dans votre dossier Python site-packages pour une installation "permanente".
            • b) Ou commencez chaque session en tapant import sys et sys.path.append("chemin du dossier où se trouve le dossier geovis") .

            En supposant que vous l'ayez déjà installé comme décrit dans la section Installation, GeoVis est importé en tant que :

            Pour commencer à utiliser geovis, consultez la liste complète des commandes dans le USER_MANUAL ou continuez à lire ci-dessous pour une introduction de base.

            Si vous souhaitez simplement inspecter un fichier de formes de manière interactive, ou pour voir comment votre fichier de formes traité s'est avéré, alors vous le faites avec une simple ligne :

            Si vous souhaitez rapidement montrer votre shapefile à quelqu'un d'autre par e-mail ou sur un forum, vous pouvez tout aussi facilement enregistrer votre map dans une image en cliquant sur le bouton "enregistrer l'image" dans la fenêtre interactive de visualisation ou avec la ligne suivante :

            Il est également possible de créer votre carte à partir de zéro afin de créer une carte plus attrayante visuellement.

            Commencez par configurer et créer une instance newmap :

            Ensuite, chaque fichier de formes doit être chargé et symbolisé dans des instances de couche :

            Si vous le souhaitez, vous pouvez également visualiser les attributs sous-jacents de votre couche en ajoutant une ou plusieurs classifications. Par exemple, la couche de points de sortie peut varier de petite à grande taille et de couleur verte à rouge en fonction de son attribut "population":

            Dans ce cas, vous souhaiterez probablement ajouter une légende afin de voir quels symboles représentent quelles valeurs. Plaçons-le dans le coin supérieur gauche de la carte :

            Enfin, rendez les couches dans l'instance newmap :

            Pour une touche finale, ajoutez un titre de carte centré en haut :

            Si vous avez plus d'un moteur de rendu et que vous souhaitez choisir celui à utiliser, par exemple PIL, vous devez le faire au début de chaque session (également, si vous optez pour une vitesse maximale/une qualité moindre, activez la réduction du nombre de vecteurs pendant que vous y êtes, bien que cela ne soit pas recommandé pour les fichiers de forme de ligne):

            Par défaut, la carte que vous créez affichera le monde entier. Pour zoomer la carte sur une zone ou une région d'intérêt particulière, il vous suffit de définir l'étendue du zoom de la carte, ce qui doit être fait avant d'ajouter vos couches :

            Il existe plusieurs façons de jouer avec les couleurs de votre carte. L'outil de stylisation le plus basique que vous voudrez connaître est le créateur de couleur (un wrapper autour du module Color de Valentin Lab avec une fonctionnalité de commodité supplémentaire). Vous pouvez soit créer une couleur aléatoire :

            Ou vous pouvez créer une couleur spécifique comme vous l'imaginez dans votre tête en écrivant le nom de la couleur et en modifiant éventuellement l'intensité et la luminosité de la couleur (valeur flottante entre 0 et 1). Créons un rouge fort (forte intensité) mais sombre (faible luminosité) :

            Alternativement, au lieu de créer une couleur très spécifique, vous pouvez créer une couleur aléatoire qui reste dans certaines limites. Par exemple, spécifier une faible valeur de luminosité et une faible valeur d'intensité mais ne pas spécifier de nom de couleur produira une couleur mate aléatoire. Mieux encore, vous pouvez définir l'argument de style sur "mat" (parmi de nombreux autres noms de style, consultez la documentation pour la liste complète) qui choisit automatiquement la luminosité et l'intensité pour vous :

            En supposant que vous sachiez maintenant définir vos propres couleurs ou styles de couleurs, ces couleurs sont utiles car elles peuvent être utilisées pour spécifier la couleur d'un nombre quelconque d'options de symboles passées en tant qu'arguments de mot-clé aux différentes fonctions de rendu de GeoVis (voir la documentation pour liste des options de symboles modifiables). Par exemple, enregistrons une image de fichier de formes comme auparavant, mais cette fois, définissez la couleur de remplissage des polygones/lignes/cercles du fichier de formes sur notre rouge foncé-fort que nous avons défini précédemment. De plus, nous augmenterons la largeur du contour pour correspondre à la couleur de remplissage forte (nous laissons le contour Couleur à son noir par défaut car cela correspond à la carte):

            Parfois, il est nécessaire de créer rapidement une galerie d'images de tous vos shapefiles dans un répertoire donné. GeoVis fournit un outil utilitaire général qui peut vous aider à le faire, il parcourt, analyse et renvoie le nom de dossier, le nom de fichier et l'extension de tous les fichiers de formes dans une arborescence de dossiers, qui à son tour peuvent être utilisés comme entrée pour la fonction SaveShapefileImage. Ainsi, par exemple, nous pouvons l'écrire comme :

            Le nom de fichier, le dossier parent et l'extension de fichier peuvent être utilisés pour effectuer de nombreuses autres opérations par lots, telles que placer chaque image de carte à côté (dans le même dossier que) chaque fichier de formes.

            Cette brève introduction n'a couvert que les fonctionnalités les plus essentielles de GeoVis. Si vous avez besoin de plus d'informations ou rencontrez des problèmes avec une fonction particulière, vous pouvez rechercher la documentation complète des fonctions, classes et arguments disponibles en tapant help(geovis) ou en consultant le USER_MANUAL.

            Si vous avez toujours besoin d'aide, vous pouvez soit soumettre un problème ici sur GitHub, soit me contacter directement à l'adresse : [email protected]

            Je salue tout effort pour contribuer à ce projet. Vous trouverez ci-dessous une liste des problèmes et limitations actuels que j'espère modifier dans les prochaines versions :

            • Les fichiers de formes doivent être en coordonnées lat/long (c'est-à-dire non projetés) afin d'être affichés correctement. C'est-à-dire que GeoVis ne gère pas encore les projections ou la transformation de coordonnées.
            • Actuellement, le zoom à une échelle locale peut être rendu beaucoup plus efficace en utilisant l'indexation spatiale telle que QuadTree.
            • Je n'ai pas encore compris comment transmettre les images rendues par PyCairo à la fenêtre Tkinter pour les afficher, donc pour l'instant, cela entraîne une erreur.
            • Actuellement, n'a pas été testé avec, et ne fonctionnera probablement pas dans Python 3.x en raison de modifications de syntaxe, vous devriez donc chercher à résoudre ce problème.

            GeoVis n'aurait pas pu être réalisé sans l'excellent travail d'autres modules open source qu'il utilise en coulisse :


            Comment charger le style de couche de Postgresql avec Python ? - Systèmes d'information géographique

            Ce projet se compose d'un certain nombre de scripts SQL et d'autres fichiers de support pour l'importation de certains ensembles de données récents du recensement américain dans une base de données PostgreSQL. Les ensembles de données d'intérêt sont le recensement décennal et l'American Community Survey (ACS) annuel. Il existe deux types de scripts :

            1. Scripts qui créent le schéma de données nécessaire, chargent en bloc les données pour importer des tables et les forcent à prendre leur forme finale
            2. Des méta-scripts, des scripts qui créent des fonctions qui génèrent les scripts de création de schéma et d'importation de données.

            La définition des données et les scripts de manipulation des données apparaissent dans les dossiers nommés pour des produits de recensement spécifiques (par exemple, 2010_5yr). Les méta-scripts apparaissent dans le dossier méta-scripts. Mon souhait est de rendre les scripts de création de schéma et d'importation de données (le premier type de script) conformes à la norme SQL, afin qu'ils puissent être utilisés dans d'autres implémentations SQL que Postgres. Comme les méta-scripts (le deuxième type de script) reposent sur PL/pgSQL, je doute qu'ils puissent être convertis en implémentation indépendante. Je serais plus susceptible de les réécrire en Python ou dans un autre langage.

            Le gestionnaire de données a le choix d'exécuter directement les scripts d'import de données ou d'exécuter d'abord les méta-scripts. Si les méta-scripts sont exécutés, ils créeront par programmation et exécuteront éventuellement le script généré. La première option (exécuter des scripts spécifiques à chaque produit de recensement) est probablement conceptuellement plus facile à comprendre. La deuxième option est plus puissante, car elle donne au gestionnaire de données plus de contrôle sur le processus d'importation (par exemple, n'importer que certains états ou séquences - le même effet en utilisant les scripts d'importation de données nécessite de rechercher dans le script des lignes de code spécifiques à exécuter ou exclure).

            Divers produits de données de recensement sont disponibles via HTTP sur www2.census.gov ou via FTP anonyme sur ftp2.census.gov. Un client FTP facilitera le téléchargement d'un grand nombre de fichiers ou de dossiers entiers. L'utilisation de HTTP peut être fastidieuse à moins que, au lieu d'un navigateur Web, vous utilisiez un programme d'assistance tel que wget. Par exemple:

            récupérera tous les fichiers associés au produit ACS 2010 sur 5 ans. Notez qu'avec ACS 2011, le Census Bureau a facilité le téléchargement de l'intégralité du produit de données dans deux fichiers TAR géants. Auparavant, ils l'avaient rendu disponible sous forme de deux fichiers ZIP géants, mais j'ai toujours eu du mal à les décompresser avec succès.

            Chaque produit de données (par exemple, American Community Survey 2006-2010) peut être considéré comme un seul gros fichier, mais les données sont divisées horizontalement par état et sont séparées verticalement en « segments » (dans le recensement décennal) ou « séquences » (dans l'ACS ) de moins de 256 colonnes chacune. Cela crée un nombre extrêmement important de tables qui doivent être chargées en bloc. Ces routines d'importation supposent que tous les fichiers du recensement décennal seront stockés dans un seul répertoire. Les données ACS sont séparées en grandes et petites zones géographiques, mais les noms de fichiers sont réutilisés pour les grandes et les petites zones géographiques. Afin de les distinguer, les routines d'importation supposent que les deux types de fichiers sont séparés dans des répertoires nommés All_Geographies_Not_Tracts_Block_Groups et Tracts_Block_Groups_Only. Dans chaque cas, le nom du répertoire parent doit correspondre au nom du schéma de base de données où les données seront stockées. Je nomme les schémas d'après le nom du dossier des ensembles de données sur le serveur FTP du Census Bureau, par ex. acs2010_5yr.

            Les scripts de données doivent être exécutés dans un ordre spécifique. Ils généreront des tables de stockage, des tables intermédiaires (temp) et des vues qui reflètent les "tables de sujet" du recensement, ainsi que l'importation des données.

            Les noms de table et de vue dans ces scripts sont ne pas qualifié par le schéma, permettant au gestionnaire de données de choisir son propre nom de schéma. Comme mentionné ci-dessus, j'utilise un nom de schéma basé sur les noms de dossier du serveur FTP du Census Bureau. En supposant que vous fassiez de même, chaque script doit être précédé de

            Si vous voulez éviter de modifier chaque script, SET search_path une fois dans psql, puis i chaque fichier de script.

            Les scripts DROP et CREATE TABLE sont séparés afin que les ensembles de données à moitié chargés ne soient pas accidentellement supprimés et que les données puissent être chargées par lots. Le processus de travail peut consister à importer un état entier ou un groupe d'états dans les tables de transfert, à transférer les données dans les tables de stockage finales, puis à supprimer toutes les tables de transfert. Lors de l'importation d'un autre lot, recréez les tables intermédiaires.

            Ces scripts peuvent être exécutés dans n'importe quel ordre.

            • create_tmp_geoheader.sql (contient l'instruction DROP … IF EXISTS)
            • drop_import_tables.sql
            • create_import_tables.sql
            • drop_import_moe.sql
            • create_import_moe.sql

            Ces scripts utilisent des instructions COPY pour effectuer l'importation réelle des données, bien que vers les tables de transfert, et non vers la destination finale. COPY requiert que les fichiers soient sur le propre système de fichiers du serveur (contrairement à psql copy). Étant donné que ces ensembles de données sont volumineux, c'est probablement une bonne idée de toute façon.

            Ces scripts utilisent des barres obliques pour représenter les séparateurs de système de fichiers. Les tests sur Windows Vista indiquent que les barres obliques seront interprétées correctement. Les barres obliques inverses, si elles sont utilisées, sont traitées comme des caractères d'échappement et doivent être doublées.

            Ces scripts contiennent un espace réservé pour le système de fichiers "<census_upload_root>". Cet espace réservé doit être mis à jour pour refléter votre système de fichiers. Ce dossier doit avoir un enfant nommé acs2010_5yr. Le dossier acs2010_5yr doit avoir deux enfants. Comme mentionné ci-dessus, les fichiers téléchargés à partir du recensement doivent se trouver dans deux répertoires frères nommés All_Geographies_Not_Tracts_Block_Groups et Tracts_Block_Groups_Only.

            Les fichiers de géo-en-tête utilisent un format de longueur fixe et sont donc importés dans une table avec une seule colonne. Cette colonne est ensuite analysée pour être insérée dans la table d'en-tête géo finale. Les fichiers de géo-header contiennent tous géographiques, qu'elles soient téléchargées avec des ensembles de données plus grands ou plus petits (zones et groupes de blocs uniquement). Ces scripts supposent l'existence du dossier All_Geographies_Not_Tracts_Block_Groups. Si vous n'avez téléchargé que les tracts et groupes de blocs, vous devrez modifier le script ou créer le dossier attendu et déplacer les fichiers géographiques (g20105xx.txt).

            Des méta-scripts (à paraître plus tard) faciliteront l'importation des états ou des séquences sélectionnés. Pour l'instant, le gestionnaire de données devra sélectionner manuellement les états et séquences souhaités à partir de ces fichiers.

            Ces scripts peuvent être exécutés dans n'importe quel ordre.

            En ce moment, j'expérimente trois formats de stockage différents. Le seul qui est terminé stocke chaque séquence dans sa propre table de base de données. Les deux autres options combinent toutes les séquences dans une seule table, mais, en raison de la limite de Postgres de

            2000 colonnes dans une table, utilisez des colonnes de tableau (une par séquence) ou une colonne hstore pour stocker les données. Pour plus d'informations sur l'état de ces options, voir ci-dessous.

            Les chercheurs interagiront généralement avec les données via un « tableau de sujets », une collection de données connexes. Souvent, un tableau de sujets divisera la population en catégories (par exemple, l'âge et le sexe) et comprendra des colonnes récapitulatives (par exemple, population totale, population masculine, population féminine). Les données sont stockées par séquences (à l'exception de hstore, qui pousse l'ensemble de données entier dans deux colonnes), de sorte que les tables de sujets sont construites sous forme de vues. Les définitions de vue dépendront bien sûr de la méthode de stockage de données choisie. Actuellement, les vues ne sont définies que pour le magasin de données basé sur une table.

            Si vous suivez l'approche d'une grande table, les colonnes d'en-tête géographique apparaissent comme les premières colonnes de ces tables. Néanmoins, les scripts CREATE TABLE reposent sur l'existence d'un géoheader (en utilisant le mot-clé LIKE), donc create_geoheader.sql doit être exécuté dans tous les cas.

            Après l'exécution, tmp_geoheader peut être TRUNCATE ou DROPped, de sorte que lorsque des données supplémentaires sont importées, parse_tmp_geoheader.sql ne tente pas de créer des enregistrements en double (ce qui échouera en raison d'une violation de PRIMARY KEY).

            Créer un magasin de données basé sur une table

            Ces scripts créent deux tables pour chaque séquence, une avec des estimations (nommée seqnnnn) et une avec des marges d'erreur (nommée seqnnnn_moe). Les noms de colonne sont uniques (la marge des tables d'erreur a _moe à la fin des noms de colonne) à l'exception des champs clés afin que les tables puissent être jointes sans conflit ni confusion. Ces scripts doivent être exécutés dans cet ordre.

            Parse_tmp_geoheader.sql peut être exécuté à tout moment. Les autres scripts doivent être exécutés dans l'ordre.

            • parse_tmp_geoheader.sql
            1. store_by_tables.sql
            2. store_moe_by_tables.sql
            3. insert_into_tables.sql
            4. insert_into_moe.sql
            5. view_estimate_stored_by_tables.sql
            6. view_moe_stored_by_tables.sql

            Créer un magasin de données basé sur des colonnes de tableau

            Pour le moment, la table des colonnes du tableau est nommée by_arrays. Lorsque ce projet dépassera la phase expérimentale, un nom moins idiot sera choisi. Tout d'abord, créez la table. Cette table n'aura aucune ligne jusqu'à ce que parse_tmp_geoheader soit exécuté, modifié en INSERT INTO by_arrays. Ensuite, les séquences peuvent être insérées, en utilisant UPDATE pour faire correspondre les données de séquence avec les données de géo-en-tête existantes. La marge des données d'erreur n'est pas encore gérée.

            1. store_by_array_columns.sql
            2. parse_tmp_geoheader.sql
            3. insert_into_array_columns.sql

            Créer un magasin de données basé sur des colonnes Hstore

            Pour le moment, la table hstore est nommée by_hstore. Lorsque ce projet dépassera la phase expérimentale, un nom moins idiot sera choisi. Tout d'abord, créez la table. Cette table n'aura aucune ligne jusqu'à ce que parse_tmp_geoheader soit exécuté, modifié en INSERT INTO by_hstore. Contrairement à by_arrays, aucun script n'existe actuellement pour insérer des données de séquence. Comme avec by_arrays, le script utilisera UPDATE pour faire correspondre les données de séquence avec les données de géo-en-tête existantes.

            1. store_by_hstore.sql
            2. parse_tmp_geoheader.sql
            3. insert_into_hstore.sql N'existe pas encore

            La méthode de stockage basée sur les colonnes du tableau et la méthode de stockage basée sur hstore doivent être terminées. Ensuite, je souhaite tester des extraits et des calculs typiques par rapport aux différentes méthodes de stockage, pour voir laquelle fonctionne le mieux.

            Le partitionnement peut améliorer la vitesse des requêtes. S'il est partitionné par état, il peut également faciliter le chargement en bloc. Cela devrait faire l'objet d'une enquête.


            Conclusion

            L'utilisation de la prise en charge intégrée de PyQt&rsquos pour travailler avec des bases de données SQL est une compétence importante pour tout développeur Python qui crée des applications d'interface graphique PyQt et doit les connecter à une base de données. PyQt fournit un ensemble cohérent de classes pour la gestion des bases de données SQL.

            Ces classes s'intègrent entièrement à l'architecture PyQt&rsquos Model-View, vous permettant de développer des applications GUI capables de gérer des bases de données de manière conviviale.

            Dans ce didacticiel, vous avez appris à :

            • Utiliser PyQt&rsquos Prise en charge de SQL se connecter à une base de données
            • Exécuter Requêtes SQL sur une base de données avec PyQt
            • Créer des applications de base de données à l'aide de PyQt&rsquos Architecture modèle-vue
            • Afficher et modifier les données d'une base de données à l'aide de PyQt widgets

            Avec ces connaissances, vous pouvez améliorer votre productivité lors de la création d'applications de base de données non triviales et rendre vos applications GUI plus robustes.

            Obtenez un court & doux Astuce Python livré dans votre boîte de réception tous les deux jours. Jamais de spam. Désabonnez-vous à tout moment. Organisé par l'équipe Real Python.

            À propos de Leodanis Pozo Ramos

            Leodanis est un ingénieur industriel qui aime Python et le développement logiciel. Il est un développeur Python autodidacte avec plus de 5 ans d'expérience.

            Chaque tutoriel de Real Python est créé par une équipe de développeurs afin qu'il réponde à nos normes de qualité élevées. Les membres de l'équipe qui ont travaillé sur ce tutoriel sont :

            Maître Compétences Python du monde réel Avec un accès illimité à Real Python

            Rejoignez-nous et accédez à des centaines de tutoriels, à des cours vidéo pratiques et à une communauté d'experts Pythonistas :

            Maître Compétences Python du monde réel
            Avec un accès illimité à Real Python

            Rejoignez-nous et accédez à des centaines de didacticiels, de cours vidéo pratiques et à une communauté d'experts Pythonistas :

            Politique de commentaires de Python réel : The most useful comments are those written with the goal of learning from or helping out other readers—after reading the whole article and all the earlier comments. Complaints and insults generally won’t make the cut here.

            What’s your #1 takeaway or favorite thing you learned? How are you going to put your newfound skills to use? Leave a comment below and let us know.


            4 réponses 4

            General answer

            First, I want to address ambiguity in the premise:

            It is common to use parameters in the WHERE part of queries, and to have some computed columns in the SELECT part, but not that common to parameterize the ORDER BY clause.

            Computed columns in the SELECT part are hardly ever relevant for the query plan or performance. Mais "in the WHERE part" is ambiguous.

            It's common to parameterize valeurs in the WHERE clause, which works for prepared statements. (And PL/pgSQL works with prepared statements internally.) A generic query plan often makes sense regardless of provided valeurs. That is, unless tables have a very uneven data distribution, but since Postgres 9.2 PL/pgSQL re-plans queries a couple of times to test whether the generic plan seems good enough:

            But it's not as common to parameterize whole predicates (including identifiants) in the WHERE clause, which is impossible with prepared statements to begin with. You need dynamic SQL with EXECUTE , or you assemble the query strings in the client.

            Dynamic ORDER BY expressions are somewhere in between both. Toi pouvez do it with a CASE expression, but that's very hard to optimize in general. Postgres might use indexes with a plain ORDER BY , but not with CASE expressions hiding the eventual sort order. The planner is smart, but not an AI. Depending on the rest of the query ( ORDER BY may be relevant for the plan or not - it's relevant in your example), you may end up with a sub-optimal query plan all the time.
            Plus, you add the minor cost of the CASE expression(s). And in your particular example also for multiple useless ORDER BY columns.

            Typically, dynamic SQL with EXECUTE is faster or much faster for this.

            Maintainability should not be a problem if you maintain a clear and readable code format in your function body.

            Fix demo function

            The function in the question is cassé. The return type is defined to return an anonymous record:

            But the query actually returns a set of records, it would have to be:

            But that's still unhelpful. You'd have to provide a column definition list with every call. Your query returns columns of well-known type. Declare the return type accordingly! I am guessing here, use actual data types of returned columns / expressions:

            I use the same column names for convenience. Columns in the RETURNS TABLE clause are effectively OUT parameters, visible in every SQL statement in the body (but not inside EXECUTE ). So table-qualify columns in queries in the function body to avoid possible naming conflicts. The demo function would work like this:

            Do not confuse the RETURNS key word in the function declaration with the plpgsql RETURN command like Evan did in his answer. Détails:

            General difficulty of the example query

            Predicate on certains columns (even worse: gamme predicates), autre columns in ORDER BY , that's already hard to optimize. But you mentioned in a comment:

            Actual result sets can be in the order of several 1.000 rows (and thus, sorted and paginated in smaller chunks server-side)

            So you'll add LIMIT and OFFSET to these queries, returning the m "best" matches first. Or some smarter pagination technique:

            Toi besoin a matching index to make this fast. I don't see how this could possibly work with CASE expressions in ORDER BY .


            MapFish Technologies¶

            MapFish JavaScript Toolbox¶

            MapFish JavaScript Toolbox is composed of four JavaScript libraries: ExtJS, OpenLayers, GeoExt and MapFish. The functionality of all these libraries will be highlighted with some example code.

            ExtJS¶

            Ext JS is a cross-browser JavaScript library for building rich internet applications. It provides a very large list of UI components.

            Some editors can help to create ExtJS UI: GUI Builder or GUI Designer. To know more about this technology, you can follow the ExtJS tutorial.

            In order to play with ExtJS, it is needed to reference the ExtJS library and the associated css (more information here: Get Prepared with ExtJS). For simplicity, we have prepared an accessible build with CacheFly.

            Then, simply add the following code in the html page:

            Ext “Hello World”¶

            Create your own html page with the following code extjs_hello_world.html. If you open it in a browser, you should get a message “Hello World! You have ExtJS configured correctly!”

            Ext.Viewport¶

            The Viewport renders itself to the document body, and automatically sizes itself to the size of the browser viewport and manages window resizing. There may only be one Viewport created in a page. Let’s have a look at the configuration of a viewport:

            Ext.grid.GridPanel¶

            OpenLayers¶

            OpenLayers makes it easy to put a dynamic map in any web page. Il peut afficher des tuiles de carte et des marqueurs chargés à partir de n'importe quelle source.

            Have a look at the OpenLayers examples to see the power of this library.

            In order to play with OpenLayers, it is needed to reference the OpenLayers library.