Module plume.pg.queries#

Requêtes prêtes à être envoyées au serveur PostgreSQL.

Ce module suppose l’usage de la bibliothèque Psycopg pour la communication avec le serveur PostgreSQL.

Il génère des requêtes à exécuter avec la méthode psycopg2.cursor.execute(). Ces requêtes - objets PgQueryWithArgs - sont auto-suffisantes, dans le sens où elles incluent tous les paramètres nécessaires.

La syntaxe pour l’usage de ces requêtes est toujours :

>>> cur.execute(*query)

References#

https://www.psycopg.org

class plume.pg.queries.PgQueryWithArgs(query, args=None, **kwargs)#

Bases : tuple

Requête PostgreSQL prête à l’emploi.

Prend la forme d’un tuple à un ou deux éléments. Le premier élément est la requête SQL, soit un objet de classe psycopg2.sql.Composed ou psycopg2.sql.SQL. Le second élément correspond aux paramètres de la requête, et peut prendre la forme d’un tuple ou d’un dictionnaire selon les cas. Il n’est présent que si la requête admet des paramètres.

D’une manière générale, il n’est pas utile de contrôler la présence du second élément. Une requête query peut toujours être passée en argument de psycopg2.cursor.execute() de la manière suivante :

>>> cur.execute(*query)

Parameters:

querypsycopg2.sql.SQL or psycopg2.sql.Composed: La requête.
argstuple or dict, optional: Les paramètres de la requête.
expecting{“some rows”, “one row”, “one value”, “nothing”}, optional: Décrit le résultat attendu, le cas échéant.
allow_nonebool, default True: True s’il est admis que la requête ne renvoie aucun enregistrement. Si False, une erreur devra être émise en l’absence de résultat.
missing_mssgstr, optional: Le message d’erreur à présenter lorsque la requête ne renvoie pas de résultat. Ce paramètre est ignoré lorsque allow_none vaut True.

Attributes:

querypsycopg2.sql.SQL or psycopg2.sql.Composed: La requête à proprement parler.
argstuple or dict or None: Les paramètres de la requête. Il s’agira d’un tuple vide si la requête ne prend pas de paramètre.
expecting{“some rows”, “one row”, “one value”, “nothing”}: Décrit le résultat attendu, le cas échéant.
allow_nonebool: True s’il est admis que la requête ne renvoie aucun enregistrement. Si False, une erreur devra être émise en l’absence de résultat.
missing_mssgstr or None: Le message d’erreur à présenter lorsque la requête ne renvoie pas de résultat. Vaut toujours None lorsque allow_none vaut True.

Methods

`count`(value, /)	Return number of occurrences of value.
`index`(value[, start, stop])	Return first index of value.

plume.pg.queries.query_delete_any_table(schema_name, table_name, pk_name, data, columns=None)#

Requête qui supprime un enregistrement d’une table quelconque.

À utiliser comme suit :

>>> query = query_delete_any_table(
...    'nom du schéma', 'nom de la table', 'nom du champ de clé primaire',
...    ['valeur champ 1', 'valeur de la clé primaire', 'valeur champ 3'],
...    ['nom champ 1', 'nom du champ de clé primaire', 'nom champ 3']
...    )
>>> cur.execute(*query)

La fonction renvoie une erreur si data et columns ne contiennent pas de valeur pour le champ de clé primaire. Il ne pose aucun problème de fournir des valeurs pour d’autres champs, même si la fonction n’en fera rien.

Parameters:

schema_namestr

Nom du schéma.

table_namestr

Nom de la table.

pk_namestr

Nom du champ de clé primaire. La fonction ne prend pas en charge les tables avec des clés primaires multi-champs. Il est admissible d’utiliser un champ non nul prenant des valeurs uniques qui ne serait pas formellement la clé primaire de la relation.

datalist or dict

data représente un enregistrement de la table. Il peut s’agir de :

La liste des valeurs des champs, dans l’ordre de columns, qui doit alors être renseigné.
Un dictionnaire dont les clés sont les noms des champs. columns est ignoré dans ce cas.

columnslist

Liste des noms des champs de la table des onglets pour lesquels data fournit des valeurs, exactement dans le même ordre. Il est possible d’obtenir la liste complète avec query_get_columns(). Ce paramètre est obligatoire si data est une liste de valeur.

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_delete_meta_categorie(data, columns=None)#

Requête qui supprime une catégorie de la table meta_categorie de PlumePg.

À utiliser comme suit :

>>> query = query_delete_meta_categorie(data)
>>> cur.execute(*query)

La fonction renvoie une erreur si data et columns ne contiennent pas de valeur pour le champ de clé primaire, path. Il ne pose aucun problème de fournir des valeurs pour d’autres champs, même si la fonction n’en fera rien.

Parameters:

datalist or dict

data représente un enregistrement de la table. Il peut s’agir de :

La liste des valeurs des champs, dans l’ordre de columns, qui doit alors être renseigné.
Un dictionnaire dont les clés sont les noms des champs. columns est ignoré dans ce cas.

columnslist

Liste des noms des champs de la table des onglets pour lesquels data fournit des valeurs, exactement dans le même ordre. Il est possible d’obtenir la liste complète avec query_get_columns().

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_delete_meta_tab(data, columns=None)#

Requête qui supprime un onglet de la table meta_tab de PlumePg.

À utiliser comme suit :

>>> query = query_delete_meta_tab(data)
>>> cur.execute(*query)

La fonction renvoie une erreur si data et columns ne contiennent pas de valeur pour le champ de clé primaire, tab_id. Il ne pose aucun problème de fournir des valeurs pour d’autres champs, même si la fonction n’en fera rien.

Parameters:

datalist or dict

data représente un enregistrement de la table. Il peut s’agir de :

La liste des valeurs des champs, dans l’ordre de columns, qui doit alors être renseigné.
Un dictionnaire dont les clés sont les noms des champs. columns est ignoré dans ce cas.

columnslist

Liste des noms des champs de la table des onglets pour lesquels data fournit des valeurs, exactement dans le même ordre. Il est possible d’obtenir la liste complète avec query_get_columns().

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_delete_meta_template(data, columns=None)#

Requête qui supprime un modèle de fiches de métadonnées de la table meta_template de PlumePg.

À utiliser comme suit :

>>> query = query_delete_meta_template(data)
>>> cur.execute(*query)

La fonction renvoie une erreur si data et columns ne contiennent pas de valeur pour le champ de clé primaire, tpl_id. Il ne pose aucun problème de fournir des valeurs pour d’autres champs, même si la fonction n’en fera rien.

Parameters:

datalist or dict

data représente un enregistrement de la table. Il peut s’agir de :

La liste des valeurs des champs, dans l’ordre de columns, qui doit alors être renseigné.
Un dictionnaire dont les clés sont les noms des champs. columns est ignoré dans ce cas.

columnslist

Liste des noms des champs de la table des onglets pour lesquels data fournit des valeurs, exactement dans le même ordre. Il est possible d’obtenir la liste complète avec query_get_columns().

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_delete_meta_template_categories(data, columns=None)#

Requête qui supprime une association modèle-catégorie de la table meta_template_categories de PlumePg.

À utiliser comme suit :

>>> query = query_delete_meta_template_categories(data)
>>> cur.execute(*query)

La fonction renvoie une erreur si data et columns ne contiennent pas de valeur pour le champ de clé primaire, tplcat_id. Il ne pose aucun problème de fournir des valeurs pour d’autres champs, même si la fonction n’en fera rien.

Parameters:

datalist or dict

data représente un enregistrement de la table. Il peut s’agir de :

La liste des valeurs des champs, dans l’ordre de columns, qui doit alors être renseigné.
Un dictionnaire dont les clés sont les noms des champs. columns est ignoré dans ce cas.

columnslist

Liste des noms des champs de la table des onglets pour lesquels data fournit des valeurs, exactement dans le même ordre. Il est possible d’obtenir la liste complète avec query_get_columns().

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_evaluate_local_templates(templates_collection, schema_name, table_name)#

Requête qui évalue côté serveur les conditions d’application des modèles locaux.

À utiliser comme suit :

>>> query = query_evaluate_local_templates()
>>> cur.execute(*query)
>>> templates = cur.fetchall()

Parameters:

templates_collectionplume.pg.template.LocalTemplatesCollection: Le répertoire des modèles stockés localement, qui aura été instancié parce que PlumePg n’est pas activée sur la base de la table dont on affiche les métadonnées.
schema_namestr: Nom du schéma.
table_namestr: Nom de la relation (table, vue…).

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL, incluant son dictionnaire de paramètres.

Notes

La forme du résultat des requêtes créées avec cette fonction est identique à celle de query_list_templates(), ce qui permet ensuite d’appliquer dans les deux cas la fonction plume.pg.template.search_template() pour obtenir le nom du modèle à appliquer.

plume.pg.queries.query_exists_extension(extension)#

Requête qui vérifie qu’une extension est installée sur la base PostgreSQL cible.

À utiliser comme suit :

>>> query = query_exists_extension('nom de l'extension')
>>> cur.execute(*query)
>>> extension_exists = cur.fetchone()[0]

Le résultat est :

True si l’extension est installée ;
False si elle est disponible dans le répertoire des extensions du serveur mais non installée ;
None si elle n’est pas disponible sur le serveur.

Parameters:

extensionstr: Nom de l’extension.

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_for_theme_computing(schema_name, table_name, level_one=True, level_two=True, **kwargs)#

Pseudo-requête pour le calcul du ou des thèmes Ecosphères associés au schéma.

Il s’agit d’une pseudo-requête, dans la mesure où aucune information n’est effectivement récupérée côté serveur, puisque c’est du nom du schéma que sont in fine déduits les thèmes. Mais elle permet de présenter les paramètres sont une forme adaptée au process de calcul.

À utiliser comme suit :

>>> query = query_for_theme_computing(schema_name='nom du schéma',
...     table_name='nom de la relation', **compute_params)
>>> cur.execute(*query)
>>> result = cur.fetchall()

compute_params est le dictionnaire fourni par la clé “compute parameters” du dictionnaire interne associé à la clé courante du dictionnaire de widgets. Si spécifié par le modèle, il contiendra la valeur des paramètres level_one et/ou level_two.

Parameters:

schema_namestr: Nom du schéma.
table_namestr: Nom de la relation (table, vue…).
level_onebool, default True: Si True, le ou les thèmes de premier niveau associés au nom du schéma sont ajoutés (les plus génériques).
level_twobool, default True: Si True, le ou les thèmes de second niveau, associés au nom du schéma sont ajoutés (les plus spécifiques).
**kwargsdict, optional: Paramètres supplémentaires ignorés.

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL, incluant son tuple de paramètres.

Notes

Cette fonction est référencée par le module plume.pg.computer.

plume.pg.queries.query_get_categories(tpl_label)#

Requête d’import des catégories à afficher dans un modèle donné.

À utiliser comme suit :

>>> query = query_get_categories('nom du modèle')
>>> cur.execute(*query)
>>> categories = cur.fetchall()

categories est une liste de tuples contenant chacun un dictionnaire. À chaque tuple correspond une catégorie de métadonnées associée au modèle. Les clés des dictionnaires correspondent aux noms des champs de la vue z_plume.meta_template_categories_full et les valeurs sont les valeurs contenues dans ces champs pour l’association modèle/catégorie considérée.

Ce résultat peut être fourni en argument au constructeur de la classe TemplateDict.

Parameters:

tpl_labelstr: Nom du modèle choisi.

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

Notes

La requête interroge la vue z_plume.meta_template_categories_full créée par l’extension PlumePg. Elle ne doit donc être exécutée qu’après contrôle de l’existence de l’extension.

plume.pg.queries.query_get_columns(schema_name, table_name)#

Requête de récupération des descriptifs des champs d’une table ou vue.

À utiliser comme suit :

>>> query = query_get_columns('nom du schéma',
...     'nom de la relation')
>>> cur.execute(*query)
>>> columns = cur.fetchall()

Parameters:

schema_namestr: Nom du schéma.
table_namestr: Nom de la relation (table, vue…).

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_get_comment_fragments(schema_name, table_name, pattern=None, flags=None, **kwargs)#

Requête de récupération d’une partie du descriptif PostgreSQL d’une table.

À utiliser comme suit :

>>> query = query_get_comment_fragments(schema_name='nom du schéma',
...     table_name='nom de la relation', **compute_params)
>>> cur.execute(*query)
>>> result = cur.fetchall()

La liste ainsi obtenue contient des tuples d’un élément, un pour chaque fragment du descriptif capturé par l’expression régulière. Si aucune expression régulière n’a été spécifiée, c’est tout le descriptif hors métadonnées qui est renvoyé. Avec ou sans expression régulière, la requête commence en effet par retirer les balises <METADATA> et leur contenu.

Parameters:

schema_namestr: Nom du schéma.
table_namestr: Nom de la relation (table, vue…).
patternstr, optional: Une expression régulière déterminant le ou les fragments du descriptif PostgreSQL à renvoyer. Si non spécifié, la requête récupèrera tout le descriptif expurgé des balises <METADATA> et de leur contenu. Si l’expression régulière est invalide (d’après les critères de PostgreSQL), la requête ne renverra rien.
flagsstr, optional: Paramètres associés à l’expression rationnelle. Si PostgreSQL ne les reconnaît pas, la requête ne renverra rien.
**kwargsdict, optional: Paramètres supplémentaires ignorés.

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL, incluant son tuple de paramètres.

Avertissement

Cette requête échouera si PlumePg n’est pas installée sur la base.

Notes

Cette fonction est référencée par le module plume.pg.computer.

plume.pg.queries.query_get_creation_date(schema_name, table_name, **kwargs)#

Requête de récupération de la date de création d’une table.

À utiliser comme suit :

>>> query = query_get_creation_date(schema_name='nom du schéma',
...     table_name='nom de la table', **compute_params)
>>> cur.execute(*query)
>>> result = cur.fetchall()

compute_params est le dictionnaire fourni par la clé “compute parameters” du dictionnaire interne associé à la clé courante du dictionnaire de widgets.

La liste ainsi obtenue contient un unique tuple dont le seul élément est la date recherchée, si tant est que l’information soit disponible.

Parameters:

schema_namestr: Nom du schéma.
table_namestr: Nom de la table. Il est possible d’appliquer cette fonction sur des vues ou d’autres types de relations, mais la requête produite ne renverra à coup sûr rien.
**kwargsdict, optional: Paramètres supplémentaires ignorés.

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL, incluant son tuple de paramètres.

Avertissement

Cette requête échouera si PlumePg n’est pas installée sur la base. Par ailleurs, elle ne renverra de date que si le suivi des dates a été activé pour la table considérée.

Notes

Cette fonction est référencée par le module plume.pg.computer.

plume.pg.queries.query_get_geom_centroid(schema_name, table_name, geom_name)#

Requête de calcul côté serveur du centre du rectangle d’emprise d’une couche.

À utiliser comme suit :

>>> query = query_get_geom_centroid('nom du schéma',
...     'nom de la relation', 'nom du champ de géométrie')
>>> cur.execute(*query)
>>> centroid_geom = cur.fetchone()[0]

À noter que le résultat est une géométrie dont le système de coordonnées n’est pas explicité. Il faudra le récupérer via query_get_geom_srid(), puis appliquer la fonction plume.rdf.utils.wkt_with_srid() pour obtenir la représention du centroïde attendue en RDF :

>>> from plume.rdf.utils import wkt_with_srid
>>> query = query_get_geom_srid('nom du schéma', 'nom de la relation'
...     'nom du champ de géométrie')
>>> cur.execute(*query)
>>> srid = cur.fetchone()[0]
>>> centroid = wkt_with_srid(centroid_geom, srid)

Parameters:

schema_namestr: Nom du schéma.
table_namestr: Nom de la relation (table, vue…).
geom_namestr: Nom du champ de géométrie.

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

Avertissement

Cette requête échouera si PostGIS n’est pas installé sur la base. Il est donc fortement recommandé de vérifier d’abord la présence de PostGIS avec query_exists_extension() :

>>> query = query_exists_extension('postgis')
>>> cur.execute(*query)
>>> postgis_exists = cur.fetchone()[0]

plume.pg.queries.query_get_geom_extent(schema_name, table_name, geom_name)#

Requête de calcul côté serveur du rectangle d’emprise d’une couche.

À utiliser comme suit :

>>> query = query_get_geom_extent('nom du schéma',
...     'nom de la relation', 'nom du champ de géométrie')
>>> cur.execute(*query)
>>> bbox_geom = cur.fetchone()[0]

>>> from plume.rdf.utils import wkt_with_srid
>>> query = query_get_geom_srid('nom du schéma', 'nom de la relation'
...     'nom du champ de géométrie')
>>> cur.execute(*query)
>>> srid = cur.fetchone()[0]
>>> bbox = wkt_with_srid(bbox_geom, srid)

Parameters:

schema_namestr: Nom du schéma.
table_namestr: Nom de la relation (table, vue…).
geom_namestr: Nom du champ de géométrie.

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

Avertissement

Cette requête échouera si PostGIS n’est pas installé sur la base. Il est donc fortement recommandé de vérifier d’abord la présence de PostGIS avec query_exists_extension() :

>>> query = query_exists_extension('postgis')
>>> cur.execute(*query)
>>> postgis_exists = cur.fetchone()[0]

plume.pg.queries.query_get_geom_srid(schema_name, table_name, geom_name)#

Requête de récupération du référentiel de coordonnées d’une couche.

À utiliser comme suit :

>>> query = query_get_geom_srid('nom du schéma', 'nom de la relation'
...     'nom du champ de géométrie')
>>> cur.execute(*query)
>>> srid = cur.fetchone()[0]

Le référentiel ainsi obtenu est de la forme 'Autorité:Code'.

Parameters:

schema_namestr: Nom du schéma.
table_namestr: Nom de la relation (table, vue…).
geom_namestr: Nom du champ de géométrie à considérer.

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

Avertissement

Cette requête échouera si PostGIS n’est pas installé sur la base. Il est donc fortement recommandé de vérifier d’abord la présence de PostGIS avec query_exists_extension() :

>>> query = query_exists_extension('postgis')
>>> cur.execute(*query)
>>> postgis_exists = cur.fetchone()[0]

plume.pg.queries.query_get_modification_date(schema_name, table_name, **kwargs)#

Requête de récupération de la date de dernière modification d’une table.

À utiliser comme suit :

>>> query = query_get_modification_date(schema_name='nom du schéma',
...     table_name='nom de la table', **compute_params)
>>> cur.execute(*query)
>>> result = cur.fetchall()

compute_params est le dictionnaire fourni par la clé “compute parameters” du dictionnaire interne associé à la clé courante du dictionnaire de widgets.

La liste ainsi obtenue contient un unique tuple dont le seul élément est la date recherchée, si tant est que l’information soit disponible.

Parameters:

schema_namestr: Nom du schéma.
table_namestr: Nom de la table. Il est possible d’appliquer cette fonction sur des vues ou d’autres types de relations, mais la requête produite ne renverra à coup sûr rien.
**kwargsdict, optional: Paramètres supplémentaires ignorés.

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL, incluant son tuple de paramètres.

Avertissement

Cette requête échouera si PlumePg n’est pas installée sur la base. Par ailleurs, elle ne renverra de date que si le suivi des dates a été activé pour la table considérée.

Notes

Cette fonction est référencée par le module plume.pg.computer.

plume.pg.queries.query_get_relation_kind(schema_name, table_name)#

Requête qui récupère le type d’une relation PostgreSQL.

À utiliser comme suit :

>>> query = query_get_relation_kind('nom du schéma',
...     'nom de la relation')
>>> cur.execute(*query)
>>> relkind = cur.fetchone()[0]

Parameters:

schema_namestr: Nom du schéma.
table_namestr: Nom de la relation (table, vue…).

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_get_srid_list(schema_name, table_name, **kwargs)#

Requête de récupération de la liste des référentiels de coordonnées utilisés par les géométries d’une relation.

À utiliser comme suit :

>>> query = query_get_srid_list(schema_name='nom du schéma',
...     table_name='nom de la relation', **compute_params)
>>> cur.execute(*query)
>>> result = cur.fetchall()

compute_params est le dictionnaire fourni par la clé “compute parameters” du dictionnaire interne associé à la clé courante du dictionnaire de widgets.

La liste ainsi obtenue contient des tuples dont le premier élément est l’identifiant de l’autorité qui référence le référentiel et le second élément est le code du référentiel dans le registre de cette autorité.

Parameters:

schema_namestr: Nom du schéma.
table_namestr: Nom de la relation (table, vue…).
**kwargsdict, optional: Paramètres supplémentaires ignorés.

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL, incluant son tuple de paramètres.

Avertissement

Cette requête échouera si PostGIS n’est pas installé sur la base. Il est donc fortement recommandé de vérifier d’abord la présence de PostGIS avec query_exists_extension() :

>>> query = query_exists_extension('postgis')
>>> cur.execute(*query)
>>> postgis_exists = cur.fetchone()[0]

Notes

Cette fonction est référencée par le module plume.pg.computer.

plume.pg.queries.query_get_table_comment(schema_name, table_name)#

Requête de récupération du descriptif d’une table ou vue.

À utiliser comme suit :

>>> query = query_get_table_comment('nom du schéma',
...     'nom de la relation')
>>> cur.execute(*query)
>>> old_description = cur.fetchone()[0]

Parameters:

schema_namestr: Nom du schéma.
table_namestr: Nom de la relation (table, vue…).

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_insert_or_update_any_table(schema_name, table_name, pk_name, data, columns=None, no_update=False)#

Requête qui crée ou met à jour un enregistrement d’une table quelconque.

À utiliser comme suit :

>>> query = query_insert_or_update_any_table(
...    'nom du schéma', 'nom de la table', 'nom du champ de clé primaire',
...    ['valeur champ 1', 'valeur champ 2', 'valeur champ 3'],
...    ['nom champ 1', 'nom champ 2', 'nom champ 3']
...    )
>>> cur.execute(*query)
>>> new_data = cur.fetchone()[0]

new_data est un dictionnaire contenant l’enregistrement mis à jour, tel qu’il est stocké en base.

Parameters:

schema_namestr

Nom du schéma.

table_namestr

Nom de la table.

pk_namestr

datalist or dict

data représente un enregistrement de la table. Il peut s’agir de :

La liste des valeurs des champs, dans l’ordre de columns, qui doit alors être renseigné.
Un dictionnaire dont les clés sont les noms des champs. columns est ignoré dans ce cas.

columnslist

Liste des noms des champs de la table des onglets pour lesquels data fournit des valeurs, exactement dans le même ordre. Il est possible d’obtenir la liste complète avec query_get_columns().

no_updatebool, default False

Si True, la requête n’aura pas d’effet sur les enregistrements pré-existants.

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_insert_or_update_meta_categorie(data, columns=None, no_update=False)#

Requête qui crée ou met à jour une catégorie de métadonnées dans la table meta_categorie de PlumePg.

À utiliser comme suit :

>>> query = query_insert_or_update_meta_categorie(data)
>>> cur.execute(*query)
>>> new_data = cur.fetchone()[0]

new_data est un dictionnaire contenant l’enregistrement mis à jour, tel qu’il est stocké en base.

Pour la mise à jour d’une catégorie commune, il est impératif :

que le champ origin soit présent et prenne la valeur 'shared' ;
que l’identifiant path soit renseigné.

Si l’une au moins de ces deux conditions n’est pas remplie, la catégorie de métadonnée est considérée comme locale.

Parameters:

datalist or dict

data représente un enregistrement de la table. Il peut s’agir de :

La liste des valeurs des champs, dans l’ordre de columns, qui doit alors être renseigné.
Un dictionnaire dont les clés sont les noms des champs. columns est ignoré dans ce cas.

columnslist

Liste des noms des champs de la table des onglets pour lesquels data fournit des valeurs, exactement dans le même ordre. Il est possible d’obtenir la liste complète avec query_get_columns().

no_updatebool, default False

Si True, la requête n’aura pas d’effet sur les enregistrements pré-existants. Dans ce cas, pour une métadonnée locale, la requête ne renvoie rien. Pour une métadonnée commune, elle renvoie l’enregistrement d’origine.

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_insert_or_update_meta_tab(data, columns=None, no_update=False)#

Requête qui crée ou met à jour un onglet dans la table meta_tab de PlumePg.

À utiliser comme suit :

>>> query = query_insert_or_update_meta_tab(data)
>>> cur.execute(*query)
>>> new_data = cur.fetchone()[0]

new_data est un dictionnaire contenant l’enregistrement mis à jour, tel qu’il est stocké en base.

Parameters:

datalist or dict

data représente un enregistrement de la table. Il peut s’agir de :

La liste des valeurs des champs, dans l’ordre de columns, qui doit alors être renseigné.
Un dictionnaire dont les clés sont les noms des champs. columns est ignoré dans ce cas.

columnslist

Liste des noms des champs de la table des onglets pour lesquels data fournit des valeurs, exactement dans le même ordre. Il est possible d’obtenir la liste complète avec query_get_columns().

no_updatebool, default False

Si True, la requête n’aura pas d’effet sur les enregistrements pré-existants. Dans ce cas, la requête ne renvoie rien.

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_insert_or_update_meta_template(data, columns=None, no_update=False)#

Requête qui crée ou met à jour un modèle de fiches de métadonnées dans la table meta_template de PlumePg.

À utiliser comme suit :

>>> query = query_insert_or_update_meta_template(data)
>>> cur.execute(*query)
>>> new_data = cur.fetchone()[0]

new_data est un dictionnaire contenant l’enregistrement mis à jour, tel qu’il est stocké en base.

Parameters:

datalist or dict

data représente un enregistrement de la table. Il peut s’agir de :

La liste des valeurs des champs, dans l’ordre de columns, qui doit alors être renseigné.
Un dictionnaire dont les clés sont les noms des champs. columns est ignoré dans ce cas.

columnslist

Liste des noms des champs de la table des onglets pour lesquels data fournit des valeurs, exactement dans le même ordre. Il est possible d’obtenir la liste complète avec query_get_columns().

no_updatebool, default False

Si True, la requête n’aura pas d’effet sur les enregistrements pré-existants. Dans ce cas, la requête ne renvoie rien.

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_insert_or_update_meta_template_categories(data, columns=None, no_update=False)#

Requête qui crée ou met à jour une association modèle-catégorie dans la table meta_template_categories de PlumePg.

À utiliser comme suit :

>>> query = query_insert_or_update_meta_template_categories(data)
>>> cur.execute(*query)
>>> new_data = cur.fetchone()[0]

new_data est un dictionnaire contenant l’enregistrement mis à jour, tel qu’il est stocké en base.

Parameters:

datalist or dict

data représente un enregistrement de la table. Il peut s’agir de :

La liste des valeurs des champs, dans l’ordre de columns, qui doit alors être renseigné.
Un dictionnaire dont les clés sont les noms des champs. columns est ignoré dans ce cas.

columnslist, optional

no_updatebool, default False

Si True, la requête n’aura pas d’effet sur les enregistrements pré-existants. Dans ce cas, la requête ne renvoie rien.

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_is_relation_owner(schema_name, table_name)#

Requête qui vérifie que le rôle courant est membre du propriétaire d’une relation (table, etc.).

À utiliser comme suit :

>>> query = query_is_relation_owner('nom du schéma', 'nom de la relation')
>>> cur.execute(*query)
>>> res = cur.fetchone()
>>> is_owner = res[0] if res else False

Parameters:

schema_namestr: Nom du schéma.
table_namestr: Nom de la relation (table, vue…).

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_is_template_admin()#

Requête qui vérifie que le rôle courant dispose des privilèges nécessaire pour configurer les modèles de fiches de métadonnées de PlumePg.

Concrètement, elle vérifie les privilèges suivants :

USAGE sur le schéma z_plume.
INSERT, UPDATE, DELETE sur la table d’association des catégories aux modèles, z_plume.meta_template_categories.
INSERT, UPDATE, DELETE sur la table des modèles, z_plume.meta_template.
INSERT, UPDATE, DELETE sur la table des catégories, z_plume.meta_categorie.
INSERT, UPDATE, DELETE sur la table des onlgets, z_plume.meta_tab.

Ces privilèges ne sont pas tout à fait suffisants pour pouvoir éditer les modèles (il faut aussi des droits sur les séquences, les types, etc.), mais en disposer signifer qu’on a voulu habiliter l’utilisateur à les modifier. S’il lui manque des droits annexes, Plume lui fera savoir par un message d’erreur qui permettra à l’administrateur du serveur d’accorder les privilèges manquants.

La requête suppose que l’extension PostgreSQL PlumePg est installée sur le serveur, sans quoi son exécution échouera.

À utiliser comme suit :

>>> query = query_is_template_admin
>>> cur.execute(*query)
>>> res = cur.fetchone()
>>> is_template_admin = res[0]

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_list_templates(schema_name, table_name)#

Requête d’import de la liste des modèles disponibles.

À utiliser comme suit :

>>> query = query_list_templates('nom du schéma', 'nom de la relation')
>>> cur.execute(*query)
>>> templates = cur.fetchall()

Parameters:

schema_namestr: Nom du schéma.
table_namestr: Nom de la relation (table, vue…).

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

Notes

La requête interroge la table z_plume.meta_template créée par l’extension PlumePg. Au lieu d’importer tel quel le contenu de son champ sql_filter, elle l’exécute et renvoie un booléen indiquant si la condition qu’il spécifie est remplie.

plume.pg.queries.query_plume_pg_check(min_version='0.3.1', max_version='1.0.0')#

Requête qui vérifie qu’une version compatible de PlumePg est installée sur la base cible.

Elle s’assure aussi que l’utilisateur dispose des privilèges nécessaires sur les objets de PlumePg.

À utiliser comme suit :

>>> query = query_plume_pg_check(min_version='0.1.0')
>>> cur.execute(*query)
>>> result = cur.fetchone()

result est un tuple constitué des éléments suivants :

[0] est un booléen. S’il vaut True, tout est en ordre pour l’utilisation des modèles de PlumePg. Sinon, les autres éléments du tuple précisent le problème.
[1] est une liste rappelant la version minimale (incluse) et la version maximale (exclue) de PlumePg compatibles avec la version courante de Plume.
[2] est la version installée de PlumePg, ou None si l’extension n’est pas installée sur la base courante.
[3] est la version de référence de PlumePg disponible sur le serveur, ou None si l’extension n’est pas disponible sur le serveur.
[4] est une liste de schémas sur lesquels l’utilisateur ne dispose pas du privilège USAGE requis.
[5] est une liste de tables et vues sur lesquelles l’utilisateur ne dispose pas du privilège SELECT requis. À noter que les droits sur les tables et vues ne sont contrôlés que si l’utilisateur dispose de tous les privilèges nécessaires sur les schémas.

Parameters:

min_versionstr, optional: La version minimale de PlumePg compatible avec la version courante de Plume (incluse). Elle doit être de la forme 'x.y.z' où x, y et z sont des entiers. Par défaut, il s’agira de PLUME_PG_MIN_VERSION. Il est possible d’indiquer None lorsqu’il n’y a pas de contrainte sur la version minimale.
max_versionstr, optional: La version maximale de PlumePg compatible avec la version courante de Plume (exclue). Elle doit être de la forme 'x.y.z' où x, y et z sont des entiers. Par défaut, il s’agira de PLUME_PG_MAX_VERSION. Il est possible d’indiquer None, la version maximale sera alors déduite du premier chiffre de la borne inférieure. Par exemple, '4.0.0' serait la borne supérieure pour la version de référence '3.1.1'.

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL et son tuple de paramètres.

plume.pg.queries.query_plume_pg_create()#

Requête qui active l’extension PlumePg sur la base courante.

La requête générée par cette fonction ne peut être utilisée que si CREATE était listé dans le résultat renvoyé par la fonction query_plume_pg_status().

À utiliser comme suit :

>>> query = query_plume_pg_create()
>>> cur.execute(*query)

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_plume_pg_drop()#

Requête qui désactive l’extension PlumePg sur la base courante.

La requête générée par cette fonction ne peut être utilisée que si DROP était listé dans le résultat renvoyé par la fonction query_plume_pg_status().

Il est nécessaire de demander confirmation de l’utilisateur avant de réaliser cette action, car elle entraîne la perte de tous les modèles et dates enregistrés.

À utiliser comme suit :

>>> query = query_plume_pg_drop()
>>> cur.execute(*query)

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_plume_pg_import_sample_template(templates=None)#

Requête qui charge un ou plusieurs modèles pré-configurés sur la base courante.

Cette fonction peut également être utilisée pour réinitialiser les modèles. Elle nécessite évidemment que l’extension PlumePg soit activée sur la base.

À utiliser comme suit :

>>> query = query_plume_pg_import_sample_template()
>>> cur.execute(*query)

Parameters:

templates str or list(str) or tuple(str), optional: Nom d’un modèle ou plusieurs modèles pré-configurés (sous forme de liste ou de tuple) à charger. Si l’argument n’est pas fourni, tous les modèles pré-configurés sont chargés.

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_plume_pg_status()#

Requête qui évalue l’état de l’extension PlumePg sur la base PostgreSQL cible.

Concrètement, cette requête liste les actions que l’utilisateur est habilité à réaliser vis-à-vis de l’extension PlumePg. À noter qu’à date toutes les actions concernées ne peuvent être réalisées que par un super-utilisateur.

À utiliser comme suit :

>>> query = query_extension_status('nom de l'extension')
>>> cur.execute(*query)
>>> actions = cur.fetchone()[0]

Le résultat est None si aucune action n’est possible, sinon il s’agit de la liste des actions disponibles, parmi :

CREATE - activation de l’extension sur la base.
UPDATE - mise à jour de l’extension.
DROP - désactivation de l’extension.
STAMP RECORDING ENABLE - activation du suivi intégral des dates de création et modification des tables. Cette action est listée dès lors que l’un au moins des déclencheurs sur évènement n’est pas actif.
STAMP RECORDING DISABLE - désactivation du suivi intégral des dates. Cette action est listée dès lors que l’un au moins des déclencheurs sur évènement est actif.
STAMP TO METADATA ENABLE - activation de l’enregistrement automatique des dates dans les métadonnées.
STAMP TO METADATA DISABLE - désactivation de l’enregistrement automatique des dates dans les métadonnées.

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

Voir aussi

query_plume_pg_check(): Pour vérifier la compatibilité des versions de Plume et PlumePg.

plume.pg.queries.query_plume_pg_update()#

Requête qui met à jour l’extension PlumePg sur la base courante.

La requête générée par cette fonction ne peut être utilisée que si UPDATE était listé dans le résultat renvoyé par la fonction query_plume_pg_status().

À utiliser comme suit :

>>> query = query_plume_pg_update()
>>> cur.execute(*query)

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_read_any_enum_type(schema_name, type_name)#

Requête qui récupère les valeurs d’un type énuméré quelconque.

À utiliser comme suit :

>>> query = query_read_any_enum_type(
...    'nom du schéma', 'nom du type'
...    )
>>> cur.execute(*query)
>>> enum_values = cur.fetchone()[0]

enum_values est une liste triée par ordre alphabétique.

Parameters:

schema_namestr: Nom du schéma.
type_namestr: Nom du type énuméré.

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_read_any_row(schema_name, table_name, pk_name, data, columns=None)#

Requête qui renvoie une ligne de données d’une table quelconque.

À utiliser comme suit :

>>> query = query_read_any_row(
...    'nom du schéma', 'nom de la table', 'nom du champ de clé primaire',
...    ['valeur champ 1', 'valeur de la clé primaire', 'valeur champ 3'],
...    ['nom champ 1', 'nom du champ de clé primaire', 'nom champ 3']
...    )
>>> cur.execute(*query)
>>> row = cur.fetchone()

Si l’identifiant spécifié avait bien une correspondance, row[0] sera un dictionnaire contenant les noms et valeurs des champs de l’enregistrement.

Parameters:

schema_namestr

Nom du schéma.

table_namestr

Nom de la table.

pk_namestr

datalist or dict

data représente un enregistrement de la table. Il peut s’agir de :

La liste des valeurs des champs, dans l’ordre de columns, qui doit alors être renseigné.
Un dictionnaire dont les clés sont les noms des champs. columns est ignoré dans ce cas.

columnslist

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_read_enum_meta_compute()#

Requête qui récupère les valeurs admises par le champ compute des tables meta_categorie et meta_template_categories.

À utiliser comme suit :

>>> query = query_read_enum_meta_compute()
>>> cur.execute(*query)
>>> enum_values = cur.fetchone()[0]

enum_values est une liste triée par ordre alphabétique.

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_read_enum_meta_datatype()#

Requête qui récupère les valeurs admises par le champ datatype des tables meta_categorie et meta_template_categories.

À utiliser comme suit :

>>> query = query_read_enum_meta_datatype()
>>> cur.execute(*query)
>>> enum_values = cur.fetchone()[0]

enum_values est une liste triée par ordre alphabétique.

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_read_enum_meta_geo_tool()#

Requête qui récupère les valeurs admises par le champ geo_tools des tables meta_categorie et meta_template_categories.

À utiliser comme suit :

>>> query = query_read_enum_meta_geo_tool()
>>> cur.execute(*query)
>>> enum_values = cur.fetchone()[0]

enum_values est une liste triée par ordre alphabétique.

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_read_enum_meta_special()#

Requête qui récupère les valeurs admises par le champ special des tables meta_categorie et meta_template_categories.

À utiliser comme suit :

>>> query = query_read_enum_meta_special()
>>> cur.execute(*query)
>>> enum_values = cur.fetchone()[0]

enum_values est une liste triée par ordre alphabétique.

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_read_meta_categorie()#

Requête qui importe le contenu de la table des catégories de métadonnées (meta_categorie) de PlumePg.

À utiliser comme suit :

>>> query = query_read_meta_categorie()
>>> cur.execute(*query)
>>> categories = cur.fetchall()

categories est une liste de tuples, où chaque tuple correspond à une catégorie. Les tuples contiennent un unique élément : un dictionnaire dont les clés sont les noms des champs de la table des catégories et les valeurs sont les valeurs contenues dans ces champs pour la catégorie considéré. L’ordre des clés ne respecte pas l’ordre des champs dans la table.

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_read_meta_tab()#

Requête qui importe le contenu de la table des onglets (meta_tab) de PlumePg.

À utiliser comme suit :

>>> query = query_read_meta_tab()
>>> cur.execute(*query)
>>> tabs = cur.fetchall()

tabs est une liste de tuples, où chaque tuple correspond à un onglet. Les tuples contiennent un unique élément : un dictionnaire dont les clés sont les noms des champs de la table des onglets et les valeurs sont les valeurs contenues dans ces champs pour l’onglet considéré. L’ordre des clés ne respecte pas l’ordre des champs dans la table.

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_read_meta_template()#

Requête qui importe le contenu de la table des modèles (meta_template) de PlumePg.

À utiliser comme suit :

>>> query = query_read_meta_template()
>>> cur.execute(*query)
>>> templates = cur.fetchall()

templates est une liste de tuples, où chaque tuple correspond à un modèle. Les tuples contiennent un unique élément : un dictionnaire dont les clés sont les noms des champs de la table des modèles et les valeurs sont les valeurs contenues dans ces champs pour le modèle considéré. L’ordre des clés ne respecte pas l’ordre des champs dans la table.

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_read_meta_template_categories()#

Requête qui importe le contenu de la table d’association des catégories aux modèles (meta_template_categories) de PlumePg.

À utiliser comme suit :

>>> query = query_read_meta_template_categories()
>>> cur.execute(*query)
>>> template_categories = cur.fetchall()

template_categories est une liste de tuples, où chaque tuple correspond à un couple modèle + catégorie. Les tuples contiennent un unique élément : un dictionnaire dont les clés sont les noms des champs de la table d’association et les valeurs sont les valeurs contenues dans ces champs pour le couple modèle + catégorie considéré. L’ordre des clés ne respecte pas l’ordre des champs dans la table.

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_stamp_recording_disable()#

Requête qui désactive entièrement le suivi des dates de création/modification des tables via PlumePg.

La requête générée par cette fonction ne peut être utilisée que si STAMP RECORDING DISABLE était listé dans le résultat renvoyé par la fonction query_plume_pg_status().

À utiliser comme suit :

>>> query = query_stamp_recording_disable()
>>> cur.execute(*query)

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_stamp_recording_enable()#

Requête qui active le suivi complet des dates de création/modification des tables via PlumePg.

La requête générée par cette fonction ne peut être utilisée que si STAMP RECORDING ENABLE était listé dans le résultat renvoyé par la fonction query_plume_pg_status().

À utiliser comme suit :

>>> query = query_stamp_recording_enable()
>>> cur.execute(*query)

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_stamp_to_metadata_disable()#

Requête qui désactive la copie automatique des dates enregistrées par le système de suivi de PlumePg dans les fiches de métadonnées.

La requête générée par cette fonction ne peut être utilisée que si STAMP TO METADATA DISABLE était listé dans le résultat renvoyé par la fonction query_plume_pg_status().

À utiliser comme suit :

>>> query = query_stamp_to_metadata_disable()
>>> cur.execute(*query)

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_stamp_to_metadata_enable()#

Requête qui active la copie automatique des dates enregistrées par le système de suivi de PlumePg dans les fiches de métadonnées.

La requête générée par cette fonction ne peut être utilisée que si STAMP TO METADATA ENABLE était listé dans le résultat renvoyé par la fonction query_plume_pg_status().

À utiliser comme suit :

>>> query = query_stamp_to_metadata_enable()
>>> cur.execute(*query)

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_template_tabs(tpl_label)#

Requête d’import des onglets utilisés par un modèle.

À utiliser comme suit :

>>> query = query_template_tabs('nom du modèle')
>>> cur.execute(*query)
>>> tabs = cur.fetchall()

Parameters:

tpl_labelstr: Nom du modèle choisi.

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

Notes

La requête interroge les tables z_plume.meta_tab et z_plume.meta_template_categories créées par l’extension PlumePg. Elle ne doit donc être exécutée qu’après contrôle de l’existence de l’extension.

L’ordre de la liste résultant de l’exécution de la requête est l’ordre dans lequel le modèle prévoit que les onglets soient présentés à l’utilisateur.

plume.pg.queries.query_update_any_table(schema_name, table_name, pk_name, data, columns=None)#

Requête qui met à jour un enregistrement existant d’une table quelconque.

La requête sera sans effet si l’enregistrement n’existait pas.

À utiliser comme suit :

>>> query = query_update_any_table(
...    'nom du schéma', 'nom de la table', 'nom du champ de clé primaire',
...    ['valeur champ 1', 'valeur champ 2', 'valeur champ 3'],
...    ['nom champ 1', 'nom champ 2', 'nom champ 3']
...    )
>>> cur.execute(*query)
>>> new_data = cur.fetchone()[0]

new_data est un dictionnaire contenant l’enregistrement mis à jour, tel qu’il est stocké en base.

Parameters:

schema_namestr

Nom du schéma.

table_namestr

Nom de la table.

pk_namestr

datalist or dict

data représente un enregistrement de la table. Il peut s’agir de :

La liste des valeurs des champs, dans l’ordre de columns, qui doit alors être renseigné.
Un dictionnaire dont les clés sont les noms des champs. columns est ignoré dans ce cas.

columnslist

Liste des noms des champs de la table des onglets pour lesquels data fournit des valeurs, exactement dans le même ordre. Il est possible d’obtenir la liste complète avec query_get_columns().

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_update_column_comment(schema_name, table_name, column_name, description='')#

Requête de mise à jour du descriptif d’un champ.

À utiliser comme suit :

>>> query = query_update_column_comment('nom du schéma',
...     'nom de la relation', 'nom du champ',
...     'Nouveau descriptif du champ')
>>> cur.execute(*query)

Parameters:

schema_namestr: Nom du schéma.
table_namestr: Nom de la relation (table, vue…).
column_namestr: Nom du champ.
descriptionstr, optional: Le nouveau descriptif du champ.

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

plume.pg.queries.query_update_columns_comments(schema_name, table_name, widgetsdict)#

Requête de mise à jour des descriptifs des champs d’une table.

À utiliser comme suit :

>>> query = query_update_columns_comments('nom du schéma',
...     'nom de la relation', widgetsdict)
>>> if query:
...     cur.execute(*query)

Parameters:

schema_namestr: Nom du schéma.
table_namestr: Nom de la relation (table, vue…).
widgetsdictplume.rdf.widgetsdict.WidgetsDict: Le dictionnaire de widgets qui contient les descriptifs actualisés des champs.

Returns:

PgQueryWithArgs or None: Une requête prête à être envoyée au serveur PostgreSQL. La fonction renvoie None si elle ne trouve aucun descriptif de champ dans le dictionnaire de widgets.

Notes

À noter que cette requête pourrait échouer si des champs ont été supprimés ou renommés entre temps.

plume.pg.queries.query_update_table_comment(schema_name, table_name, relation_kind='r', description='')#

Requête de mise à jour du descriptif d’une table ou vue.

À utiliser comme suit :

>>> query = query_update_table_comment('nom du schéma',
...     'nom de la relation', 'type de relation',
...     'Nouveau descriptif')
>>> cur.execute(*query)

Parameters:

schema_namestr: Nom du schéma.
table_namestr: Nom de la relation (table, vue…).
relation_kind{“r”, “v”, “m”, “f”, “p”}, optional: Le type de relation. 'r' par défaut, ce qui correspond à une table simple.
descriptionstr, optional: Le nouveau descriptif.

Returns:

PgQueryWithArgs: Une requête prête à être envoyée au serveur PostgreSQL.

Raises:

UnknownParameterValue: Si le type de relation n’est pas l’une des valeurs autorisées.