Prise en charge de la base de données PostgreSQL.\nPrise en charge DBAPI\nLes options dialect / DBAPI suivantes sont disponibles. Veuillez vous reporter aux sections individuelles de DBAPI pour obtenir des informations sur la connexion.
"},{"id":"text-2","type":"text","heading":"","plain_text":"Séquences / SERIAL / IDENTITY\nPostgreSQL supporte les séquences et SQLAlchemy les utilise par défaut\nde créer de nouvelles valeurs de clé primaire pour les colonnes de clé primaire basées sur des nombres entiers. Quand\ncréer des tables, SQLAlchemy va publier le EN SÉRIE type de données pour\ncolonnes de clé primaire basées sur des nombres entiers, qui génèrent une séquence et un côté serveur\ndéfaut correspondant à la colonne.\nPour spécifier une séquence nommée spécifique à utiliser pour la génération de clé primaire,\nUtilisez le Séquence() construction:","html":"Séquences / SERIAL / IDENTITY\nPostgreSQL supporte les séquences et SQLAlchemy les utilise par défaut\nde créer de nouvelles valeurs de clé primaire pour les colonnes de clé primaire basées sur des nombres entiers. Quand\ncréer des tables, SQLAlchemy va publier le EN SÉRIE type de données pour\ncolonnes de clé primaire basées sur des nombres entiers, qui génèrent une séquence et un côté serveur\ndéfaut correspondant à la colonne.\nPour spécifier une séquence nommée spécifique à utiliser pour la génération de clé primaire,\nUtilisez le Séquence() construction:
"},{"id":"text-3","type":"text","heading":"","plain_text":"Table('quelque chose', métadonnées,\n Colonne('id', Entier, Séquence('some_id_seq'), clé primaire=Vrai)\n )","html":"Table('quelque chose', métadonnées,\n Colonne('id', Entier, Séquence('some_id_seq'), clé primaire=Vrai)\n )
"},{"id":"text-4","type":"text","heading":"","plain_text":"Lorsque SQLAlchemy émet une seule instruction INSERT, pour remplir le contrat de\nayant le "dernier identifiant d'insertion" disponible, une clause RETURNING est ajoutée à\nl'instruction INSERT qui spécifie les colonnes de clé primaire doit être\nretourné une fois la déclaration terminée. La fonctionnalité RETURNING ne prend que\nplace si PostgreSQL 8.2 ou version ultérieure est utilisé. Dans une approche de repli, le\nséquence, spécifiée explicitement ou implicitement via EN SÉRIE, est\npréalablement exécutée indépendamment, la valeur renvoyée à utiliser dans la\ninsertion ultérieure. Notez que lorsqu'un\ninsérer() la construction est exécutée en utilisant\nSémantique «executemany», la fonctionnalité «dernier identifiant inséré» ne\nappliquer; aucune clause RETURNING n’est émise et la séquence n’a pas été pré-exécutée dans cette\nCas.\nPour forcer l'utilisation de RETURNING par défaut, spécifiez l'indicateur.\nimplicit_returning = False à create_engine ().","html":"Lorsque SQLAlchemy émet une seule instruction INSERT, pour remplir le contrat de\nayant le "dernier identifiant d'insertion" disponible, une clause RETURNING est ajoutée à\nl'instruction INSERT qui spécifie les colonnes de clé primaire doit être\nretourné une fois la déclaration terminée. La fonctionnalité RETURNING ne prend que\nplace si PostgreSQL 8.2 ou version ultérieure est utilisé. Dans une approche de repli, le\nséquence, spécifiée explicitement ou implicitement via EN SÉRIE, est\npréalablement exécutée indépendamment, la valeur renvoyée à utiliser dans la\ninsertion ultérieure. Notez que lorsqu'un\ninsérer() la construction est exécutée en utilisant\nSémantique «executemany», la fonctionnalité «dernier identifiant inséré» ne\nappliquer; aucune clause RETURNING n’est émise et la séquence n’a pas été pré-exécutée dans cette\nCas.\nPour forcer l'utilisation de RETURNING par défaut, spécifiez l'indicateur.\nimplicit_returning = False à create_engine ().
"},{"id":"text-5","type":"text","heading":"","plain_text":"Colonnes PostgreSQL 10 IDENTITY\nPostgreSQL 10 a une nouvelle fonctionnalité IDENTITY qui remplace l’utilisation de SERIAL.\nLe support intégré pour le rendu de IDENTITY n’est pas encore disponible, mais le\nle crochet de compilation suivant peut être utilisé pour remplacer les occurrences de SERIAL par\nIDENTITÉ:","html":"Colonnes PostgreSQL 10 IDENTITY\nPostgreSQL 10 a une nouvelle fonctionnalité IDENTITY qui remplace l’utilisation de SERIAL.\nLe support intégré pour le rendu de IDENTITY n’est pas encore disponible, mais le\nle crochet de compilation suivant peut être utilisé pour remplacer les occurrences de SERIAL par\nIDENTITÉ:
"},{"id":"text-6","type":"text","heading":"","plain_text":"de sqlalchemy.schema importation CreateColumn\nde sqlalchemy.ext.compiler importation compile","html":"de sqlalchemy.schema importation CreateColumn\nde sqlalchemy.ext.compiler importation compile
"},{"id":"text-7","type":"text","heading":"","plain_text":"@compiles(CreateColumn, 'postgresql')\ndef use_identity(élément, compilateur, **kw):\n texte = compilateur.visit_create_column(élément, **kw)\n texte = texte.remplacer("EN SÉRIE", "INT GÉNÉRÉ PAR DÉFAUT COMME IDENTITÉ")\n revenir texte","html":"@compiles(CreateColumn, 'postgresql')\ndef use_identity(élément, compilateur, **kw):\n texte = compilateur.visit_create_column(élément, **kw)\n texte = texte.remplacer("EN SÉRIE", "INT GÉNÉRÉ PAR DÉFAUT COMME IDENTITÉ")\n revenir texte
"},{"id":"text-8","type":"text","heading":"","plain_text":"En utilisant ce qui précède, un tableau tel que:","html":"En utilisant ce qui précède, un tableau tel que:
"},{"id":"text-9","type":"text","heading":"","plain_text":"t = Table(\n 't', m,\n Colonne('id', Entier, clé primaire=Vrai),\n Colonne('Les données', Chaîne)\n)","html":"t = Table(\n 't', m,\n Colonne('id', Entier, clé primaire=Vrai),\n Colonne('Les données', Chaîne)\n)
"},{"id":"text-10","type":"text","heading":"","plain_text":"Générera sur la base de données de sauvegarde en tant que:","html":"Générera sur la base de données de sauvegarde en tant que:
"},{"id":"text-11","type":"text","heading":"","plain_text":"CRÉER TABLE t (\n identifiant INT GÉNÉRÉ PAR DÉFAUT COMME IDENTITÉ NE PAS NUL,\n Les données VARCHAR,\n PRIMAIRE CLÉ (identifiant)\n)","html":"CRÉER TABLE t (\n identifiant INT GÉNÉRÉ PAR DÉFAUT COMME IDENTITÉ NE PAS NUL,\n Les données VARCHAR,\n PRIMAIRE CLÉ (identifiant)\n)
"},{"id":"text-12","type":"text","heading":"","plain_text":"Niveau d'isolation de la transaction\nTous les dialectes PostgreSQL supportent la définition du niveau d'isolation des transactions\nà la fois via un paramètre spécifique au dialecte\ncreate_engine.isolation_level accepté par create_engine (),\naussi bien que Connection.execution_options.isolation_level\nargument passé à Connection.execution_options ().\nLors de l’utilisation d’un dialecte autre que psycopg2, cette fonction fonctionne en lançant la commande\nENSEMBLE SESSION LES CARACTÉRISTIQUES COMME TRANSACTION ISOLEMENT NIVEAU pour\nchaque nouvelle connexion. Pour le niveau d'isolement AUTOCOMMIT spécial,\nDes techniques spécifiques à DBAPI sont utilisées.\nPour définir le niveau d'isolement à l'aide de create_engine ():","html":"Niveau d'isolation de la transaction\nTous les dialectes PostgreSQL supportent la définition du niveau d'isolation des transactions\nà la fois via un paramètre spécifique au dialecte\ncreate_engine.isolation_level accepté par create_engine (),\naussi bien que Connection.execution_options.isolation_level\nargument passé à Connection.execution_options ().\nLors de l’utilisation d’un dialecte autre que psycopg2, cette fonction fonctionne en lançant la commande\nENSEMBLE SESSION LES CARACTÉRISTIQUES COMME TRANSACTION ISOLEMENT NIVEAU pour\nchaque nouvelle connexion. Pour le niveau d'isolement AUTOCOMMIT spécial,\nDes techniques spécifiques à DBAPI sont utilisées.\nPour définir le niveau d'isolement à l'aide de create_engine ():
"},{"id":"text-13","type":"text","heading":"","plain_text":"moteur = create_engine(\n "postgresql + pg8000: // scott: tiger @ localhost / test",\n niveau_isolement="READ UNCOMMITTED"\n)","html":"moteur = create_engine(\n "postgresql + pg8000: // scott: tiger @ localhost / test",\n niveau_isolement="READ UNCOMMITTED"\n)
"},{"id":"text-14","type":"text","heading":"","plain_text":"Pour définir à l'aide des options d'exécution par connexion:","html":"Pour définir à l'aide des options d'exécution par connexion:
"},{"id":"text-15","type":"text","heading":"","plain_text":"lien = moteur.relier()\nlien = lien.execution_options(\n niveau_isolement="LIRE ENGAGÉ"\n)","html":"lien = moteur.relier()\nlien = lien.execution_options(\n niveau_isolement="LIRE ENGAGÉ"\n)
"},{"id":"text-16","type":"text","heading":"","plain_text":"Valeurs valides pour niveau_isolement comprendre:","html":"Valeurs valides pour niveau_isolement comprendre:
"},{"id":"text-17","type":"text","heading":"","plain_text":"Introspection de la table de schémas distants et chemin de recherche PostgreSQL\nTL; DR;: garder le chemin_recherche variable définie à sa valeur par défaut de Publique,\nnommer des schémas autre que Publique explicitement dans Table définitions.\nLe dialecte PostgreSQL peut refléter les tables de n’importe quel schéma. le\nTable.schema argument, ou bien la\nMetaData.reflect.schema l'argument détermine quel schéma sera\nêtre recherché pour la ou les tables. Le reflété Table objets\nconservera dans tous les cas cette .schéma attribut comme spécifié.\nCependant, en ce qui concerne les tableaux que ces Table les objets font référence à\nvia une contrainte de clé étrangère, une décision doit être prise quant à la .schéma\nest représenté dans ces tables distantes, dans le cas où cette distance\nnom de schéma est également un membre du courant\nChemin de recherche PostgreSQL.\nPar défaut, le dialecte PostgreSQL reproduit le comportement encouragé par\nPostgreSQL propre pg_get_constraintdef () procédure intégrée. Cette fonction\nrenvoie un exemple de définition pour une contrainte de clé étrangère particulière,\nomettant le nom de schéma référencé de cette définition lorsque le nom est\négalement dans le chemin de recherche du schéma PostgreSQL. L'interaction ci-dessous\nillustre ce comportement:","html":"Introspection de la table de schémas distants et chemin de recherche PostgreSQL\nTL; DR;: garder le chemin_recherche variable définie à sa valeur par défaut de Publique,\nnommer des schémas autre que Publique explicitement dans Table définitions.\nLe dialecte PostgreSQL peut refléter les tables de n’importe quel schéma. le\nTable.schema argument, ou bien la\nMetaData.reflect.schema l'argument détermine quel schéma sera\nêtre recherché pour la ou les tables. Le reflété Table objets\nconservera dans tous les cas cette .schéma attribut comme spécifié.\nCependant, en ce qui concerne les tableaux que ces Table les objets font référence à\nvia une contrainte de clé étrangère, une décision doit être prise quant à la .schéma\nest représenté dans ces tables distantes, dans le cas où cette distance\nnom de schéma est également un membre du courant\nChemin de recherche PostgreSQL.\nPar défaut, le dialecte PostgreSQL reproduit le comportement encouragé par\nPostgreSQL propre pg_get_constraintdef () procédure intégrée. Cette fonction\nrenvoie un exemple de définition pour une contrainte de clé étrangère particulière,\nomettant le nom de schéma référencé de cette définition lorsque le nom est\négalement dans le chemin de recherche du schéma PostgreSQL. L'interaction ci-dessous\nillustre ce comportement:
"},{"id":"text-18","type":"text","heading":"","plain_text":"tester=> CRÉER TABLE test_schema.référé(identifiant ENTIER PRIMAIRE CLÉ)\nCRÉER TABLE\ntester=> CRÉER TABLE référant(\ntester(> identifiant ENTIER PRIMAIRE CLÉ,\ntester(> id_référé ENTIER RÉFÉRENCES test_schema.référé(identifiant));\nCRÉER TABLE\ntester=> ENSEMBLE chemin_recherche À Publique, test_schema;\ntester=> SÉLECTIONNER pg_catalog.pg_get_constraintdef(r.oid, vrai) DE\ntester-> pg_catalog.pg_class c JOINDRE pg_catalog.pg_namespace n\ntester-> SUR n.oid = c.espace de noms\ntester-> JOINDRE pg_catalog.pg_constraint r SUR c.oid = r.conrelide\ntester-> OÙ c.nom de famille='référant' ET r.contype = 'F'\ntester-> ;\n pg_get_constraintdef\n-------------------------------------------------- -\n ÉTRANGER CLÉ (id_référé) RÉFÉRENCES référé(identifiant)\n(1 rangée)","html":"tester=> CRÉER TABLE test_schema.référé(identifiant ENTIER PRIMAIRE CLÉ)\nCRÉER TABLE\ntester=> CRÉER TABLE référant(\ntester(> identifiant ENTIER PRIMAIRE CLÉ,\ntester(> id_référé ENTIER RÉFÉRENCES test_schema.référé(identifiant));\nCRÉER TABLE\ntester=> ENSEMBLE chemin_recherche À Publique, test_schema;\ntester=> SÉLECTIONNER pg_catalog.pg_get_constraintdef(r.oid, vrai) DE\ntester-> pg_catalog.pg_class c JOINDRE pg_catalog.pg_namespace n\ntester-> SUR n.oid = c.espace de noms\ntester-> JOINDRE pg_catalog.pg_constraint r SUR c.oid = r.conrelide\ntester-> OÙ c.nom de famille='référant' ET r.contype = 'F'\ntester-> ;\n pg_get_constraintdef\n-------------------------------------------------- -\n ÉTRANGER CLÉ (id_référé) RÉFÉRENCES référé(identifiant)\n(1 rangée)
"},{"id":"text-19","type":"text","heading":"","plain_text":"Ci-dessus, nous avons créé une table référé en tant que membre du schéma distant\ntest_schemaCependant, lorsque nous avons ajouté test_schema à la\nPG chemin_recherche et ensuite demandé pg_get_constraintdef () pour le\nÉTRANGER CLÉ syntaxe, test_schema n'a pas été inclus dans la sortie de\nla fonction.\nD'autre part, si nous redéfinissons le chemin de recherche sur la valeur par défaut typique\nde Publique:","html":"Ci-dessus, nous avons créé une table référé en tant que membre du schéma distant\ntest_schemaCependant, lorsque nous avons ajouté test_schema à la\nPG chemin_recherche et ensuite demandé pg_get_constraintdef () pour le\nÉTRANGER CLÉ syntaxe, test_schema n'a pas été inclus dans la sortie de\nla fonction.\nD'autre part, si nous redéfinissons le chemin de recherche sur la valeur par défaut typique\nde Publique:
"},{"id":"text-20","type":"text","heading":"","plain_text":"tester=> ENSEMBLE chemin_recherche À Publique;\nENSEMBLE","html":"tester=> ENSEMBLE chemin_recherche À Publique;\nENSEMBLE
"},{"id":"text-21","type":"text","heading":"","plain_text":"La même requête contre pg_get_constraintdef () retourne maintenant complètement\nnom qualifié du schéma pour nous:","html":"La même requête contre pg_get_constraintdef () retourne maintenant complètement\nnom qualifié du schéma pour nous:
"},{"id":"text-22","type":"text","heading":"","plain_text":"tester=> SÉLECTIONNER pg_catalog.pg_get_constraintdef(r.oid, vrai) DE\ntester-> pg_catalog.pg_class c JOINDRE pg_catalog.pg_namespace n\ntester-> SUR n.oid = c.espace de noms\ntester-> JOINDRE pg_catalog.pg_constraint r SUR c.oid = r.conrelide\ntester-> OÙ c.nom de famille='référant' ET r.contype = 'F';\n pg_get_constraintdef\n-------------------------------------------------- -------------\n ÉTRANGER CLÉ (id_référé) RÉFÉRENCES test_schema.référé(identifiant)\n(1 rangée)","html":"tester=> SÉLECTIONNER pg_catalog.pg_get_constraintdef(r.oid, vrai) DE\ntester-> pg_catalog.pg_class c JOINDRE pg_catalog.pg_namespace n\ntester-> SUR n.oid = c.espace de noms\ntester-> JOINDRE pg_catalog.pg_constraint r SUR c.oid = r.conrelide\ntester-> OÙ c.nom de famille='référant' ET r.contype = 'F';\n pg_get_constraintdef\n-------------------------------------------------- -------------\n ÉTRANGER CLÉ (id_référé) RÉFÉRENCES test_schema.référé(identifiant)\n(1 rangée)
"},{"id":"text-23","type":"text","heading":"","plain_text":"SQLAlchemy utilisera par défaut la valeur de retour de pg_get_constraintdef ()\nafin de déterminer le nom du schéma distant. C’est-à-dire si notre chemin_recherche\nont été mis à inclure test_schemaet nous avons invoqué une table\nprocessus de réflexion comme suit:","html":"SQLAlchemy utilisera par défaut la valeur de retour de pg_get_constraintdef ()\nafin de déterminer le nom du schéma distant. C’est-à-dire si notre chemin_recherche\nont été mis à inclure test_schemaet nous avons invoqué une table\nprocessus de réflexion comme suit:
"},{"id":"text-24","type":"text","heading":"","plain_text":">>> de sqlalchemy importation Table, MetaData, create_engine\n>>> moteur = create_engine("postgresql: // scott: tiger @ localhost / test")\n>>> avec moteur.relier() comme Connecticut:\n... Connecticut.exécuter("SET search_path TO test_schema, public")\n... méta = MetaData()\n... référant = Table('référant', méta,\n... chargement automatique=Vrai, autoload_with=Connecticut)\n...","html":">>> de sqlalchemy importation Table, MetaData, create_engine\n>>> moteur = create_engine("postgresql: // scott: tiger @ localhost / test")\n>>> avec moteur.relier() comme Connecticut:\n... Connecticut.exécuter("SET search_path TO test_schema, public")\n... méta = MetaData()\n... référant = Table('référant', méta,\n... chargement automatique=Vrai, autoload_with=Connecticut)\n...
"},{"id":"text-25","type":"text","heading":"","plain_text":"Le processus ci-dessus fournirait à la MetaData.tables collection\nréféré table nommée sans pour autant le schéma:","html":"Le processus ci-dessus fournirait à la MetaData.tables collection\nréféré table nommée sans pour autant le schéma:
"},{"id":"text-26","type":"text","heading":"","plain_text":">>> méta.les tables[[[['référé'].schéma est Aucun\nVrai","html":">>> méta.les tables[[[['référé'].schéma est Aucun\nVrai
"},{"id":"text-27","type":"text","heading":"","plain_text":"Pour modifier le comportement de la réflexion de sorte que le schéma référencé soit\nmaintenu indépendamment de la chemin_recherche réglage, utilisez le\npostgresql_ignore_search_path option, qui peut être spécifiée en tant que\nargument spécifique au dialecte à la fois Table aussi bien que\nMetaData.reflect ():","html":"Pour modifier le comportement de la réflexion de sorte que le schéma référencé soit\nmaintenu indépendamment de la chemin_recherche réglage, utilisez le\npostgresql_ignore_search_path option, qui peut être spécifiée en tant que\nargument spécifique au dialecte à la fois Table aussi bien que\nMetaData.reflect ():
"},{"id":"text-28","type":"text","heading":"","plain_text":">>> avec moteur.relier() comme Connecticut:\n... Connecticut.exécuter("SET search_path TO test_schema, public")\n... méta = MetaData()\n... référant = Table('référant', méta, chargement automatique=Vrai,\n... autoload_with=Connecticut,\n... postgresql_ignore_search_path=Vrai)\n...","html":">>> avec moteur.relier() comme Connecticut:\n... Connecticut.exécuter("SET search_path TO test_schema, public")\n... méta = MetaData()\n... référant = Table('référant', méta, chargement automatique=Vrai,\n... autoload_with=Connecticut,\n... postgresql_ignore_search_path=Vrai)\n...
"},{"id":"text-29","type":"text","heading":"","plain_text":"Nous allons maintenant avoir test_schema.referred stocké comme qualifié de schéma:","html":"Nous allons maintenant avoir test_schema.referred stocké comme qualifié de schéma:
"},{"id":"text-30","type":"text","heading":"","plain_text":">>> méta.les tables[[[['test_schema.referred'].schéma\n'test_schema'","html":">>> méta.les tables[[[['test_schema.referred'].schéma\n'test_schema'
"},{"id":"text-31","type":"text","heading":"","plain_text":"Notez que dans tous les cas, le schéma «par défaut» est toujours reflété comme\nAucun. Le schéma «par défaut» sur PostgreSQL est celui qui est renvoyé par le\nPostgreSQL current_schema () une fonction. Sur un PostgreSQL typique\nl'installation, c'est le nom Publique. Donc, un tableau qui fait référence à un autre\nqui est dans le Publique (c'est-à-dire par défaut) le schéma aura toujours le\n.schéma attribut mis à Aucun.","html":"Notez que dans tous les cas, le schéma «par défaut» est toujours reflété comme\nAucun. Le schéma «par défaut» sur PostgreSQL est celui qui est renvoyé par le\nPostgreSQL current_schema () une fonction. Sur un PostgreSQL typique\nl'installation, c'est le nom Publique. Donc, un tableau qui fait référence à un autre\nqui est dans le Publique (c'est-à-dire par défaut) le schéma aura toujours le\n.schéma attribut mis à Aucun.
"},{"id":"text-32","type":"text","heading":"","plain_text":"Nouveau dans la version 0.9.2: Ajouté le postgresql_ignore_search_path\noption dialecte acceptée par Table et\nMetaData.reflect ().","html":"Nouveau dans la version 0.9.2: Ajouté le postgresql_ignore_search_path\noption dialecte acceptée par Table et\nMetaData.reflect ().
"},{"id":"text-33","type":"text","heading":"","plain_text":"INSERT / UPDATE… RETOURNER\nLe dialecte supporte les PG 8.2 INSERT..RECLINANT, MISE À JOUR..RECLINANT et\nSUPPRIMER .. RETOURNER syntaxes. INSERT..RECLINANT est utilisé par défaut\npour les instructions INSERT à une seule ligne afin d'extraire les données nouvellement générées\nidentificateurs de clé primaire. Pour spécifier un explicite RETOUR clause,\nUtilisez le _UpdateBase.returning () méthode par déclaration:","html":"INSERT / UPDATE… RETOURNER\nLe dialecte supporte les PG 8.2 INSERT..RECLINANT, MISE À JOUR..RECLINANT et\nSUPPRIMER .. RETOURNER syntaxes. INSERT..RECLINANT est utilisé par défaut\npour les instructions INSERT à une seule ligne afin d'extraire les données nouvellement générées\nidentificateurs de clé primaire. Pour spécifier un explicite RETOUR clause,\nUtilisez le _UpdateBase.returning () méthode par déclaration:
"},{"id":"text-34","type":"text","heading":"","plain_text":"# INSERT..RETURNING\nrésultat = table.insérer().rentrant(table.c.col1, table.c.col2).\n valeurs(Nom='foo')\nimpression résultat.fetchall()","html":"# INSERT..RETURNING\nrésultat = table.insérer().rentrant(table.c.col1, table.c.col2).\n valeurs(Nom='foo')\nimpression résultat.fetchall()
"},{"id":"text-35","type":"text","heading":"","plain_text":"# UPDATE..RETURNING\nrésultat = table.mise à jour().rentrant(table.c.col1, table.c.col2).\n où(table.c.Nom=='foo').valeurs(Nom='bar')\nimpression résultat.fetchall()","html":"# UPDATE..RETURNING\nrésultat = table.mise à jour().rentrant(table.c.col1, table.c.col2).\n où(table.c.Nom=='foo').valeurs(Nom='bar')\nimpression résultat.fetchall()
"},{"id":"text-36","type":"text","heading":"","plain_text":"# DELETE..RETURNING\nrésultat = table.effacer().rentrant(table.c.col1, table.c.col2).\n où(table.c.Nom=='foo')\nimpression résultat.fetchall()","html":"# DELETE..RETURNING\nrésultat = table.effacer().rentrant(table.c.col1, table.c.col2).\n où(table.c.Nom=='foo')\nimpression résultat.fetchall()
"},{"id":"text-37","type":"text","heading":"","plain_text":"INSERT… SUR CONFLICT (Upsert)\nA partir de la version 9.5, PostgreSQL permet les «upserts» (mises à jour ou insert) de\nlignes dans une table via le SUR CONFLIT clause de la INSÉRER déclaration. UNE\nLa ligne candidate ne sera insérée que si cette ligne ne viole aucun code unique.\ncontraintes. Dans le cas d’une violation de contrainte unique, une action secondaire\npeut être soit “DO UPDATE”, indiquant que les données dans le fichier\nla ligne cible doit être mise à jour, ou “NE RIEN FAIRE”, ce qui indique de sauter silencieusement\ncette rangée.\nLes conflits sont déterminés à l'aide de contraintes et d'index uniques existants. Celles-ci\nles contraintes peuvent être identifiées en utilisant leur nom comme indiqué dans DDL,\nou ils peuvent être inféré en indiquant les colonnes et les conditions qui composent\nles index.\nSQLAlchemy fournit SUR CONFLIT support via le spécifique PostgreSQL\npostgresql.dml.insert () fonction, qui fournit\nles méthodes génératives on_conflict_do_update ()\net on_conflict_do_nothing ():","html":"INSERT… SUR CONFLICT (Upsert)\nA partir de la version 9.5, PostgreSQL permet les «upserts» (mises à jour ou insert) de\nlignes dans une table via le SUR CONFLIT clause de la INSÉRER déclaration. UNE\nLa ligne candidate ne sera insérée que si cette ligne ne viole aucun code unique.\ncontraintes. Dans le cas d’une violation de contrainte unique, une action secondaire\npeut être soit “DO UPDATE”, indiquant que les données dans le fichier\nla ligne cible doit être mise à jour, ou “NE RIEN FAIRE”, ce qui indique de sauter silencieusement\ncette rangée.\nLes conflits sont déterminés à l'aide de contraintes et d'index uniques existants. Celles-ci\nles contraintes peuvent être identifiées en utilisant leur nom comme indiqué dans DDL,\nou ils peuvent être inféré en indiquant les colonnes et les conditions qui composent\nles index.\nSQLAlchemy fournit SUR CONFLIT support via le spécifique PostgreSQL\npostgresql.dml.insert () fonction, qui fournit\nles méthodes génératives on_conflict_do_update ()\net on_conflict_do_nothing ():
"},{"id":"text-38","type":"text","heading":"","plain_text":"de sqlalchemy.dialects.postgresql importation insérer","html":"de sqlalchemy.dialects.postgresql importation insérer
"},{"id":"text-39","type":"text","heading":"","plain_text":"insert_stmt = insérer(ma table).valeurs(\n identifiant='some_existing_id',\n Les données='valeur insérée')","html":"insert_stmt = insérer(ma table).valeurs(\n identifiant='some_existing_id',\n Les données='valeur insérée')
"},{"id":"text-40","type":"text","heading":"","plain_text":"do_nothing_stmt = insert_stmt.on_conflict_do_nothing(\n éléments_index=[[[['id']\n)","html":"do_nothing_stmt = insert_stmt.on_conflict_do_nothing(\n éléments_index=[[[['id']\n)
"},{"id":"text-41","type":"text","heading":"","plain_text":"Connecticut.exécuter(do_nothing_stmt)","html":"Connecticut.exécuter(do_nothing_stmt)
"},{"id":"text-42","type":"text","heading":"","plain_text":"do_update_stmt = insert_stmt.on_conflict_do_update(\n contrainte='pk_my_table',\n ensemble_=dict(Les données='valeur mise à jour')\n)","html":"do_update_stmt = insert_stmt.on_conflict_do_update(\n contrainte='pk_my_table',\n ensemble_=dict(Les données='valeur mise à jour')\n)
"},{"id":"text-43","type":"text","heading":"","plain_text":"Connecticut.exécuter(do_update_stmt)","html":"Connecticut.exécuter(do_update_stmt)
"},{"id":"text-44","type":"text","heading":"","plain_text":"Les deux méthodes fournissent la "cible" du conflit en utilisant soit la\ncontrainte nommée ou par inférence de colonne:","html":"Les deux méthodes fournissent la "cible" du conflit en utilisant soit la\ncontrainte nommée ou par inférence de colonne:
"},{"id":"text-45","type":"text","heading":"","plain_text":"le Insert.on_conflict_do_update.index_elements argument\nspécifie une séquence contenant des noms de colonne de chaîne, Colonne\ndes objets, et / ou des éléments d’expression SQL, qui identifieraient un unique\nindice:","html":"le Insert.on_conflict_do_update.index_elements argument\nspécifie une séquence contenant des noms de colonne de chaîne, Colonne\ndes objets, et / ou des éléments d’expression SQL, qui identifieraient un unique\nindice:
"},{"id":"text-46","type":"text","heading":"","plain_text":"do_update_stmt = insert_stmt.on_conflict_do_update(\n éléments_index=[[[['id'],\n ensemble_=dict(Les données='valeur mise à jour')\n)","html":"do_update_stmt = insert_stmt.on_conflict_do_update(\n éléments_index=[[[['id'],\n ensemble_=dict(Les données='valeur mise à jour')\n)
"},{"id":"text-47","type":"text","heading":"","plain_text":"do_update_stmt = insert_stmt.on_conflict_do_update(\n éléments_index=[[[[ma table.c.identifiant],\n ensemble_=dict(Les données='valeur mise à jour')\n)","html":"do_update_stmt = insert_stmt.on_conflict_do_update(\n éléments_index=[[[[ma table.c.identifiant],\n ensemble_=dict(Les données='valeur mise à jour')\n)
"},{"id":"text-48","type":"text","heading":"","plain_text":"Lors de l'utilisation Insert.on_conflict_do_update.index_elements à\ndéduire un index, un index partiel peut être déduit en spécifiant également le\nUtilisez le Insert.on_conflict_do_update.index_where paramètre:","html":"Lors de l'utilisation Insert.on_conflict_do_update.index_elements à\ndéduire un index, un index partiel peut être déduit en spécifiant également le\nUtilisez le Insert.on_conflict_do_update.index_where paramètre:
"},{"id":"text-49","type":"text","heading":"","plain_text":"de sqlalchemy.dialects.postgresql importation insérer","html":"de sqlalchemy.dialects.postgresql importation insérer
"},{"id":"text-50","type":"text","heading":"","plain_text":"stmt = insérer(ma table).valeurs(utilisateur_email='a@b.com', Les données='données insérées')\nstmt = stmt.on_conflict_do_update(\n éléments_index=[[[[ma table.c.utilisateur_email],\n index_where=ma table.c.utilisateur_email.comme('%@gmail.com'),\n ensemble_=dict(Les données=stmt.exclu.Les données)\n )\nConnecticut.exécuter(stmt)","html":"stmt = insérer(ma table).valeurs(utilisateur_email='a@b.com', Les données='données insérées')\nstmt = stmt.on_conflict_do_update(\n éléments_index=[[[[ma table.c.utilisateur_email],\n index_where=ma table.c.utilisateur_email.comme('%@gmail.com'),\n ensemble_=dict(Les données=stmt.exclu.Les données)\n )\nConnecticut.exécuter(stmt)
"},{"id":"text-51","type":"text","heading":"","plain_text":"le Insert.on_conflict_do_update.constraint l'argument est\nutilisé pour spécifier directement un index plutôt que de l'inférer. Cela peut être\nle nom d'une contrainte UNIQUE, d'une contrainte PRIMARY KEY ou d'un INDEX:","html":"le Insert.on_conflict_do_update.constraint l'argument est\nutilisé pour spécifier directement un index plutôt que de l'inférer. Cela peut être\nle nom d'une contrainte UNIQUE, d'une contrainte PRIMARY KEY ou d'un INDEX:
"},{"id":"text-52","type":"text","heading":"","plain_text":"do_update_stmt = insert_stmt.on_conflict_do_update(\n contrainte='ma_table_idx_1',\n ensemble_=dict(Les données='valeur mise à jour')\n)","html":"do_update_stmt = insert_stmt.on_conflict_do_update(\n contrainte='ma_table_idx_1',\n ensemble_=dict(Les données='valeur mise à jour')\n)
"},{"id":"text-53","type":"text","heading":"","plain_text":"do_update_stmt = insert_stmt.on_conflict_do_update(\n contrainte='ma_table_pk',\n ensemble_=dict(Les données='valeur mise à jour')\n)","html":"do_update_stmt = insert_stmt.on_conflict_do_update(\n contrainte='ma_table_pk',\n ensemble_=dict(Les données='valeur mise à jour')\n)
"},{"id":"text-54","type":"text","heading":"","plain_text":"le Insert.on_conflict_do_update.constraint argument peut\nse référer également à une construction SQLAlchemy représentant une contrainte,\npar exemple. Contrainte unique, PrimaryKeyConstraint,\nIndice, ou ExcludeConstraint. Dans cette utilisation,\nsi la contrainte a un nom, elle est utilisée directement. Sinon, si le\ncontrainte est non nommée, alors l’inférence sera utilisée, où les expressions\net la clause optionnelle WHERE de la contrainte sera précisée dans le\nconstruction. Cette utilisation est particulièrement pratique\nfaire référence à la clé primaire nommée ou non nommée d'un Table en utilisant le\nTable.primary_key attribut:","html":"le Insert.on_conflict_do_update.constraint argument peut\nse référer également à une construction SQLAlchemy représentant une contrainte,\npar exemple. Contrainte unique, PrimaryKeyConstraint,\nIndice, ou ExcludeConstraint. Dans cette utilisation,\nsi la contrainte a un nom, elle est utilisée directement. Sinon, si le\ncontrainte est non nommée, alors l’inférence sera utilisée, où les expressions\net la clause optionnelle WHERE de la contrainte sera précisée dans le\nconstruction. Cette utilisation est particulièrement pratique\nfaire référence à la clé primaire nommée ou non nommée d'un Table en utilisant le\nTable.primary_key attribut:
"},{"id":"text-55","type":"text","heading":"","plain_text":"do_update_stmt = insert_stmt.on_conflict_do_update(\n contrainte=ma table.clé primaire,\n ensemble_=dict(Les données='valeur mise à jour')\n)","html":"do_update_stmt = insert_stmt.on_conflict_do_update(\n contrainte=ma table.clé primaire,\n ensemble_=dict(Les données='valeur mise à jour')\n)
"},{"id":"text-56","type":"text","heading":"","plain_text":"SUR CONFLIT ... FAIRE MISE À JOUR est utilisé pour effectuer une mise à jour du déjà\nligne existante, en utilisant n'importe quelle combinaison de nouvelles valeurs ainsi que de valeurs\nde l'insertion proposée. Ces valeurs sont spécifiées à l'aide du\nInsert.on_conflict_do_update.set_ paramètre. Cette\nparamètre accepte un dictionnaire composé de valeurs directes\npour UPDATE:","html":"SUR CONFLIT ... FAIRE MISE À JOUR est utilisé pour effectuer une mise à jour du déjà\nligne existante, en utilisant n'importe quelle combinaison de nouvelles valeurs ainsi que de valeurs\nde l'insertion proposée. Ces valeurs sont spécifiées à l'aide du\nInsert.on_conflict_do_update.set_ paramètre. Cette\nparamètre accepte un dictionnaire composé de valeurs directes\npour UPDATE:
"},{"id":"text-57","type":"text","heading":"","plain_text":"de sqlalchemy.dialects.postgresql importation insérer","html":"de sqlalchemy.dialects.postgresql importation insérer
"},{"id":"text-58","type":"text","heading":"","plain_text":"stmt = insérer(ma table).valeurs(identifiant='some_id', Les données='valeur insérée')\ndo_update_stmt = stmt.on_conflict_do_update(\n éléments_index=[[[['id'],\n ensemble_=dict(Les données='valeur mise à jour')\n )\nConnecticut.exécuter(do_update_stmt)","html":"stmt = insérer(ma table).valeurs(identifiant='some_id', Les données='valeur insérée')\ndo_update_stmt = stmt.on_conflict_do_update(\n éléments_index=[[[['id'],\n ensemble_=dict(Les données='valeur mise à jour')\n )\nConnecticut.exécuter(do_update_stmt)
"},{"id":"text-59","type":"text","heading":"","plain_text":"Pour faire référence à la ligne d’insertion proposée, l’alias spécial\nexclu est disponible en tant qu'attribut sur\nle postgresql.dml.Insert objet; cet objet est un\nColumnCollection lequel alias contient toutes les colonnes de la cible\ntable:","html":"Pour faire référence à la ligne d’insertion proposée, l’alias spécial\nexclu est disponible en tant qu'attribut sur\nle postgresql.dml.Insert objet; cet objet est un\nColumnCollection lequel alias contient toutes les colonnes de la cible\ntable:
"},{"id":"text-60","type":"text","heading":"","plain_text":"de sqlalchemy.dialects.postgresql importation insérer","html":"de sqlalchemy.dialects.postgresql importation insérer
"},{"id":"text-61","type":"text","heading":"","plain_text":"stmt = insérer(ma table).valeurs(\n identifiant='some_id',\n Les données='valeur insérée',\n auteur='jlh')\ndo_update_stmt = stmt.on_conflict_do_update(\n éléments_index=[[[['id'],\n ensemble_=dict(Les données='valeur mise à jour', auteur=stmt.exclu.auteur)\n )\nConnecticut.exécuter(do_update_stmt)","html":"stmt = insérer(ma table).valeurs(\n identifiant='some_id',\n Les données='valeur insérée',\n auteur='jlh')\ndo_update_stmt = stmt.on_conflict_do_update(\n éléments_index=[[[['id'],\n ensemble_=dict(Les données='valeur mise à jour', auteur=stmt.exclu.auteur)\n )\nConnecticut.exécuter(do_update_stmt)
"},{"id":"text-62","type":"text","heading":"","plain_text":"le Insert.on_conflict_do_update () méthode accepte également\nune clause WHERE utilisant le Insert.on_conflict_do_update.where\nparamètre, qui limitera les lignes qui reçoivent un UPDATE:","html":"le Insert.on_conflict_do_update () méthode accepte également\nune clause WHERE utilisant le Insert.on_conflict_do_update.where\nparamètre, qui limitera les lignes qui reçoivent un UPDATE:
"},{"id":"text-63","type":"text","heading":"","plain_text":"de sqlalchemy.dialects.postgresql importation insérer","html":"de sqlalchemy.dialects.postgresql importation insérer
"},{"id":"text-64","type":"text","heading":"","plain_text":"stmt = insérer(ma table).valeurs(\n identifiant='some_id',\n Les données='valeur insérée',\n auteur='jlh')\non_update_stmt = stmt.on_conflict_do_update(\n éléments_index=[[[['id'],\n ensemble_=dict(Les données='valeur mise à jour', auteur=stmt.exclu.auteur)\n où=(ma table.c.statut == 2)\n )\nConnecticut.exécuter(on_update_stmt)","html":"stmt = insérer(ma table).valeurs(\n identifiant='some_id',\n Les données='valeur insérée',\n auteur='jlh')\non_update_stmt = stmt.on_conflict_do_update(\n éléments_index=[[[['id'],\n ensemble_=dict(Les données='valeur mise à jour', auteur=stmt.exclu.auteur)\n où=(ma table.c.statut == 2)\n )\nConnecticut.exécuter(on_update_stmt)
"},{"id":"text-65","type":"text","heading":"","plain_text":"SUR CONFLIT peut également être utilisé pour ignorer l'insertion complète d'une ligne\nen cas de conflit avec une contrainte unique ou d'exclusion; au dessous de\nceci est illustré en utilisant le\non_conflict_do_nothing () méthode:","html":"SUR CONFLIT peut également être utilisé pour ignorer l'insertion complète d'une ligne\nen cas de conflit avec une contrainte unique ou d'exclusion; au dessous de\nceci est illustré en utilisant le\non_conflict_do_nothing () méthode:
"},{"id":"text-66","type":"text","heading":"","plain_text":"de sqlalchemy.dialects.postgresql importation insérer","html":"de sqlalchemy.dialects.postgresql importation insérer
"},{"id":"text-67","type":"text","heading":"","plain_text":"stmt = insérer(ma table).valeurs(identifiant='some_id', Les données='valeur insérée')\nstmt = stmt.on_conflict_do_nothing(éléments_index=[[[['id'])\nConnecticut.exécuter(stmt)","html":"stmt = insérer(ma table).valeurs(identifiant='some_id', Les données='valeur insérée')\nstmt = stmt.on_conflict_do_nothing(éléments_index=[[[['id'])\nConnecticut.exécuter(stmt)
"},{"id":"text-68","type":"text","heading":"","plain_text":"Si FAIRE RIEN est utilisé sans spécifier de colonne ou de contrainte,\nil a pour effet de sauter l'INSERT pour toute exception unique ou d'exclusion\nviolation de contrainte qui se produit:","html":"Si FAIRE RIEN est utilisé sans spécifier de colonne ou de contrainte,\nil a pour effet de sauter l'INSERT pour toute exception unique ou d'exclusion\nviolation de contrainte qui se produit:
"},{"id":"text-69","type":"text","heading":"","plain_text":"de sqlalchemy.dialects.postgresql importation insérer","html":"de sqlalchemy.dialects.postgresql importation insérer
"},{"id":"text-70","type":"text","heading":"","plain_text":"stmt = insérer(ma table).valeurs(identifiant='some_id', Les données='valeur insérée')\nstmt = stmt.on_conflict_do_nothing()\nConnecticut.exécuter(stmt)","html":"stmt = insérer(ma table).valeurs(identifiant='some_id', Les données='valeur insérée')\nstmt = stmt.on_conflict_do_nothing()\nConnecticut.exécuter(stmt)
"},{"id":"text-71","type":"text","heading":"","plain_text":"Nouveau dans la version 1.1: Ajout du support pour les clauses PostgreSQL ™ ON CONFLICT","html":"Nouveau dans la version 1.1: Ajout du support pour les clauses PostgreSQL ™ ON CONFLICT
"},{"id":"text-72","type":"text","heading":"","plain_text":"Recherche en texte intégral\nSQLAlchemy met à disposition le PostgreSQL @@ opérateur via le\nColumnElement.match () méthode sur toute expression de colonne textuelle.\nSur un dialecte PostgreSQL, une expression comme celle-ci:","html":"Recherche en texte intégral\nSQLAlchemy met à disposition le PostgreSQL @@ opérateur via le\nColumnElement.match () méthode sur toute expression de colonne textuelle.\nSur un dialecte PostgreSQL, une expression comme celle-ci:
"},{"id":"text-73","type":"text","heading":"","plain_text":"sélectionner([[[[quelque chose.c.texte.rencontre("chaîne de recherche")])","html":"sélectionner([[[[quelque chose.c.texte.rencontre("chaîne de recherche")])
"},{"id":"text-74","type":"text","heading":"","plain_text":"émettra dans la base de données:","html":"émettra dans la base de données:
"},{"id":"text-75","type":"text","heading":"","plain_text":"SÉLECTIONNER texte @@ to_tsquery('chaîne de recherche') DE table","html":"SÉLECTIONNER texte @@ to_tsquery('chaîne de recherche') DE table
"},{"id":"text-76","type":"text","heading":"","plain_text":"Les fonctions de recherche de texte PostgreSQL telles que to_tsquery ()\net to_tsvector () sont disponibles\nen utilisant explicitement la norme func construction. Par exemple:","html":"Les fonctions de recherche de texte PostgreSQL telles que to_tsquery ()\net to_tsvector () sont disponibles\nen utilisant explicitement la norme func construction. Par exemple:
"},{"id":"text-77","type":"text","heading":"","plain_text":"sélectionner([[[[\n func.to_tsvector("les gros chats mangeaient des rats").rencontre('chat et rat')\n])","html":"sélectionner([[[[\n func.to_tsvector("les gros chats mangeaient des rats").rencontre('chat et rat')\n])
"},{"id":"text-78","type":"text","heading":"","plain_text":"Emet l'équivalent de:","html":"Emet l'équivalent de:
"},{"id":"text-79","type":"text","heading":"","plain_text":"SÉLECTIONNER to_tsvector("les gros chats mangeaient des rats") @@ to_tsquery('chat et rat')","html":"SÉLECTIONNER to_tsvector("les gros chats mangeaient des rats") @@ to_tsquery('chat et rat')
"},{"id":"text-80","type":"text","heading":"","plain_text":"le postgresql.TSVECTOR type peut fournir des CAST explicites:","html":"le postgresql.TSVECTOR type peut fournir des CAST explicites:
"},{"id":"text-81","type":"text","heading":"","plain_text":"de sqlalchemy.dialects.postgresql importation TSVECTOR\nde sqlalchemy importation sélectionner, jeter\nsélectionner([[[[jeter("Du texte", TSVECTOR)])","html":"de sqlalchemy.dialects.postgresql importation TSVECTOR\nde sqlalchemy importation sélectionner, jeter\nsélectionner([[[[jeter("Du texte", TSVECTOR)])
"},{"id":"text-82","type":"text","heading":"","plain_text":"produit une déclaration équivalente à:","html":"produit une déclaration équivalente à:
"},{"id":"text-83","type":"text","heading":"","plain_text":"SÉLECTIONNER JETER('Du texte' COMME TSVECTOR) COMME anon_1","html":"SÉLECTIONNER JETER('Du texte' COMME TSVECTOR) COMME anon_1
"},{"id":"text-84","type":"text","heading":"","plain_text":"Les recherches en texte intégral dans PostgreSQL sont influencées par la combinaison de:\nParamètre PostgreSQL de default_text_search_config, le regconfig utilisé\npour construire les index GIN / GiST, et le regconfig éventuellement passé\nlors d'une requête.\nLorsque vous effectuez une recherche en texte intégral sur une colonne comportant un code GIN ou\nIndex GiST déjà pré-calculé (qui est commun au texte intégral\nrecherches), il peut être nécessaire de passer explicitement à un serveur PostgreSQL spécifique.\nregconfig valeur pour assurer que le planificateur de requêtes utilise l'index et\nne pas recalculer la colonne à la demande.\nAfin de permettre cette planification explicite des requêtes, ou d’utiliser différentes\nstratégies de recherche, la rencontre méthode accepte un postgresql_regconfig\nargument de mot clé:","html":"Les recherches en texte intégral dans PostgreSQL sont influencées par la combinaison de:\nParamètre PostgreSQL de default_text_search_config, le regconfig utilisé\npour construire les index GIN / GiST, et le regconfig éventuellement passé\nlors d'une requête.\nLorsque vous effectuez une recherche en texte intégral sur une colonne comportant un code GIN ou\nIndex GiST déjà pré-calculé (qui est commun au texte intégral\nrecherches), il peut être nécessaire de passer explicitement à un serveur PostgreSQL spécifique.\nregconfig valeur pour assurer que le planificateur de requêtes utilise l'index et\nne pas recalculer la colonne à la demande.\nAfin de permettre cette planification explicite des requêtes, ou d’utiliser différentes\nstratégies de recherche, la rencontre méthode accepte un postgresql_regconfig\nargument de mot clé:
"},{"id":"text-85","type":"text","heading":"","plain_text":"sélectionner([[[[ma table.c.identifiant]).où(\n ma table.c.Titre.rencontre('somestring', postgresql_regconfig='Anglais')\n)","html":"sélectionner([[[[ma table.c.identifiant]).où(\n ma table.c.Titre.rencontre('somestring', postgresql_regconfig='Anglais')\n)
"},{"id":"text-86","type":"text","heading":"","plain_text":"Emet l'équivalent de:","html":"Emet l'équivalent de:
"},{"id":"text-87","type":"text","heading":"","plain_text":"SÉLECTIONNER ma table.identifiant DE ma table\nOÙ ma table.Titre @@ to_tsquery('Anglais', 'somestring')","html":"SÉLECTIONNER ma table.identifiant DE ma table\nOÙ ma table.Titre @@ to_tsquery('Anglais', 'somestring')
"},{"id":"text-88","type":"text","heading":"","plain_text":"On peut aussi spécifiquement passer dans un «Regconfig» valeur à la\nto_tsvector () commande comme argument initial:","html":"On peut aussi spécifiquement passer dans un «Regconfig» valeur à la\nto_tsvector () commande comme argument initial:
"},{"id":"text-89","type":"text","heading":"","plain_text":"sélectionner([[[[ma table.c.identifiant]).où(\n func.to_tsvector('Anglais', ma table.c.Titre )\n .rencontre('somestring', postgresql_regconfig='Anglais')\n )","html":"sélectionner([[[[ma table.c.identifiant]).où(\n func.to_tsvector('Anglais', ma table.c.Titre )\n .rencontre('somestring', postgresql_regconfig='Anglais')\n )
"},{"id":"text-90","type":"text","heading":"","plain_text":"produit une déclaration équivalente à:","html":"produit une déclaration équivalente à:
"},{"id":"text-91","type":"text","heading":"","plain_text":"SÉLECTIONNER ma table.identifiant DE ma table\nOÙ to_tsvector('Anglais', ma table.Titre) @@\n to_tsquery('Anglais', 'somestring')","html":"SÉLECTIONNER ma table.identifiant DE ma table\nOÙ to_tsvector('Anglais', ma table.Titre) @@\n to_tsquery('Anglais', 'somestring')
"},{"id":"text-92","type":"text","heading":"","plain_text":"Il est recommandé d’utiliser le EXPLIQUE ANALYSER... outil de\nPostgreSQL ™ pour vous assurer que vous générez des requêtes avec SQLAlchemy qui\nTirez pleinement parti des index que vous avez éventuellement créés pour la recherche en texte intégral.","html":"Il est recommandé d’utiliser le EXPLIQUE ANALYSER... outil de\nPostgreSQL ™ pour vous assurer que vous générez des requêtes avec SQLAlchemy qui\nTirez pleinement parti des index que vous avez éventuellement créés pour la recherche en texte intégral.
"},{"id":"text-93","type":"text","heading":"","plain_text":"DE SEULEMENT…\nLe dialecte prend en charge le mot clé ONLY de PostgreSQL pour ne cibler que certains\ntable dans une hiérarchie d'héritage. Ceci peut être utilisé pour produire le\nSÉLECTIONNER ... DE SEULEMENT, MISE À JOUR SEULEMENT ..., et EFFACER DE SEULEMENT ...\nsyntaxes. Il utilise le mécanisme des astuces de SQLAlchemy:","html":"DE SEULEMENT…\nLe dialecte prend en charge le mot clé ONLY de PostgreSQL pour ne cibler que certains\ntable dans une hiérarchie d'héritage. Ceci peut être utilisé pour produire le\nSÉLECTIONNER ... DE SEULEMENT, MISE À JOUR SEULEMENT ..., et EFFACER DE SEULEMENT ...\nsyntaxes. Il utilise le mécanisme des astuces de SQLAlchemy:
"},{"id":"text-94","type":"text","heading":"","plain_text":"# SELECTIONNER ... A PARTIR DE ...\nrésultat = table.sélectionner().avec_hint(table, 'SEULEMENT', 'postgresql')\nimpression résultat.fetchall()","html":"# SELECTIONNER ... A PARTIR DE ...\nrésultat = table.sélectionner().avec_hint(table, 'SEULEMENT', 'postgresql')\nimpression résultat.fetchall()
"},{"id":"text-95","type":"text","heading":"","plain_text":"# MISE À JOUR UNIQUEMENT ...\ntable.mise à jour(valeurs=dict(foo='bar')).avec_hint('SEULEMENT',\n nom du dialecte='postgresql')","html":"# MISE À JOUR UNIQUEMENT ...\ntable.mise à jour(valeurs=dict(foo='bar')).avec_hint('SEULEMENT',\n nom du dialecte='postgresql')
"},{"id":"text-96","type":"text","heading":"","plain_text":"# SUPPRIMER DE SEULEMENT ...\ntable.effacer().avec_hint('SEULEMENT', nom du dialecte='postgresql')","html":"# SUPPRIMER DE SEULEMENT ...\ntable.effacer().avec_hint('SEULEMENT', nom du dialecte='postgresql')
"},{"id":"text-97","type":"text","heading":"","plain_text":"Options d'index spécifiques à PostgreSQL\nPlusieurs extensions à la Indice construct sont disponibles, spécifiques\nau dialecte PostgreSQL.","html":"Options d'index spécifiques à PostgreSQL\nPlusieurs extensions à la Indice construct sont disponibles, spécifiques\nau dialecte PostgreSQL.
"},{"id":"text-98","type":"text","heading":"","plain_text":"Index partiels\nLes index partiels ajoutent un critère à la définition de l’index afin que celui-ci soit\nappliqué à un sous-ensemble de lignes. Ceux-ci peuvent être spécifiés sur Indice\nen utilisant le postgresql_where argument de mot clé:","html":"Index partiels\nLes index partiels ajoutent un critère à la définition de l’index afin que celui-ci soit\nappliqué à un sous-ensemble de lignes. Ceux-ci peuvent être spécifiés sur Indice\nen utilisant le postgresql_where argument de mot clé:
"},{"id":"text-99","type":"text","heading":"","plain_text":"Indice('mon_index', ma table.c.identifiant, postgresql_where=ma table.c.valeur > dix)","html":"Indice('mon_index', ma table.c.identifiant, postgresql_where=ma table.c.valeur > dix)
"},{"id":"text-100","type":"text","heading":"","plain_text":"Classes d'opérateurs\nPostgreSQL permet la spécification d’un classe d'opérateur pour chaque colonne de\nun index (voir\nhttp://www.postgresql.org/docs/8.3/interactive/indexes-opclass.html).\nle Indice la construction permet de les spécifier via le\npostgresql_ops argument de mot clé:","html":"Classes d'opérateurs\nPostgreSQL permet la spécification d’un classe d'opérateur pour chaque colonne de\nun index (voir\nhttp://www.postgresql.org/docs/8.3/interactive/indexes-opclass.html).\nle Indice la construction permet de les spécifier via le\npostgresql_ops argument de mot clé:
"},{"id":"text-101","type":"text","heading":"","plain_text":"Indice(\n 'mon_index', ma table.c.identifiant, ma table.c.Les données,\n postgresql_ops=\n 'Les données': 'text_pattern_ops',\n 'id': 'int4_ops'\n )","html":"Indice(\n 'mon_index', ma table.c.identifiant, ma table.c.Les données,\n postgresql_ops=\n 'Les données': 'text_pattern_ops',\n 'id': 'int4_ops'\n )
"},{"id":"text-102","type":"text","heading":"","plain_text":"Notez que les clés dans le postgresql_ops dictionnaire sont le nom “clé” de\nle Colonnec'est-à-dire le nom utilisé pour y accéder depuis le .c\ncollection de Table, qui peut être configuré pour être différent de\nle nom réel de la colonne tel qu'il est exprimé dans la base de données.\nSi postgresql_ops doit être utilisé contre une expression SQL complexe telle que\nen tant qu'appel de fonction, pour l'appliquer à la colonne, il faut lui attribuer une étiquette\nqui est identifié dans le dictionnaire par son nom, par exemple:","html":"Notez que les clés dans le postgresql_ops dictionnaire sont le nom “clé” de\nle Colonnec'est-à-dire le nom utilisé pour y accéder depuis le .c\ncollection de Table, qui peut être configuré pour être différent de\nle nom réel de la colonne tel qu'il est exprimé dans la base de données.\nSi postgresql_ops doit être utilisé contre une expression SQL complexe telle que\nen tant qu'appel de fonction, pour l'appliquer à la colonne, il faut lui attribuer une étiquette\nqui est identifié dans le dictionnaire par son nom, par exemple:
"},{"id":"text-103","type":"text","heading":"","plain_text":"Indice(\n 'mon_index', ma table.c.identifiant,\n func.inférieur(ma table.c.Les données).étiquette('data_lower'),\n postgresql_ops=\n 'data_lower': 'text_pattern_ops',\n 'id': 'int4_ops'\n )","html":"Indice(\n 'mon_index', ma table.c.identifiant,\n func.inférieur(ma table.c.Les données).étiquette('data_lower'),\n postgresql_ops=\n 'data_lower': 'text_pattern_ops',\n 'id': 'int4_ops'\n )
"},{"id":"text-104","type":"text","heading":"","plain_text":"Types d'index\nPostgreSQL fournit plusieurs types d’index: B-Tree, Hash, GiST et GIN, ainsi que\ncomme la possibilité pour les utilisateurs de créer leurs propres projets (voir\nhttp://www.postgresql.org/docs/8.3/static/indexes-types.html). Ceux-ci peuvent être\nspécifié sur Indice en utilisant le postgresql_using argument de mot clé:","html":"Types d'index\nPostgreSQL fournit plusieurs types d’index: B-Tree, Hash, GiST et GIN, ainsi que\ncomme la possibilité pour les utilisateurs de créer leurs propres projets (voir\nhttp://www.postgresql.org/docs/8.3/static/indexes-types.html). Ceux-ci peuvent être\nspécifié sur Indice en utilisant le postgresql_using argument de mot clé:
"},{"id":"text-105","type":"text","heading":"","plain_text":"Indice('mon_index', ma table.c.Les données, postgresql_using='Gin')","html":"Indice('mon_index', ma table.c.Les données, postgresql_using='Gin')
"},{"id":"text-106","type":"text","heading":"","plain_text":"La valeur transmise à l’argument du mot clé sera simplement transmise au\ncommande CREATE INDEX sous-jacente, de sorte doit être un type d'index valide pour votre\nversion de PostgreSQL.","html":"La valeur transmise à l’argument du mot clé sera simplement transmise au\ncommande CREATE INDEX sous-jacente, de sorte doit être un type d'index valide pour votre\nversion de PostgreSQL.
"},{"id":"text-107","type":"text","heading":"","plain_text":"Paramètres de stockage d'index\nPostgreSQL permet de définir des paramètres de stockage sur des index. Le stockage\nles paramètres disponibles dépendent de la méthode d'index utilisée par l'index. Espace de rangement\nles paramètres peuvent être spécifiés sur Indice en utilisant le postgresql_with\nargument de mot clé:","html":"Paramètres de stockage d'index\nPostgreSQL permet de définir des paramètres de stockage sur des index. Le stockage\nles paramètres disponibles dépendent de la méthode d'index utilisée par l'index. Espace de rangement\nles paramètres peuvent être spécifiés sur Indice en utilisant le postgresql_with\nargument de mot clé:
"},{"id":"text-108","type":"text","heading":"","plain_text":"Indice('mon_index', ma table.c.Les données, postgresql_with="facteur de remplissage": 50)","html":"Indice('mon_index', ma table.c.Les données, postgresql_with="facteur de remplissage": 50)
"},{"id":"text-109","type":"text","heading":"","plain_text":"PostgreSQL permet de définir le tablespace dans lequel créer l'index.\nLe tablespace peut être spécifié sur Indice en utilisant le\npostgresql_tablespace argument de mot clé:","html":"PostgreSQL permet de définir le tablespace dans lequel créer l'index.\nLe tablespace peut être spécifié sur Indice en utilisant le\npostgresql_tablespace argument de mot clé:
"},{"id":"text-110","type":"text","heading":"","plain_text":"Indice('mon_index', ma table.c.Les données, postgresql_tablespace='mon espace de tables')","html":"Indice('mon_index', ma table.c.Les données, postgresql_tablespace='mon espace de tables')
"},{"id":"text-111","type":"text","heading":"","plain_text":"Notez que la même option est disponible sur Table ainsi que.","html":"Notez que la même option est disponible sur Table ainsi que.
"},{"id":"text-112","type":"text","heading":"","plain_text":"Index avec concurremment\nL’option d’index CONCORDREMENT de PostgreSQL est supportée en passant le\ndrapeau postgresql_concurrently à la Indice construction:","html":"Index avec concurremment\nL’option d’index CONCORDREMENT de PostgreSQL est supportée en passant le\ndrapeau postgresql_concurrently à la Indice construction:
"},{"id":"text-113","type":"text","heading":"","plain_text":"tbl = Table('testtbl', m, Colonne('Les données', Entier))","html":"tbl = Table('testtbl', m, Colonne('Les données', Entier))
"},{"id":"text-114","type":"text","heading":"","plain_text":"idx1 = Indice('test_idx1', tbl.c.Les données, postgresql_concurrently=Vrai)","html":"idx1 = Indice('test_idx1', tbl.c.Les données, postgresql_concurrently=Vrai)
"},{"id":"text-115","type":"text","heading":"","plain_text":"La construction d’index ci-dessus rendra le DDL pour CREATE INDEX, en supposant que\nPostgreSQL 8.2 ou supérieur est détecté ou pour un dialecte sans connexion, comme:","html":"La construction d’index ci-dessus rendra le DDL pour CREATE INDEX, en supposant que\nPostgreSQL 8.2 ou supérieur est détecté ou pour un dialecte sans connexion, comme:
"},{"id":"text-116","type":"text","heading":"","plain_text":"CRÉER INDICE De manière concurrente test_idx1 SUR testtbl (Les données)","html":"CRÉER INDICE De manière concurrente test_idx1 SUR testtbl (Les données)
"},{"id":"text-117","type":"text","heading":"","plain_text":"Pour DROP INDEX, en supposant que PostgreSQL 9.2 ou supérieur soit détecté ou pour\nun dialecte sans connexion, il émettra:","html":"Pour DROP INDEX, en supposant que PostgreSQL 9.2 ou supérieur soit détecté ou pour\nun dialecte sans connexion, il émettra:
"},{"id":"text-118","type":"text","heading":"","plain_text":"LAISSEZ TOMBER INDICE De manière concurrente test_idx1","html":"LAISSEZ TOMBER INDICE De manière concurrente test_idx1
"},{"id":"text-119","type":"text","heading":"","plain_text":"Nouveau dans la version 1.1: support pour concurremment sur DROP INDEX. le\nLe mot clé est simultanément émis uniquement si une version suffisamment élevée\nde PostgreSQL est détecté sur la connexion (ou pour une connexion sans connexion)\ndialecte).","html":"Nouveau dans la version 1.1: support pour concurremment sur DROP INDEX. le\nLe mot clé est simultanément émis uniquement si une version suffisamment élevée\nde PostgreSQL est détecté sur la connexion (ou pour une connexion sans connexion)\ndialecte).
"},{"id":"text-120","type":"text","heading":"","plain_text":"Lors de l'utilisation concurrente, la base de données PostgreSQL requiert que l'instruction\nêtre appelé en dehors d'un bloc de transaction. La base de données Python DBAPI\nmême pour une seule déclaration, une transaction est présente, donc pour utiliser cette\nle mode «autocommit» de DBAPI doit être utilisé:","html":"Lors de l'utilisation concurrente, la base de données PostgreSQL requiert que l'instruction\nêtre appelé en dehors d'un bloc de transaction. La base de données Python DBAPI\nmême pour une seule déclaration, une transaction est présente, donc pour utiliser cette\nle mode «autocommit» de DBAPI doit être utilisé:
"},{"id":"text-121","type":"text","heading":"","plain_text":"métadonnées = MetaData()\ntable = Table(\n "foo", métadonnées,\n Colonne("id", Chaîne))\nindice = Indice(\n "foo_idx", table.c.identifiant, postgresql_concurrently=Vrai)","html":"métadonnées = MetaData()\ntable = Table(\n "foo", métadonnées,\n Colonne("id", Chaîne))\nindice = Indice(\n "foo_idx", table.c.identifiant, postgresql_concurrently=Vrai)
"},{"id":"text-122","type":"text","heading":"","plain_text":"avec moteur.relier() comme Connecticut:\n avec Connecticut.execution_options(niveau_isolement='AUTOCOMMIT'):\n table.créer(Connecticut)","html":"avec moteur.relier() comme Connecticut:\n avec Connecticut.execution_options(niveau_isolement='AUTOCOMMIT'):\n table.créer(Connecticut)
"},{"id":"text-123","type":"text","heading":"","plain_text":"PostgreSQL Index Reflection\nLa base de données PostgreSQL crée implicitement un INDEX UNIQUE chaque fois que le\nLa construction UNIQUE CONSTRAINT est utilisée. Lors de l'inspection d'une table en utilisant\nInspecteur, le Inspector.get_indexes ()\net le Inspector.get_unique_constraints () fera rapport sur ces\ndeux constructions distinctement; dans le cas de l'index, la clé\nduplicates_constraint sera présent dans l'entrée d'index s'il est\ndétecté comme reflétant une contrainte. Lors de la réflexion en utilisant\nTable(..., autoload = True), l'INDICE UNIQUE est ne pas revenu\ndans Table.indexes quand il est détecté comme reflétant un\nContrainte unique dans le Table.constraints collection.","html":"PostgreSQL Index Reflection\nLa base de données PostgreSQL crée implicitement un INDEX UNIQUE chaque fois que le\nLa construction UNIQUE CONSTRAINT est utilisée. Lors de l'inspection d'une table en utilisant\nInspecteur, le Inspector.get_indexes ()\net le Inspector.get_unique_constraints () fera rapport sur ces\ndeux constructions distinctement; dans le cas de l'index, la clé\nduplicates_constraint sera présent dans l'entrée d'index s'il est\ndétecté comme reflétant une contrainte. Lors de la réflexion en utilisant\nTable(..., autoload = True), l'INDICE UNIQUE est ne pas revenu\ndans Table.indexes quand il est détecté comme reflétant un\nContrainte unique dans le Table.constraints collection.
"},{"id":"text-124","type":"text","heading":"","plain_text":"Modifié dans la version 1.0.0: – Table la réflexion comprend maintenant\nContrainte unique objets présents dans le Table.constraints\ncollection; le backend de PostgreSQL n'inclura plus de “miroir”\nIndice construire dans Table.indexes si c'est détecté\ncomme correspondant à une contrainte unique.","html":"Modifié dans la version 1.0.0: – Table la réflexion comprend maintenant\nContrainte unique objets présents dans le Table.constraints\ncollection; le backend de PostgreSQL n'inclura plus de “miroir”\nIndice construire dans Table.indexes si c'est détecté\ncomme correspondant à une contrainte unique.
"},{"id":"text-125","type":"text","heading":"","plain_text":"Options de réflexion spéciales\nle Inspecteur utilisé pour le backend PostgreSQL est une instance\nde PGInspector, qui offre des méthodes supplémentaires:","html":"Options de réflexion spéciales\nle Inspecteur utilisé pour le backend PostgreSQL est une instance\nde PGInspector, qui offre des méthodes supplémentaires:
"},{"id":"text-126","type":"text","heading":"","plain_text":"de sqlalchemy importation create_engine, inspecter","html":"de sqlalchemy importation create_engine, inspecter
"},{"id":"text-127","type":"text","heading":"","plain_text":"moteur = create_engine("postgresql + psycopg2: // localhost / test")\ninsp = inspecter(moteur) # sera un PGInspector","html":"moteur = create_engine("postgresql + psycopg2: // localhost / test")\ninsp = inspecter(moteur) # sera un PGInspector
"},{"id":"text-128","type":"text","heading":"","plain_text":"impression(insp.get_enums())","html":"impression(insp.get_enums())
"},{"id":"text-129","type":"text","heading":"","plain_text":"classe sqlalchemy.dialects.postgresql.base.PGInspector(Connecticut)","html":"classe sqlalchemy.dialects.postgresql.base.PGInspector(Connecticut)
"},{"id":"text-130","type":"text","heading":"","plain_text":"Bases: sqlalchemy.engine.reflection.Inspector","html":"Bases: sqlalchemy.engine.reflection.Inspector
"},{"id":"text-131","type":"text","heading":"","plain_text":"get_enums(schéma = Aucun)","html":"get_enums(schéma = Aucun)
"},{"id":"text-132","type":"text","heading":"","plain_text":"Retourne une liste d'objets ENUM.\nChaque membre est un dictionnaire contenant ces champs:","html":"Retourne une liste d'objets ENUM.\nChaque membre est un dictionnaire contenant ces champs:
"},{"id":"text-133","type":"text","heading":"","plain_text":"name – nom de l'énum","html":"name – nom de l'énum
"},{"id":"text-134","type":"text","heading":"","plain_text":"schéma – le nom du schéma pour l'énumération.","html":"schéma – le nom du schéma pour l'énumération.
"},{"id":"text-135","type":"text","heading":"","plain_text":"visible – booléen, que cette énumération soit visible ou non\ndans le chemin de recherche par défaut.","html":"visible – booléen, que cette énumération soit visible ou non\ndans le chemin de recherche par défaut.
"},{"id":"text-136","type":"text","heading":"","plain_text":"étiquettes – une liste d'étiquettes de chaîne qui s'appliquent à l'énumération.","html":"étiquettes – une liste d'étiquettes de chaîne qui s'appliquent à l'énumération.
"},{"id":"text-137","type":"text","heading":"","plain_text":"Paramètres","html":"Paramètres
"},{"id":"text-138","type":"text","heading":"","plain_text":"schéma – nom du schéma. Si aucun, le schéma par défaut\n(généralement «public») est utilisé. Peut également être réglé sur '*' pour\nindiquez des énumérations de charge pour tous les schémas.","html":"schéma – nom du schéma. Si aucun, le schéma par défaut\n(généralement «public») est utilisé. Peut également être réglé sur '*' pour\nindiquez des énumérations de charge pour tous les schémas.
"},{"id":"text-139","type":"text","heading":"","plain_text":"get_foreign_table_names(schéma = Aucun)","html":"get_foreign_table_names(schéma = Aucun)
"},{"id":"text-140","type":"text","heading":"","plain_text":"Renvoie une liste de noms FOREIGN TABLE.\nLe comportement est similaire à celui de Inspector.get_table_names (),\nsauf que la liste est limitée aux tables qui signalent une\nrelâchement valeur de F.","html":"Renvoie une liste de noms FOREIGN TABLE.\nLe comportement est similaire à celui de Inspector.get_table_names (),\nsauf que la liste est limitée aux tables qui signalent une\nrelâchement valeur de F.
"},{"id":"text-141","type":"text","heading":"","plain_text":"get_table_oid(nom de la table, schéma = Aucun)","html":"get_table_oid(nom de la table, schéma = Aucun)
"},{"id":"text-142","type":"text","heading":"","plain_text":"Renvoie l'OID du nom de la table donnée.","html":"Renvoie l'OID du nom de la table donnée.
"},{"id":"text-143","type":"text","heading":"","plain_text":"get_view_names(schéma = Aucun, include = ('plain', 'matérialisé'))","html":"get_view_names(schéma = Aucun, include = ('plain', 'matérialisé'))
"},{"id":"text-144","type":"text","heading":"","plain_text":"Renvoyer tous les noms de vue dans schéma.","html":"Renvoyer tous les noms de vue dans schéma.
"},{"id":"text-145","type":"text","heading":"","plain_text":"Paramètres","html":"Paramètres
"},{"id":"text-146","type":"text","heading":"","plain_text":"schéma – Facultatif, récupérez les noms d'un schéma autre que celui par défaut.\nPour les devis spéciaux, utilisez quoted_name.","html":"schéma – Facultatif, récupérez les noms d'un schéma autre que celui par défaut.\nPour les devis spéciaux, utilisez quoted_name.
"},{"id":"text-147","type":"text","heading":"","plain_text":"comprendre – \nspécifier les types de vues à renvoyer. Passé\nsous forme de valeur de chaîne (pour un type unique) ou de tuple (pour un nombre quelconque)\nde types). Par défaut à ('plaine', 'matérialisé').","html":"comprendre – \nspécifier les types de vues à renvoyer. Passé\nsous forme de valeur de chaîne (pour un type unique) ou de tuple (pour un nombre quelconque)\nde types). Par défaut à ('plaine', 'matérialisé').
"},{"id":"text-148","type":"text","heading":"","plain_text":"Options de la table PostgreSQL\nPlusieurs options pour CREATE TABLE sont supportées directement par PostgreSQL\ndialecte en conjonction avec le Table construction:","html":"Options de la table PostgreSQL\nPlusieurs options pour CREATE TABLE sont supportées directement par PostgreSQL\ndialecte en conjonction avec le Table construction:
"},{"id":"text-149","type":"text","heading":"","plain_text":"Types de tableau\nLe dialecte PostgreSQL supporte les tableaux, à la fois en tant que types de colonne multidimensionnels\nainsi que des littéraux de tableau:","html":"Types de tableau\nLe dialecte PostgreSQL supporte les tableaux, à la fois en tant que types de colonne multidimensionnels\nainsi que des littéraux de tableau:
"},{"id":"text-150","type":"text","heading":"","plain_text":"Types JSON\nLe dialecte PostgreSQL prend en charge les types de données JSON et JSONB, y compris\nLe support natif de psycopg2 et celui de tous les logiciels spéciaux de PostgreSQL\nles opérateurs:","html":"Types JSON\nLe dialecte PostgreSQL prend en charge les types de données JSON et JSONB, y compris\nLe support natif de psycopg2 et celui de tous les logiciels spéciaux de PostgreSQL\nles opérateurs:
"},{"id":"text-151","type":"text","heading":"","plain_text":"Type HSTORE\nLe type HSTORE PostgreSQL ainsi que les littéraux hstore sont pris en charge:","html":"Type HSTORE\nLe type HSTORE PostgreSQL ainsi que les littéraux hstore sont pris en charge:
"},{"id":"text-152","type":"text","heading":"","plain_text":"Types ENUM\nPostgreSQL a une structure TYPE pouvant être créée indépendamment qui est utilisée\npour implémenter un type énuméré. Cette approche introduit des\nla complexité du côté SQLAlchemy en termes de quand ce type devrait être\nCréé et abandonné. Le type object est aussi un reflet indépendant\nentité. Les sections suivantes doivent être consultées:","html":"Types ENUM\nPostgreSQL a une structure TYPE pouvant être créée indépendamment qui est utilisée\npour implémenter un type énuméré. Cette approche introduit des\nla complexité du côté SQLAlchemy en termes de quand ce type devrait être\nCréé et abandonné. Le type object est aussi un reflet indépendant\nentité. Les sections suivantes doivent être consultées:
"},{"id":"text-153","type":"text","heading":"","plain_text":"Utiliser ENUM avec ARRAY\nLa combinaison de ENUM et ARRAY n’est pas directement prise en charge par le backend\nDBAPIs à ce moment. Pour envoyer et recevoir un ARRAY of ENUM,\nutilisez le type de solution de contournement suivant, qui décore le\npostgresql.ARRAY Type de données.","html":"Utiliser ENUM avec ARRAY\nLa combinaison de ENUM et ARRAY n’est pas directement prise en charge par le backend\nDBAPIs à ce moment. Pour envoyer et recevoir un ARRAY of ENUM,\nutilisez le type de solution de contournement suivant, qui décore le\npostgresql.ARRAY Type de données.
"},{"id":"text-154","type":"text","heading":"","plain_text":"de sqlalchemy importation TypeDécorateur\nde sqlalchemy.dialects.postgresql importation Tableau","html":"de sqlalchemy importation TypeDécorateur\nde sqlalchemy.dialects.postgresql importation Tableau
"},{"id":"text-155","type":"text","heading":"","plain_text":"classe ArrayOfEnum(TypeDécorateur):\n impl = Tableau","html":"classe ArrayOfEnum(TypeDécorateur):\n impl = Tableau
"},{"id":"text-156","type":"text","heading":"","plain_text":"def bind_expression(soi, bindvalue):\n revenir sa.jeter(bindvalue, soi)","html":"def bind_expression(soi, bindvalue):\n revenir sa.jeter(bindvalue, soi)
"},{"id":"text-157","type":"text","heading":"","plain_text":"def result_processor(soi, dialecte, coltype):\n super_rp = super(ArrayOfEnum, soi).result_processor(\n dialecte, coltype)","html":"def result_processor(soi, dialecte, coltype):\n super_rp = super(ArrayOfEnum, soi).result_processor(\n dialecte, coltype)
"},{"id":"text-158","type":"text","heading":"","plain_text":"def handle_raw_string(valeur):\n interne = ré.rencontre(r"^ (. *) $", valeur).groupe(1)\n revenir interne.Divisé(",") si interne autre []","html":"def handle_raw_string(valeur):\n interne = ré.rencontre(r"^ (. *) $", valeur).groupe(1)\n revenir interne.Divisé(",") si interne autre []
"},{"id":"text-159","type":"text","heading":"","plain_text":"def processus(valeur):\n si valeur est Aucun:\n revenir Aucun\n revenir super_rp(handle_raw_string(valeur))\n revenir processus","html":"def processus(valeur):\n si valeur est Aucun:\n revenir Aucun\n revenir super_rp(handle_raw_string(valeur))\n revenir processus
"},{"id":"text-160","type":"text","heading":"","plain_text":"Par exemple.:","html":"Par exemple.:
"},{"id":"text-161","type":"text","heading":"","plain_text":"Table(\n 'mes données', métadonnées,\n Colonne('id', Entier, clé primaire=Vrai),\n Colonne('Les données', ArrayOfEnum(ENUM('une', 'b'c', nom ='myenum')))","html":"Table(\n 'mes données', métadonnées,\n Colonne('id', Entier, clé primaire=Vrai),\n Colonne('Les données', ArrayOfEnum(ENUM('une', 'b'c', nom ='myenum')))
"},{"id":"text-162","type":"text","heading":"","plain_text":")","html":")
"},{"id":"text-163","type":"text","heading":"","plain_text":"Ce type n'est pas inclus en tant que type intégré car il serait incompatible\navec une DBAPI qui décide soudainement de soutenir ARRAY of ENUM directement dans\nune nouvelle version.","html":"Ce type n'est pas inclus en tant que type intégré car il serait incompatible\navec une DBAPI qui décide soudainement de soutenir ARRAY of ENUM directement dans\nune nouvelle version.
"},{"id":"text-164","type":"text","heading":"","plain_text":"Utilisation de JSON / JSONB avec ARRAY\nSemblable à utiliser ENUM, pour un ARRAY of JSON / JSONB, nous devons rendre le\nCAST approprié, cependant les pilotes psycopg2 actuels semblent gérer le résultat\npour ARRAY of JSON automatiquement, le type est donc plus simple:","html":"Utilisation de JSON / JSONB avec ARRAY\nSemblable à utiliser ENUM, pour un ARRAY of JSON / JSONB, nous devons rendre le\nCAST approprié, cependant les pilotes psycopg2 actuels semblent gérer le résultat\npour ARRAY of JSON automatiquement, le type est donc plus simple:
"},{"id":"text-165","type":"text","heading":"","plain_text":"classe CastingArray(Tableau):\n def bind_expression(soi, bindvalue):\n revenir sa.jeter(bindvalue, soi)","html":"classe CastingArray(Tableau):\n def bind_expression(soi, bindvalue):\n revenir sa.jeter(bindvalue, soi)
"},{"id":"text-166","type":"text","heading":"","plain_text":"Par exemple.:","html":"Par exemple.:
"},{"id":"text-167","type":"text","heading":"","plain_text":"Table(\n 'mes données', métadonnées,\n Colonne('id', Entier, clé primaire=Vrai),\n Colonne('Les données', CastingArray(JSONB))\n)","html":"Table(\n 'mes données', métadonnées,\n Colonne('id', Entier, clé primaire=Vrai),\n Colonne('Les données', CastingArray(JSONB))\n)
"},{"id":"text-168","type":"text","heading":"","plain_text":"Types de données PostgreSQL\nComme avec tous les dialectes SQLAlchemy, tous les types UPPERCASE connus pour être\nvalables avec PostgreSQL sont importables à partir du dialecte de niveau supérieur, que ce soit\nils proviennent de sqlalchemy.types ou du dialecte local:","html":"Types de données PostgreSQL\nComme avec tous les dialectes SQLAlchemy, tous les types UPPERCASE connus pour être\nvalables avec PostgreSQL sont importables à partir du dialecte de niveau supérieur, que ce soit\nils proviennent de sqlalchemy.types ou du dialecte local:
"},{"id":"text-169","type":"text","heading":"","plain_text":"de sqlalchemy.dialects.postgresql importation \n Tableau, BIGINT, BIT, BOOLÉAN, BYTEA, CARBONISER, CIDR, DATE, \n DOUBLE PRECISION, ENUM, FLOTTE, HSTORE, INET, ENTIER, \n INTERVALLE, JSON, JSONB, MACADDR, ARGENT, NUMERIC, OID, REAL, SMALLINT, TEXT, \n TEMPS, TIMESTAMP, UUID, VARCHAR, INT4RANGE, INT8RANGE, NUMRANGE, \n DATERANGE, TSRANGE, TSTZRANGE, TSVECTOR","html":"de sqlalchemy.dialects.postgresql importation \n Tableau, BIGINT, BIT, BOOLÉAN, BYTEA, CARBONISER, CIDR, DATE, \n DOUBLE PRECISION, ENUM, FLOTTE, HSTORE, INET, ENTIER, \n INTERVALLE, JSON, JSONB, MACADDR, ARGENT, NUMERIC, OID, REAL, SMALLINT, TEXT, \n TEMPS, TIMESTAMP, UUID, VARCHAR, INT4RANGE, INT8RANGE, NUMRANGE, \n DATERANGE, TSRANGE, TSTZRANGE, TSVECTOR
"},{"id":"text-170","type":"text","heading":"","plain_text":"Types which are specific to PostgreSQL, or have PostgreSQL-specific\nconstruction arguments, are as follows:","html":"Types which are specific to PostgreSQL, or have PostgreSQL-specific\nconstruction arguments, are as follows:
"},{"id":"text-171","type":"text","heading":"","plain_text":"class sqlalchemy.dialects.postgresql.aggregate_order_by(cible, *order_by)","html":"class sqlalchemy.dialects.postgresql.aggregate_order_by(cible, *order_by)
"},{"id":"text-172","type":"text","heading":"","plain_text":"Bases: sqlalchemy.sql.expression.ColumnElement\nRepresent a PostgreSQL aggregate order by expression.\nE.g.:","html":"Bases: sqlalchemy.sql.expression.ColumnElement\nRepresent a PostgreSQL aggregate order by expression.\nE.g.:
"},{"id":"text-173","type":"text","heading":"","plain_text":"de sqlalchemy.dialects.postgresql importation aggregate_order_by\nexpr = func.array_agg(aggregate_order_by(table.c.une, table.c.b.desc()))\nstmt = sélectionner([[[[expr])","html":"de sqlalchemy.dialects.postgresql importation aggregate_order_by\nexpr = func.array_agg(aggregate_order_by(table.c.une, table.c.b.desc()))\nstmt = sélectionner([[[[expr])
"},{"id":"text-174","type":"text","heading":"","plain_text":"would represent the expression:","html":"would represent the expression:
"},{"id":"text-175","type":"text","heading":"","plain_text":"SELECT array_agg(une ORDER BY b DESC) FROM table;","html":"SELECT array_agg(une ORDER BY b DESC) FROM table;
"},{"id":"text-176","type":"text","heading":"","plain_text":"Similarly:","html":"Similarly:
"},{"id":"text-177","type":"text","heading":"","plain_text":"expr = func.string_agg(\n table.c.une,\n aggregate_order_by(literal_column("','"), table.c.une)\n)\nstmt = sélectionner([[[[expr])","html":"expr = func.string_agg(\n table.c.une,\n aggregate_order_by(literal_column("','"), table.c.une)\n)\nstmt = sélectionner([[[[expr])
"},{"id":"text-178","type":"text","heading":"","plain_text":"Would represent:","html":"Would represent:
"},{"id":"text-179","type":"text","heading":"","plain_text":"SELECT string_agg(une, ',' ORDER BY une) FROM table;","html":"SELECT string_agg(une, ',' ORDER BY une) FROM table;
"},{"id":"text-180","type":"text","heading":"","plain_text":"Changed in version 1.2.13: – the ORDER BY argument may be multiple terms","html":"Changed in version 1.2.13: – the ORDER BY argument may be multiple terms
"},{"id":"text-181","type":"text","heading":"","plain_text":"class sqlalchemy.dialects.postgresql.array(clauses, **kw)","html":"class sqlalchemy.dialects.postgresql.array(clauses, **kw)
"},{"id":"text-182","type":"text","heading":"","plain_text":"Bases: sqlalchemy.sql.expression.Tuple\nA PostgreSQL ARRAY literal.\nThis is used to produce ARRAY literals in SQL expressions, e.g.:","html":"Bases: sqlalchemy.sql.expression.Tuple\nA PostgreSQL ARRAY literal.\nThis is used to produce ARRAY literals in SQL expressions, e.g.:
"},{"id":"text-183","type":"text","heading":"","plain_text":"de sqlalchemy.dialects.postgresql importation array\nde sqlalchemy.dialects importation postgresql\nde sqlalchemy importation sélectionner, func","html":"de sqlalchemy.dialects.postgresql importation array\nde sqlalchemy.dialects importation postgresql\nde sqlalchemy importation sélectionner, func
"},{"id":"text-184","type":"text","heading":"","plain_text":"stmt = sélectionner([[[[\n array([[[[1,2]) + array([[[[3,4,5])\n ])","html":"stmt = sélectionner([[[[\n array([[[[1,2]) + array([[[[3,4,5])\n ])
"},{"id":"text-185","type":"text","heading":"","plain_text":"impression(stmt.compile(dialect=postgresql.dialect()))","html":"impression(stmt.compile(dialect=postgresql.dialect()))
"},{"id":"text-186","type":"text","heading":"","plain_text":"Produces the SQL:","html":"Produces the SQL:
"},{"id":"text-187","type":"text","heading":"","plain_text":"SELECT ARRAY[[[[%(param_1)s, %(param_2)s] ||\n ARRAY[[[[%(param_3)s, %(param_4)s, %(param_5)s]) AS anon_1","html":"SELECT ARRAY[[[[%(param_1)s, %(param_2)s] ||\n ARRAY[[[[%(param_3)s, %(param_4)s, %(param_5)s]) AS anon_1
"},{"id":"text-188","type":"text","heading":"","plain_text":"An instance of array will always have the datatype\nARRAY. The “inner” type of the array is inferred from\nthe values present, unless the type_ keyword argument is passed:","html":"An instance of array will always have the datatype\nARRAY. The “inner” type of the array is inferred from\nthe values present, unless the type_ keyword argument is passed:
"},{"id":"text-189","type":"text","heading":"","plain_text":"array([[[['foo', 'bar'], type_=CHAR)","html":"array([[[['foo', 'bar'], type_=CHAR)
"},{"id":"text-190","type":"text","heading":"","plain_text":"Multidimensional arrays are produced by nesting array constructs.\nThe dimensionality of the final ARRAY type is calculated by\nrecursively adding the dimensions of the inner ARRAY type:","html":"Multidimensional arrays are produced by nesting array constructs.\nThe dimensionality of the final ARRAY type is calculated by\nrecursively adding the dimensions of the inner ARRAY type:
"},{"id":"text-191","type":"text","heading":"","plain_text":"stmt = sélectionner([[[[\n array([[[[\n array([[[[1, 2]), array([[[[3, 4]), array([[[[colonne('q'), colonne('x')])\n ])\n])\nimpression(stmt.compile(dialect=postgresql.dialect()))","html":"stmt = sélectionner([[[[\n array([[[[\n array([[[[1, 2]), array([[[[3, 4]), array([[[[colonne('q'), colonne('x')])\n ])\n])\nimpression(stmt.compile(dialect=postgresql.dialect()))
"},{"id":"text-192","type":"text","heading":"","plain_text":"Produces:","html":"Produces:
"},{"id":"text-193","type":"text","heading":"","plain_text":"SELECT ARRAY[[[[ARRAY[[[[%(param_1)s, %(param_2)s],\nARRAY[[[[%(param_3)s, %(param_4)s], ARRAY[[[[q, x]] AS anon_1","html":"SELECT ARRAY[[[[ARRAY[[[[%(param_1)s, %(param_2)s],\nARRAY[[[[%(param_3)s, %(param_4)s], ARRAY[[[[q, x]] AS anon_1
"},{"id":"text-194","type":"text","heading":"","plain_text":"New in version 1.3.6: added support for multidimensional array literals","html":"New in version 1.3.6: added support for multidimensional array literals
"},{"id":"text-195","type":"text","heading":"","plain_text":"class sqlalchemy.dialects.postgresql.ARRAY(item_type, as_tuple=False, dimensions=None, zero_indexes=False)","html":"class sqlalchemy.dialects.postgresql.ARRAY(item_type, as_tuple=False, dimensions=None, zero_indexes=False)
"},{"id":"text-196","type":"text","heading":"","plain_text":"Bases: sqlalchemy.types.ARRAY\nPostgreSQL ARRAY type.\nle postgresql.ARRAY type is constructed in the same way\nas the core types.ARRAY type; a member type is required, and a\nnumber of dimensions is recommended if the type is to be used for more\nthan one dimension:","html":"Bases: sqlalchemy.types.ARRAY\nPostgreSQL ARRAY type.\nle postgresql.ARRAY type is constructed in the same way\nas the core types.ARRAY type; a member type is required, and a\nnumber of dimensions is recommended if the type is to be used for more\nthan one dimension:
"},{"id":"text-197","type":"text","heading":"","plain_text":"de sqlalchemy.dialects importation postgresql","html":"de sqlalchemy.dialects importation postgresql
"},{"id":"text-198","type":"text","heading":"","plain_text":"mytable = Table("mytable", metadata,\n Column("data", postgresql.ARRAY(Integer, dimensions=2))\n )","html":"mytable = Table("mytable", metadata,\n Column("data", postgresql.ARRAY(Integer, dimensions=2))\n )
"},{"id":"text-199","type":"text","heading":"","plain_text":"le postgresql.ARRAY type provides all operations defined on the\ncore types.ARRAY type, including support for “dimensions”,\nindexed access, and simple matching such as\ntypes.ARRAY.Comparator.any() et\ntypes.ARRAY.Comparator.all(). postgresql.ARRAY class also\nprovides PostgreSQL-specific methods for containment operations, including\npostgresql.ARRAY.Comparator.contains()\npostgresql.ARRAY.Comparator.contained_by(), et\npostgresql.ARRAY.Comparator.overlap(), e.g.:","html":"le postgresql.ARRAY type provides all operations defined on the\ncore types.ARRAY type, including support for “dimensions”,\nindexed access, and simple matching such as\ntypes.ARRAY.Comparator.any() et\ntypes.ARRAY.Comparator.all(). postgresql.ARRAY class also\nprovides PostgreSQL-specific methods for containment operations, including\npostgresql.ARRAY.Comparator.contains()\npostgresql.ARRAY.Comparator.contained_by(), et\npostgresql.ARRAY.Comparator.overlap(), e.g.:
"},{"id":"text-200","type":"text","heading":"","plain_text":"mytable.c.Les données.contient([[[[1, 2])","html":"mytable.c.Les données.contient([[[[1, 2])
"},{"id":"text-201","type":"text","heading":"","plain_text":"le postgresql.ARRAY type may not be supported on all\nPostgreSQL DBAPIs; it is currently known to work on psycopg2 only.\nDe plus, le postgresql.ARRAY type does not work directly in\nconjunction with the ENUM type. For a workaround, see the\nspecial type at Using ENUM with ARRAY.","html":"le postgresql.ARRAY type may not be supported on all\nPostgreSQL DBAPIs; it is currently known to work on psycopg2 only.\nDe plus, le postgresql.ARRAY type does not work directly in\nconjunction with the ENUM type. For a workaround, see the\nspecial type at Using ENUM with ARRAY.
"},{"id":"text-202","type":"text","heading":"","plain_text":"class Comparator(expr)","html":"class Comparator(expr)
"},{"id":"text-203","type":"text","heading":"","plain_text":"Bases: sqlalchemy.types.Comparator\nDefine comparison operations for ARRAY.\nNote that these operations are in addition to those provided\nby the base types.ARRAY.Comparator class, including\ntypes.ARRAY.Comparator.any() et\ntypes.ARRAY.Comparator.all().","html":"Bases: sqlalchemy.types.Comparator\nDefine comparison operations for ARRAY.\nNote that these operations are in addition to those provided\nby the base types.ARRAY.Comparator class, including\ntypes.ARRAY.Comparator.any() et\ntypes.ARRAY.Comparator.all().
"},{"id":"text-204","type":"text","heading":"","plain_text":"contained_by(other)","html":"contained_by(other)
"},{"id":"text-205","type":"text","heading":"","plain_text":"Boolean expression. Test if elements are a proper subset of the\nelements of the argument array expression.","html":"Boolean expression. Test if elements are a proper subset of the\nelements of the argument array expression.
"},{"id":"text-206","type":"text","heading":"","plain_text":"contient(other, **kwargs)","html":"contient(other, **kwargs)
"},{"id":"text-207","type":"text","heading":"","plain_text":"Boolean expression. Test if elements are a superset of the\nelements of the argument array expression.","html":"Boolean expression. Test if elements are a superset of the\nelements of the argument array expression.
"},{"id":"text-208","type":"text","heading":"","plain_text":"overlap(other)","html":"overlap(other)
"},{"id":"text-209","type":"text","heading":"","plain_text":"Boolean expression. Test if array has elements in common with\nan argument array expression.","html":"Boolean expression. Test if array has elements in common with\nan argument array expression.
"},{"id":"text-210","type":"text","heading":"","plain_text":"__init__(item_type, as_tuple=False, dimensions=None, zero_indexes=False)","html":"__init__(item_type, as_tuple=False, dimensions=None, zero_indexes=False)
"},{"id":"text-211","type":"text","heading":"","plain_text":"Construct an ARRAY.\nE.g.:","html":"Construct an ARRAY.\nE.g.:
"},{"id":"text-212","type":"text","heading":"","plain_text":"Column('myarray', ARRAY(Integer))","html":"Column('myarray', ARRAY(Integer))
"},{"id":"text-213","type":"text","heading":"","plain_text":"Arguments are:","html":"Arguments are:
"},{"id":"text-214","type":"text","heading":"","plain_text":"Paramètres","html":"Paramètres
"},{"id":"text-215","type":"text","heading":"","plain_text":"item_type – The data type of items of this array. Note that\ndimensionality is irrelevant here, so multi-dimensional arrays like\nINTEGER[][], are constructed as ARRAY(Integer), not as\nARRAY(ARRAY(Integer)) or such.","html":"item_type – The data type of items of this array. Note that\ndimensionality is irrelevant here, so multi-dimensional arrays like\nINTEGER[][], are constructed as ARRAY(Integer), not as\nARRAY(ARRAY(Integer)) or such.
"},{"id":"text-216","type":"text","heading":"","plain_text":"as_tuple=False – Specify whether return results\nshould be converted to tuples from lists. DBAPIs such\nas psycopg2 return lists by default. When tuples are\nreturned, the results are hashable.","html":"as_tuple=False – Specify whether return results\nshould be converted to tuples from lists. DBAPIs such\nas psycopg2 return lists by default. When tuples are\nreturned, the results are hashable.
"},{"id":"text-217","type":"text","heading":"","plain_text":"dimensions – if non-None, the ARRAY will assume a fixed\nnumber of dimensions. This will cause the DDL emitted for this\nARRAY to include the exact number of bracket clauses [],\nand will also optimize the performance of the type overall.\nNote that PG arrays are always implicitly “non-dimensioned”,\nmeaning they can store any number of dimensions no matter how\nthey were declared.","html":"dimensions – if non-None, the ARRAY will assume a fixed\nnumber of dimensions. This will cause the DDL emitted for this\nARRAY to include the exact number of bracket clauses [],\nand will also optimize the performance of the type overall.\nNote that PG arrays are always implicitly “non-dimensioned”,\nmeaning they can store any number of dimensions no matter how\nthey were declared.
"},{"id":"text-218","type":"text","heading":"","plain_text":"zero_indexes=False – \nwhen True, index values will be converted\nbetween Python zero-based and PostgreSQL one-based indexes, e.g.\na value of one will be added to all index values before passing\nto the database.","html":"zero_indexes=False – \nwhen True, index values will be converted\nbetween Python zero-based and PostgreSQL one-based indexes, e.g.\na value of one will be added to all index values before passing\nto the database.
"},{"id":"text-219","type":"text","heading":"","plain_text":"sqlalchemy.dialects.postgresql.array_agg(*arg, **kw)","html":"sqlalchemy.dialects.postgresql.array_agg(*arg, **kw)
"},{"id":"text-220","type":"text","heading":"","plain_text":"PostgreSQL-specific form of array_agg, ensures\nreturn type is postgresql.ARRAY and not\nthe plain types.ARRAY, unless an explicit type_\nis passed.","html":"PostgreSQL-specific form of array_agg, ensures\nreturn type is postgresql.ARRAY and not\nthe plain types.ARRAY, unless an explicit type_\nis passed.
"},{"id":"text-221","type":"text","heading":"","plain_text":"sqlalchemy.dialects.postgresql.Any(other, arrexpr, operator=)","html":"sqlalchemy.dialects.postgresql.Any(other, arrexpr, operator=)
"},{"id":"text-222","type":"text","heading":"","plain_text":"A synonym for the ARRAY.Comparator.any() method.\nThis method is legacy and is here for backwards-compatibility.","html":"A synonym for the ARRAY.Comparator.any() method.\nThis method is legacy and is here for backwards-compatibility.
"},{"id":"text-223","type":"text","heading":"","plain_text":"sqlalchemy.dialects.postgresql.Tout(other, arrexpr, operator=)","html":"sqlalchemy.dialects.postgresql.Tout(other, arrexpr, operator=)
"},{"id":"text-224","type":"text","heading":"","plain_text":"A synonym for the ARRAY.Comparator.all() method.\nThis method is legacy and is here for backwards-compatibility.","html":"A synonym for the ARRAY.Comparator.all() method.\nThis method is legacy and is here for backwards-compatibility.
"},{"id":"text-225","type":"text","heading":"","plain_text":"class sqlalchemy.dialects.postgresql.BIT(length=None, varying=False)","html":"class sqlalchemy.dialects.postgresql.BIT(length=None, varying=False)
"},{"id":"text-226","type":"text","heading":"","plain_text":"Bases: sqlalchemy.types.TypeEngine","html":"Bases: sqlalchemy.types.TypeEngine
"},{"id":"text-227","type":"text","heading":"","plain_text":"class sqlalchemy.dialects.postgresql.BYTEA(length=None)","html":"class sqlalchemy.dialects.postgresql.BYTEA(length=None)
"},{"id":"text-228","type":"text","heading":"","plain_text":"Bases: sqlalchemy.types.LargeBinary","html":"Bases: sqlalchemy.types.LargeBinary
"},{"id":"text-229","type":"text","heading":"","plain_text":"__init__(length=None)","html":"__init__(length=None)
"},{"id":"text-230","type":"text","heading":"","plain_text":"Construct a LargeBinary type.","html":"Construct a LargeBinary type.
"},{"id":"text-231","type":"text","heading":"","plain_text":"Paramètres","html":"Paramètres
"},{"id":"text-232","type":"text","heading":"","plain_text":"length – optional, a length for the column for use in\nDDL statements, for those binary types that accept a length,\nsuch as the MySQL BLOB type.","html":"length – optional, a length for the column for use in\nDDL statements, for those binary types that accept a length,\nsuch as the MySQL BLOB type.
"},{"id":"text-233","type":"text","heading":"","plain_text":"class sqlalchemy.dialects.postgresql.CIDR","html":"class sqlalchemy.dialects.postgresql.CIDR
"},{"id":"text-234","type":"text","heading":"","plain_text":"Bases: sqlalchemy.types.TypeEngine","html":"Bases: sqlalchemy.types.TypeEngine
"},{"id":"text-235","type":"text","heading":"","plain_text":"class sqlalchemy.dialects.postgresql.DOUBLE_PRECISION(precision=None, asdecimal=False, decimal_return_scale=None)","html":"class sqlalchemy.dialects.postgresql.DOUBLE_PRECISION(precision=None, asdecimal=False, decimal_return_scale=None)
"},{"id":"text-236","type":"text","heading":"","plain_text":"Bases: sqlalchemy.types.Float","html":"Bases: sqlalchemy.types.Float
"},{"id":"text-237","type":"text","heading":"","plain_text":"__init__(precision=None, asdecimal=False, decimal_return_scale=None)","html":"__init__(precision=None, asdecimal=False, decimal_return_scale=None)
"},{"id":"text-238","type":"text","heading":"","plain_text":"Construct a Float.","html":"Construct a Float.
"},{"id":"text-239","type":"text","heading":"","plain_text":"Paramètres","html":"Paramètres
"},{"id":"text-240","type":"text","heading":"","plain_text":"précision – the numeric precision for use in DDL CREATE\nTABLE.","html":"précision – the numeric precision for use in DDL CREATE\nTABLE.
"},{"id":"text-241","type":"text","heading":"","plain_text":"asdecimal – the same flag as that of Numeric, but\ndefaults to Faux. Note that setting this flag to True\nresults in floating point conversion.","html":"asdecimal – the same flag as that of Numeric, but\ndefaults to Faux. Note that setting this flag to True\nresults in floating point conversion.
"},{"id":"text-242","type":"text","heading":"","plain_text":"decimal_return_scale – \nDefault scale to use when converting\nfrom floats to Python decimals. Floating point values will typically\nbe much longer due to decimal inaccuracy, and most floating point\ndatabase types don’t have a notion of “scale”, so by default the\nfloat type looks for the first ten decimal places when converting.\nSpecifying this value will override that length. Note that the\nMySQL float types, which do include “scale”, will use “scale”\nas the default for decimal_return_scale, if not otherwise specified.","html":"decimal_return_scale – \nDefault scale to use when converting\nfrom floats to Python decimals. Floating point values will typically\nbe much longer due to decimal inaccuracy, and most floating point\ndatabase types don’t have a notion of “scale”, so by default the\nfloat type looks for the first ten decimal places when converting.\nSpecifying this value will override that length. Note that the\nMySQL float types, which do include “scale”, will use “scale”\nas the default for decimal_return_scale, if not otherwise specified.
"},{"id":"text-243","type":"text","heading":"","plain_text":"class sqlalchemy.dialects.postgresql.ENUM(*enums, **kw)","html":"class sqlalchemy.dialects.postgresql.ENUM(*enums, **kw)
"},{"id":"text-244","type":"text","heading":"","plain_text":"Bases: sqlalchemy.types.NativeForEmulated, sqlalchemy.types.Enum\nPostgreSQL ENUM type.\nThis is a subclass of types.Enum which includes\nsupport for PG’s CREATE TYPE et DROP TYPE.\nWhen the builtin type types.Enum is used and the\nEnum.native_enum flag is left at its default of\nTrue, the PostgreSQL backend will use a postgresql.ENUM\ntype as the implementation, so the special create/drop rules\nwill be used.\nThe create/drop behavior of ENUM is necessarily intricate, due to the\nawkward relationship the ENUM type has in relationship to the\nparent table, in that it may be “owned” by just a single table, or\nmay be shared among many tables.\nWhen using types.Enum ou postgresql.ENUM\nin an “inline” fashion, the CREATE TYPE et DROP TYPE is emitted\ncorresponding to when the Table.create() et Table.drop()\nmethods are called:","html":"Bases: sqlalchemy.types.NativeForEmulated, sqlalchemy.types.Enum\nPostgreSQL ENUM type.\nThis is a subclass of types.Enum which includes\nsupport for PG’s CREATE TYPE et DROP TYPE.\nWhen the builtin type types.Enum is used and the\nEnum.native_enum flag is left at its default of\nTrue, the PostgreSQL backend will use a postgresql.ENUM\ntype as the implementation, so the special create/drop rules\nwill be used.\nThe create/drop behavior of ENUM is necessarily intricate, due to the\nawkward relationship the ENUM type has in relationship to the\nparent table, in that it may be “owned” by just a single table, or\nmay be shared among many tables.\nWhen using types.Enum ou postgresql.ENUM\nin an “inline” fashion, the CREATE TYPE et DROP TYPE is emitted\ncorresponding to when the Table.create() et Table.drop()\nmethods are called:
"},{"id":"text-245","type":"text","heading":"","plain_text":"table = Table('sometable', metadata,\n Column('some_enum', ENUM('a', 'b', 'c', name='myenum'))\n)","html":"table = Table('sometable', metadata,\n Column('some_enum', ENUM('a', 'b', 'c', name='myenum'))\n)
"},{"id":"text-246","type":"text","heading":"","plain_text":"table.create(engine) # will emit CREATE ENUM and CREATE TABLE\ntable.drop(engine) # will emit DROP TABLE and DROP ENUM","html":"table.create(engine) # will emit CREATE ENUM and CREATE TABLE\ntable.drop(engine) # will emit DROP TABLE and DROP ENUM
"},{"id":"text-247","type":"text","heading":"","plain_text":"To use a common enumerated type between multiple tables, the best\npractice is to declare the types.Enum ou\npostgresql.ENUM independently, and associate it with the\nMetaData object itself:","html":"To use a common enumerated type between multiple tables, the best\npractice is to declare the types.Enum ou\npostgresql.ENUM independently, and associate it with the\nMetaData object itself:
"},{"id":"text-248","type":"text","heading":"","plain_text":"my_enum = ENUM('a', 'b', 'c', name='myenum', metadata=metadata)","html":"my_enum = ENUM('a', 'b', 'c', name='myenum', metadata=metadata)
"},{"id":"text-249","type":"text","heading":"","plain_text":"t1 = Table('sometable_one', metadata,\n Column('some_enum', myenum)\n)","html":"t1 = Table('sometable_one', metadata,\n Column('some_enum', myenum)\n)
"},{"id":"text-250","type":"text","heading":"","plain_text":"t2 = Table('sometable_two', metadata,\n Column('some_enum', myenum)\n)","html":"t2 = Table('sometable_two', metadata,\n Column('some_enum', myenum)\n)
"},{"id":"text-251","type":"text","heading":"","plain_text":"When this pattern is used, care must still be taken at the level\nof individual table creates. Emitting CREATE TABLE without also\nspecifying checkfirst=True will still cause issues:","html":"When this pattern is used, care must still be taken at the level\nof individual table creates. Emitting CREATE TABLE without also\nspecifying checkfirst=True will still cause issues:
"},{"id":"text-252","type":"text","heading":"","plain_text":"t1.create(engine) # will fail: no such type 'myenum'","html":"t1.create(engine) # will fail: no such type 'myenum'
"},{"id":"text-253","type":"text","heading":"","plain_text":"If we specify checkfirst=True, the individual table-level create\noperation will check for the ENUM and create if not exists:","html":"If we specify checkfirst=True, the individual table-level create\noperation will check for the ENUM and create if not exists:
"},{"id":"text-254","type":"text","heading":"","plain_text":"# will check if enum exists, and emit CREATE TYPE if not\nt1.create(engine, checkfirst=True)","html":"# will check if enum exists, and emit CREATE TYPE if not\nt1.create(engine, checkfirst=True)
"},{"id":"text-255","type":"text","heading":"","plain_text":"When using a metadata-level ENUM type, the type will always be created\nand dropped if either the metadata-wide create/drop is called:","html":"When using a metadata-level ENUM type, the type will always be created\nand dropped if either the metadata-wide create/drop is called:
"},{"id":"text-256","type":"text","heading":"","plain_text":"metadata.create_all(engine) # will emit CREATE TYPE\nmetadata.drop_all(engine) # will emit DROP TYPE","html":"metadata.create_all(engine) # will emit CREATE TYPE\nmetadata.drop_all(engine) # will emit DROP TYPE
"},{"id":"text-257","type":"text","heading":"","plain_text":"The type can also be created and dropped directly:","html":"The type can also be created and dropped directly:
"},{"id":"text-258","type":"text","heading":"","plain_text":"my_enum.create(engine)\nmy_enum.drop(engine)","html":"my_enum.create(engine)\nmy_enum.drop(engine)
"},{"id":"text-259","type":"text","heading":"","plain_text":"Changed in version 1.0.0: The PostgreSQL postgresql.ENUM type\nnow behaves more strictly with regards to CREATE/DROP. A metadata-level\nENUM type will only be created and dropped at the metadata level,\nnot the table level, with the exception of\ntable.create(checkfirst=True).\nle table.drop() call will now emit a DROP TYPE for a table-level\nenumerated type.","html":"Changed in version 1.0.0: The PostgreSQL postgresql.ENUM type\nnow behaves more strictly with regards to CREATE/DROP. A metadata-level\nENUM type will only be created and dropped at the metadata level,\nnot the table level, with the exception of\ntable.create(checkfirst=True).\nle table.drop() call will now emit a DROP TYPE for a table-level\nenumerated type.
"},{"id":"text-260","type":"text","heading":"","plain_text":"__init__(*enums, **kw)","html":"__init__(*enums, **kw)
"},{"id":"text-261","type":"text","heading":"","plain_text":"Construct an ENUM.\nArguments are the same as that of\ntypes.Enum, but also including\nthe following parameters.","html":"Construct an ENUM.\nArguments are the same as that of\ntypes.Enum, but also including\nthe following parameters.
"},{"id":"text-262","type":"text","heading":"","plain_text":"Paramètres","html":"Paramètres
"},{"id":"text-263","type":"text","heading":"","plain_text":"create_type – Defaults to True.\nIndicates that CREATE TYPE should be\nemitted, after optionally checking for the\npresence of the type, when the parent\ntable is being created; and additionally\ncette DROP TYPE is called when the table\nis dropped. Quand Faux, no check\nwill be performed and no CREATE TYPE\nou DROP TYPE is emitted, unless\ncreate()\nou drop()\nare called directly.\nSetting to Faux is helpful\nwhen invoking a creation scheme to a SQL file\nwithout access to the actual database –\nle create() et\ndrop() methods can\nbe used to emit SQL to a target bind.","html":"create_type – Defaults to True.\nIndicates that CREATE TYPE should be\nemitted, after optionally checking for the\npresence of the type, when the parent\ntable is being created; and additionally\ncette DROP TYPE is called when the table\nis dropped. Quand Faux, no check\nwill be performed and no CREATE TYPE\nou DROP TYPE is emitted, unless\ncreate()\nou drop()\nare called directly.\nSetting to Faux is helpful\nwhen invoking a creation scheme to a SQL file\nwithout access to the actual database –\nle create() et\ndrop() methods can\nbe used to emit SQL to a target bind.
"},{"id":"text-264","type":"text","heading":"","plain_text":"create(bind=None, checkfirst=True)","html":"create(bind=None, checkfirst=True)
"},{"id":"text-265","type":"text","heading":"","plain_text":"Émettre CREATE TYPE for this\nENUM.\nIf the underlying dialect does not support\nPostgreSQL CREATE TYPE, no action is taken.","html":"Émettre CREATE TYPE for this\nENUM.\nIf the underlying dialect does not support\nPostgreSQL CREATE TYPE, no action is taken.
"},{"id":"text-266","type":"text","heading":"","plain_text":"Paramètres","html":"Paramètres
"},{"id":"text-267","type":"text","heading":"","plain_text":"bind – a connectable Moteur,\nConnection, or similar object to emit\nSQL.","html":"bind – a connectable Moteur,\nConnection, or similar object to emit\nSQL.
"},{"id":"text-268","type":"text","heading":"","plain_text":"checkfirst – if True, a query against\nthe PG catalog will be first performed to see\nif the type does not exist already before\ncreating.","html":"checkfirst – if True, a query against\nthe PG catalog will be first performed to see\nif the type does not exist already before\ncreating.
"},{"id":"text-269","type":"text","heading":"","plain_text":"drop(bind=None, checkfirst=True)","html":"drop(bind=None, checkfirst=True)
"},{"id":"text-270","type":"text","heading":"","plain_text":"Émettre DROP TYPE for this\nENUM.\nIf the underlying dialect does not support\nPostgreSQL DROP TYPE, no action is taken.","html":"Émettre DROP TYPE for this\nENUM.\nIf the underlying dialect does not support\nPostgreSQL DROP TYPE, no action is taken.
"},{"id":"text-271","type":"text","heading":"","plain_text":"Paramètres","html":"Paramètres
"},{"id":"text-272","type":"text","heading":"","plain_text":"bind – a connectable Moteur,\nConnection, or similar object to emit\nSQL.","html":"bind – a connectable Moteur,\nConnection, or similar object to emit\nSQL.
"},{"id":"text-273","type":"text","heading":"","plain_text":"checkfirst – if True, a query against\nthe PG catalog will be first performed to see\nif the type actually exists before dropping.","html":"checkfirst – if True, a query against\nthe PG catalog will be first performed to see\nif the type actually exists before dropping.
"},{"id":"text-274","type":"text","heading":"","plain_text":"class sqlalchemy.dialects.postgresql.HSTORE(text_type=None)","html":"class sqlalchemy.dialects.postgresql.HSTORE(text_type=None)
"},{"id":"text-275","type":"text","heading":"","plain_text":"Bases: sqlalchemy.types.Indexable, sqlalchemy.types.Concatenable, sqlalchemy.types.TypeEngine\nRepresent the PostgreSQL HSTORE type.\nle HSTORE type stores dictionaries containing strings, e.g.:","html":"Bases: sqlalchemy.types.Indexable, sqlalchemy.types.Concatenable, sqlalchemy.types.TypeEngine\nRepresent the PostgreSQL HSTORE type.\nle HSTORE type stores dictionaries containing strings, e.g.:
"},{"id":"text-276","type":"text","heading":"","plain_text":"data_table = Table('data_table', metadata,\n Column('id', Integer, primary_key=True),\n Column('data', HSTORE)\n)","html":"data_table = Table('data_table', metadata,\n Column('id', Integer, primary_key=True),\n Column('data', HSTORE)\n)
"},{"id":"text-277","type":"text","heading":"","plain_text":"avec engine.connect() comme conn:\n conn.execute(\n data_table.insérer(),\n Les données = "key1": "value1", "key2": "value2"\n )","html":"avec engine.connect() comme conn:\n conn.execute(\n data_table.insérer(),\n Les données = "key1": "value1", "key2": "value2"\n )
"},{"id":"text-278","type":"text","heading":"","plain_text":"HSTORE provides for a wide range of operations, including:","html":"HSTORE provides for a wide range of operations, including:
"},{"id":"text-279","type":"text","heading":"","plain_text":"Index operations:","html":"Index operations:
"},{"id":"text-280","type":"text","heading":"","plain_text":"data_table.c.Les données[[[['some key'] == 'some value'","html":"data_table.c.Les données[[[['some key'] == 'some value'
"},{"id":"text-281","type":"text","heading":"","plain_text":"Containment operations:","html":"Containment operations:
"},{"id":"text-282","type":"text","heading":"","plain_text":"data_table.c.Les données.has_key('some key')","html":"data_table.c.Les données.has_key('some key')
"},{"id":"text-283","type":"text","heading":"","plain_text":"data_table.c.Les données.has_all([[[['one', 'two', 'three'])","html":"data_table.c.Les données.has_all([[[['one', 'two', 'three'])
"},{"id":"text-284","type":"text","heading":"","plain_text":"Concatenation:","html":"Concatenation:
"},{"id":"text-285","type":"text","heading":"","plain_text":"data_table.c.Les données + "k1": "v1"","html":"data_table.c.Les données + "k1": "v1"
"},{"id":"text-286","type":"text","heading":"","plain_text":"For a full list of special methods see\nHSTORE.comparator_factory.\nFor usage with the SQLAlchemy ORM, it may be desirable to combine\nthe usage of HSTORE avec MutableDict dictionary\nnow part of the sqlalchemy.ext.mutable\nextension. This extension will allow “in-place” changes to the\ndictionary, e.g. addition of new keys or replacement/removal of existing\nkeys to/from the current dictionary, to produce events which will be\ndetected by the unit of work:","html":"For a full list of special methods see\nHSTORE.comparator_factory.\nFor usage with the SQLAlchemy ORM, it may be desirable to combine\nthe usage of HSTORE avec MutableDict dictionary\nnow part of the sqlalchemy.ext.mutable\nextension. This extension will allow “in-place” changes to the\ndictionary, e.g. addition of new keys or replacement/removal of existing\nkeys to/from the current dictionary, to produce events which will be\ndetected by the unit of work:
"},{"id":"text-287","type":"text","heading":"","plain_text":"de sqlalchemy.ext.mutable importation MutableDict","html":"de sqlalchemy.ext.mutable importation MutableDict
"},{"id":"text-288","type":"text","heading":"","plain_text":"class MyClass(Base):\n __tablename__ = 'data_table'","html":"class MyClass(Base):\n __tablename__ = 'data_table'
"},{"id":"text-289","type":"text","heading":"","plain_text":"identifiant = Column(Integer, primary_key=True)\n Les données = Column(MutableDict.as_mutable(HSTORE))","html":"identifiant = Column(Integer, primary_key=True)\n Les données = Column(MutableDict.as_mutable(HSTORE))
"},{"id":"text-290","type":"text","heading":"","plain_text":"my_object = session.query(MyClass).un()","html":"my_object = session.query(MyClass).un()
"},{"id":"text-291","type":"text","heading":"","plain_text":"# in-place mutation, requires Mutable extension\n# in order for the ORM to detect\nmy_object.Les données[[[['some_key'] = 'some value'","html":"# in-place mutation, requires Mutable extension\n# in order for the ORM to detect\nmy_object.Les données[[[['some_key'] = 'some value'
"},{"id":"text-292","type":"text","heading":"","plain_text":"session.commit()","html":"session.commit()
"},{"id":"text-293","type":"text","heading":"","plain_text":"When the sqlalchemy.ext.mutable extension is not used, the ORM\nwill not be alerted to any changes to the contents of an existing\ndictionary, unless that dictionary value is re-assigned to the\nHSTORE-attribute itself, thus generating a change event.","html":"When the sqlalchemy.ext.mutable extension is not used, the ORM\nwill not be alerted to any changes to the contents of an existing\ndictionary, unless that dictionary value is re-assigned to the\nHSTORE-attribute itself, thus generating a change event.
"},{"id":"text-294","type":"text","heading":"","plain_text":"Voir également\nhstore – render the PostgreSQL hstore() une fonction.","html":"Voir également\nhstore – render the PostgreSQL hstore() une fonction.
"},{"id":"text-295","type":"text","heading":"","plain_text":"class Comparator(expr)","html":"class Comparator(expr)
"},{"id":"text-296","type":"text","heading":"","plain_text":"Bases: sqlalchemy.types.Comparator, sqlalchemy.types.Comparator\nDefine comparison operations for HSTORE.","html":"Bases: sqlalchemy.types.Comparator, sqlalchemy.types.Comparator\nDefine comparison operations for HSTORE.
"},{"id":"text-297","type":"text","heading":"","plain_text":"array()","html":"array()
"},{"id":"text-298","type":"text","heading":"","plain_text":"Text array expression. Returns array of alternating keys and\nvaleurs.","html":"Text array expression. Returns array of alternating keys and\nvaleurs.
"},{"id":"text-299","type":"text","heading":"","plain_text":"contained_by(other)","html":"contained_by(other)
"},{"id":"text-300","type":"text","heading":"","plain_text":"Boolean expression. Test if keys are a proper subset of the\nkeys of the argument jsonb expression.","html":"Boolean expression. Test if keys are a proper subset of the\nkeys of the argument jsonb expression.
"},{"id":"text-301","type":"text","heading":"","plain_text":"contient(other, **kwargs)","html":"contient(other, **kwargs)
"},{"id":"text-302","type":"text","heading":"","plain_text":"Boolean expression. Test if keys (or array) are a superset\nof/contained the keys of the argument jsonb expression.","html":"Boolean expression. Test if keys (or array) are a superset\nof/contained the keys of the argument jsonb expression.
"},{"id":"text-303","type":"text","heading":"","plain_text":"defined(clé)","html":"defined(clé)
"},{"id":"text-304","type":"text","heading":"","plain_text":"Boolean expression. Test for presence of a non-NULL value for\nthe key. Note that the key may be a SQLA expression.","html":"Boolean expression. Test for presence of a non-NULL value for\nthe key. Note that the key may be a SQLA expression.
"},{"id":"text-305","type":"text","heading":"","plain_text":"effacer(clé)","html":"effacer(clé)
"},{"id":"text-306","type":"text","heading":"","plain_text":"HStore expression. Returns the contents of this hstore with the\ngiven key deleted. Note that the key may be a SQLA expression.","html":"HStore expression. Returns the contents of this hstore with the\ngiven key deleted. Note that the key may be a SQLA expression.
"},{"id":"text-307","type":"text","heading":"","plain_text":"has_all(other)","html":"has_all(other)
"},{"id":"text-308","type":"text","heading":"","plain_text":"Boolean expression. Test for presence of all keys in jsonb","html":"Boolean expression. Test for presence of all keys in jsonb
"},{"id":"text-309","type":"text","heading":"","plain_text":"has_any(other)","html":"has_any(other)
"},{"id":"text-310","type":"text","heading":"","plain_text":"Boolean expression. Test for presence of any key in jsonb","html":"Boolean expression. Test for presence of any key in jsonb
"},{"id":"text-311","type":"text","heading":"","plain_text":"has_key(other)","html":"has_key(other)
"},{"id":"text-312","type":"text","heading":"","plain_text":"Boolean expression. Test for presence of a key. Note that the\nkey may be a SQLA expression.","html":"Boolean expression. Test for presence of a key. Note that the\nkey may be a SQLA expression.
"},{"id":"text-313","type":"text","heading":"","plain_text":"keys()","html":"keys()
"},{"id":"text-314","type":"text","heading":"","plain_text":"Text array expression. Returns array of keys.","html":"Text array expression. Returns array of keys.
"},{"id":"text-315","type":"text","heading":"","plain_text":"matrix()","html":"matrix()
"},{"id":"text-316","type":"text","heading":"","plain_text":"Text array expression. Returns array of [key, value] pairs.","html":"Text array expression. Returns array of [key, value] pairs.
"},{"id":"text-317","type":"text","heading":"","plain_text":"slice(array)","html":"slice(array)
"},{"id":"text-318","type":"text","heading":"","plain_text":"HStore expression. Returns a subset of an hstore defined by\narray of keys.","html":"HStore expression. Returns a subset of an hstore defined by\narray of keys.
"},{"id":"text-319","type":"text","heading":"","plain_text":"vals()","html":"vals()
"},{"id":"text-320","type":"text","heading":"","plain_text":"Text array expression. Returns array of values.","html":"Text array expression. Returns array of values.
"},{"id":"text-321","type":"text","heading":"","plain_text":"__init__(text_type=None)","html":"__init__(text_type=None)
"},{"id":"text-322","type":"text","heading":"","plain_text":"Construct a new HSTORE.","html":"Construct a new HSTORE.
"},{"id":"text-323","type":"text","heading":"","plain_text":"Paramètres","html":"Paramètres
"},{"id":"text-324","type":"text","heading":"","plain_text":"text_type – \nthe type that should be used for indexed values.\nDefaults to types.Text.","html":"text_type – \nthe type that should be used for indexed values.\nDefaults to types.Text.
"},{"id":"text-325","type":"text","heading":"","plain_text":"bind_processor(dialect)","html":"bind_processor(dialect)
"},{"id":"text-326","type":"text","heading":"","plain_text":"Return a conversion function for processing bind values.\nReturns a callable which will receive a bind parameter value\nas the sole positional argument and will return a value to\nsend to the DB-API.\nIf processing is not necessary, the method should return None.","html":"Return a conversion function for processing bind values.\nReturns a callable which will receive a bind parameter value\nas the sole positional argument and will return a value to\nsend to the DB-API.\nIf processing is not necessary, the method should return None.
"},{"id":"text-327","type":"text","heading":"","plain_text":"Paramètres","html":"Paramètres
"},{"id":"text-328","type":"text","heading":"","plain_text":"dialect – Dialect instance in use.","html":"dialect – Dialect instance in use.
"},{"id":"text-329","type":"text","heading":"","plain_text":"comparator_factory","html":"comparator_factory
"},{"id":"text-330","type":"text","heading":"","plain_text":"alias of HSTORE.Comparator","html":"alias of HSTORE.Comparator
"},{"id":"text-331","type":"text","heading":"","plain_text":"result_processor(dialect, coltype)","html":"result_processor(dialect, coltype)
"},{"id":"text-332","type":"text","heading":"","plain_text":"Return a conversion function for processing result row values.\nReturns a callable which will receive a result row column\nvalue as the sole positional argument and will return a value\nto return to the user.\nIf processing is not necessary, the method should return None.","html":"Return a conversion function for processing result row values.\nReturns a callable which will receive a result row column\nvalue as the sole positional argument and will return a value\nto return to the user.\nIf processing is not necessary, the method should return None.
"},{"id":"text-333","type":"text","heading":"","plain_text":"Paramètres","html":"Paramètres
"},{"id":"text-334","type":"text","heading":"","plain_text":"class sqlalchemy.dialects.postgresql.hstore(*args, **kwargs)","html":"class sqlalchemy.dialects.postgresql.hstore(*args, **kwargs)
"},{"id":"text-335","type":"text","heading":"","plain_text":"Bases: sqlalchemy.sql.functions.GenericFunction\nConstruct an hstore value within a SQL expression using the\nPostgreSQL hstore() une fonction.\nle hstore function accepts one or two arguments as described\nin the PostgreSQL documentation.\nE.g.:","html":"Bases: sqlalchemy.sql.functions.GenericFunction\nConstruct an hstore value within a SQL expression using the\nPostgreSQL hstore() une fonction.\nle hstore function accepts one or two arguments as described\nin the PostgreSQL documentation.\nE.g.:
"},{"id":"text-336","type":"text","heading":"","plain_text":"de sqlalchemy.dialects.postgresql importation array, hstore","html":"de sqlalchemy.dialects.postgresql importation array, hstore
"},{"id":"text-337","type":"text","heading":"","plain_text":"sélectionner([[[[hstore('key1', 'value1')])","html":"sélectionner([[[[hstore('key1', 'value1')])
"},{"id":"text-338","type":"text","heading":"","plain_text":"sélectionner([[[[\n hstore(\n array([[[['key1', 'key2', 'key3']),\n array([[[['value1', 'value2', 'value3'])\n )\n ])","html":"sélectionner([[[[\n hstore(\n array([[[['key1', 'key2', 'key3']),\n array([[[['value1', 'value2', 'value3'])\n )\n ])
"},{"id":"text-339","type":"text","heading":"","plain_text":"Voir également\nHSTORE – the PostgreSQL HSTORE datatype.","html":"Voir également\nHSTORE – the PostgreSQL HSTORE datatype.
"},{"id":"text-340","type":"text","heading":"","plain_text":"type","html":"type
"},{"id":"text-341","type":"text","heading":"","plain_text":"alias of HSTORE","html":"alias of HSTORE
"},{"id":"text-342","type":"text","heading":"","plain_text":"class sqlalchemy.dialects.postgresql.INET","html":"class sqlalchemy.dialects.postgresql.INET
"},{"id":"text-343","type":"text","heading":"","plain_text":"Bases: sqlalchemy.types.TypeEngine","html":"Bases: sqlalchemy.types.TypeEngine
"},{"id":"text-344","type":"text","heading":"","plain_text":"class sqlalchemy.dialects.postgresql.INTERVAL(precision=None, fields=None)","html":"class sqlalchemy.dialects.postgresql.INTERVAL(precision=None, fields=None)
"},{"id":"text-345","type":"text","heading":"","plain_text":"Bases: sqlalchemy.types.NativeForEmulated, sqlalchemy.types._AbstractInterval\nPostgreSQL INTERVAL type.\nThe INTERVAL type may not be supported on all DBAPIs.\nIt is known to work on psycopg2 and not pg8000 or zxjdbc.","html":"Bases: sqlalchemy.types.NativeForEmulated, sqlalchemy.types._AbstractInterval\nPostgreSQL INTERVAL type.\nThe INTERVAL type may not be supported on all DBAPIs.\nIt is known to work on psycopg2 and not pg8000 or zxjdbc.
"},{"id":"text-346","type":"text","heading":"","plain_text":"__init__(precision=None, fields=None)","html":"__init__(precision=None, fields=None)
"},{"id":"text-347","type":"text","heading":"","plain_text":"Construct an INTERVAL.","html":"Construct an INTERVAL.
"},{"id":"text-348","type":"text","heading":"","plain_text":"Paramètres","html":"Paramètres
"},{"id":"text-349","type":"text","heading":"","plain_text":"précision – optional integer precision value","html":"précision – optional integer precision value
"},{"id":"text-350","type":"text","heading":"","plain_text":"fields – \nstring fields specifier. allows storage of fields\nto be limited, such as "YEAR", "MONTH", "DAY TO HOUR",\netc.","html":"fields – \nstring fields specifier. allows storage of fields\nto be limited, such as "YEAR", "MONTH", "DAY TO HOUR",\netc.
"},{"id":"text-351","type":"text","heading":"","plain_text":"class sqlalchemy.dialects.postgresql.JSON(none_as_null=False, astext_type=None)","html":"class sqlalchemy.dialects.postgresql.JSON(none_as_null=False, astext_type=None)
"},{"id":"text-352","type":"text","heading":"","plain_text":"Bases: sqlalchemy.types.JSON\nRepresent the PostgreSQL JSON type.\nThis type is a specialization of the Core-level types.JSON\ntype. Be sure to read the documentation for types.JSON for\nimportant tips regarding treatment of NULL values and ORM use.\nThe operators provided by the PostgreSQL version of JSON\ninclude:","html":"Bases: sqlalchemy.types.JSON\nRepresent the PostgreSQL JSON type.\nThis type is a specialization of the Core-level types.JSON\ntype. Be sure to read the documentation for types.JSON for\nimportant tips regarding treatment of NULL values and ORM use.\nThe operators provided by the PostgreSQL version of JSON\ninclude:
"},{"id":"text-353","type":"text","heading":"","plain_text":"Index operations (the -> operator):","html":"Index operations (the -> operator):
"},{"id":"text-354","type":"text","heading":"","plain_text":"data_table.c.Les données[[[['some key']","html":"data_table.c.Les données[[[['some key']
"},{"id":"text-355","type":"text","heading":"","plain_text":"data_table.c.Les données[[[[5]","html":"data_table.c.Les données[[[[5]
"},{"id":"text-356","type":"text","heading":"","plain_text":"Index operations returning text (the ->> operator):","html":"Index operations returning text (the ->> operator):
"},{"id":"text-357","type":"text","heading":"","plain_text":"data_table.c.Les données[[[['some key'].astext == 'some value'","html":"data_table.c.Les données[[[['some key'].astext == 'some value'
"},{"id":"text-358","type":"text","heading":"","plain_text":"Index operations with CAST\n(equivalent to CAST(col ->> ['some['some['some['some key'] AS )):","html":"Index operations with CAST\n(equivalent to CAST(col ->> ['some['some['some['some key'] AS )):
"},{"id":"text-359","type":"text","heading":"","plain_text":"data_table.c.Les données[[[['some key'].astext.jeter(Integer) == 5","html":"data_table.c.Les données[[[['some key'].astext.jeter(Integer) == 5
"},{"id":"text-360","type":"text","heading":"","plain_text":"Path index operations (the #> operator):","html":"Path index operations (the #> operator):
"},{"id":"text-361","type":"text","heading":"","plain_text":"data_table.c.Les données[([([([('key_1', 'key_2', 5, ..., 'key_n')]","html":"data_table.c.Les données[([([([('key_1', 'key_2', 5, ..., 'key_n')]
"},{"id":"text-362","type":"text","heading":"","plain_text":"Path index operations returning text (the #>> operator):","html":"Path index operations returning text (the #>> operator):
"},{"id":"text-363","type":"text","heading":"","plain_text":"data_table.c.Les données[([([([('key_1', 'key_2', 5, ..., 'key_n')].astext == 'some value'","html":"data_table.c.Les données[([([([('key_1', 'key_2', 5, ..., 'key_n')].astext == 'some value'
"},{"id":"text-364","type":"text","heading":"","plain_text":"Changed in version 1.1: le ColumnElement.cast() operator on\nJSON objects now requires that the JSON.Comparator.astext\nmodifier be called explicitly, if the cast works only from a textual\nstring.","html":"Changed in version 1.1: le ColumnElement.cast() operator on\nJSON objects now requires that the JSON.Comparator.astext\nmodifier be called explicitly, if the cast works only from a textual\nstring.
"},{"id":"text-365","type":"text","heading":"","plain_text":"Index operations return an expression object whose type defaults to\nJSON by default, so that further JSON-oriented instructions\nmay be called upon the result type.\nCustom serializers and deserializers are specified at the dialect level,\nthat is using create_engine(). The reason for this is that when\nusing psycopg2, the DBAPI only allows serializers at the per-cursor\nor per-connection level. E.g.:","html":"Index operations return an expression object whose type defaults to\nJSON by default, so that further JSON-oriented instructions\nmay be called upon the result type.\nCustom serializers and deserializers are specified at the dialect level,\nthat is using create_engine(). The reason for this is that when\nusing psycopg2, the DBAPI only allows serializers at the per-cursor\nor per-connection level. E.g.:
"},{"id":"text-366","type":"text","heading":"","plain_text":"engine = create_engine("postgresql://scott:tiger@localhost/test",\n json_serializer=my_serialize_fn,\n json_deserializer=my_deserialize_fn\n )","html":"engine = create_engine("postgresql://scott:tiger@localhost/test",\n json_serializer=my_serialize_fn,\n json_deserializer=my_deserialize_fn\n )
"},{"id":"text-367","type":"text","heading":"","plain_text":"When using the psycopg2 dialect, the json_deserializer is registered\nagainst the database using psycopg2.extras.register_default_json.","html":"When using the psycopg2 dialect, the json_deserializer is registered\nagainst the database using psycopg2.extras.register_default_json.
"},{"id":"text-368","type":"text","heading":"","plain_text":"class Comparator(expr)","html":"class Comparator(expr)
"},{"id":"text-369","type":"text","heading":"","plain_text":"Bases: sqlalchemy.types.Comparator\nDefine comparison operations for JSON.","html":"Bases: sqlalchemy.types.Comparator\nDefine comparison operations for JSON.
"},{"id":"text-370","type":"text","heading":"","plain_text":"property astext","html":"property astext
"},{"id":"text-371","type":"text","heading":"","plain_text":"On an indexed expression, use the “astext” (e.g. “->>”)\nconversion when rendered in SQL.\nE.g.:","html":"On an indexed expression, use the “astext” (e.g. “->>”)\nconversion when rendered in SQL.\nE.g.:
"},{"id":"text-372","type":"text","heading":"","plain_text":"sélectionner([[[[data_table.c.Les données[[[['some key'].astext])","html":"sélectionner([[[[data_table.c.Les données[[[['some key'].astext])
"},{"id":"text-373","type":"text","heading":"","plain_text":"__init__(none_as_null=False, astext_type=None)","html":"__init__(none_as_null=False, astext_type=None)
"},{"id":"text-374","type":"text","heading":"","plain_text":"Construct a JSON type.","html":"Construct a JSON type.
"},{"id":"text-375","type":"text","heading":"","plain_text":"Paramètres","html":"Paramètres
"},{"id":"text-376","type":"text","heading":"","plain_text":"none_as_null – \nif True, persist the value None as a\nSQL NULL value, not the JSON encoding of nul. Note that\nwhen this flag is False, the null() construct can still\nbe used to persist a NULL value:","html":"none_as_null – \nif True, persist the value None as a\nSQL NULL value, not the JSON encoding of nul. Note that\nwhen this flag is False, the null() construct can still\nbe used to persist a NULL value:
"},{"id":"text-377","type":"text","heading":"","plain_text":"de sqlalchemy importation nul\nconn.execute(table.insérer(), Les données=nul())","html":"de sqlalchemy importation nul\nconn.execute(table.insérer(), Les données=nul())
"},{"id":"text-378","type":"text","heading":"","plain_text":"Changed in version 0.9.8: – Added none_as_null, et null()\nis now supported in order to persist a NULL value.","html":"Changed in version 0.9.8: – Added none_as_null, et null()\nis now supported in order to persist a NULL value.
"},{"id":"text-379","type":"text","heading":"","plain_text":"astext_type – \nthe type to use for the\nJSON.Comparator.astext\naccessor on indexed attributes. Defaults to types.Text.","html":"astext_type – \nthe type to use for the\nJSON.Comparator.astext\naccessor on indexed attributes. Defaults to types.Text.
"},{"id":"text-380","type":"text","heading":"","plain_text":"comparator_factory","html":"comparator_factory
"},{"id":"text-381","type":"text","heading":"","plain_text":"alias of JSON.Comparator","html":"alias of JSON.Comparator
"},{"id":"text-382","type":"text","heading":"","plain_text":"class sqlalchemy.dialects.postgresql.JSONB(none_as_null=False, astext_type=None)","html":"class sqlalchemy.dialects.postgresql.JSONB(none_as_null=False, astext_type=None)
"},{"id":"text-383","type":"text","heading":"","plain_text":"Bases: sqlalchemy.dialects.postgresql.json.JSON\nRepresent the PostgreSQL JSONB type.\nle JSONB type stores arbitrary JSONB format data, e.g.:","html":"Bases: sqlalchemy.dialects.postgresql.json.JSON\nRepresent the PostgreSQL JSONB type.\nle JSONB type stores arbitrary JSONB format data, e.g.:
"},{"id":"text-384","type":"text","heading":"","plain_text":"data_table = Table('data_table', metadata,\n Column('id', Integer, primary_key=True),\n Column('data', JSONB)\n)","html":"data_table = Table('data_table', metadata,\n Column('id', Integer, primary_key=True),\n Column('data', JSONB)\n)
"},{"id":"text-385","type":"text","heading":"","plain_text":"avec engine.connect() comme conn:\n conn.execute(\n data_table.insérer(),\n Les données = "key1": "value1", "key2": "value2"\n )","html":"avec engine.connect() comme conn:\n conn.execute(\n data_table.insérer(),\n Les données = "key1": "value1", "key2": "value2"\n )
"},{"id":"text-386","type":"text","heading":"","plain_text":"le JSONB type includes all operations provided by\nJSON, including the same behaviors for indexing operations.\nIt also adds additional operators specific to JSONB, including\nJSONB.Comparator.has_key(), JSONB.Comparator.has_all(),\nJSONB.Comparator.has_any(), JSONB.Comparator.contains(),\net JSONB.Comparator.contained_by().\nComme le JSON type, the JSONB type does not detect\nin-place changes when used with the ORM, unless the\nsqlalchemy.ext.mutable extension is used.\nCustom serializers and deserializers\nare shared with the JSON class, using the json_serializer\net json_deserializer keyword arguments. These must be specified\nat the dialect level using create_engine(). When using\npsycopg2, the serializers are associated with the jsonb type using\npsycopg2.extras.register_default_jsonb on a per-connection basis,\nin the same way that psycopg2.extras.register_default_json is used\nto register these handlers with the json type.","html":"le JSONB type includes all operations provided by\nJSON, including the same behaviors for indexing operations.\nIt also adds additional operators specific to JSONB, including\nJSONB.Comparator.has_key(), JSONB.Comparator.has_all(),\nJSONB.Comparator.has_any(), JSONB.Comparator.contains(),\net JSONB.Comparator.contained_by().\nComme le JSON type, the JSONB type does not detect\nin-place changes when used with the ORM, unless the\nsqlalchemy.ext.mutable extension is used.\nCustom serializers and deserializers\nare shared with the JSON class, using the json_serializer\net json_deserializer keyword arguments. These must be specified\nat the dialect level using create_engine(). When using\npsycopg2, the serializers are associated with the jsonb type using\npsycopg2.extras.register_default_jsonb on a per-connection basis,\nin the same way that psycopg2.extras.register_default_json is used\nto register these handlers with the json type.
"},{"id":"text-387","type":"text","heading":"","plain_text":"class Comparator(expr)","html":"class Comparator(expr)
"},{"id":"text-388","type":"text","heading":"","plain_text":"Bases: sqlalchemy.dialects.postgresql.json.Comparator\nDefine comparison operations for JSON.","html":"Bases: sqlalchemy.dialects.postgresql.json.Comparator\nDefine comparison operations for JSON.
"},{"id":"text-389","type":"text","heading":"","plain_text":"contained_by(other)","html":"contained_by(other)
"},{"id":"text-390","type":"text","heading":"","plain_text":"Boolean expression. Test if keys are a proper subset of the\nkeys of the argument jsonb expression.","html":"Boolean expression. Test if keys are a proper subset of the\nkeys of the argument jsonb expression.
"},{"id":"text-391","type":"text","heading":"","plain_text":"contient(other, **kwargs)","html":"contient(other, **kwargs)
"},{"id":"text-392","type":"text","heading":"","plain_text":"Boolean expression. Test if keys (or array) are a superset\nof/contained the keys of the argument jsonb expression.","html":"Boolean expression. Test if keys (or array) are a superset\nof/contained the keys of the argument jsonb expression.
"},{"id":"text-393","type":"text","heading":"","plain_text":"has_all(other)","html":"has_all(other)
"},{"id":"text-394","type":"text","heading":"","plain_text":"Boolean expression. Test for presence of all keys in jsonb","html":"Boolean expression. Test for presence of all keys in jsonb
"},{"id":"text-395","type":"text","heading":"","plain_text":"has_any(other)","html":"has_any(other)
"},{"id":"text-396","type":"text","heading":"","plain_text":"Boolean expression. Test for presence of any key in jsonb","html":"Boolean expression. Test for presence of any key in jsonb
"},{"id":"text-397","type":"text","heading":"","plain_text":"has_key(other)","html":"has_key(other)
"},{"id":"text-398","type":"text","heading":"","plain_text":"Boolean expression. Test for presence of a key. Note that the\nkey may be a SQLA expression.","html":"Boolean expression. Test for presence of a key. Note that the\nkey may be a SQLA expression.
"},{"id":"text-399","type":"text","heading":"","plain_text":"comparator_factory","html":"comparator_factory
"},{"id":"text-400","type":"text","heading":"","plain_text":"alias of JSONB.Comparator","html":"alias of JSONB.Comparator
"},{"id":"text-401","type":"text","heading":"","plain_text":"class sqlalchemy.dialects.postgresql.MACADDR","html":"class sqlalchemy.dialects.postgresql.MACADDR
"},{"id":"text-402","type":"text","heading":"","plain_text":"Bases: sqlalchemy.types.TypeEngine","html":"Bases: sqlalchemy.types.TypeEngine
"},{"id":"text-403","type":"text","heading":"","plain_text":"class sqlalchemy.dialects.postgresql.ARGENT","html":"class sqlalchemy.dialects.postgresql.ARGENT
"},{"id":"text-404","type":"text","heading":"","plain_text":"Bases: sqlalchemy.types.TypeEngine\nProvide the PostgreSQL MONEY type.","html":"Bases: sqlalchemy.types.TypeEngine\nProvide the PostgreSQL MONEY type.
"},{"id":"text-405","type":"text","heading":"","plain_text":"class sqlalchemy.dialects.postgresql.OID","html":"class sqlalchemy.dialects.postgresql.OID
"},{"id":"text-406","type":"text","heading":"","plain_text":"Bases: sqlalchemy.types.TypeEngine\nProvide the PostgreSQL OID type.","html":"Bases: sqlalchemy.types.TypeEngine\nProvide the PostgreSQL OID type.
"},{"id":"text-407","type":"text","heading":"","plain_text":"class sqlalchemy.dialects.postgresql.REAL(precision=None, asdecimal=False, decimal_return_scale=None)","html":"class sqlalchemy.dialects.postgresql.REAL(precision=None, asdecimal=False, decimal_return_scale=None)
"},{"id":"text-408","type":"text","heading":"","plain_text":"Bases: sqlalchemy.types.Float\nThe SQL REAL type.","html":"Bases: sqlalchemy.types.Float\nThe SQL REAL type.
"},{"id":"text-409","type":"text","heading":"","plain_text":"__init__(precision=None, asdecimal=False, decimal_return_scale=None)","html":"__init__(precision=None, asdecimal=False, decimal_return_scale=None)
"},{"id":"text-410","type":"text","heading":"","plain_text":"Construct a Float.","html":"Construct a Float.
"},{"id":"text-411","type":"text","heading":"","plain_text":"Paramètres","html":"Paramètres
"},{"id":"text-412","type":"text","heading":"","plain_text":"précision – the numeric precision for use in DDL CREATE\nTABLE.","html":"précision – the numeric precision for use in DDL CREATE\nTABLE.
"},{"id":"text-413","type":"text","heading":"","plain_text":"asdecimal – the same flag as that of Numeric, but\ndefaults to Faux. Note that setting this flag to True\nresults in floating point conversion.","html":"asdecimal – the same flag as that of Numeric, but\ndefaults to Faux. Note that setting this flag to True\nresults in floating point conversion.
"},{"id":"text-414","type":"text","heading":"","plain_text":"decimal_return_scale – \nDefault scale to use when converting\nfrom floats to Python decimals. Floating point values will typically\nbe much longer due to decimal inaccuracy, and most floating point\ndatabase types don’t have a notion of “scale”, so by default the\nfloat type looks for the first ten decimal places when converting.\nSpecifying this value will override that length. Note that the\nMySQL float types, which do include “scale”, will use “scale”\nas the default for decimal_return_scale, if not otherwise specified.","html":"decimal_return_scale – \nDefault scale to use when converting\nfrom floats to Python decimals. Floating point values will typically\nbe much longer due to decimal inaccuracy, and most floating point\ndatabase types don’t have a notion of “scale”, so by default the\nfloat type looks for the first ten decimal places when converting.\nSpecifying this value will override that length. Note that the\nMySQL float types, which do include “scale”, will use “scale”\nas the default for decimal_return_scale, if not otherwise specified.
"},{"id":"text-415","type":"text","heading":"","plain_text":"class sqlalchemy.dialects.postgresql.REGCLASS","html":"class sqlalchemy.dialects.postgresql.REGCLASS
"},{"id":"text-416","type":"text","heading":"","plain_text":"Bases: sqlalchemy.types.TypeEngine\nProvide the PostgreSQL REGCLASS type.","html":"Bases: sqlalchemy.types.TypeEngine\nProvide the PostgreSQL REGCLASS type.
"},{"id":"text-417","type":"text","heading":"","plain_text":"class sqlalchemy.dialects.postgresql.TSVECTOR","html":"class sqlalchemy.dialects.postgresql.TSVECTOR
"},{"id":"text-418","type":"text","heading":"","plain_text":"Bases: sqlalchemy.types.TypeEngine\nle postgresql.TSVECTOR type implements the PostgreSQL\ntext search type TSVECTOR.\nIt can be used to do full text queries on natural language\ndocuments.","html":"Bases: sqlalchemy.types.TypeEngine\nle postgresql.TSVECTOR type implements the PostgreSQL\ntext search type TSVECTOR.\nIt can be used to do full text queries on natural language\ndocuments.
"},{"id":"text-419","type":"text","heading":"","plain_text":"class sqlalchemy.dialects.postgresql.UUID(as_uuid=False)","html":"class sqlalchemy.dialects.postgresql.UUID(as_uuid=False)
"},{"id":"text-420","type":"text","heading":"","plain_text":"Bases: sqlalchemy.types.TypeEngine\nPostgreSQL UUID type.\nRepresents the UUID column type, interpreting\ndata either as natively returned by the DBAPI\nor as Python uuid objects.\nThe UUID type may not be supported on all DBAPIs.\nIt is known to work on psycopg2 and not pg8000.","html":"Bases: sqlalchemy.types.TypeEngine\nPostgreSQL UUID type.\nRepresents the UUID column type, interpreting\ndata either as natively returned by the DBAPI\nor as Python uuid objects.\nThe UUID type may not be supported on all DBAPIs.\nIt is known to work on psycopg2 and not pg8000.
"},{"id":"text-421","type":"text","heading":"","plain_text":"__init__(as_uuid=False)","html":"__init__(as_uuid=False)
"},{"id":"text-422","type":"text","heading":"","plain_text":"Construct a UUID type.","html":"Construct a UUID type.
"},{"id":"text-423","type":"text","heading":"","plain_text":"Paramètres","html":"Paramètres
"},{"id":"text-424","type":"text","heading":"","plain_text":"as_uuid=False – if True, values will be interpreted\nas Python uuid objects, converting to/from string via the\nDBAPI.","html":"as_uuid=False – if True, values will be interpreted\nas Python uuid objects, converting to/from string via the\nDBAPI.
"},{"id":"text-425","type":"text","heading":"","plain_text":"Range Types\nThe new range column types found in PostgreSQL 9.2 onwards are\ncatered for by the following types:","html":"Range Types\nThe new range column types found in PostgreSQL 9.2 onwards are\ncatered for by the following types:
"},{"id":"text-426","type":"text","heading":"","plain_text":"class sqlalchemy.dialects.postgresql.INT4RANGE","html":"class sqlalchemy.dialects.postgresql.INT4RANGE
"},{"id":"text-427","type":"text","heading":"","plain_text":"Bases: sqlalchemy.dialects.postgresql.ranges.RangeOperators, sqlalchemy.types.TypeEngine\nRepresent the PostgreSQL INT4RANGE type.","html":"Bases: sqlalchemy.dialects.postgresql.ranges.RangeOperators, sqlalchemy.types.TypeEngine\nRepresent the PostgreSQL INT4RANGE type.
"},{"id":"text-428","type":"text","heading":"","plain_text":"class sqlalchemy.dialects.postgresql.INT8RANGE","html":"class sqlalchemy.dialects.postgresql.INT8RANGE
"},{"id":"text-429","type":"text","heading":"","plain_text":"Bases: sqlalchemy.dialects.postgresql.ranges.RangeOperators, sqlalchemy.types.TypeEngine\nRepresent the PostgreSQL INT8RANGE type.","html":"Bases: sqlalchemy.dialects.postgresql.ranges.RangeOperators, sqlalchemy.types.TypeEngine\nRepresent the PostgreSQL INT8RANGE type.
"},{"id":"text-430","type":"text","heading":"","plain_text":"class sqlalchemy.dialects.postgresql.NUMRANGE","html":"class sqlalchemy.dialects.postgresql.NUMRANGE
"},{"id":"text-431","type":"text","heading":"","plain_text":"Bases: sqlalchemy.dialects.postgresql.ranges.RangeOperators, sqlalchemy.types.TypeEngine\nRepresent the PostgreSQL NUMRANGE type.","html":"Bases: sqlalchemy.dialects.postgresql.ranges.RangeOperators, sqlalchemy.types.TypeEngine\nRepresent the PostgreSQL NUMRANGE type.
"},{"id":"text-432","type":"text","heading":"","plain_text":"class sqlalchemy.dialects.postgresql.DATERANGE","html":"class sqlalchemy.dialects.postgresql.DATERANGE
"},{"id":"text-433","type":"text","heading":"","plain_text":"Bases: sqlalchemy.dialects.postgresql.ranges.RangeOperators, sqlalchemy.types.TypeEngine\nRepresent the PostgreSQL DATERANGE type.","html":"Bases: sqlalchemy.dialects.postgresql.ranges.RangeOperators, sqlalchemy.types.TypeEngine\nRepresent the PostgreSQL DATERANGE type.
"},{"id":"text-434","type":"text","heading":"","plain_text":"class sqlalchemy.dialects.postgresql.TSRANGE","html":"class sqlalchemy.dialects.postgresql.TSRANGE
"},{"id":"text-435","type":"text","heading":"","plain_text":"Bases: sqlalchemy.dialects.postgresql.ranges.RangeOperators, sqlalchemy.types.TypeEngine\nRepresent the PostgreSQL TSRANGE type.","html":"Bases: sqlalchemy.dialects.postgresql.ranges.RangeOperators, sqlalchemy.types.TypeEngine\nRepresent the PostgreSQL TSRANGE type.
"},{"id":"text-436","type":"text","heading":"","plain_text":"class sqlalchemy.dialects.postgresql.TSTZRANGE","html":"class sqlalchemy.dialects.postgresql.TSTZRANGE
"},{"id":"text-437","type":"text","heading":"","plain_text":"Bases: sqlalchemy.dialects.postgresql.ranges.RangeOperators, sqlalchemy.types.TypeEngine\nRepresent the PostgreSQL TSTZRANGE type.","html":"Bases: sqlalchemy.dialects.postgresql.ranges.RangeOperators, sqlalchemy.types.TypeEngine\nRepresent the PostgreSQL TSTZRANGE type.
"},{"id":"text-438","type":"text","heading":"","plain_text":"The types above get most of their functionality from the following\nmixin:","html":"The types above get most of their functionality from the following\nmixin:
"},{"id":"text-439","type":"text","heading":"","plain_text":"class sqlalchemy.dialects.postgresql.ranges.RangeOperators","html":"class sqlalchemy.dialects.postgresql.ranges.RangeOperators
"},{"id":"text-440","type":"text","heading":"","plain_text":"This mixin provides functionality for the Range Operators\nlisted in Table 9-44 of the postgres documentation for Range\nFunctions and Operators. It is used by all the range types\nprovided in the postgres dialect and can likely be used for\nany range types you create yourself.\nNo extra support is provided for the Range Functions listed in\nTable 9-45 of the postgres documentation. For these, the normal\nfunc() object should be used.","html":"This mixin provides functionality for the Range Operators\nlisted in Table 9-44 of the postgres documentation for Range\nFunctions and Operators. It is used by all the range types\nprovided in the postgres dialect and can likely be used for\nany range types you create yourself.\nNo extra support is provided for the Range Functions listed in\nTable 9-45 of the postgres documentation. For these, the normal\nfunc() object should be used.
"},{"id":"text-441","type":"text","heading":"","plain_text":"class comparator_factory(expr)","html":"class comparator_factory(expr)
"},{"id":"text-442","type":"text","heading":"","plain_text":"Bases: sqlalchemy.types.Comparator\nDefine comparison operations for range types.","html":"Bases: sqlalchemy.types.Comparator\nDefine comparison operations for range types.
"},{"id":"text-443","type":"text","heading":"","plain_text":"__ne__(other)","html":"__ne__(other)
"},{"id":"text-444","type":"text","heading":"","plain_text":"Boolean expression. Returns true if two ranges are not equal","html":"Boolean expression. Returns true if two ranges are not equal
"},{"id":"text-445","type":"text","heading":"","plain_text":"adjacent_to(other)","html":"adjacent_to(other)
"},{"id":"text-446","type":"text","heading":"","plain_text":"Boolean expression. Returns true if the range in the column\nis adjacent to the range in the operand.","html":"Boolean expression. Returns true if the range in the column\nis adjacent to the range in the operand.
"},{"id":"text-447","type":"text","heading":"","plain_text":"contained_by(other)","html":"contained_by(other)
"},{"id":"text-448","type":"text","heading":"","plain_text":"Boolean expression. Returns true if the column is contained\nwithin the right hand operand.","html":"Boolean expression. Returns true if the column is contained\nwithin the right hand operand.
"},{"id":"text-449","type":"text","heading":"","plain_text":"contient(other, **kw)","html":"contient(other, **kw)
"},{"id":"text-450","type":"text","heading":"","plain_text":"Boolean expression. Returns true if the right hand operand,\nwhich can be an element or a range, is contained within the\ncolumn.","html":"Boolean expression. Returns true if the right hand operand,\nwhich can be an element or a range, is contained within the\ncolumn.
"},{"id":"text-451","type":"text","heading":"","plain_text":"not_extend_left_of(other)","html":"not_extend_left_of(other)
"},{"id":"text-452","type":"text","heading":"","plain_text":"Boolean expression. Returns true if the range in the column\ndoes not extend left of the range in the operand.","html":"Boolean expression. Returns true if the range in the column\ndoes not extend left of the range in the operand.
"},{"id":"text-453","type":"text","heading":"","plain_text":"not_extend_right_of(other)","html":"not_extend_right_of(other)
"},{"id":"text-454","type":"text","heading":"","plain_text":"Boolean expression. Returns true if the range in the column\ndoes not extend right of the range in the operand.","html":"Boolean expression. Returns true if the range in the column\ndoes not extend right of the range in the operand.
"},{"id":"text-455","type":"text","heading":"","plain_text":"overlaps(other)","html":"overlaps(other)
"},{"id":"text-456","type":"text","heading":"","plain_text":"Boolean expression. Returns true if the column overlaps\n(has points in common with) the right hand operand.","html":"Boolean expression. Returns true if the column overlaps\n(has points in common with) the right hand operand.
"},{"id":"text-457","type":"text","heading":"","plain_text":"strictly_left_of(other)","html":"strictly_left_of(other)
"},{"id":"text-458","type":"text","heading":"","plain_text":"Boolean expression. Returns true if the column is strictly\nleft of the right hand operand.","html":"Boolean expression. Returns true if the column is strictly\nleft of the right hand operand.
"},{"id":"text-459","type":"text","heading":"","plain_text":"strictly_right_of(other)","html":"strictly_right_of(other)
"},{"id":"text-460","type":"text","heading":"","plain_text":"Boolean expression. Returns true if the column is strictly\nright of the right hand operand.","html":"Boolean expression. Returns true if the column is strictly\nright of the right hand operand.
"},{"id":"text-461","type":"text","heading":"","plain_text":"Attention\nThe range type DDL support should work with any PostgreSQL DBAPI\ndriver, however the data types returned may vary. If you are using\npsycopg2, it’s recommended to upgrade to version 2.5 or later\nbefore using these column types.","html":"Attention\nThe range type DDL support should work with any PostgreSQL DBAPI\ndriver, however the data types returned may vary. If you are using\npsycopg2, it’s recommended to upgrade to version 2.5 or later\nbefore using these column types.
"},{"id":"text-462","type":"text","heading":"","plain_text":"When instantiating models that use these column types, you should pass\nwhatever data type is expected by the DBAPI driver you’re using for\nthe column type. Pour psycopg2 these are\npsycopg2.extras.NumericRange,\npsycopg2.extras.DateRange,\npsycopg2.extras.DateTimeRange et\npsycopg2.extras.DateTimeTZRange or the class you’ve\nregistered with psycopg2.extras.register_range.\nPar exemple:","html":"When instantiating models that use these column types, you should pass\nwhatever data type is expected by the DBAPI driver you’re using for\nthe column type. Pour psycopg2 these are\npsycopg2.extras.NumericRange,\npsycopg2.extras.DateRange,\npsycopg2.extras.DateTimeRange et\npsycopg2.extras.DateTimeTZRange or the class you’ve\nregistered with psycopg2.extras.register_range.\nPar exemple:
"},{"id":"text-463","type":"text","heading":"","plain_text":"de psycopg2.extras importation DateTimeRange\nde sqlalchemy.dialects.postgresql importation TSRANGE","html":"de psycopg2.extras importation DateTimeRange\nde sqlalchemy.dialects.postgresql importation TSRANGE
"},{"id":"text-464","type":"text","heading":"","plain_text":"class RoomBooking(Base):","html":"class RoomBooking(Base):
"},{"id":"text-465","type":"text","heading":"","plain_text":"__tablename__ = 'room_booking'","html":"__tablename__ = 'room_booking'
"},{"id":"text-466","type":"text","heading":"","plain_text":"room = Column(Integer(), primary_key=True)\n pendant = Column(TSRANGE())","html":"room = Column(Integer(), primary_key=True)\n pendant = Column(TSRANGE())
"},{"id":"text-467","type":"text","heading":"","plain_text":"booking = RoomBooking(\n room=101,\n pendant=DateTimeRange(datetime(2013, 3, 23), None)\n)","html":"booking = RoomBooking(\n room=101,\n pendant=DateTimeRange(datetime(2013, 3, 23), None)\n)
"},{"id":"text-468","type":"text","heading":"","plain_text":"PostgreSQL Constraint Types\nSQLAlchemy supports PostgreSQL EXCLUDE constraints via the\nExcludeConstraint class:","html":"PostgreSQL Constraint Types\nSQLAlchemy supports PostgreSQL EXCLUDE constraints via the\nExcludeConstraint class:
"},{"id":"text-469","type":"text","heading":"","plain_text":"class sqlalchemy.dialects.postgresql.ExcludeConstraint(*elements, **kw)","html":"class sqlalchemy.dialects.postgresql.ExcludeConstraint(*elements, **kw)
"},{"id":"text-470","type":"text","heading":"","plain_text":"Bases: sqlalchemy.schema.ColumnCollectionConstraint\nA table-level EXCLUDE constraint.\nDefines an EXCLUDE constraint as described in the postgres\ndocumentation.","html":"Bases: sqlalchemy.schema.ColumnCollectionConstraint\nA table-level EXCLUDE constraint.\nDefines an EXCLUDE constraint as described in the postgres\ndocumentation.
"},{"id":"text-471","type":"text","heading":"","plain_text":"__init__(*elements, **kw)","html":"__init__(*elements, **kw)
"},{"id":"text-472","type":"text","heading":"","plain_text":"Créé un ExcludeConstraint object.\nE.g.:","html":"Créé un ExcludeConstraint object.\nE.g.:
"},{"id":"text-473","type":"text","heading":"","plain_text":"const = ExcludeConstraint(\n (Column('period'), '&&'),\n (Column('group'), '='),\n where=(Column('group') != 'some group')\n)","html":"const = ExcludeConstraint(\n (Column('period'), '&&'),\n (Column('group'), '='),\n where=(Column('group') != 'some group')\n)
"},{"id":"text-474","type":"text","heading":"","plain_text":"The constraint is normally embedded into the Table construct\ndirectly, or added later using append_constraint():","html":"The constraint is normally embedded into the Table construct\ndirectly, or added later using append_constraint():
"},{"id":"text-475","type":"text","heading":"","plain_text":"some_table = Table(\n 'some_table', metadata,\n Column('id', Integer, primary_key=True),\n Column('period', TSRANGE()),\n Column('group', Chaîne)\n)","html":"some_table = Table(\n 'some_table', metadata,\n Column('id', Integer, primary_key=True),\n Column('period', TSRANGE()),\n Column('group', Chaîne)\n)
"},{"id":"text-476","type":"text","heading":"","plain_text":"some_table.append_constraint(\n ExcludeConstraint(\n (some_table.c.period, '&&'),\n (some_table.c.group, '='),\n where=some_table.c.group != 'some group',\n name='some_table_excl_const'\n )\n)","html":"some_table.append_constraint(\n ExcludeConstraint(\n (some_table.c.period, '&&'),\n (some_table.c.group, '='),\n where=some_table.c.group != 'some group',\n name='some_table_excl_const'\n )\n)
"},{"id":"text-477","type":"text","heading":"","plain_text":"Paramètres","html":"Paramètres
"},{"id":"text-478","type":"text","heading":"","plain_text":"*elements – A sequence of two tuples of the form (column, operator) where\n“column” is a SQL expression element or a raw SQL string, most\ntypically a Column object, and “operator” is a string\ncontaining the operator to use. In order to specify a column name\nwhen a Column object is not available, while ensuring\nthat any necessary quoting rules take effect, an ad-hoc\nColumn ou sql.expression.column() object should be\nused.","html":"*elements – A sequence of two tuples of the form (column, operator) where\n“column” is a SQL expression element or a raw SQL string, most\ntypically a Column object, and “operator” is a string\ncontaining the operator to use. In order to specify a column name\nwhen a Column object is not available, while ensuring\nthat any necessary quoting rules take effect, an ad-hoc\nColumn ou sql.expression.column() object should be\nused.
"},{"id":"text-479","type":"text","heading":"","plain_text":"name – Optional, the in-database name of this constraint.","html":"name – Optional, the in-database name of this constraint.
"},{"id":"text-480","type":"text","heading":"","plain_text":"deferrable – Optional bool. If set, emit DEFERRABLE or NOT DEFERRABLE when\nissuing DDL for this constraint.","html":"deferrable – Optional bool. If set, emit DEFERRABLE or NOT DEFERRABLE when\nissuing DDL for this constraint.
"},{"id":"text-481","type":"text","heading":"","plain_text":"initialement – Optional string. If set, emit INITIALLY when issuing DDL\nfor this constraint.","html":"initialement – Optional string. If set, emit INITIALLY when issuing DDL\nfor this constraint.
"},{"id":"text-482","type":"text","heading":"","plain_text":"using – Optional string. If set, emit USING when issuing DDL\nfor this constraint. Defaults to ‘gist’.","html":"using – Optional string. If set, emit USING when issuing DDL\nfor this constraint. Defaults to ‘gist’.
"},{"id":"text-483","type":"text","heading":"","plain_text":"where – \nOptional SQL expression construct or literal SQL string.\nIf set, emit WHERE \n when issuing DDL\nfor this constraint.","html":"where – \nOptional SQL expression construct or literal SQL string.\nIf set, emit WHERE \n when issuing DDL\nfor this constraint.
"},{"id":"text-484","type":"text","heading":"","plain_text":"Attention\nle ExcludeConstraint.where argument to ExcludeConstraint can be passed as a Python string argument, which will be treated as trusted SQL text and rendered as given. DO NOT PASS UNTRUSTED INPUT TO THIS PARAMETER.","html":"Attention\nle ExcludeConstraint.where argument to ExcludeConstraint can be passed as a Python string argument, which will be treated as trusted SQL text and rendered as given. DO NOT PASS UNTRUSTED INPUT TO THIS PARAMETER.
"},{"id":"text-485","type":"text","heading":"","plain_text":"Par exemple:\nde sqlalchemy.dialects.postgresql importation ExcludeConstraint, TSRANGE","html":"Par exemple:\nde sqlalchemy.dialects.postgresql importation ExcludeConstraint, TSRANGE
"},{"id":"text-486","type":"text","heading":"","plain_text":"class RoomBooking(Base):","html":"class RoomBooking(Base):
"},{"id":"text-487","type":"text","heading":"","plain_text":"__tablename__ = 'room_booking'","html":"__tablename__ = 'room_booking'
"},{"id":"text-488","type":"text","heading":"","plain_text":"room = Column(Integer(), primary_key=True)\n pendant = Column(TSRANGE())","html":"room = Column(Integer(), primary_key=True)\n pendant = Column(TSRANGE())
"},{"id":"text-489","type":"text","heading":"","plain_text":"__table_args__ = (\n ExcludeConstraint(('room', '='), ('during', '&&')),\n )","html":"__table_args__ = (\n ExcludeConstraint(('room', '='), ('during', '&&')),\n )
"},{"id":"text-490","type":"text","heading":"","plain_text":"PostgreSQL DML Constructs","html":"PostgreSQL DML Constructs
"},{"id":"text-491","type":"text","heading":"","plain_text":"sqlalchemy.dialects.postgresql.dml.insérer(table, values=None, inline=False, bind=None, prefixes=None, returning=None, return_defaults=False, **dialect_kw)","html":"sqlalchemy.dialects.postgresql.dml.insérer(table, values=None, inline=False, bind=None, prefixes=None, returning=None, return_defaults=False, **dialect_kw)
"},{"id":"text-492","type":"text","heading":"","plain_text":"Construct a new Insert object.\nThis constructor is mirrored as a public API function; voir insert() for a full usage and argument description.","html":"Construct a new Insert object.\nThis constructor is mirrored as a public API function; voir insert() for a full usage and argument description.
"},{"id":"text-493","type":"text","heading":"","plain_text":"class sqlalchemy.dialects.postgresql.dml.Insert(table, values=None, inline=False, bind=None, prefixes=None, returning=None, return_defaults=False, **dialect_kw)","html":"class sqlalchemy.dialects.postgresql.dml.Insert(table, values=None, inline=False, bind=None, prefixes=None, returning=None, return_defaults=False, **dialect_kw)
"},{"id":"text-494","type":"text","heading":"","plain_text":"Bases: sqlalchemy.sql.expression.Insert\nPostgreSQL-specific implementation of INSERT.\nAdds methods for PG-specific syntaxes such as ON CONFLICT.","html":"Bases: sqlalchemy.sql.expression.Insert\nPostgreSQL-specific implementation of INSERT.\nAdds methods for PG-specific syntaxes such as ON CONFLICT.
"},{"id":"text-495","type":"text","heading":"","plain_text":"excluded","html":"excluded
"},{"id":"text-496","type":"text","heading":"","plain_text":"Provide the excluded namespace for an ON CONFLICT statement\nPG’s ON CONFLICT clause allows reference to the row that would\nbe inserted, known as excluded. This attribute provides\nall columns in this row to be referenceable.","html":"Provide the excluded namespace for an ON CONFLICT statement\nPG’s ON CONFLICT clause allows reference to the row that would\nbe inserted, known as excluded. This attribute provides\nall columns in this row to be referenceable.
"},{"id":"text-497","type":"text","heading":"","plain_text":"on_conflict_do_nothing(constraint=None, index_elements=None, index_where=None)","html":"on_conflict_do_nothing(constraint=None, index_elements=None, index_where=None)
"},{"id":"text-498","type":"text","heading":"","plain_text":"Specifies a DO NOTHING action for ON CONFLICT clause.\nle constraint et index_elements arguments\nare optional, but only one of these can be specified.","html":"Specifies a DO NOTHING action for ON CONFLICT clause.\nle constraint et index_elements arguments\nare optional, but only one of these can be specified.
"},{"id":"text-499","type":"text","heading":"","plain_text":"Paramètres","html":"Paramètres
"},{"id":"text-500","type":"text","heading":"","plain_text":"constraint – The name of a unique or exclusion constraint on the table,\nor the constraint object itself if it has a .name attribute.","html":"constraint – The name of a unique or exclusion constraint on the table,\nor the constraint object itself if it has a .name attribute.
"},{"id":"text-501","type":"text","heading":"","plain_text":"index_elements – A sequence consisting of string column names, Column\nobjects, or other column expression objects that will be used\nto infer a target index.","html":"index_elements – A sequence consisting of string column names, Column\nobjects, or other column expression objects that will be used\nto infer a target index.
"},{"id":"text-502","type":"text","heading":"","plain_text":"index_where – \nAdditional WHERE criterion that can be used to infer a\nconditional target index.","html":"index_where – \nAdditional WHERE criterion that can be used to infer a\nconditional target index.
"},{"id":"text-503","type":"text","heading":"","plain_text":"on_conflict_do_update(constraint=None, index_elements=None, index_where=None, set_=None, where=None)","html":"on_conflict_do_update(constraint=None, index_elements=None, index_where=None, set_=None, where=None)
"},{"id":"text-504","type":"text","heading":"","plain_text":"Specifies a DO UPDATE SET action for ON CONFLICT clause.\nEither the constraint ou index_elements argument is\nrequired, but only one of these can be specified.","html":"Specifies a DO UPDATE SET action for ON CONFLICT clause.\nEither the constraint ou index_elements argument is\nrequired, but only one of these can be specified.
"},{"id":"text-505","type":"text","heading":"","plain_text":"Paramètres","html":"Paramètres
"},{"id":"text-506","type":"text","heading":"","plain_text":"constraint – The name of a unique or exclusion constraint on the table,\nor the constraint object itself if it has a .name attribute.","html":"constraint – The name of a unique or exclusion constraint on the table,\nor the constraint object itself if it has a .name attribute.
"},{"id":"text-507","type":"text","heading":"","plain_text":"index_elements – A sequence consisting of string column names, Column\nobjects, or other column expression objects that will be used\nto infer a target index.","html":"index_elements – A sequence consisting of string column names, Column\nobjects, or other column expression objects that will be used\nto infer a target index.
"},{"id":"text-508","type":"text","heading":"","plain_text":"index_where – Additional WHERE criterion that can be used to infer a\nconditional target index.","html":"index_where – Additional WHERE criterion that can be used to infer a\nconditional target index.
"},{"id":"text-509","type":"text","heading":"","plain_text":"set_ – \nRequired argument. A dictionary or other mapping object\nwith column names as keys and expressions or literals as values,\nspecifying the SET actions to take.\nIf the target Column specifies a “.key” attribute distinct\nfrom the column name, that key should be used.","html":"set_ – \nRequired argument. A dictionary or other mapping object\nwith column names as keys and expressions or literals as values,\nspecifying the SET actions to take.\nIf the target Column specifies a “.key” attribute distinct\nfrom the column name, that key should be used.
"},{"id":"text-510","type":"text","heading":"","plain_text":"Attention\nThis dictionary does ne pas take into account\nPython-specified default UPDATE values or generation functions,\ne.g. those specified using Column.onupdate.\nThese values will not be exercised for an ON CONFLICT style of\nUPDATE, unless they are manually specified in the\nInsert.on_conflict_do_update.set_ dictionary.","html":"Attention\nThis dictionary does ne pas take into account\nPython-specified default UPDATE values or generation functions,\ne.g. those specified using Column.onupdate.\nThese values will not be exercised for an ON CONFLICT style of\nUPDATE, unless they are manually specified in the\nInsert.on_conflict_do_update.set_ dictionary.
"},{"id":"text-511","type":"text","heading":"","plain_text":"where – \nOptional argument. If present, can be a literal SQL\nstring or an acceptable expression for a WHERE clause\nthat restricts the rows affected by DO UPDATE SET. Rows\nnot meeting the WHERE condition will not be updated\n(effectively a DO NOTHING for those rows).","html":"where – \nOptional argument. If present, can be a literal SQL\nstring or an acceptable expression for a WHERE clause\nthat restricts the rows affected by DO UPDATE SET. Rows\nnot meeting the WHERE condition will not be updated\n(effectively a DO NOTHING for those rows).
"},{"id":"text-512","type":"text","heading":"","plain_text":"psycopg2\nSupport for the PostgreSQL database via the psycopg2 driver.","html":"psycopg2\nSupport for the PostgreSQL database via the psycopg2 driver.
"},{"id":"text-513","type":"text","heading":"","plain_text":"DBAPI\nDocumentation and download information (if applicable) for psycopg2 is available at:\nhttp://pypi.python.org/pypi/psycopg2/","html":"DBAPI\nDocumentation and download information (if applicable) for psycopg2 is available at:\nhttp://pypi.python.org/pypi/psycopg2/
"},{"id":"text-514","type":"text","heading":"","plain_text":"Connecting\nConnect String:","html":"Connecting\nConnect String:
"},{"id":"text-515","type":"text","heading":"","plain_text":"postgresql+psycopg2://user:password@host:port/dbname[?key=value&key=value...]","html":"postgresql+psycopg2://user:password@host:port/dbname[?key=value&key=value...]
"},{"id":"text-516","type":"text","heading":"","plain_text":"psycopg2 Connect Arguments\npsycopg2-specific keyword arguments which are accepted by\ncreate_engine() sont:","html":"psycopg2 Connect Arguments\npsycopg2-specific keyword arguments which are accepted by\ncreate_engine() sont:
"},{"id":"text-517","type":"text","heading":"","plain_text":"server_side_cursors: Enable the usage of “server side cursors” for SQL\nstatements which support this feature. What this essentially means from a\npsycopg2 point of view is that the cursor is created using a name, e.g.\nconnection.cursor('some name'), which has the effect that result rows\nare not immediately pre-fetched and buffered after statement execution, but\nare instead left on the server and only retrieved as needed. SQLAlchemy’s\nResultProxy uses special row-buffering\nbehavior when this feature is enabled, such that groups of 100 rows at a\ntime are fetched over the wire to reduce conversational overhead.\nNote that the Connection.execution_options.stream_results\nexecution option is a more targeted\nway of enabling this mode on a per-execution basis.","html":"server_side_cursors: Enable the usage of “server side cursors” for SQL\nstatements which support this feature. What this essentially means from a\npsycopg2 point of view is that the cursor is created using a name, e.g.\nconnection.cursor('some name'), which has the effect that result rows\nare not immediately pre-fetched and buffered after statement execution, but\nare instead left on the server and only retrieved as needed. SQLAlchemy’s\nResultProxy uses special row-buffering\nbehavior when this feature is enabled, such that groups of 100 rows at a\ntime are fetched over the wire to reduce conversational overhead.\nNote that the Connection.execution_options.stream_results\nexecution option is a more targeted\nway of enabling this mode on a per-execution basis.
"},{"id":"text-518","type":"text","heading":"","plain_text":"use_native_unicode: Enable the usage of Psycopg2 “native unicode” mode\nper connection. True by default.","html":"use_native_unicode: Enable the usage of Psycopg2 “native unicode” mode\nper connection. True by default.
"},{"id":"text-519","type":"text","heading":"","plain_text":"isolation_level: This option, available for all PostgreSQL dialects,\ncomprend le AUTOCOMMIT isolation level when using the psycopg2\ndialect.","html":"isolation_level: This option, available for all PostgreSQL dialects,\ncomprend le AUTOCOMMIT isolation level when using the psycopg2\ndialect.
"},{"id":"text-520","type":"text","heading":"","plain_text":"client_encoding: sets the client encoding in a libpq-agnostic way,\nusing psycopg2’s set_client_encoding() method.","html":"client_encoding: sets the client encoding in a libpq-agnostic way,\nusing psycopg2’s set_client_encoding() method.
"},{"id":"text-521","type":"text","heading":"","plain_text":"executemany_mode, executemany_batch_page_size,\nexecutemany_values_page_size: Allows use of psycopg2\nextensions for optimizing “executemany”-stye queries. See the referenced\nsection below for details.","html":"executemany_mode, executemany_batch_page_size,\nexecutemany_values_page_size: Allows use of psycopg2\nextensions for optimizing “executemany”-stye queries. See the referenced\nsection below for details.
"},{"id":"text-522","type":"text","heading":"","plain_text":"use_batch_mode: this is the previous setting used to affect “executemany”\nmode and is now deprecated.","html":"use_batch_mode: this is the previous setting used to affect “executemany”\nmode and is now deprecated.
"},{"id":"text-523","type":"text","heading":"","plain_text":"Unix Domain Connections\npsycopg2 supports connecting via Unix domain connections. When the hôte\nportion of the URL is omitted, SQLAlchemy passes None to psycopg2,\nwhich specifies Unix-domain communication rather than TCP/IP communication:","html":"Unix Domain Connections\npsycopg2 supports connecting via Unix domain connections. When the hôte\nportion of the URL is omitted, SQLAlchemy passes None to psycopg2,\nwhich specifies Unix-domain communication rather than TCP/IP communication:
"},{"id":"text-524","type":"text","heading":"","plain_text":"create_engine("postgresql+psycopg2://user:password@/dbname")","html":"create_engine("postgresql+psycopg2://user:password@/dbname")
"},{"id":"text-525","type":"text","heading":"","plain_text":"By default, the socket file used is to connect to a Unix-domain socket\ndans /tmp, or whatever socket directory was specified when PostgreSQL\nwas built. This value can be overridden by passing a pathname to psycopg2,\nusing hôte as an additional keyword argument:","html":"By default, the socket file used is to connect to a Unix-domain socket\ndans /tmp, or whatever socket directory was specified when PostgreSQL\nwas built. This value can be overridden by passing a pathname to psycopg2,\nusing hôte as an additional keyword argument:
"},{"id":"text-526","type":"text","heading":"","plain_text":"create_engine("postgresql+psycopg2://user:password@/dbname?host=/var/lib/postgresql")","html":"create_engine("postgresql+psycopg2://user:password@/dbname?host=/var/lib/postgresql")
"},{"id":"text-527","type":"text","heading":"","plain_text":"Empty DSN Connections / Environment Variable Connections\nThe psycopg2 DBAPI can connect to PostgreSQL by passing an empty DSN to the\nlibpq client library, which by default indicates to connect to a localhost\nPostgreSQL database that is open for “trust” connections. This behavior can be\nfurther tailored using a particular set of environment variables which are\nprefixed with PG_..., which are consumed by libpq to take the place of\nany or all elements of the connection string.\nFor this form, the URL can be passed without any elements other than the\ninitial scheme:","html":"Empty DSN Connections / Environment Variable Connections\nThe psycopg2 DBAPI can connect to PostgreSQL by passing an empty DSN to the\nlibpq client library, which by default indicates to connect to a localhost\nPostgreSQL database that is open for “trust” connections. This behavior can be\nfurther tailored using a particular set of environment variables which are\nprefixed with PG_..., which are consumed by libpq to take the place of\nany or all elements of the connection string.\nFor this form, the URL can be passed without any elements other than the\ninitial scheme:
"},{"id":"text-528","type":"text","heading":"","plain_text":"engine = create_engine('postgresql+psycopg2://')","html":"engine = create_engine('postgresql+psycopg2://')
"},{"id":"text-529","type":"text","heading":"","plain_text":"In the above form, a blank “dsn” string is passed to the psycopg2.connect()\nfunction which in turn represents an empty DSN passed to libpq.","html":"In the above form, a blank “dsn” string is passed to the psycopg2.connect()\nfunction which in turn represents an empty DSN passed to libpq.
"},{"id":"text-530","type":"text","heading":"","plain_text":"New in version 1.3.2: support for parameter-less connections with psycopg2.","html":"New in version 1.3.2: support for parameter-less connections with psycopg2.
"},{"id":"text-531","type":"text","heading":"","plain_text":"Voir également\nEnvironment Variables –\nPostgreSQL documentation on how to use PG_...\nenvironment variables for connections.","html":"Voir également\nEnvironment Variables –\nPostgreSQL documentation on how to use PG_...\nenvironment variables for connections.
"},{"id":"text-532","type":"text","heading":"","plain_text":"Per-Statement/Connection Execution Options\nThe following DBAPI-specific options are respected when used with\nConnection.execution_options(), Executable.execution_options(),\nQuery.execution_options(), in addition to those not specific to DBAPIs:","html":"Per-Statement/Connection Execution Options\nThe following DBAPI-specific options are respected when used with\nConnection.execution_options(), Executable.execution_options(),\nQuery.execution_options(), in addition to those not specific to DBAPIs:
"},{"id":"text-533","type":"text","heading":"","plain_text":"isolation_level – Set the transaction isolation level for the lifespan\nd'un Connection (can only be set on a connection, not a statement\nor query). See Psycopg2 Transaction Isolation Level.","html":"isolation_level – Set the transaction isolation level for the lifespan\nd'un Connection (can only be set on a connection, not a statement\nor query). See Psycopg2 Transaction Isolation Level.
"},{"id":"text-534","type":"text","heading":"","plain_text":"stream_results – Enable or disable usage of psycopg2 server side\ncursors – this feature makes use of “named” cursors in combination with\nspecial result handling methods so that result rows are not fully buffered.\nSi None or not set, the server_side_cursors option of the\nMoteur est utilisé.","html":"stream_results – Enable or disable usage of psycopg2 server side\ncursors – this feature makes use of “named” cursors in combination with\nspecial result handling methods so that result rows are not fully buffered.\nSi None or not set, the server_side_cursors option of the\nMoteur est utilisé.
"},{"id":"text-535","type":"text","heading":"","plain_text":"max_row_buffer – when using stream_results, an integer value that\nspecifies the maximum number of rows to buffer at a time. This is\ninterpreted by the BufferedRowResultProxy, and if omitted the\nbuffer will grow to ultimately store 1000 rows at a time.","html":"max_row_buffer – when using stream_results, an integer value that\nspecifies the maximum number of rows to buffer at a time. This is\ninterpreted by the BufferedRowResultProxy, and if omitted the\nbuffer will grow to ultimately store 1000 rows at a time.
"},{"id":"text-536","type":"text","heading":"","plain_text":"Psycopg2 Fast Execution Helpers\nModern versions of psycopg2 include a feature known as\nFast Execution Helpers , which\nhave been shown in benchmarking to improve psycopg2’s executemany()\nperformance, primarily with INSERT statements, by multiple orders of magnitude.\nSQLAlchemy allows this extension to be used for all executemany() style\ncalls invoked by an Moteur when used with multiple parameter\nensembles, which includes the use of this feature both by the\nCore as well as by the ORM for inserts of objects with non-autogenerated\nprimary key values, by adding the executemany_mode flag to\ncreate_engine():","html":"Psycopg2 Fast Execution Helpers\nModern versions of psycopg2 include a feature known as\nFast Execution Helpers , which\nhave been shown in benchmarking to improve psycopg2’s executemany()\nperformance, primarily with INSERT statements, by multiple orders of magnitude.\nSQLAlchemy allows this extension to be used for all executemany() style\ncalls invoked by an Moteur when used with multiple parameter\nensembles, which includes the use of this feature both by the\nCore as well as by the ORM for inserts of objects with non-autogenerated\nprimary key values, by adding the executemany_mode flag to\ncreate_engine():
"},{"id":"text-537","type":"text","heading":"","plain_text":"engine = create_engine(\n "postgresql+psycopg2://scott:tiger@host/dbname",\n executemany_mode='batch')","html":"engine = create_engine(\n "postgresql+psycopg2://scott:tiger@host/dbname",\n executemany_mode='batch')
"},{"id":"text-538","type":"text","heading":"","plain_text":"Changed in version 1.3.7: – le use_batch_mode flag has been superseded\nby a new parameter executemany_mode which provides support both for\npsycopg2’s execute_batch helper as well as the execute_values\nhelper.","html":"Changed in version 1.3.7: – le use_batch_mode flag has been superseded\nby a new parameter executemany_mode which provides support both for\npsycopg2’s execute_batch helper as well as the execute_values\nhelper.
"},{"id":"text-539","type":"text","heading":"","plain_text":"Possible options for executemany_mode include:","html":"Possible options for executemany_mode include:
"},{"id":"text-540","type":"text","heading":"","plain_text":"None – By default, psycopg2’s extensions are not used, and the usual\ncursor.executemany() method is used when invoking batches of statements.","html":"None – By default, psycopg2’s extensions are not used, and the usual\ncursor.executemany() method is used when invoking batches of statements.
"},{"id":"text-541","type":"text","heading":"","plain_text":"'batch' – Uses psycopg2.extras.execute_batch so that multiple copies\nof a SQL query, each one corresponding to a parameter set passed to\nexecutemany(), are joined into a single SQL string separated by a\nsemicolon. This is the same behavior as was provided by the\nuse_batch_mode=True flag.","html":"'batch' – Uses psycopg2.extras.execute_batch so that multiple copies\nof a SQL query, each one corresponding to a parameter set passed to\nexecutemany(), are joined into a single SQL string separated by a\nsemicolon. This is the same behavior as was provided by the\nuse_batch_mode=True flag.
"},{"id":"text-542","type":"text","heading":"","plain_text":"'values'– For Core insert() constructs only (including those\nemitted by the ORM automatically), the psycopg2.extras.execute_values\nextension is used so that multiple parameter sets are grouped into a single\nINSERT statement and joined together with multiple VALUES expressions. Cette\nmethod requires that the string text of the VALUES clause inside the\nINSERT statement is manipulated, so is only supported with a compiled\ninsert() construct where the format is predictable. For all other\nconstructs, including plain textual INSERT statements not rendered by the\nSQLAlchemy expression language compiler, the\npsycopg2.extras.execute_batch method is used. It is therefore important\nto note that “values” mode implies that “batch” mode is also used for\nall statements for which “values” mode does not apply.","html":"'values'– For Core insert() constructs only (including those\nemitted by the ORM automatically), the psycopg2.extras.execute_values\nextension is used so that multiple parameter sets are grouped into a single\nINSERT statement and joined together with multiple VALUES expressions. Cette\nmethod requires that the string text of the VALUES clause inside the\nINSERT statement is manipulated, so is only supported with a compiled\ninsert() construct where the format is predictable. For all other\nconstructs, including plain textual INSERT statements not rendered by the\nSQLAlchemy expression language compiler, the\npsycopg2.extras.execute_batch method is used. It is therefore important\nto note that “values” mode implies that “batch” mode is also used for\nall statements for which “values” mode does not apply.
"},{"id":"text-543","type":"text","heading":"","plain_text":"For both strategies, the executemany_batch_page_size et\nexecutemany_values_page_size arguments control how many parameter sets\nshould be represented in each execution. Because “values” mode implies a\nfallback down to “batch” mode for non-INSERT statements, there are two\nindependent page size arguments. For each, the default value of None means\nto use psycopg2’s defaults, which at the time of this writing are quite low at\n100. For the execute_values method, a number as high as 10000 may prove\nto be performant, whereas for execute_batch, as the number represents\nfull statements repeated, a number closer to the default of 100 is likely\nmore appropriate:","html":"For both strategies, the executemany_batch_page_size et\nexecutemany_values_page_size arguments control how many parameter sets\nshould be represented in each execution. Because “values” mode implies a\nfallback down to “batch” mode for non-INSERT statements, there are two\nindependent page size arguments. For each, the default value of None means\nto use psycopg2’s defaults, which at the time of this writing are quite low at\n100. For the execute_values method, a number as high as 10000 may prove\nto be performant, whereas for execute_batch, as the number represents\nfull statements repeated, a number closer to the default of 100 is likely\nmore appropriate:
"},{"id":"text-544","type":"text","heading":"","plain_text":"engine = create_engine(\n "postgresql+psycopg2://scott:tiger@host/dbname",\n executemany_mode='values',\n executemany_values_page_size=10000, executemany_batch_page_size=500)","html":"engine = create_engine(\n "postgresql+psycopg2://scott:tiger@host/dbname",\n executemany_mode='values',\n executemany_values_page_size=10000, executemany_batch_page_size=500)
"},{"id":"text-545","type":"text","heading":"","plain_text":"Changed in version 1.3.7: – Added support for\npsycopg2.extras.execute_values. le use_batch_mode flag is\nsuperseded by the executemany_mode flag.","html":"Changed in version 1.3.7: – Added support for\npsycopg2.extras.execute_values. le use_batch_mode flag is\nsuperseded by the executemany_mode flag.
"},{"id":"text-546","type":"text","heading":"","plain_text":"Unicode with Psycopg2\nBy default, the psycopg2 driver uses the psycopg2.extensions.UNICODE\nextension, such that the DBAPI receives and returns all strings as Python\nUnicode objects directly – SQLAlchemy passes these values through without\nchange. Psycopg2 here will encode/decode string values based on the\ncurrent “client encoding” setting; by default this is the value in\nle postgresql.conf file, which often defaults to SQL_ASCII.\nTypically, this can be changed to utf8, as a more useful default:","html":"Unicode with Psycopg2\nBy default, the psycopg2 driver uses the psycopg2.extensions.UNICODE\nextension, such that the DBAPI receives and returns all strings as Python\nUnicode objects directly – SQLAlchemy passes these values through without\nchange. Psycopg2 here will encode/decode string values based on the\ncurrent “client encoding” setting; by default this is the value in\nle postgresql.conf file, which often defaults to SQL_ASCII.\nTypically, this can be changed to utf8, as a more useful default:
"},{"id":"text-547","type":"text","heading":"","plain_text":"# postgresql.conf file","html":"# postgresql.conf file
"},{"id":"text-548","type":"text","heading":"","plain_text":"# client_encoding = sql_ascii # actually, defaults to database\n # encoding\nclient_encoding = utf8","html":"# client_encoding = sql_ascii # actually, defaults to database\n # encoding\nclient_encoding = utf8
"},{"id":"text-549","type":"text","heading":"","plain_text":"A second way to affect the client encoding is to set it within Psycopg2\nlocally. SQLAlchemy will call psycopg2’s\npsycopg2:connection.set_client_encoding() method\non all new connections based on the value passed to\ncreate_engine() using the client_encoding parameter:","html":"A second way to affect the client encoding is to set it within Psycopg2\nlocally. SQLAlchemy will call psycopg2’s\npsycopg2:connection.set_client_encoding() method\non all new connections based on the value passed to\ncreate_engine() using the client_encoding parameter:
"},{"id":"text-550","type":"text","heading":"","plain_text":"# set_client_encoding() setting;\n# works for *all* PostgreSQL versions\nengine = create_engine("postgresql://user:pass@host/dbname",\n client_encoding='utf8')","html":"# set_client_encoding() setting;\n# works for *all* PostgreSQL versions\nengine = create_engine("postgresql://user:pass@host/dbname",\n client_encoding='utf8')
"},{"id":"text-551","type":"text","heading":"","plain_text":"This overrides the encoding specified in the PostgreSQL client configuration.\nWhen using the parameter in this way, the psycopg2 driver emits\nSET client_encoding TO 'utf8' on the connection explicitly, and works\nin all PostgreSQL versions.\nNote that the client_encoding setting as passed to create_engine()\nest not the same as the more recently added client_encoding parameter\nnow supported by libpq directly. This is enabled when client_encoding\nis passed directly to psycopg2.connect(), and from SQLAlchemy is passed\nusing the create_engine.connect_args parameter:","html":"This overrides the encoding specified in the PostgreSQL client configuration.\nWhen using the parameter in this way, the psycopg2 driver emits\nSET client_encoding TO 'utf8' on the connection explicitly, and works\nin all PostgreSQL versions.\nNote that the client_encoding setting as passed to create_engine()\nest not the same as the more recently added client_encoding parameter\nnow supported by libpq directly. This is enabled when client_encoding\nis passed directly to psycopg2.connect(), and from SQLAlchemy is passed\nusing the create_engine.connect_args parameter:
"},{"id":"text-552","type":"text","heading":"","plain_text":"engine = create_engine(\n "postgresql://user:pass@host/dbname",\n connect_args='client_encoding': 'utf8')","html":"engine = create_engine(\n "postgresql://user:pass@host/dbname",\n connect_args='client_encoding': 'utf8')
"},{"id":"text-553","type":"text","heading":"","plain_text":"# using the query string is equivalent\nengine = create_engine("postgresql://user:pass@host/dbname?client_encoding=utf8")","html":"# using the query string is equivalent\nengine = create_engine("postgresql://user:pass@host/dbname?client_encoding=utf8")
"},{"id":"text-554","type":"text","heading":"","plain_text":"The above parameter was only added to libpq as of version 9.1 of PostgreSQL,\nso using the previous method is better for cross-version support.","html":"The above parameter was only added to libpq as of version 9.1 of PostgreSQL,\nso using the previous method is better for cross-version support.
"},{"id":"text-555","type":"text","heading":"","plain_text":"Disabling Native Unicode\nSQLAlchemy can also be instructed to skip the usage of the psycopg2\nUNICODE extension and to instead utilize its own unicode encode/decode\nservices, which are normally reserved only for those DBAPIs that don’t\nfully support unicode directly. Passing use_native_unicode=False à\ncreate_engine() will disable usage of psycopg2.extensions.UNICODE.\nSQLAlchemy will instead encode data itself into Python bytestrings on the way\nin and coerce from bytes on the way back,\nusing the value of the create_engine() encoding parameter, which\ndefaults to utf-8.\nSQLAlchemy’s own unicode encode/decode functionality is steadily becoming\nobsolete as most DBAPIs now support unicode fully.","html":"Disabling Native Unicode\nSQLAlchemy can also be instructed to skip the usage of the psycopg2\nUNICODE extension and to instead utilize its own unicode encode/decode\nservices, which are normally reserved only for those DBAPIs that don’t\nfully support unicode directly. Passing use_native_unicode=False à\ncreate_engine() will disable usage of psycopg2.extensions.UNICODE.\nSQLAlchemy will instead encode data itself into Python bytestrings on the way\nin and coerce from bytes on the way back,\nusing the value of the create_engine() encoding parameter, which\ndefaults to utf-8.\nSQLAlchemy’s own unicode encode/decode functionality is steadily becoming\nobsolete as most DBAPIs now support unicode fully.
"},{"id":"text-556","type":"text","heading":"","plain_text":"Bound Parameter Styles\nThe default parameter style for the psycopg2 dialect is “pyformat”, where\nSQL is rendered using %(paramname)s style. This format has the limitation\nthat it does not accommodate the unusual case of parameter names that\nactually contain percent or parenthesis symbols; as SQLAlchemy in many cases\ngenerates bound parameter names based on the name of a column, the presence\nof these characters in a column name can lead to problems.\nThere are two solutions to the issue of a schema.Column that contains\none of these characters in its name. One is to specify the\nschema.Column.key for columns that have such names:","html":"Bound Parameter Styles\nThe default parameter style for the psycopg2 dialect is “pyformat”, where\nSQL is rendered using %(paramname)s style. This format has the limitation\nthat it does not accommodate the unusual case of parameter names that\nactually contain percent or parenthesis symbols; as SQLAlchemy in many cases\ngenerates bound parameter names based on the name of a column, the presence\nof these characters in a column name can lead to problems.\nThere are two solutions to the issue of a schema.Column that contains\none of these characters in its name. One is to specify the\nschema.Column.key for columns that have such names:
"},{"id":"text-557","type":"text","heading":"","plain_text":"measurement = Table('measurement', metadata,\n Column('Size (meters)', Integer, clé='size_meters')\n)","html":"measurement = Table('measurement', metadata,\n Column('Size (meters)', Integer, clé='size_meters')\n)
"},{"id":"text-558","type":"text","heading":"","plain_text":"Above, an INSERT statement such as measurement.insert() will use\nsize_meters as the parameter name, and a SQL expression such as\nmeasurement.c.size_meters > dix will derive the bound parameter name\nfrom the size_meters key as well.","html":"Above, an INSERT statement such as measurement.insert() will use\nsize_meters as the parameter name, and a SQL expression such as\nmeasurement.c.size_meters > dix will derive the bound parameter name\nfrom the size_meters key as well.
"},{"id":"text-559","type":"text","heading":"","plain_text":"Changed in version 1.0.0: – SQL expressions will use Column.key\nas the source of naming when anonymous bound parameters are created\nin SQL expressions; previously, this behavior only applied to\nTable.insert() et Table.update() parameter names.","html":"Changed in version 1.0.0: – SQL expressions will use Column.key\nas the source of naming when anonymous bound parameters are created\nin SQL expressions; previously, this behavior only applied to\nTable.insert() et Table.update() parameter names.
"},{"id":"text-560","type":"text","heading":"","plain_text":"The other solution is to use a positional format; psycopg2 allows use of the\n“format” paramstyle, which can be passed to\ncreate_engine.paramstyle:","html":"The other solution is to use a positional format; psycopg2 allows use of the\n“format” paramstyle, which can be passed to\ncreate_engine.paramstyle:
"},{"id":"text-561","type":"text","heading":"","plain_text":"engine = create_engine(\n 'postgresql://scott:tiger@localhost:5432/test', paramstyle='format')","html":"engine = create_engine(\n 'postgresql://scott:tiger@localhost:5432/test', paramstyle='format')
"},{"id":"text-562","type":"text","heading":"","plain_text":"With the above engine, instead of a statement like:","html":"With the above engine, instead of a statement like:
"},{"id":"text-563","type":"text","heading":"","plain_text":"INSERT INTO measurement ("Size (meters)") VALUES (%(Taille (meters))s)\n'Size (meters)': 1","html":"INSERT INTO measurement ("Size (meters)") VALUES (%(Taille (meters))s)\n'Size (meters)': 1
"},{"id":"text-564","type":"text","heading":"","plain_text":"we instead see:","html":"we instead see:
"},{"id":"text-565","type":"text","heading":"","plain_text":"INSERT INTO measurement ("Size (meters)") VALUES (%s)\n(1, )","html":"INSERT INTO measurement ("Size (meters)") VALUES (%s)\n(1, )
"},{"id":"text-566","type":"text","heading":"","plain_text":"Where above, the dictionary style is converted into a tuple with positional\nstyle.","html":"Where above, the dictionary style is converted into a tuple with positional\nstyle.
"},{"id":"text-567","type":"text","heading":"","plain_text":"Transactions\nThe psycopg2 dialect fully supports SAVEPOINT and two-phase commit operations.","html":"Transactions\nThe psycopg2 dialect fully supports SAVEPOINT and two-phase commit operations.
"},{"id":"text-568","type":"text","heading":"","plain_text":"Psycopg2 Transaction Isolation Level\nAs discussed in Transaction Isolation Level,\nall PostgreSQL dialects support setting of transaction isolation level\nboth via the isolation_level parameter passed to create_engine(),\nas well as the isolation_level argument used by\nConnection.execution_options(). When using the psycopg2 dialect, these\noptions make use of psycopg2’s set_isolation_level() connection method,\nrather than emitting a PostgreSQL directive; this is because psycopg2’s\nAPI-level setting is always emitted at the start of each transaction in any\nCas.\nThe psycopg2 dialect supports these constants for isolation level:","html":"Psycopg2 Transaction Isolation Level\nAs discussed in Transaction Isolation Level,\nall PostgreSQL dialects support setting of transaction isolation level\nboth via the isolation_level parameter passed to create_engine(),\nas well as the isolation_level argument used by\nConnection.execution_options(). When using the psycopg2 dialect, these\noptions make use of psycopg2’s set_isolation_level() connection method,\nrather than emitting a PostgreSQL directive; this is because psycopg2’s\nAPI-level setting is always emitted at the start of each transaction in any\nCas.\nThe psycopg2 dialect supports these constants for isolation level:
"},{"id":"text-569","type":"text","heading":"","plain_text":"READ COMMITTED","html":"READ COMMITTED
"},{"id":"text-570","type":"text","heading":"","plain_text":"READ UNCOMMITTED","html":"READ UNCOMMITTED
"},{"id":"text-571","type":"text","heading":"","plain_text":"REPEATABLE READ","html":"REPEATABLE READ
"},{"id":"text-572","type":"text","heading":"","plain_text":"SERIALIZABLE","html":"SERIALIZABLE
"},{"id":"text-573","type":"text","heading":"","plain_text":"AUTOCOMMIT","html":"AUTOCOMMIT
"},{"id":"text-574","type":"text","heading":"","plain_text":"NOTICE logging\nThe psycopg2 dialect will log PostgreSQL NOTICE messages\nvia the sqlalchemy.dialects.postgresql logger. When this logger\nis set to the logging.INFO level, notice messages will be logged:","html":"NOTICE logging\nThe psycopg2 dialect will log PostgreSQL NOTICE messages\nvia the sqlalchemy.dialects.postgresql logger. When this logger\nis set to the logging.INFO level, notice messages will be logged:
"},{"id":"text-575","type":"text","heading":"","plain_text":"importation logging","html":"importation logging
"},{"id":"text-576","type":"text","heading":"","plain_text":"logging.getLogger('sqlalchemy.dialects.postgresql').setLevel(logging.INFO)","html":"logging.getLogger('sqlalchemy.dialects.postgresql').setLevel(logging.INFO)
"},{"id":"text-577","type":"text","heading":"","plain_text":"Above, it is assumed that logging is configured externally. If this is not\nthe case, configuration such as logging.basicConfig() must be utilized:","html":"Above, it is assumed that logging is configured externally. If this is not\nthe case, configuration such as logging.basicConfig() must be utilized:
"},{"id":"text-578","type":"text","heading":"","plain_text":"importation logging","html":"importation logging
"},{"id":"text-579","type":"text","heading":"","plain_text":"logging.basicConfig() # log messages to stdout\nlogging.getLogger('sqlalchemy.dialects.postgresql').setLevel(logging.INFO)","html":"logging.basicConfig() # log messages to stdout\nlogging.getLogger('sqlalchemy.dialects.postgresql').setLevel(logging.INFO)
"},{"id":"text-580","type":"text","heading":"","plain_text":"HSTORE type\nle psycopg2 DBAPI includes an extension to natively handle marshalling of\nthe HSTORE type. The SQLAlchemy psycopg2 dialect will enable this extension\nby default when psycopg2 version 2.4 or greater is used, and\nit is detected that the target database has the HSTORE type set up for use.\nIn other words, when the dialect makes the first\nconnection, a sequence like the following is performed:","html":"HSTORE type\nle psycopg2 DBAPI includes an extension to natively handle marshalling of\nthe HSTORE type. The SQLAlchemy psycopg2 dialect will enable this extension\nby default when psycopg2 version 2.4 or greater is used, and\nit is detected that the target database has the HSTORE type set up for use.\nIn other words, when the dialect makes the first\nconnection, a sequence like the following is performed:
"},{"id":"text-581","type":"text","heading":"","plain_text":"Request the available HSTORE oids using\npsycopg2.extras.HstoreAdapter.get_oids().\nIf this function returns a list of HSTORE identifiers, we then determine\nque le HSTORE extension is present.\nThis function is skipped if the version of psycopg2 installed is\nless than version 2.4.","html":"Request the available HSTORE oids using\npsycopg2.extras.HstoreAdapter.get_oids().\nIf this function returns a list of HSTORE identifiers, we then determine\nque le HSTORE extension is present.\nThis function is skipped if the version of psycopg2 installed is\nless than version 2.4.
"},{"id":"text-582","type":"text","heading":"","plain_text":"If the use_native_hstore flag is at its default of True, et\nwe’ve detected that HSTORE oids are available, the\npsycopg2.extensions.register_hstore() extension is invoked for all\nles liaisons.","html":"If the use_native_hstore flag is at its default of True, et\nwe’ve detected that HSTORE oids are available, the\npsycopg2.extensions.register_hstore() extension is invoked for all\nles liaisons.
"},{"id":"text-583","type":"text","heading":"","plain_text":"le register_hstore() extension has the effect of all Python\ndictionaries being accepted as parameters regardless of the type of target\ncolumn in SQL. The dictionaries are converted by this extension into a\ntextual HSTORE expression. If this behavior is not desired, disable the\nuse of the hstore extension by setting use_native_hstore à Faux comme\nfollows:","html":"le register_hstore() extension has the effect of all Python\ndictionaries being accepted as parameters regardless of the type of target\ncolumn in SQL. The dictionaries are converted by this extension into a\ntextual HSTORE expression. If this behavior is not desired, disable the\nuse of the hstore extension by setting use_native_hstore à Faux comme\nfollows:
"},{"id":"text-584","type":"text","heading":"","plain_text":"engine = create_engine("postgresql+psycopg2://scott:tiger@localhost/test",\n use_native_hstore=Faux)","html":"engine = create_engine("postgresql+psycopg2://scott:tiger@localhost/test",\n use_native_hstore=Faux)
"},{"id":"text-585","type":"text","heading":"","plain_text":"le HSTORE type is still supported when the\npsycopg2.extensions.register_hstore() extension is not used. It merely\nmeans that the coercion between Python dictionaries and the HSTORE\nstring format, on both the parameter side and the result side, will take\nplace within SQLAlchemy’s own marshalling logic, and not that of psycopg2\nwhich may be more performant.","html":"le HSTORE type is still supported when the\npsycopg2.extensions.register_hstore() extension is not used. It merely\nmeans that the coercion between Python dictionaries and the HSTORE\nstring format, on both the parameter side and the result side, will take\nplace within SQLAlchemy’s own marshalling logic, and not that of psycopg2\nwhich may be more performant.
"},{"id":"text-586","type":"text","heading":"","plain_text":"pg8000\nSupport for the PostgreSQL database via the pg8000 driver.","html":"pg8000\nSupport for the PostgreSQL database via the pg8000 driver.
"},{"id":"text-587","type":"text","heading":"","plain_text":"DBAPI\nDocumentation and download information (if applicable) for pg8000 is available at:\nhttps://pythonhosted.org/pg8000/","html":"DBAPI\nDocumentation and download information (if applicable) for pg8000 is available at:\nhttps://pythonhosted.org/pg8000/
"},{"id":"text-588","type":"text","heading":"","plain_text":"Connecting\nConnect String:","html":"Connecting\nConnect String:
"},{"id":"text-589","type":"text","heading":"","plain_text":"postgresql+pg8000://user:password@host:port/dbname[?key=value&key=value...]","html":"postgresql+pg8000://user:password@host:port/dbname[?key=value&key=value...]
"},{"id":"text-590","type":"text","heading":"","plain_text":"Remarque\nThe pg8000 dialect is not tested as part of SQLAlchemy’s continuous\nintegration and may have unresolved issues. The recommended PostgreSQL\ndialect is psycopg2.","html":"Remarque\nThe pg8000 dialect is not tested as part of SQLAlchemy’s continuous\nintegration and may have unresolved issues. The recommended PostgreSQL\ndialect is psycopg2.
"},{"id":"text-591","type":"text","heading":"","plain_text":"Unicode\npg8000 will encode / decode string values between it and the server using the\nPostgreSQL client_encoding parameter; by default this is the value in\nle postgresql.conf file, which often defaults to SQL_ASCII.\nTypically, this can be changed to utf-8, as a more useful default:","html":"Unicode\npg8000 will encode / decode string values between it and the server using the\nPostgreSQL client_encoding parameter; by default this is the value in\nle postgresql.conf file, which often defaults to SQL_ASCII.\nTypically, this can be changed to utf-8, as a more useful default:
"},{"id":"text-592","type":"text","heading":"","plain_text":"#client_encoding = sql_ascii # actually, defaults to database\n # encoding\nclient_encoding = utf8","html":"#client_encoding = sql_ascii # actually, defaults to database\n # encoding\nclient_encoding = utf8
"},{"id":"text-593","type":"text","heading":"","plain_text":"le client_encoding can be overridden for a session by executing the SQL:\nSET CLIENT_ENCODING TO ‘utf8’;\nSQLAlchemy will execute this SQL on all new connections based on the value\npassed to create_engine() using the client_encoding parameter:","html":"le client_encoding can be overridden for a session by executing the SQL:\nSET CLIENT_ENCODING TO ‘utf8’;\nSQLAlchemy will execute this SQL on all new connections based on the value\npassed to create_engine() using the client_encoding parameter:
"},{"id":"text-594","type":"text","heading":"","plain_text":"engine = create_engine(\n "postgresql+pg8000://user:pass@host/dbname", client_encoding='utf8')","html":"engine = create_engine(\n "postgresql+pg8000://user:pass@host/dbname", client_encoding='utf8')
"},{"id":"text-595","type":"text","heading":"","plain_text":"pg8000 Transaction Isolation Level\nThe pg8000 dialect offers the same isolation level settings as that\nof the psycopg2 dialect:","html":"pg8000 Transaction Isolation Level\nThe pg8000 dialect offers the same isolation level settings as that\nof the psycopg2 dialect:
"},{"id":"text-596","type":"text","heading":"","plain_text":"READ COMMITTED","html":"READ COMMITTED
"},{"id":"text-597","type":"text","heading":"","plain_text":"READ UNCOMMITTED","html":"READ UNCOMMITTED
"},{"id":"text-598","type":"text","heading":"","plain_text":"REPEATABLE READ","html":"REPEATABLE READ
"},{"id":"text-599","type":"text","heading":"","plain_text":"SERIALIZABLE","html":"SERIALIZABLE
"},{"id":"text-600","type":"text","heading":"","plain_text":"AUTOCOMMIT","html":"AUTOCOMMIT
"},{"id":"text-601","type":"text","heading":"","plain_text":"New in version 0.9.5: support for AUTOCOMMIT isolation level when using\npg8000.","html":"New in version 0.9.5: support for AUTOCOMMIT isolation level when using\npg8000.
"},{"id":"text-602","type":"text","heading":"","plain_text":"psycopg2cffi\nSupport for the PostgreSQL database via the psycopg2cffi driver.","html":"psycopg2cffi\nSupport for the PostgreSQL database via the psycopg2cffi driver.
"},{"id":"text-603","type":"text","heading":"","plain_text":"DBAPI\nDocumentation and download information (if applicable) for psycopg2cffi is available at:\nhttp://pypi.python.org/pypi/psycopg2cffi/","html":"DBAPI\nDocumentation and download information (if applicable) for psycopg2cffi is available at:\nhttp://pypi.python.org/pypi/psycopg2cffi/
"},{"id":"text-604","type":"text","heading":"","plain_text":"Connecting\nConnect String:","html":"Connecting\nConnect String:
"},{"id":"text-605","type":"text","heading":"","plain_text":"postgresql+psycopg2cffi://user:password@host:port/dbname[?key=value&key=value...]","html":"postgresql+psycopg2cffi://user:password@host:port/dbname[?key=value&key=value...]
"},{"id":"text-606","type":"text","heading":"","plain_text":"psycopg2cffi is an adaptation of psycopg2, using CFFI for the C\ncouche. This makes it suitable for use in e.g. PyPy. Documentation\nis as per psycopg2.","html":"psycopg2cffi is an adaptation of psycopg2, using CFFI for the C\ncouche. This makes it suitable for use in e.g. PyPy. Documentation\nis as per psycopg2.
"},{"id":"text-607","type":"text","heading":"","plain_text":"py-postgresql\nSupport for the PostgreSQL database via the py-postgresql driver.","html":"py-postgresql\nSupport for the PostgreSQL database via the py-postgresql driver.
"},{"id":"text-608","type":"text","heading":"","plain_text":"DBAPI\nDocumentation and download information (if applicable) for py-postgresql is available at:\nhttp://python.projects.pgfoundry.org/","html":"DBAPI\nDocumentation and download information (if applicable) for py-postgresql is available at:\nhttp://python.projects.pgfoundry.org/
"},{"id":"text-609","type":"text","heading":"","plain_text":"Connecting\nConnect String:","html":"Connecting\nConnect String:
"},{"id":"text-610","type":"text","heading":"","plain_text":"postgresql+pypostgresql://user:password@host:port/dbname[?key=value&key=value...]","html":"postgresql+pypostgresql://user:password@host:port/dbname[?key=value&key=value...]
"},{"id":"text-611","type":"text","heading":"","plain_text":"Remarque\nThe pypostgresql dialect is not tested as part of SQLAlchemy’s continuous\nintegration and may have unresolved issues. The recommended PostgreSQL\ndriver is psycopg2.","html":"Remarque\nThe pypostgresql dialect is not tested as part of SQLAlchemy’s continuous\nintegration and may have unresolved issues. The recommended PostgreSQL\ndriver is psycopg2.
"},{"id":"text-612","type":"text","heading":"","plain_text":"pygresql\nSupport for the PostgreSQL database via the pygresql driver.","html":"pygresql\nSupport for the PostgreSQL database via the pygresql driver.
"},{"id":"text-613","type":"text","heading":"","plain_text":"DBAPI\nDocumentation and download information (if applicable) for pygresql is available at:\nhttp://www.pygresql.org/","html":"DBAPI\nDocumentation and download information (if applicable) for pygresql is available at:\nhttp://www.pygresql.org/
"},{"id":"text-614","type":"text","heading":"","plain_text":"Connecting\nConnect String:","html":"Connecting\nConnect String:
"},{"id":"text-615","type":"text","heading":"","plain_text":"postgresql+pygresql://user:password@host:port/dbname[?key=value&key=value...]","html":"postgresql+pygresql://user:password@host:port/dbname[?key=value&key=value...]
"},{"id":"text-616","type":"text","heading":"","plain_text":"Remarque\nThe pygresql dialect is not tested as part of SQLAlchemy’s continuous\nintegration and may have unresolved issues. The recommended PostgreSQL\ndialect is psycopg2.","html":"Remarque\nThe pygresql dialect is not tested as part of SQLAlchemy’s continuous\nintegration and may have unresolved issues. The recommended PostgreSQL\ndialect is psycopg2.
"},{"id":"text-617","type":"text","heading":"","plain_text":"zxjdbc\nSupport for the PostgreSQL database via the zxJDBC for Jython driver.","html":"zxjdbc\nSupport for the PostgreSQL database via the zxJDBC for Jython driver.
"},{"id":"text-618","type":"text","heading":"","plain_text":"DBAPI\nDrivers for this database are available at:\nhttp://jdbc.postgresql.org/","html":"DBAPI\nDrivers for this database are available at:\nhttp://jdbc.postgresql.org/
"},{"id":"text-619","type":"text","heading":"","plain_text":"Connecting\nConnect String:","html":"Connecting\nConnect String:
"},{"id":"text-620","type":"text","heading":"","plain_text":"postgresql+zxjdbc://scott:tiger@localhost/db","html":"postgresql+zxjdbc://scott:tiger@localhost/db
"},{"id":"text-621","type":"text","heading":"","plain_text":"Click to rate this post!\n \n [Total: 0 Average: 0]","html":"Click to rate this post!\n \n [Total: 0 Average: 0]
"}],"sections":[{"id":"text-1","heading":"Text","content":"Prise en charge de la base de données PostgreSQL.\nPrise en charge DBAPI\nLes options dialect / DBAPI suivantes sont disponibles. Veuillez vous reporter aux sections individuelles de DBAPI pour obtenir des informations sur la connexion."},{"id":"text-2","heading":"Text","content":"Séquences / SERIAL / IDENTITY\nPostgreSQL supporte les séquences et SQLAlchemy les utilise par défaut\nde créer de nouvelles valeurs de clé primaire pour les colonnes de clé primaire basées sur des nombres entiers. Quand\ncréer des tables, SQLAlchemy va publier le EN SÉRIE type de données pour\ncolonnes de clé primaire basées sur des nombres entiers, qui génèrent une séquence et un côté serveur\ndéfaut correspondant à la colonne.\nPour spécifier une séquence nommée spécifique à utiliser pour la génération de clé primaire,\nUtilisez le Séquence() construction:"},{"id":"text-3","heading":"Text","content":"Table('quelque chose', métadonnées,\n Colonne('id', Entier, Séquence('some_id_seq'), clé primaire=Vrai)\n )"},{"id":"text-4","heading":"Text","content":"Lorsque SQLAlchemy émet une seule instruction INSERT, pour remplir le contrat de\nayant le "dernier identifiant d'insertion" disponible, une clause RETURNING est ajoutée à\nl'instruction INSERT qui spécifie les colonnes de clé primaire doit être\nretourné une fois la déclaration terminée. La fonctionnalité RETURNING ne prend que\nplace si PostgreSQL 8.2 ou version ultérieure est utilisé. Dans une approche de repli, le\nséquence, spécifiée explicitement ou implicitement via EN SÉRIE, est\npréalablement exécutée indépendamment, la valeur renvoyée à utiliser dans la\ninsertion ultérieure. Notez que lorsqu'un\ninsérer() la construction est exécutée en utilisant\nSémantique «executemany», la fonctionnalité «dernier identifiant inséré» ne\nappliquer; aucune clause RETURNING n’est émise et la séquence n’a pas été pré-exécutée dans cette\nCas.\nPour forcer l'utilisation de RETURNING par défaut, spécifiez l'indicateur.\nimplicit_returning = False à create_engine ()."},{"id":"text-5","heading":"Text","content":"Colonnes PostgreSQL 10 IDENTITY\nPostgreSQL 10 a une nouvelle fonctionnalité IDENTITY qui remplace l’utilisation de SERIAL.\nLe support intégré pour le rendu de IDENTITY n’est pas encore disponible, mais le\nle crochet de compilation suivant peut être utilisé pour remplacer les occurrences de SERIAL par\nIDENTITÉ:"},{"id":"text-6","heading":"Text","content":"de sqlalchemy.schema importation CreateColumn\nde sqlalchemy.ext.compiler importation compile"},{"id":"text-7","heading":"Text","content":"@compiles(CreateColumn, 'postgresql')\ndef use_identity(élément, compilateur, **kw):\n texte = compilateur.visit_create_column(élément, **kw)\n texte = texte.remplacer("EN SÉRIE", "INT GÉNÉRÉ PAR DÉFAUT COMME IDENTITÉ")\n revenir texte"},{"id":"text-8","heading":"Text","content":"En utilisant ce qui précède, un tableau tel que:"},{"id":"text-9","heading":"Text","content":"t = Table(\n 't', m,\n Colonne('id', Entier, clé primaire=Vrai),\n Colonne('Les données', Chaîne)\n)"},{"id":"text-10","heading":"Text","content":"Générera sur la base de données de sauvegarde en tant que:"},{"id":"text-11","heading":"Text","content":"CRÉER TABLE t (\n identifiant INT GÉNÉRÉ PAR DÉFAUT COMME IDENTITÉ NE PAS NUL,\n Les données VARCHAR,\n PRIMAIRE CLÉ (identifiant)\n)"},{"id":"text-12","heading":"Text","content":"Niveau d'isolation de la transaction\nTous les dialectes PostgreSQL supportent la définition du niveau d'isolation des transactions\nà la fois via un paramètre spécifique au dialecte\ncreate_engine.isolation_level accepté par create_engine (),\naussi bien que Connection.execution_options.isolation_level\nargument passé à Connection.execution_options ().\nLors de l’utilisation d’un dialecte autre que psycopg2, cette fonction fonctionne en lançant la commande\nENSEMBLE SESSION LES CARACTÉRISTIQUES COMME TRANSACTION ISOLEMENT NIVEAU pour\nchaque nouvelle connexion. Pour le niveau d'isolement AUTOCOMMIT spécial,\nDes techniques spécifiques à DBAPI sont utilisées.\nPour définir le niveau d'isolement à l'aide de create_engine ():"},{"id":"text-13","heading":"Text","content":"moteur = create_engine(\n "postgresql + pg8000: // scott: tiger @ localhost / test",\n niveau_isolement="READ UNCOMMITTED"\n)"},{"id":"text-14","heading":"Text","content":"Pour définir à l'aide des options d'exécution par connexion:"},{"id":"text-15","heading":"Text","content":"lien = moteur.relier()\nlien = lien.execution_options(\n niveau_isolement="LIRE ENGAGÉ"\n)"},{"id":"text-16","heading":"Text","content":"Valeurs valides pour niveau_isolement comprendre:"},{"id":"text-17","heading":"Text","content":"Introspection de la table de schémas distants et chemin de recherche PostgreSQL\nTL; DR;: garder le chemin_recherche variable définie à sa valeur par défaut de Publique,\nnommer des schémas autre que Publique explicitement dans Table définitions.\nLe dialecte PostgreSQL peut refléter les tables de n’importe quel schéma. le\nTable.schema argument, ou bien la\nMetaData.reflect.schema l'argument détermine quel schéma sera\nêtre recherché pour la ou les tables. Le reflété Table objets\nconservera dans tous les cas cette .schéma attribut comme spécifié.\nCependant, en ce qui concerne les tableaux que ces Table les objets font référence à\nvia une contrainte de clé étrangère, une décision doit être prise quant à la .schéma\nest représenté dans ces tables distantes, dans le cas où cette distance\nnom de schéma est également un membre du courant\nChemin de recherche PostgreSQL.\nPar défaut, le dialecte PostgreSQL reproduit le comportement encouragé par\nPostgreSQL propre pg_get_constraintdef () procédure intégrée. Cette fonction\nrenvoie un exemple de définition pour une contrainte de clé étrangère particulière,\nomettant le nom de schéma référencé de cette définition lorsque le nom est\négalement dans le chemin de recherche du schéma PostgreSQL. L'interaction ci-dessous\nillustre ce comportement:"},{"id":"text-18","heading":"Text","content":"tester=> CRÉER TABLE test_schema.référé(identifiant ENTIER PRIMAIRE CLÉ)\nCRÉER TABLE\ntester=> CRÉER TABLE référant(\ntester(> identifiant ENTIER PRIMAIRE CLÉ,\ntester(> id_référé ENTIER RÉFÉRENCES test_schema.référé(identifiant));\nCRÉER TABLE\ntester=> ENSEMBLE chemin_recherche À Publique, test_schema;\ntester=> SÉLECTIONNER pg_catalog.pg_get_constraintdef(r.oid, vrai) DE\ntester-> pg_catalog.pg_class c JOINDRE pg_catalog.pg_namespace n\ntester-> SUR n.oid = c.espace de noms\ntester-> JOINDRE pg_catalog.pg_constraint r SUR c.oid = r.conrelide\ntester-> OÙ c.nom de famille='référant' ET r.contype = 'F'\ntester-> ;\n pg_get_constraintdef\n-------------------------------------------------- -\n ÉTRANGER CLÉ (id_référé) RÉFÉRENCES référé(identifiant)\n(1 rangée)"},{"id":"text-19","heading":"Text","content":"Ci-dessus, nous avons créé une table référé en tant que membre du schéma distant\ntest_schemaCependant, lorsque nous avons ajouté test_schema à la\nPG chemin_recherche et ensuite demandé pg_get_constraintdef () pour le\nÉTRANGER CLÉ syntaxe, test_schema n'a pas été inclus dans la sortie de\nla fonction.\nD'autre part, si nous redéfinissons le chemin de recherche sur la valeur par défaut typique\nde Publique:"},{"id":"text-20","heading":"Text","content":"tester=> ENSEMBLE chemin_recherche À Publique;\nENSEMBLE"},{"id":"text-21","heading":"Text","content":"La même requête contre pg_get_constraintdef () retourne maintenant complètement\nnom qualifié du schéma pour nous:"},{"id":"text-22","heading":"Text","content":"tester=> SÉLECTIONNER pg_catalog.pg_get_constraintdef(r.oid, vrai) DE\ntester-> pg_catalog.pg_class c JOINDRE pg_catalog.pg_namespace n\ntester-> SUR n.oid = c.espace de noms\ntester-> JOINDRE pg_catalog.pg_constraint r SUR c.oid = r.conrelide\ntester-> OÙ c.nom de famille='référant' ET r.contype = 'F';\n pg_get_constraintdef\n-------------------------------------------------- -------------\n ÉTRANGER CLÉ (id_référé) RÉFÉRENCES test_schema.référé(identifiant)\n(1 rangée)"},{"id":"text-23","heading":"Text","content":"SQLAlchemy utilisera par défaut la valeur de retour de pg_get_constraintdef ()\nafin de déterminer le nom du schéma distant. C’est-à-dire si notre chemin_recherche\nont été mis à inclure test_schemaet nous avons invoqué une table\nprocessus de réflexion comme suit:"},{"id":"text-24","heading":"Text","content":">>> de sqlalchemy importation Table, MetaData, create_engine\n>>> moteur = create_engine("postgresql: // scott: tiger @ localhost / test")\n>>> avec moteur.relier() comme Connecticut:\n... Connecticut.exécuter("SET search_path TO test_schema, public")\n... méta = MetaData()\n... référant = Table('référant', méta,\n... chargement automatique=Vrai, autoload_with=Connecticut)\n..."},{"id":"text-25","heading":"Text","content":"Le processus ci-dessus fournirait à la MetaData.tables collection\nréféré table nommée sans pour autant le schéma:"},{"id":"text-26","heading":"Text","content":">>> méta.les tables[[[['référé'].schéma est Aucun\nVrai"},{"id":"text-27","heading":"Text","content":"Pour modifier le comportement de la réflexion de sorte que le schéma référencé soit\nmaintenu indépendamment de la chemin_recherche réglage, utilisez le\npostgresql_ignore_search_path option, qui peut être spécifiée en tant que\nargument spécifique au dialecte à la fois Table aussi bien que\nMetaData.reflect ():"},{"id":"text-28","heading":"Text","content":">>> avec moteur.relier() comme Connecticut:\n... Connecticut.exécuter("SET search_path TO test_schema, public")\n... méta = MetaData()\n... référant = Table('référant', méta, chargement automatique=Vrai,\n... autoload_with=Connecticut,\n... postgresql_ignore_search_path=Vrai)\n..."},{"id":"text-29","heading":"Text","content":"Nous allons maintenant avoir test_schema.referred stocké comme qualifié de schéma:"},{"id":"text-30","heading":"Text","content":">>> méta.les tables[[[['test_schema.referred'].schéma\n'test_schema'"},{"id":"text-31","heading":"Text","content":"Notez que dans tous les cas, le schéma «par défaut» est toujours reflété comme\nAucun. Le schéma «par défaut» sur PostgreSQL est celui qui est renvoyé par le\nPostgreSQL current_schema () une fonction. Sur un PostgreSQL typique\nl'installation, c'est le nom Publique. Donc, un tableau qui fait référence à un autre\nqui est dans le Publique (c'est-à-dire par défaut) le schéma aura toujours le\n.schéma attribut mis à Aucun."},{"id":"text-32","heading":"Text","content":"Nouveau dans la version 0.9.2: Ajouté le postgresql_ignore_search_path\noption dialecte acceptée par Table et\nMetaData.reflect ()."},{"id":"text-33","heading":"Text","content":"INSERT / UPDATE… RETOURNER\nLe dialecte supporte les PG 8.2 INSERT..RECLINANT, MISE À JOUR..RECLINANT et\nSUPPRIMER .. RETOURNER syntaxes. INSERT..RECLINANT est utilisé par défaut\npour les instructions INSERT à une seule ligne afin d'extraire les données nouvellement générées\nidentificateurs de clé primaire. Pour spécifier un explicite RETOUR clause,\nUtilisez le _UpdateBase.returning () méthode par déclaration:"},{"id":"text-34","heading":"Text","content":"# INSERT..RETURNING\nrésultat = table.insérer().rentrant(table.c.col1, table.c.col2).\n valeurs(Nom='foo')\nimpression résultat.fetchall()"},{"id":"text-35","heading":"Text","content":"# UPDATE..RETURNING\nrésultat = table.mise à jour().rentrant(table.c.col1, table.c.col2).\n où(table.c.Nom=='foo').valeurs(Nom='bar')\nimpression résultat.fetchall()"},{"id":"text-36","heading":"Text","content":"# DELETE..RETURNING\nrésultat = table.effacer().rentrant(table.c.col1, table.c.col2).\n où(table.c.Nom=='foo')\nimpression résultat.fetchall()"},{"id":"text-37","heading":"Text","content":"INSERT… SUR CONFLICT (Upsert)\nA partir de la version 9.5, PostgreSQL permet les «upserts» (mises à jour ou insert) de\nlignes dans une table via le SUR CONFLIT clause de la INSÉRER déclaration. UNE\nLa ligne candidate ne sera insérée que si cette ligne ne viole aucun code unique.\ncontraintes. Dans le cas d’une violation de contrainte unique, une action secondaire\npeut être soit “DO UPDATE”, indiquant que les données dans le fichier\nla ligne cible doit être mise à jour, ou “NE RIEN FAIRE”, ce qui indique de sauter silencieusement\ncette rangée.\nLes conflits sont déterminés à l'aide de contraintes et d'index uniques existants. Celles-ci\nles contraintes peuvent être identifiées en utilisant leur nom comme indiqué dans DDL,\nou ils peuvent être inféré en indiquant les colonnes et les conditions qui composent\nles index.\nSQLAlchemy fournit SUR CONFLIT support via le spécifique PostgreSQL\npostgresql.dml.insert () fonction, qui fournit\nles méthodes génératives on_conflict_do_update ()\net on_conflict_do_nothing ():"},{"id":"text-38","heading":"Text","content":"de sqlalchemy.dialects.postgresql importation insérer"},{"id":"text-39","heading":"Text","content":"insert_stmt = insérer(ma table).valeurs(\n identifiant='some_existing_id',\n Les données='valeur insérée')"},{"id":"text-40","heading":"Text","content":"do_nothing_stmt = insert_stmt.on_conflict_do_nothing(\n éléments_index=[[[['id']\n)"},{"id":"text-41","heading":"Text","content":"Connecticut.exécuter(do_nothing_stmt)"},{"id":"text-42","heading":"Text","content":"do_update_stmt = insert_stmt.on_conflict_do_update(\n contrainte='pk_my_table',\n ensemble_=dict(Les données='valeur mise à jour')\n)"},{"id":"text-43","heading":"Text","content":"Connecticut.exécuter(do_update_stmt)"},{"id":"text-44","heading":"Text","content":"Les deux méthodes fournissent la "cible" du conflit en utilisant soit la\ncontrainte nommée ou par inférence de colonne:"},{"id":"text-45","heading":"Text","content":"le Insert.on_conflict_do_update.index_elements argument\nspécifie une séquence contenant des noms de colonne de chaîne, Colonne\ndes objets, et / ou des éléments d’expression SQL, qui identifieraient un unique\nindice:"},{"id":"text-46","heading":"Text","content":"do_update_stmt = insert_stmt.on_conflict_do_update(\n éléments_index=[[[['id'],\n ensemble_=dict(Les données='valeur mise à jour')\n)"},{"id":"text-47","heading":"Text","content":"do_update_stmt = insert_stmt.on_conflict_do_update(\n éléments_index=[[[[ma table.c.identifiant],\n ensemble_=dict(Les données='valeur mise à jour')\n)"},{"id":"text-48","heading":"Text","content":"Lors de l'utilisation Insert.on_conflict_do_update.index_elements à\ndéduire un index, un index partiel peut être déduit en spécifiant également le\nUtilisez le Insert.on_conflict_do_update.index_where paramètre:"},{"id":"text-49","heading":"Text","content":"de sqlalchemy.dialects.postgresql importation insérer"},{"id":"text-50","heading":"Text","content":"stmt = insérer(ma table).valeurs(utilisateur_email='a@b.com', Les données='données insérées')\nstmt = stmt.on_conflict_do_update(\n éléments_index=[[[[ma table.c.utilisateur_email],\n index_where=ma table.c.utilisateur_email.comme('%@gmail.com'),\n ensemble_=dict(Les données=stmt.exclu.Les données)\n )\nConnecticut.exécuter(stmt)"},{"id":"text-51","heading":"Text","content":"le Insert.on_conflict_do_update.constraint l'argument est\nutilisé pour spécifier directement un index plutôt que de l'inférer. Cela peut être\nle nom d'une contrainte UNIQUE, d'une contrainte PRIMARY KEY ou d'un INDEX:"},{"id":"text-52","heading":"Text","content":"do_update_stmt = insert_stmt.on_conflict_do_update(\n contrainte='ma_table_idx_1',\n ensemble_=dict(Les données='valeur mise à jour')\n)"},{"id":"text-53","heading":"Text","content":"do_update_stmt = insert_stmt.on_conflict_do_update(\n contrainte='ma_table_pk',\n ensemble_=dict(Les données='valeur mise à jour')\n)"},{"id":"text-54","heading":"Text","content":"le Insert.on_conflict_do_update.constraint argument peut\nse référer également à une construction SQLAlchemy représentant une contrainte,\npar exemple. Contrainte unique, PrimaryKeyConstraint,\nIndice, ou ExcludeConstraint. Dans cette utilisation,\nsi la contrainte a un nom, elle est utilisée directement. Sinon, si le\ncontrainte est non nommée, alors l’inférence sera utilisée, où les expressions\net la clause optionnelle WHERE de la contrainte sera précisée dans le\nconstruction. Cette utilisation est particulièrement pratique\nfaire référence à la clé primaire nommée ou non nommée d'un Table en utilisant le\nTable.primary_key attribut:"},{"id":"text-55","heading":"Text","content":"do_update_stmt = insert_stmt.on_conflict_do_update(\n contrainte=ma table.clé primaire,\n ensemble_=dict(Les données='valeur mise à jour')\n)"},{"id":"text-56","heading":"Text","content":"SUR CONFLIT ... FAIRE MISE À JOUR est utilisé pour effectuer une mise à jour du déjà\nligne existante, en utilisant n'importe quelle combinaison de nouvelles valeurs ainsi que de valeurs\nde l'insertion proposée. Ces valeurs sont spécifiées à l'aide du\nInsert.on_conflict_do_update.set_ paramètre. Cette\nparamètre accepte un dictionnaire composé de valeurs directes\npour UPDATE:"},{"id":"text-57","heading":"Text","content":"de sqlalchemy.dialects.postgresql importation insérer"},{"id":"text-58","heading":"Text","content":"stmt = insérer(ma table).valeurs(identifiant='some_id', Les données='valeur insérée')\ndo_update_stmt = stmt.on_conflict_do_update(\n éléments_index=[[[['id'],\n ensemble_=dict(Les données='valeur mise à jour')\n )\nConnecticut.exécuter(do_update_stmt)"},{"id":"text-59","heading":"Text","content":"Pour faire référence à la ligne d’insertion proposée, l’alias spécial\nexclu est disponible en tant qu'attribut sur\nle postgresql.dml.Insert objet; cet objet est un\nColumnCollection lequel alias contient toutes les colonnes de la cible\ntable:"},{"id":"text-60","heading":"Text","content":"de sqlalchemy.dialects.postgresql importation insérer"},{"id":"text-61","heading":"Text","content":"stmt = insérer(ma table).valeurs(\n identifiant='some_id',\n Les données='valeur insérée',\n auteur='jlh')\ndo_update_stmt = stmt.on_conflict_do_update(\n éléments_index=[[[['id'],\n ensemble_=dict(Les données='valeur mise à jour', auteur=stmt.exclu.auteur)\n )\nConnecticut.exécuter(do_update_stmt)"},{"id":"text-62","heading":"Text","content":"le Insert.on_conflict_do_update () méthode accepte également\nune clause WHERE utilisant le Insert.on_conflict_do_update.where\nparamètre, qui limitera les lignes qui reçoivent un UPDATE:"},{"id":"text-63","heading":"Text","content":"de sqlalchemy.dialects.postgresql importation insérer"},{"id":"text-64","heading":"Text","content":"stmt = insérer(ma table).valeurs(\n identifiant='some_id',\n Les données='valeur insérée',\n auteur='jlh')\non_update_stmt = stmt.on_conflict_do_update(\n éléments_index=[[[['id'],\n ensemble_=dict(Les données='valeur mise à jour', auteur=stmt.exclu.auteur)\n où=(ma table.c.statut == 2)\n )\nConnecticut.exécuter(on_update_stmt)"},{"id":"text-65","heading":"Text","content":"SUR CONFLIT peut également être utilisé pour ignorer l'insertion complète d'une ligne\nen cas de conflit avec une contrainte unique ou d'exclusion; au dessous de\nceci est illustré en utilisant le\non_conflict_do_nothing () méthode:"},{"id":"text-66","heading":"Text","content":"de sqlalchemy.dialects.postgresql importation insérer"},{"id":"text-67","heading":"Text","content":"stmt = insérer(ma table).valeurs(identifiant='some_id', Les données='valeur insérée')\nstmt = stmt.on_conflict_do_nothing(éléments_index=[[[['id'])\nConnecticut.exécuter(stmt)"},{"id":"text-68","heading":"Text","content":"Si FAIRE RIEN est utilisé sans spécifier de colonne ou de contrainte,\nil a pour effet de sauter l'INSERT pour toute exception unique ou d'exclusion\nviolation de contrainte qui se produit:"},{"id":"text-69","heading":"Text","content":"de sqlalchemy.dialects.postgresql importation insérer"},{"id":"text-70","heading":"Text","content":"stmt = insérer(ma table).valeurs(identifiant='some_id', Les données='valeur insérée')\nstmt = stmt.on_conflict_do_nothing()\nConnecticut.exécuter(stmt)"},{"id":"text-71","heading":"Text","content":"Nouveau dans la version 1.1: Ajout du support pour les clauses PostgreSQL ™ ON CONFLICT"},{"id":"text-72","heading":"Text","content":"Recherche en texte intégral\nSQLAlchemy met à disposition le PostgreSQL @@ opérateur via le\nColumnElement.match () méthode sur toute expression de colonne textuelle.\nSur un dialecte PostgreSQL, une expression comme celle-ci:"},{"id":"text-73","heading":"Text","content":"sélectionner([[[[quelque chose.c.texte.rencontre("chaîne de recherche")])"},{"id":"text-74","heading":"Text","content":"émettra dans la base de données:"},{"id":"text-75","heading":"Text","content":"SÉLECTIONNER texte @@ to_tsquery('chaîne de recherche') DE table"},{"id":"text-76","heading":"Text","content":"Les fonctions de recherche de texte PostgreSQL telles que to_tsquery ()\net to_tsvector () sont disponibles\nen utilisant explicitement la norme func construction. Par exemple:"},{"id":"text-77","heading":"Text","content":"sélectionner([[[[\n func.to_tsvector("les gros chats mangeaient des rats").rencontre('chat et rat')\n])"},{"id":"text-78","heading":"Text","content":"Emet l'équivalent de:"},{"id":"text-79","heading":"Text","content":"SÉLECTIONNER to_tsvector("les gros chats mangeaient des rats") @@ to_tsquery('chat et rat')"},{"id":"text-80","heading":"Text","content":"le postgresql.TSVECTOR type peut fournir des CAST explicites:"},{"id":"text-81","heading":"Text","content":"de sqlalchemy.dialects.postgresql importation TSVECTOR\nde sqlalchemy importation sélectionner, jeter\nsélectionner([[[[jeter("Du texte", TSVECTOR)])"},{"id":"text-82","heading":"Text","content":"produit une déclaration équivalente à:"},{"id":"text-83","heading":"Text","content":"SÉLECTIONNER JETER('Du texte' COMME TSVECTOR) COMME anon_1"},{"id":"text-84","heading":"Text","content":"Les recherches en texte intégral dans PostgreSQL sont influencées par la combinaison de:\nParamètre PostgreSQL de default_text_search_config, le regconfig utilisé\npour construire les index GIN / GiST, et le regconfig éventuellement passé\nlors d'une requête.\nLorsque vous effectuez une recherche en texte intégral sur une colonne comportant un code GIN ou\nIndex GiST déjà pré-calculé (qui est commun au texte intégral\nrecherches), il peut être nécessaire de passer explicitement à un serveur PostgreSQL spécifique.\nregconfig valeur pour assurer que le planificateur de requêtes utilise l'index et\nne pas recalculer la colonne à la demande.\nAfin de permettre cette planification explicite des requêtes, ou d’utiliser différentes\nstratégies de recherche, la rencontre méthode accepte un postgresql_regconfig\nargument de mot clé:"},{"id":"text-85","heading":"Text","content":"sélectionner([[[[ma table.c.identifiant]).où(\n ma table.c.Titre.rencontre('somestring', postgresql_regconfig='Anglais')\n)"},{"id":"text-86","heading":"Text","content":"Emet l'équivalent de:"},{"id":"text-87","heading":"Text","content":"SÉLECTIONNER ma table.identifiant DE ma table\nOÙ ma table.Titre @@ to_tsquery('Anglais', 'somestring')"},{"id":"text-88","heading":"Text","content":"On peut aussi spécifiquement passer dans un «Regconfig» valeur à la\nto_tsvector () commande comme argument initial:"},{"id":"text-89","heading":"Text","content":"sélectionner([[[[ma table.c.identifiant]).où(\n func.to_tsvector('Anglais', ma table.c.Titre )\n .rencontre('somestring', postgresql_regconfig='Anglais')\n )"},{"id":"text-90","heading":"Text","content":"produit une déclaration équivalente à:"},{"id":"text-91","heading":"Text","content":"SÉLECTIONNER ma table.identifiant DE ma table\nOÙ to_tsvector('Anglais', ma table.Titre) @@\n to_tsquery('Anglais', 'somestring')"},{"id":"text-92","heading":"Text","content":"Il est recommandé d’utiliser le EXPLIQUE ANALYSER... outil de\nPostgreSQL ™ pour vous assurer que vous générez des requêtes avec SQLAlchemy qui\nTirez pleinement parti des index que vous avez éventuellement créés pour la recherche en texte intégral."},{"id":"text-93","heading":"Text","content":"DE SEULEMENT…\nLe dialecte prend en charge le mot clé ONLY de PostgreSQL pour ne cibler que certains\ntable dans une hiérarchie d'héritage. Ceci peut être utilisé pour produire le\nSÉLECTIONNER ... DE SEULEMENT, MISE À JOUR SEULEMENT ..., et EFFACER DE SEULEMENT ...\nsyntaxes. Il utilise le mécanisme des astuces de SQLAlchemy:"},{"id":"text-94","heading":"Text","content":"# SELECTIONNER ... A PARTIR DE ...\nrésultat = table.sélectionner().avec_hint(table, 'SEULEMENT', 'postgresql')\nimpression résultat.fetchall()"},{"id":"text-95","heading":"Text","content":"# MISE À JOUR UNIQUEMENT ...\ntable.mise à jour(valeurs=dict(foo='bar')).avec_hint('SEULEMENT',\n nom du dialecte='postgresql')"},{"id":"text-96","heading":"Text","content":"# SUPPRIMER DE SEULEMENT ...\ntable.effacer().avec_hint('SEULEMENT', nom du dialecte='postgresql')"},{"id":"text-97","heading":"Text","content":"Options d'index spécifiques à PostgreSQL\nPlusieurs extensions à la Indice construct sont disponibles, spécifiques\nau dialecte PostgreSQL."},{"id":"text-98","heading":"Text","content":"Index partiels\nLes index partiels ajoutent un critère à la définition de l’index afin que celui-ci soit\nappliqué à un sous-ensemble de lignes. Ceux-ci peuvent être spécifiés sur Indice\nen utilisant le postgresql_where argument de mot clé:"},{"id":"text-99","heading":"Text","content":"Indice('mon_index', ma table.c.identifiant, postgresql_where=ma table.c.valeur > dix)"},{"id":"text-100","heading":"Text","content":"Classes d'opérateurs\nPostgreSQL permet la spécification d’un classe d'opérateur pour chaque colonne de\nun index (voir\nhttp://www.postgresql.org/docs/8.3/interactive/indexes-opclass.html).\nle Indice la construction permet de les spécifier via le\npostgresql_ops argument de mot clé:"},{"id":"text-101","heading":"Text","content":"Indice(\n 'mon_index', ma table.c.identifiant, ma table.c.Les données,\n postgresql_ops=\n 'Les données': 'text_pattern_ops',\n 'id': 'int4_ops'\n )"},{"id":"text-102","heading":"Text","content":"Notez que les clés dans le postgresql_ops dictionnaire sont le nom “clé” de\nle Colonnec'est-à-dire le nom utilisé pour y accéder depuis le .c\ncollection de Table, qui peut être configuré pour être différent de\nle nom réel de la colonne tel qu'il est exprimé dans la base de données.\nSi postgresql_ops doit être utilisé contre une expression SQL complexe telle que\nen tant qu'appel de fonction, pour l'appliquer à la colonne, il faut lui attribuer une étiquette\nqui est identifié dans le dictionnaire par son nom, par exemple:"},{"id":"text-103","heading":"Text","content":"Indice(\n 'mon_index', ma table.c.identifiant,\n func.inférieur(ma table.c.Les données).étiquette('data_lower'),\n postgresql_ops=\n 'data_lower': 'text_pattern_ops',\n 'id': 'int4_ops'\n )"},{"id":"text-104","heading":"Text","content":"Types d'index\nPostgreSQL fournit plusieurs types d’index: B-Tree, Hash, GiST et GIN, ainsi que\ncomme la possibilité pour les utilisateurs de créer leurs propres projets (voir\nhttp://www.postgresql.org/docs/8.3/static/indexes-types.html). Ceux-ci peuvent être\nspécifié sur Indice en utilisant le postgresql_using argument de mot clé:"},{"id":"text-105","heading":"Text","content":"Indice('mon_index', ma table.c.Les données, postgresql_using='Gin')"},{"id":"text-106","heading":"Text","content":"La valeur transmise à l’argument du mot clé sera simplement transmise au\ncommande CREATE INDEX sous-jacente, de sorte doit être un type d'index valide pour votre\nversion de PostgreSQL."},{"id":"text-107","heading":"Text","content":"Paramètres de stockage d'index\nPostgreSQL permet de définir des paramètres de stockage sur des index. Le stockage\nles paramètres disponibles dépendent de la méthode d'index utilisée par l'index. Espace de rangement\nles paramètres peuvent être spécifiés sur Indice en utilisant le postgresql_with\nargument de mot clé:"},{"id":"text-108","heading":"Text","content":"Indice('mon_index', ma table.c.Les données, postgresql_with="facteur de remplissage": 50)"},{"id":"text-109","heading":"Text","content":"PostgreSQL permet de définir le tablespace dans lequel créer l'index.\nLe tablespace peut être spécifié sur Indice en utilisant le\npostgresql_tablespace argument de mot clé:"},{"id":"text-110","heading":"Text","content":"Indice('mon_index', ma table.c.Les données, postgresql_tablespace='mon espace de tables')"},{"id":"text-111","heading":"Text","content":"Notez que la même option est disponible sur Table ainsi que."},{"id":"text-112","heading":"Text","content":"Index avec concurremment\nL’option d’index CONCORDREMENT de PostgreSQL est supportée en passant le\ndrapeau postgresql_concurrently à la Indice construction:"},{"id":"text-113","heading":"Text","content":"tbl = Table('testtbl', m, Colonne('Les données', Entier))"},{"id":"text-114","heading":"Text","content":"idx1 = Indice('test_idx1', tbl.c.Les données, postgresql_concurrently=Vrai)"},{"id":"text-115","heading":"Text","content":"La construction d’index ci-dessus rendra le DDL pour CREATE INDEX, en supposant que\nPostgreSQL 8.2 ou supérieur est détecté ou pour un dialecte sans connexion, comme:"},{"id":"text-116","heading":"Text","content":"CRÉER INDICE De manière concurrente test_idx1 SUR testtbl (Les données)"},{"id":"text-117","heading":"Text","content":"Pour DROP INDEX, en supposant que PostgreSQL 9.2 ou supérieur soit détecté ou pour\nun dialecte sans connexion, il émettra:"},{"id":"text-118","heading":"Text","content":"LAISSEZ TOMBER INDICE De manière concurrente test_idx1"},{"id":"text-119","heading":"Text","content":"Nouveau dans la version 1.1: support pour concurremment sur DROP INDEX. le\nLe mot clé est simultanément émis uniquement si une version suffisamment élevée\nde PostgreSQL est détecté sur la connexion (ou pour une connexion sans connexion)\ndialecte)."},{"id":"text-120","heading":"Text","content":"Lors de l'utilisation concurrente, la base de données PostgreSQL requiert que l'instruction\nêtre appelé en dehors d'un bloc de transaction. La base de données Python DBAPI\nmême pour une seule déclaration, une transaction est présente, donc pour utiliser cette\nle mode «autocommit» de DBAPI doit être utilisé:"},{"id":"text-121","heading":"Text","content":"métadonnées = MetaData()\ntable = Table(\n "foo", métadonnées,\n Colonne("id", Chaîne))\nindice = Indice(\n "foo_idx", table.c.identifiant, postgresql_concurrently=Vrai)"},{"id":"text-122","heading":"Text","content":"avec moteur.relier() comme Connecticut:\n avec Connecticut.execution_options(niveau_isolement='AUTOCOMMIT'):\n table.créer(Connecticut)"},{"id":"text-123","heading":"Text","content":"PostgreSQL Index Reflection\nLa base de données PostgreSQL crée implicitement un INDEX UNIQUE chaque fois que le\nLa construction UNIQUE CONSTRAINT est utilisée. Lors de l'inspection d'une table en utilisant\nInspecteur, le Inspector.get_indexes ()\net le Inspector.get_unique_constraints () fera rapport sur ces\ndeux constructions distinctement; dans le cas de l'index, la clé\nduplicates_constraint sera présent dans l'entrée d'index s'il est\ndétecté comme reflétant une contrainte. Lors de la réflexion en utilisant\nTable(..., autoload = True), l'INDICE UNIQUE est ne pas revenu\ndans Table.indexes quand il est détecté comme reflétant un\nContrainte unique dans le Table.constraints collection."},{"id":"text-124","heading":"Text","content":"Modifié dans la version 1.0.0: – Table la réflexion comprend maintenant\nContrainte unique objets présents dans le Table.constraints\ncollection; le backend de PostgreSQL n'inclura plus de “miroir”\nIndice construire dans Table.indexes si c'est détecté\ncomme correspondant à une contrainte unique."},{"id":"text-125","heading":"Text","content":"Options de réflexion spéciales\nle Inspecteur utilisé pour le backend PostgreSQL est une instance\nde PGInspector, qui offre des méthodes supplémentaires:"},{"id":"text-126","heading":"Text","content":"de sqlalchemy importation create_engine, inspecter"},{"id":"text-127","heading":"Text","content":"moteur = create_engine("postgresql + psycopg2: // localhost / test")\ninsp = inspecter(moteur) # sera un PGInspector"},{"id":"text-128","heading":"Text","content":"impression(insp.get_enums())"},{"id":"text-129","heading":"Text","content":"classe sqlalchemy.dialects.postgresql.base.PGInspector(Connecticut)"},{"id":"text-130","heading":"Text","content":"Bases: sqlalchemy.engine.reflection.Inspector"},{"id":"text-131","heading":"Text","content":"get_enums(schéma = Aucun)"},{"id":"text-132","heading":"Text","content":"Retourne une liste d'objets ENUM.\nChaque membre est un dictionnaire contenant ces champs:"},{"id":"text-133","heading":"Text","content":"name – nom de l'énum"},{"id":"text-134","heading":"Text","content":"schéma – le nom du schéma pour l'énumération."},{"id":"text-135","heading":"Text","content":"visible – booléen, que cette énumération soit visible ou non\ndans le chemin de recherche par défaut."},{"id":"text-136","heading":"Text","content":"étiquettes – une liste d'étiquettes de chaîne qui s'appliquent à l'énumération."},{"id":"text-137","heading":"Text","content":"Paramètres"},{"id":"text-138","heading":"Text","content":"schéma – nom du schéma. Si aucun, le schéma par défaut\n(généralement «public») est utilisé. Peut également être réglé sur '*' pour\nindiquez des énumérations de charge pour tous les schémas."},{"id":"text-139","heading":"Text","content":"get_foreign_table_names(schéma = Aucun)"},{"id":"text-140","heading":"Text","content":"Renvoie une liste de noms FOREIGN TABLE.\nLe comportement est similaire à celui de Inspector.get_table_names (),\nsauf que la liste est limitée aux tables qui signalent une\nrelâchement valeur de F."},{"id":"text-141","heading":"Text","content":"get_table_oid(nom de la table, schéma = Aucun)"},{"id":"text-142","heading":"Text","content":"Renvoie l'OID du nom de la table donnée."},{"id":"text-143","heading":"Text","content":"get_view_names(schéma = Aucun, include = ('plain', 'matérialisé'))"},{"id":"text-144","heading":"Text","content":"Renvoyer tous les noms de vue dans schéma."},{"id":"text-145","heading":"Text","content":"Paramètres"},{"id":"text-146","heading":"Text","content":"schéma – Facultatif, récupérez les noms d'un schéma autre que celui par défaut.\nPour les devis spéciaux, utilisez quoted_name."},{"id":"text-147","heading":"Text","content":"comprendre – \nspécifier les types de vues à renvoyer. Passé\nsous forme de valeur de chaîne (pour un type unique) ou de tuple (pour un nombre quelconque)\nde types). Par défaut à ('plaine', 'matérialisé')."},{"id":"text-148","heading":"Text","content":"Options de la table PostgreSQL\nPlusieurs options pour CREATE TABLE sont supportées directement par PostgreSQL\ndialecte en conjonction avec le Table construction:"},{"id":"text-149","heading":"Text","content":"Types de tableau\nLe dialecte PostgreSQL supporte les tableaux, à la fois en tant que types de colonne multidimensionnels\nainsi que des littéraux de tableau:"},{"id":"text-150","heading":"Text","content":"Types JSON\nLe dialecte PostgreSQL prend en charge les types de données JSON et JSONB, y compris\nLe support natif de psycopg2 et celui de tous les logiciels spéciaux de PostgreSQL\nles opérateurs:"},{"id":"text-151","heading":"Text","content":"Type HSTORE\nLe type HSTORE PostgreSQL ainsi que les littéraux hstore sont pris en charge:"},{"id":"text-152","heading":"Text","content":"Types ENUM\nPostgreSQL a une structure TYPE pouvant être créée indépendamment qui est utilisée\npour implémenter un type énuméré. Cette approche introduit des\nla complexité du côté SQLAlchemy en termes de quand ce type devrait être\nCréé et abandonné. Le type object est aussi un reflet indépendant\nentité. Les sections suivantes doivent être consultées:"},{"id":"text-153","heading":"Text","content":"Utiliser ENUM avec ARRAY\nLa combinaison de ENUM et ARRAY n’est pas directement prise en charge par le backend\nDBAPIs à ce moment. Pour envoyer et recevoir un ARRAY of ENUM,\nutilisez le type de solution de contournement suivant, qui décore le\npostgresql.ARRAY Type de données."},{"id":"text-154","heading":"Text","content":"de sqlalchemy importation TypeDécorateur\nde sqlalchemy.dialects.postgresql importation Tableau"},{"id":"text-155","heading":"Text","content":"classe ArrayOfEnum(TypeDécorateur):\n impl = Tableau"},{"id":"text-156","heading":"Text","content":"def bind_expression(soi, bindvalue):\n revenir sa.jeter(bindvalue, soi)"},{"id":"text-157","heading":"Text","content":"def result_processor(soi, dialecte, coltype):\n super_rp = super(ArrayOfEnum, soi).result_processor(\n dialecte, coltype)"},{"id":"text-158","heading":"Text","content":"def handle_raw_string(valeur):\n interne = ré.rencontre(r"^ (. *) $", valeur).groupe(1)\n revenir interne.Divisé(",") si interne autre []"},{"id":"text-159","heading":"Text","content":"def processus(valeur):\n si valeur est Aucun:\n revenir Aucun\n revenir super_rp(handle_raw_string(valeur))\n revenir processus"},{"id":"text-160","heading":"Text","content":"Par exemple.:"},{"id":"text-161","heading":"Text","content":"Table(\n 'mes données', métadonnées,\n Colonne('id', Entier, clé primaire=Vrai),\n Colonne('Les données', ArrayOfEnum(ENUM('une', 'b'c', nom ='myenum')))"},{"id":"text-162","heading":"Text","content":")"},{"id":"text-163","heading":"Text","content":"Ce type n'est pas inclus en tant que type intégré car il serait incompatible\navec une DBAPI qui décide soudainement de soutenir ARRAY of ENUM directement dans\nune nouvelle version."},{"id":"text-164","heading":"Text","content":"Utilisation de JSON / JSONB avec ARRAY\nSemblable à utiliser ENUM, pour un ARRAY of JSON / JSONB, nous devons rendre le\nCAST approprié, cependant les pilotes psycopg2 actuels semblent gérer le résultat\npour ARRAY of JSON automatiquement, le type est donc plus simple:"},{"id":"text-165","heading":"Text","content":"classe CastingArray(Tableau):\n def bind_expression(soi, bindvalue):\n revenir sa.jeter(bindvalue, soi)"},{"id":"text-166","heading":"Text","content":"Par exemple.:"},{"id":"text-167","heading":"Text","content":"Table(\n 'mes données', métadonnées,\n Colonne('id', Entier, clé primaire=Vrai),\n Colonne('Les données', CastingArray(JSONB))\n)"},{"id":"text-168","heading":"Text","content":"Types de données PostgreSQL\nComme avec tous les dialectes SQLAlchemy, tous les types UPPERCASE connus pour être\nvalables avec PostgreSQL sont importables à partir du dialecte de niveau supérieur, que ce soit\nils proviennent de sqlalchemy.types ou du dialecte local:"},{"id":"text-169","heading":"Text","content":"de sqlalchemy.dialects.postgresql importation \n Tableau, BIGINT, BIT, BOOLÉAN, BYTEA, CARBONISER, CIDR, DATE, \n DOUBLE PRECISION, ENUM, FLOTTE, HSTORE, INET, ENTIER, \n INTERVALLE, JSON, JSONB, MACADDR, ARGENT, NUMERIC, OID, REAL, SMALLINT, TEXT, \n TEMPS, TIMESTAMP, UUID, VARCHAR, INT4RANGE, INT8RANGE, NUMRANGE, \n DATERANGE, TSRANGE, TSTZRANGE, TSVECTOR"},{"id":"text-170","heading":"Text","content":"Types which are specific to PostgreSQL, or have PostgreSQL-specific\nconstruction arguments, are as follows:"},{"id":"text-171","heading":"Text","content":"class sqlalchemy.dialects.postgresql.aggregate_order_by(cible, *order_by)"},{"id":"text-172","heading":"Text","content":"Bases: sqlalchemy.sql.expression.ColumnElement\nRepresent a PostgreSQL aggregate order by expression.\nE.g.:"},{"id":"text-173","heading":"Text","content":"de sqlalchemy.dialects.postgresql importation aggregate_order_by\nexpr = func.array_agg(aggregate_order_by(table.c.une, table.c.b.desc()))\nstmt = sélectionner([[[[expr])"},{"id":"text-174","heading":"Text","content":"would represent the expression:"},{"id":"text-175","heading":"Text","content":"SELECT array_agg(une ORDER BY b DESC) FROM table;"},{"id":"text-176","heading":"Text","content":"Similarly:"},{"id":"text-177","heading":"Text","content":"expr = func.string_agg(\n table.c.une,\n aggregate_order_by(literal_column("','"), table.c.une)\n)\nstmt = sélectionner([[[[expr])"},{"id":"text-178","heading":"Text","content":"Would represent:"},{"id":"text-179","heading":"Text","content":"SELECT string_agg(une, ',' ORDER BY une) FROM table;"},{"id":"text-180","heading":"Text","content":"Changed in version 1.2.13: – the ORDER BY argument may be multiple terms"},{"id":"text-181","heading":"Text","content":"class sqlalchemy.dialects.postgresql.array(clauses, **kw)"},{"id":"text-182","heading":"Text","content":"Bases: sqlalchemy.sql.expression.Tuple\nA PostgreSQL ARRAY literal.\nThis is used to produce ARRAY literals in SQL expressions, e.g.:"},{"id":"text-183","heading":"Text","content":"de sqlalchemy.dialects.postgresql importation array\nde sqlalchemy.dialects importation postgresql\nde sqlalchemy importation sélectionner, func"},{"id":"text-184","heading":"Text","content":"stmt = sélectionner([[[[\n array([[[[1,2]) + array([[[[3,4,5])\n ])"},{"id":"text-185","heading":"Text","content":"impression(stmt.compile(dialect=postgresql.dialect()))"},{"id":"text-186","heading":"Text","content":"Produces the SQL:"},{"id":"text-187","heading":"Text","content":"SELECT ARRAY[[[[%(param_1)s, %(param_2)s] ||\n ARRAY[[[[%(param_3)s, %(param_4)s, %(param_5)s]) AS anon_1"},{"id":"text-188","heading":"Text","content":"An instance of array will always have the datatype\nARRAY. The “inner” type of the array is inferred from\nthe values present, unless the type_ keyword argument is passed:"},{"id":"text-189","heading":"Text","content":"array([[[['foo', 'bar'], type_=CHAR)"},{"id":"text-190","heading":"Text","content":"Multidimensional arrays are produced by nesting array constructs.\nThe dimensionality of the final ARRAY type is calculated by\nrecursively adding the dimensions of the inner ARRAY type:"},{"id":"text-191","heading":"Text","content":"stmt = sélectionner([[[[\n array([[[[\n array([[[[1, 2]), array([[[[3, 4]), array([[[[colonne('q'), colonne('x')])\n ])\n])\nimpression(stmt.compile(dialect=postgresql.dialect()))"},{"id":"text-192","heading":"Text","content":"Produces:"},{"id":"text-193","heading":"Text","content":"SELECT ARRAY[[[[ARRAY[[[[%(param_1)s, %(param_2)s],\nARRAY[[[[%(param_3)s, %(param_4)s], ARRAY[[[[q, x]] AS anon_1"},{"id":"text-194","heading":"Text","content":"New in version 1.3.6: added support for multidimensional array literals"},{"id":"text-195","heading":"Text","content":"class sqlalchemy.dialects.postgresql.ARRAY(item_type, as_tuple=False, dimensions=None, zero_indexes=False)"},{"id":"text-196","heading":"Text","content":"Bases: sqlalchemy.types.ARRAY\nPostgreSQL ARRAY type.\nle postgresql.ARRAY type is constructed in the same way\nas the core types.ARRAY type; a member type is required, and a\nnumber of dimensions is recommended if the type is to be used for more\nthan one dimension:"},{"id":"text-197","heading":"Text","content":"de sqlalchemy.dialects importation postgresql"},{"id":"text-198","heading":"Text","content":"mytable = Table("mytable", metadata,\n Column("data", postgresql.ARRAY(Integer, dimensions=2))\n )"},{"id":"text-199","heading":"Text","content":"le postgresql.ARRAY type provides all operations defined on the\ncore types.ARRAY type, including support for “dimensions”,\nindexed access, and simple matching such as\ntypes.ARRAY.Comparator.any() et\ntypes.ARRAY.Comparator.all(). postgresql.ARRAY class also\nprovides PostgreSQL-specific methods for containment operations, including\npostgresql.ARRAY.Comparator.contains()\npostgresql.ARRAY.Comparator.contained_by(), et\npostgresql.ARRAY.Comparator.overlap(), e.g.:"},{"id":"text-200","heading":"Text","content":"mytable.c.Les données.contient([[[[1, 2])"},{"id":"text-201","heading":"Text","content":"le postgresql.ARRAY type may not be supported on all\nPostgreSQL DBAPIs; it is currently known to work on psycopg2 only.\nDe plus, le postgresql.ARRAY type does not work directly in\nconjunction with the ENUM type. For a workaround, see the\nspecial type at Using ENUM with ARRAY."},{"id":"text-202","heading":"Text","content":"class Comparator(expr)"},{"id":"text-203","heading":"Text","content":"Bases: sqlalchemy.types.Comparator\nDefine comparison operations for ARRAY.\nNote that these operations are in addition to those provided\nby the base types.ARRAY.Comparator class, including\ntypes.ARRAY.Comparator.any() et\ntypes.ARRAY.Comparator.all()."},{"id":"text-204","heading":"Text","content":"contained_by(other)"},{"id":"text-205","heading":"Text","content":"Boolean expression. Test if elements are a proper subset of the\nelements of the argument array expression."},{"id":"text-206","heading":"Text","content":"contient(other, **kwargs)"},{"id":"text-207","heading":"Text","content":"Boolean expression. Test if elements are a superset of the\nelements of the argument array expression."},{"id":"text-208","heading":"Text","content":"overlap(other)"},{"id":"text-209","heading":"Text","content":"Boolean expression. Test if array has elements in common with\nan argument array expression."},{"id":"text-210","heading":"Text","content":"__init__(item_type, as_tuple=False, dimensions=None, zero_indexes=False)"},{"id":"text-211","heading":"Text","content":"Construct an ARRAY.\nE.g.:"},{"id":"text-212","heading":"Text","content":"Column('myarray', ARRAY(Integer))"},{"id":"text-213","heading":"Text","content":"Arguments are:"},{"id":"text-214","heading":"Text","content":"Paramètres"},{"id":"text-215","heading":"Text","content":"item_type – The data type of items of this array. Note that\ndimensionality is irrelevant here, so multi-dimensional arrays like\nINTEGER[][], are constructed as ARRAY(Integer), not as\nARRAY(ARRAY(Integer)) or such."},{"id":"text-216","heading":"Text","content":"as_tuple=False – Specify whether return results\nshould be converted to tuples from lists. DBAPIs such\nas psycopg2 return lists by default. When tuples are\nreturned, the results are hashable."},{"id":"text-217","heading":"Text","content":"dimensions – if non-None, the ARRAY will assume a fixed\nnumber of dimensions. This will cause the DDL emitted for this\nARRAY to include the exact number of bracket clauses [],\nand will also optimize the performance of the type overall.\nNote that PG arrays are always implicitly “non-dimensioned”,\nmeaning they can store any number of dimensions no matter how\nthey were declared."},{"id":"text-218","heading":"Text","content":"zero_indexes=False – \nwhen True, index values will be converted\nbetween Python zero-based and PostgreSQL one-based indexes, e.g.\na value of one will be added to all index values before passing\nto the database."},{"id":"text-219","heading":"Text","content":"sqlalchemy.dialects.postgresql.array_agg(*arg, **kw)"},{"id":"text-220","heading":"Text","content":"PostgreSQL-specific form of array_agg, ensures\nreturn type is postgresql.ARRAY and not\nthe plain types.ARRAY, unless an explicit type_\nis passed."},{"id":"text-221","heading":"Text","content":"sqlalchemy.dialects.postgresql.Any(other, arrexpr, operator=)"},{"id":"text-222","heading":"Text","content":"A synonym for the ARRAY.Comparator.any() method.\nThis method is legacy and is here for backwards-compatibility."},{"id":"text-223","heading":"Text","content":"sqlalchemy.dialects.postgresql.Tout(other, arrexpr, operator=)"},{"id":"text-224","heading":"Text","content":"A synonym for the ARRAY.Comparator.all() method.\nThis method is legacy and is here for backwards-compatibility."},{"id":"text-225","heading":"Text","content":"class sqlalchemy.dialects.postgresql.BIT(length=None, varying=False)"},{"id":"text-226","heading":"Text","content":"Bases: sqlalchemy.types.TypeEngine"},{"id":"text-227","heading":"Text","content":"class sqlalchemy.dialects.postgresql.BYTEA(length=None)"},{"id":"text-228","heading":"Text","content":"Bases: sqlalchemy.types.LargeBinary"},{"id":"text-229","heading":"Text","content":"__init__(length=None)"},{"id":"text-230","heading":"Text","content":"Construct a LargeBinary type."},{"id":"text-231","heading":"Text","content":"Paramètres"},{"id":"text-232","heading":"Text","content":"length – optional, a length for the column for use in\nDDL statements, for those binary types that accept a length,\nsuch as the MySQL BLOB type."},{"id":"text-233","heading":"Text","content":"class sqlalchemy.dialects.postgresql.CIDR"},{"id":"text-234","heading":"Text","content":"Bases: sqlalchemy.types.TypeEngine"},{"id":"text-235","heading":"Text","content":"class sqlalchemy.dialects.postgresql.DOUBLE_PRECISION(precision=None, asdecimal=False, decimal_return_scale=None)"},{"id":"text-236","heading":"Text","content":"Bases: sqlalchemy.types.Float"},{"id":"text-237","heading":"Text","content":"__init__(precision=None, asdecimal=False, decimal_return_scale=None)"},{"id":"text-238","heading":"Text","content":"Construct a Float."},{"id":"text-239","heading":"Text","content":"Paramètres"},{"id":"text-240","heading":"Text","content":"précision – the numeric precision for use in DDL CREATE\nTABLE."},{"id":"text-241","heading":"Text","content":"asdecimal – the same flag as that of Numeric, but\ndefaults to Faux. Note that setting this flag to True\nresults in floating point conversion."},{"id":"text-242","heading":"Text","content":"decimal_return_scale – \nDefault scale to use when converting\nfrom floats to Python decimals. Floating point values will typically\nbe much longer due to decimal inaccuracy, and most floating point\ndatabase types don’t have a notion of “scale”, so by default the\nfloat type looks for the first ten decimal places when converting.\nSpecifying this value will override that length. Note that the\nMySQL float types, which do include “scale”, will use “scale”\nas the default for decimal_return_scale, if not otherwise specified."},{"id":"text-243","heading":"Text","content":"class sqlalchemy.dialects.postgresql.ENUM(*enums, **kw)"},{"id":"text-244","heading":"Text","content":"Bases: sqlalchemy.types.NativeForEmulated, sqlalchemy.types.Enum\nPostgreSQL ENUM type.\nThis is a subclass of types.Enum which includes\nsupport for PG’s CREATE TYPE et DROP TYPE.\nWhen the builtin type types.Enum is used and the\nEnum.native_enum flag is left at its default of\nTrue, the PostgreSQL backend will use a postgresql.ENUM\ntype as the implementation, so the special create/drop rules\nwill be used.\nThe create/drop behavior of ENUM is necessarily intricate, due to the\nawkward relationship the ENUM type has in relationship to the\nparent table, in that it may be “owned” by just a single table, or\nmay be shared among many tables.\nWhen using types.Enum ou postgresql.ENUM\nin an “inline” fashion, the CREATE TYPE et DROP TYPE is emitted\ncorresponding to when the Table.create() et Table.drop()\nmethods are called:"},{"id":"text-245","heading":"Text","content":"table = Table('sometable', metadata,\n Column('some_enum', ENUM('a', 'b', 'c', name='myenum'))\n)"},{"id":"text-246","heading":"Text","content":"table.create(engine) # will emit CREATE ENUM and CREATE TABLE\ntable.drop(engine) # will emit DROP TABLE and DROP ENUM"},{"id":"text-247","heading":"Text","content":"To use a common enumerated type between multiple tables, the best\npractice is to declare the types.Enum ou\npostgresql.ENUM independently, and associate it with the\nMetaData object itself:"},{"id":"text-248","heading":"Text","content":"my_enum = ENUM('a', 'b', 'c', name='myenum', metadata=metadata)"},{"id":"text-249","heading":"Text","content":"t1 = Table('sometable_one', metadata,\n Column('some_enum', myenum)\n)"},{"id":"text-250","heading":"Text","content":"t2 = Table('sometable_two', metadata,\n Column('some_enum', myenum)\n)"},{"id":"text-251","heading":"Text","content":"When this pattern is used, care must still be taken at the level\nof individual table creates. Emitting CREATE TABLE without also\nspecifying checkfirst=True will still cause issues:"},{"id":"text-252","heading":"Text","content":"t1.create(engine) # will fail: no such type 'myenum'"},{"id":"text-253","heading":"Text","content":"If we specify checkfirst=True, the individual table-level create\noperation will check for the ENUM and create if not exists:"},{"id":"text-254","heading":"Text","content":"# will check if enum exists, and emit CREATE TYPE if not\nt1.create(engine, checkfirst=True)"},{"id":"text-255","heading":"Text","content":"When using a metadata-level ENUM type, the type will always be created\nand dropped if either the metadata-wide create/drop is called:"},{"id":"text-256","heading":"Text","content":"metadata.create_all(engine) # will emit CREATE TYPE\nmetadata.drop_all(engine) # will emit DROP TYPE"},{"id":"text-257","heading":"Text","content":"The type can also be created and dropped directly:"},{"id":"text-258","heading":"Text","content":"my_enum.create(engine)\nmy_enum.drop(engine)"},{"id":"text-259","heading":"Text","content":"Changed in version 1.0.0: The PostgreSQL postgresql.ENUM type\nnow behaves more strictly with regards to CREATE/DROP. A metadata-level\nENUM type will only be created and dropped at the metadata level,\nnot the table level, with the exception of\ntable.create(checkfirst=True).\nle table.drop() call will now emit a DROP TYPE for a table-level\nenumerated type."},{"id":"text-260","heading":"Text","content":"__init__(*enums, **kw)"},{"id":"text-261","heading":"Text","content":"Construct an ENUM.\nArguments are the same as that of\ntypes.Enum, but also including\nthe following parameters."},{"id":"text-262","heading":"Text","content":"Paramètres"},{"id":"text-263","heading":"Text","content":"create_type – Defaults to True.\nIndicates that CREATE TYPE should be\nemitted, after optionally checking for the\npresence of the type, when the parent\ntable is being created; and additionally\ncette DROP TYPE is called when the table\nis dropped. Quand Faux, no check\nwill be performed and no CREATE TYPE\nou DROP TYPE is emitted, unless\ncreate()\nou drop()\nare called directly.\nSetting to Faux is helpful\nwhen invoking a creation scheme to a SQL file\nwithout access to the actual database –\nle create() et\ndrop() methods can\nbe used to emit SQL to a target bind."},{"id":"text-264","heading":"Text","content":"create(bind=None, checkfirst=True)"},{"id":"text-265","heading":"Text","content":"Émettre CREATE TYPE for this\nENUM.\nIf the underlying dialect does not support\nPostgreSQL CREATE TYPE, no action is taken."},{"id":"text-266","heading":"Text","content":"Paramètres"},{"id":"text-267","heading":"Text","content":"bind – a connectable Moteur,\nConnection, or similar object to emit\nSQL."},{"id":"text-268","heading":"Text","content":"checkfirst – if True, a query against\nthe PG catalog will be first performed to see\nif the type does not exist already before\ncreating."},{"id":"text-269","heading":"Text","content":"drop(bind=None, checkfirst=True)"},{"id":"text-270","heading":"Text","content":"Émettre DROP TYPE for this\nENUM.\nIf the underlying dialect does not support\nPostgreSQL DROP TYPE, no action is taken."},{"id":"text-271","heading":"Text","content":"Paramètres"},{"id":"text-272","heading":"Text","content":"bind – a connectable Moteur,\nConnection, or similar object to emit\nSQL."},{"id":"text-273","heading":"Text","content":"checkfirst – if True, a query against\nthe PG catalog will be first performed to see\nif the type actually exists before dropping."},{"id":"text-274","heading":"Text","content":"class sqlalchemy.dialects.postgresql.HSTORE(text_type=None)"},{"id":"text-275","heading":"Text","content":"Bases: sqlalchemy.types.Indexable, sqlalchemy.types.Concatenable, sqlalchemy.types.TypeEngine\nRepresent the PostgreSQL HSTORE type.\nle HSTORE type stores dictionaries containing strings, e.g.:"},{"id":"text-276","heading":"Text","content":"data_table = Table('data_table', metadata,\n Column('id', Integer, primary_key=True),\n Column('data', HSTORE)\n)"},{"id":"text-277","heading":"Text","content":"avec engine.connect() comme conn:\n conn.execute(\n data_table.insérer(),\n Les données = "key1": "value1", "key2": "value2"\n )"},{"id":"text-278","heading":"Text","content":"HSTORE provides for a wide range of operations, including:"},{"id":"text-279","heading":"Text","content":"Index operations:"},{"id":"text-280","heading":"Text","content":"data_table.c.Les données[[[['some key'] == 'some value'"},{"id":"text-281","heading":"Text","content":"Containment operations:"},{"id":"text-282","heading":"Text","content":"data_table.c.Les données.has_key('some key')"},{"id":"text-283","heading":"Text","content":"data_table.c.Les données.has_all([[[['one', 'two', 'three'])"},{"id":"text-284","heading":"Text","content":"Concatenation:"},{"id":"text-285","heading":"Text","content":"data_table.c.Les données + "k1": "v1""},{"id":"text-286","heading":"Text","content":"For a full list of special methods see\nHSTORE.comparator_factory.\nFor usage with the SQLAlchemy ORM, it may be desirable to combine\nthe usage of HSTORE avec MutableDict dictionary\nnow part of the sqlalchemy.ext.mutable\nextension. This extension will allow “in-place” changes to the\ndictionary, e.g. addition of new keys or replacement/removal of existing\nkeys to/from the current dictionary, to produce events which will be\ndetected by the unit of work:"},{"id":"text-287","heading":"Text","content":"de sqlalchemy.ext.mutable importation MutableDict"},{"id":"text-288","heading":"Text","content":"class MyClass(Base):\n __tablename__ = 'data_table'"},{"id":"text-289","heading":"Text","content":"identifiant = Column(Integer, primary_key=True)\n Les données = Column(MutableDict.as_mutable(HSTORE))"},{"id":"text-290","heading":"Text","content":"my_object = session.query(MyClass).un()"},{"id":"text-291","heading":"Text","content":"# in-place mutation, requires Mutable extension\n# in order for the ORM to detect\nmy_object.Les données[[[['some_key'] = 'some value'"},{"id":"text-292","heading":"Text","content":"session.commit()"},{"id":"text-293","heading":"Text","content":"When the sqlalchemy.ext.mutable extension is not used, the ORM\nwill not be alerted to any changes to the contents of an existing\ndictionary, unless that dictionary value is re-assigned to the\nHSTORE-attribute itself, thus generating a change event."},{"id":"text-294","heading":"Text","content":"Voir également\nhstore – render the PostgreSQL hstore() une fonction."},{"id":"text-295","heading":"Text","content":"class Comparator(expr)"},{"id":"text-296","heading":"Text","content":"Bases: sqlalchemy.types.Comparator, sqlalchemy.types.Comparator\nDefine comparison operations for HSTORE."},{"id":"text-297","heading":"Text","content":"array()"},{"id":"text-298","heading":"Text","content":"Text array expression. Returns array of alternating keys and\nvaleurs."},{"id":"text-299","heading":"Text","content":"contained_by(other)"},{"id":"text-300","heading":"Text","content":"Boolean expression. Test if keys are a proper subset of the\nkeys of the argument jsonb expression."},{"id":"text-301","heading":"Text","content":"contient(other, **kwargs)"},{"id":"text-302","heading":"Text","content":"Boolean expression. Test if keys (or array) are a superset\nof/contained the keys of the argument jsonb expression."},{"id":"text-303","heading":"Text","content":"defined(clé)"},{"id":"text-304","heading":"Text","content":"Boolean expression. Test for presence of a non-NULL value for\nthe key. Note that the key may be a SQLA expression."},{"id":"text-305","heading":"Text","content":"effacer(clé)"},{"id":"text-306","heading":"Text","content":"HStore expression. Returns the contents of this hstore with the\ngiven key deleted. Note that the key may be a SQLA expression."},{"id":"text-307","heading":"Text","content":"has_all(other)"},{"id":"text-308","heading":"Text","content":"Boolean expression. Test for presence of all keys in jsonb"},{"id":"text-309","heading":"Text","content":"has_any(other)"},{"id":"text-310","heading":"Text","content":"Boolean expression. Test for presence of any key in jsonb"},{"id":"text-311","heading":"Text","content":"has_key(other)"},{"id":"text-312","heading":"Text","content":"Boolean expression. Test for presence of a key. Note that the\nkey may be a SQLA expression."},{"id":"text-313","heading":"Text","content":"keys()"},{"id":"text-314","heading":"Text","content":"Text array expression. Returns array of keys."},{"id":"text-315","heading":"Text","content":"matrix()"},{"id":"text-316","heading":"Text","content":"Text array expression. Returns array of [key, value] pairs."},{"id":"text-317","heading":"Text","content":"slice(array)"},{"id":"text-318","heading":"Text","content":"HStore expression. Returns a subset of an hstore defined by\narray of keys."},{"id":"text-319","heading":"Text","content":"vals()"},{"id":"text-320","heading":"Text","content":"Text array expression. Returns array of values."},{"id":"text-321","heading":"Text","content":"__init__(text_type=None)"},{"id":"text-322","heading":"Text","content":"Construct a new HSTORE."},{"id":"text-323","heading":"Text","content":"Paramètres"},{"id":"text-324","heading":"Text","content":"text_type – \nthe type that should be used for indexed values.\nDefaults to types.Text."},{"id":"text-325","heading":"Text","content":"bind_processor(dialect)"},{"id":"text-326","heading":"Text","content":"Return a conversion function for processing bind values.\nReturns a callable which will receive a bind parameter value\nas the sole positional argument and will return a value to\nsend to the DB-API.\nIf processing is not necessary, the method should return None."},{"id":"text-327","heading":"Text","content":"Paramètres"},{"id":"text-328","heading":"Text","content":"dialect – Dialect instance in use."},{"id":"text-329","heading":"Text","content":"comparator_factory"},{"id":"text-330","heading":"Text","content":"alias of HSTORE.Comparator"},{"id":"text-331","heading":"Text","content":"result_processor(dialect, coltype)"},{"id":"text-332","heading":"Text","content":"Return a conversion function for processing result row values.\nReturns a callable which will receive a result row column\nvalue as the sole positional argument and will return a value\nto return to the user.\nIf processing is not necessary, the method should return None."},{"id":"text-333","heading":"Text","content":"Paramètres"},{"id":"text-334","heading":"Text","content":"class sqlalchemy.dialects.postgresql.hstore(*args, **kwargs)"},{"id":"text-335","heading":"Text","content":"Bases: sqlalchemy.sql.functions.GenericFunction\nConstruct an hstore value within a SQL expression using the\nPostgreSQL hstore() une fonction.\nle hstore function accepts one or two arguments as described\nin the PostgreSQL documentation.\nE.g.:"},{"id":"text-336","heading":"Text","content":"de sqlalchemy.dialects.postgresql importation array, hstore"},{"id":"text-337","heading":"Text","content":"sélectionner([[[[hstore('key1', 'value1')])"},{"id":"text-338","heading":"Text","content":"sélectionner([[[[\n hstore(\n array([[[['key1', 'key2', 'key3']),\n array([[[['value1', 'value2', 'value3'])\n )\n ])"},{"id":"text-339","heading":"Text","content":"Voir également\nHSTORE – the PostgreSQL HSTORE datatype."},{"id":"text-340","heading":"Text","content":"type"},{"id":"text-341","heading":"Text","content":"alias of HSTORE"},{"id":"text-342","heading":"Text","content":"class sqlalchemy.dialects.postgresql.INET"},{"id":"text-343","heading":"Text","content":"Bases: sqlalchemy.types.TypeEngine"},{"id":"text-344","heading":"Text","content":"class sqlalchemy.dialects.postgresql.INTERVAL(precision=None, fields=None)"},{"id":"text-345","heading":"Text","content":"Bases: sqlalchemy.types.NativeForEmulated, sqlalchemy.types._AbstractInterval\nPostgreSQL INTERVAL type.\nThe INTERVAL type may not be supported on all DBAPIs.\nIt is known to work on psycopg2 and not pg8000 or zxjdbc."},{"id":"text-346","heading":"Text","content":"__init__(precision=None, fields=None)"},{"id":"text-347","heading":"Text","content":"Construct an INTERVAL."},{"id":"text-348","heading":"Text","content":"Paramètres"},{"id":"text-349","heading":"Text","content":"précision – optional integer precision value"},{"id":"text-350","heading":"Text","content":"fields – \nstring fields specifier. allows storage of fields\nto be limited, such as "YEAR", "MONTH", "DAY TO HOUR",\netc."},{"id":"text-351","heading":"Text","content":"class sqlalchemy.dialects.postgresql.JSON(none_as_null=False, astext_type=None)"},{"id":"text-352","heading":"Text","content":"Bases: sqlalchemy.types.JSON\nRepresent the PostgreSQL JSON type.\nThis type is a specialization of the Core-level types.JSON\ntype. Be sure to read the documentation for types.JSON for\nimportant tips regarding treatment of NULL values and ORM use.\nThe operators provided by the PostgreSQL version of JSON\ninclude:"},{"id":"text-353","heading":"Text","content":"Index operations (the -> operator):"},{"id":"text-354","heading":"Text","content":"data_table.c.Les données[[[['some key']"},{"id":"text-355","heading":"Text","content":"data_table.c.Les données[[[[5]"},{"id":"text-356","heading":"Text","content":"Index operations returning text (the ->> operator):"},{"id":"text-357","heading":"Text","content":"data_table.c.Les données[[[['some key'].astext == 'some value'"},{"id":"text-358","heading":"Text","content":"Index operations with CAST\n(equivalent to CAST(col ->> ['some['some['some['some key'] AS )):"},{"id":"text-359","heading":"Text","content":"data_table.c.Les données[[[['some key'].astext.jeter(Integer) == 5"},{"id":"text-360","heading":"Text","content":"Path index operations (the #> operator):"},{"id":"text-361","heading":"Text","content":"data_table.c.Les données[([([([('key_1', 'key_2', 5, ..., 'key_n')]"},{"id":"text-362","heading":"Text","content":"Path index operations returning text (the #>> operator):"},{"id":"text-363","heading":"Text","content":"data_table.c.Les données[([([([('key_1', 'key_2', 5, ..., 'key_n')].astext == 'some value'"},{"id":"text-364","heading":"Text","content":"Changed in version 1.1: le ColumnElement.cast() operator on\nJSON objects now requires that the JSON.Comparator.astext\nmodifier be called explicitly, if the cast works only from a textual\nstring."},{"id":"text-365","heading":"Text","content":"Index operations return an expression object whose type defaults to\nJSON by default, so that further JSON-oriented instructions\nmay be called upon the result type.\nCustom serializers and deserializers are specified at the dialect level,\nthat is using create_engine(). The reason for this is that when\nusing psycopg2, the DBAPI only allows serializers at the per-cursor\nor per-connection level. E.g.:"},{"id":"text-366","heading":"Text","content":"engine = create_engine("postgresql://scott:tiger@localhost/test",\n json_serializer=my_serialize_fn,\n json_deserializer=my_deserialize_fn\n )"},{"id":"text-367","heading":"Text","content":"When using the psycopg2 dialect, the json_deserializer is registered\nagainst the database using psycopg2.extras.register_default_json."},{"id":"text-368","heading":"Text","content":"class Comparator(expr)"},{"id":"text-369","heading":"Text","content":"Bases: sqlalchemy.types.Comparator\nDefine comparison operations for JSON."},{"id":"text-370","heading":"Text","content":"property astext"},{"id":"text-371","heading":"Text","content":"On an indexed expression, use the “astext” (e.g. “->>”)\nconversion when rendered in SQL.\nE.g.:"},{"id":"text-372","heading":"Text","content":"sélectionner([[[[data_table.c.Les données[[[['some key'].astext])"},{"id":"text-373","heading":"Text","content":"__init__(none_as_null=False, astext_type=None)"},{"id":"text-374","heading":"Text","content":"Construct a JSON type."},{"id":"text-375","heading":"Text","content":"Paramètres"},{"id":"text-376","heading":"Text","content":"none_as_null – \nif True, persist the value None as a\nSQL NULL value, not the JSON encoding of nul. Note that\nwhen this flag is False, the null() construct can still\nbe used to persist a NULL value:"},{"id":"text-377","heading":"Text","content":"de sqlalchemy importation nul\nconn.execute(table.insérer(), Les données=nul())"},{"id":"text-378","heading":"Text","content":"Changed in version 0.9.8: – Added none_as_null, et null()\nis now supported in order to persist a NULL value."},{"id":"text-379","heading":"Text","content":"astext_type – \nthe type to use for the\nJSON.Comparator.astext\naccessor on indexed attributes. Defaults to types.Text."},{"id":"text-380","heading":"Text","content":"comparator_factory"},{"id":"text-381","heading":"Text","content":"alias of JSON.Comparator"},{"id":"text-382","heading":"Text","content":"class sqlalchemy.dialects.postgresql.JSONB(none_as_null=False, astext_type=None)"},{"id":"text-383","heading":"Text","content":"Bases: sqlalchemy.dialects.postgresql.json.JSON\nRepresent the PostgreSQL JSONB type.\nle JSONB type stores arbitrary JSONB format data, e.g.:"},{"id":"text-384","heading":"Text","content":"data_table = Table('data_table', metadata,\n Column('id', Integer, primary_key=True),\n Column('data', JSONB)\n)"},{"id":"text-385","heading":"Text","content":"avec engine.connect() comme conn:\n conn.execute(\n data_table.insérer(),\n Les données = "key1": "value1", "key2": "value2"\n )"},{"id":"text-386","heading":"Text","content":"le JSONB type includes all operations provided by\nJSON, including the same behaviors for indexing operations.\nIt also adds additional operators specific to JSONB, including\nJSONB.Comparator.has_key(), JSONB.Comparator.has_all(),\nJSONB.Comparator.has_any(), JSONB.Comparator.contains(),\net JSONB.Comparator.contained_by().\nComme le JSON type, the JSONB type does not detect\nin-place changes when used with the ORM, unless the\nsqlalchemy.ext.mutable extension is used.\nCustom serializers and deserializers\nare shared with the JSON class, using the json_serializer\net json_deserializer keyword arguments. These must be specified\nat the dialect level using create_engine(). When using\npsycopg2, the serializers are associated with the jsonb type using\npsycopg2.extras.register_default_jsonb on a per-connection basis,\nin the same way that psycopg2.extras.register_default_json is used\nto register these handlers with the json type."},{"id":"text-387","heading":"Text","content":"class Comparator(expr)"},{"id":"text-388","heading":"Text","content":"Bases: sqlalchemy.dialects.postgresql.json.Comparator\nDefine comparison operations for JSON."},{"id":"text-389","heading":"Text","content":"contained_by(other)"},{"id":"text-390","heading":"Text","content":"Boolean expression. Test if keys are a proper subset of the\nkeys of the argument jsonb expression."},{"id":"text-391","heading":"Text","content":"contient(other, **kwargs)"},{"id":"text-392","heading":"Text","content":"Boolean expression. Test if keys (or array) are a superset\nof/contained the keys of the argument jsonb expression."},{"id":"text-393","heading":"Text","content":"has_all(other)"},{"id":"text-394","heading":"Text","content":"Boolean expression. Test for presence of all keys in jsonb"},{"id":"text-395","heading":"Text","content":"has_any(other)"},{"id":"text-396","heading":"Text","content":"Boolean expression. Test for presence of any key in jsonb"},{"id":"text-397","heading":"Text","content":"has_key(other)"},{"id":"text-398","heading":"Text","content":"Boolean expression. Test for presence of a key. Note that the\nkey may be a SQLA expression."},{"id":"text-399","heading":"Text","content":"comparator_factory"},{"id":"text-400","heading":"Text","content":"alias of JSONB.Comparator"},{"id":"text-401","heading":"Text","content":"class sqlalchemy.dialects.postgresql.MACADDR"},{"id":"text-402","heading":"Text","content":"Bases: sqlalchemy.types.TypeEngine"},{"id":"text-403","heading":"Text","content":"class sqlalchemy.dialects.postgresql.ARGENT"},{"id":"text-404","heading":"Text","content":"Bases: sqlalchemy.types.TypeEngine\nProvide the PostgreSQL MONEY type."},{"id":"text-405","heading":"Text","content":"class sqlalchemy.dialects.postgresql.OID"},{"id":"text-406","heading":"Text","content":"Bases: sqlalchemy.types.TypeEngine\nProvide the PostgreSQL OID type."},{"id":"text-407","heading":"Text","content":"class sqlalchemy.dialects.postgresql.REAL(precision=None, asdecimal=False, decimal_return_scale=None)"},{"id":"text-408","heading":"Text","content":"Bases: sqlalchemy.types.Float\nThe SQL REAL type."},{"id":"text-409","heading":"Text","content":"__init__(precision=None, asdecimal=False, decimal_return_scale=None)"},{"id":"text-410","heading":"Text","content":"Construct a Float."},{"id":"text-411","heading":"Text","content":"Paramètres"},{"id":"text-412","heading":"Text","content":"précision – the numeric precision for use in DDL CREATE\nTABLE."},{"id":"text-413","heading":"Text","content":"asdecimal – the same flag as that of Numeric, but\ndefaults to Faux. Note that setting this flag to True\nresults in floating point conversion."},{"id":"text-414","heading":"Text","content":"decimal_return_scale – \nDefault scale to use when converting\nfrom floats to Python decimals. Floating point values will typically\nbe much longer due to decimal inaccuracy, and most floating point\ndatabase types don’t have a notion of “scale”, so by default the\nfloat type looks for the first ten decimal places when converting.\nSpecifying this value will override that length. Note that the\nMySQL float types, which do include “scale”, will use “scale”\nas the default for decimal_return_scale, if not otherwise specified."},{"id":"text-415","heading":"Text","content":"class sqlalchemy.dialects.postgresql.REGCLASS"},{"id":"text-416","heading":"Text","content":"Bases: sqlalchemy.types.TypeEngine\nProvide the PostgreSQL REGCLASS type."},{"id":"text-417","heading":"Text","content":"class sqlalchemy.dialects.postgresql.TSVECTOR"},{"id":"text-418","heading":"Text","content":"Bases: sqlalchemy.types.TypeEngine\nle postgresql.TSVECTOR type implements the PostgreSQL\ntext search type TSVECTOR.\nIt can be used to do full text queries on natural language\ndocuments."},{"id":"text-419","heading":"Text","content":"class sqlalchemy.dialects.postgresql.UUID(as_uuid=False)"},{"id":"text-420","heading":"Text","content":"Bases: sqlalchemy.types.TypeEngine\nPostgreSQL UUID type.\nRepresents the UUID column type, interpreting\ndata either as natively returned by the DBAPI\nor as Python uuid objects.\nThe UUID type may not be supported on all DBAPIs.\nIt is known to work on psycopg2 and not pg8000."},{"id":"text-421","heading":"Text","content":"__init__(as_uuid=False)"},{"id":"text-422","heading":"Text","content":"Construct a UUID type."},{"id":"text-423","heading":"Text","content":"Paramètres"},{"id":"text-424","heading":"Text","content":"as_uuid=False – if True, values will be interpreted\nas Python uuid objects, converting to/from string via the\nDBAPI."},{"id":"text-425","heading":"Text","content":"Range Types\nThe new range column types found in PostgreSQL 9.2 onwards are\ncatered for by the following types:"},{"id":"text-426","heading":"Text","content":"class sqlalchemy.dialects.postgresql.INT4RANGE"},{"id":"text-427","heading":"Text","content":"Bases: sqlalchemy.dialects.postgresql.ranges.RangeOperators, sqlalchemy.types.TypeEngine\nRepresent the PostgreSQL INT4RANGE type."},{"id":"text-428","heading":"Text","content":"class sqlalchemy.dialects.postgresql.INT8RANGE"},{"id":"text-429","heading":"Text","content":"Bases: sqlalchemy.dialects.postgresql.ranges.RangeOperators, sqlalchemy.types.TypeEngine\nRepresent the PostgreSQL INT8RANGE type."},{"id":"text-430","heading":"Text","content":"class sqlalchemy.dialects.postgresql.NUMRANGE"},{"id":"text-431","heading":"Text","content":"Bases: sqlalchemy.dialects.postgresql.ranges.RangeOperators, sqlalchemy.types.TypeEngine\nRepresent the PostgreSQL NUMRANGE type."},{"id":"text-432","heading":"Text","content":"class sqlalchemy.dialects.postgresql.DATERANGE"},{"id":"text-433","heading":"Text","content":"Bases: sqlalchemy.dialects.postgresql.ranges.RangeOperators, sqlalchemy.types.TypeEngine\nRepresent the PostgreSQL DATERANGE type."},{"id":"text-434","heading":"Text","content":"class sqlalchemy.dialects.postgresql.TSRANGE"},{"id":"text-435","heading":"Text","content":"Bases: sqlalchemy.dialects.postgresql.ranges.RangeOperators, sqlalchemy.types.TypeEngine\nRepresent the PostgreSQL TSRANGE type."},{"id":"text-436","heading":"Text","content":"class sqlalchemy.dialects.postgresql.TSTZRANGE"},{"id":"text-437","heading":"Text","content":"Bases: sqlalchemy.dialects.postgresql.ranges.RangeOperators, sqlalchemy.types.TypeEngine\nRepresent the PostgreSQL TSTZRANGE type."},{"id":"text-438","heading":"Text","content":"The types above get most of their functionality from the following\nmixin:"},{"id":"text-439","heading":"Text","content":"class sqlalchemy.dialects.postgresql.ranges.RangeOperators"},{"id":"text-440","heading":"Text","content":"This mixin provides functionality for the Range Operators\nlisted in Table 9-44 of the postgres documentation for Range\nFunctions and Operators. It is used by all the range types\nprovided in the postgres dialect and can likely be used for\nany range types you create yourself.\nNo extra support is provided for the Range Functions listed in\nTable 9-45 of the postgres documentation. For these, the normal\nfunc() object should be used."},{"id":"text-441","heading":"Text","content":"class comparator_factory(expr)"},{"id":"text-442","heading":"Text","content":"Bases: sqlalchemy.types.Comparator\nDefine comparison operations for range types."},{"id":"text-443","heading":"Text","content":"__ne__(other)"},{"id":"text-444","heading":"Text","content":"Boolean expression. Returns true if two ranges are not equal"},{"id":"text-445","heading":"Text","content":"adjacent_to(other)"},{"id":"text-446","heading":"Text","content":"Boolean expression. Returns true if the range in the column\nis adjacent to the range in the operand."},{"id":"text-447","heading":"Text","content":"contained_by(other)"},{"id":"text-448","heading":"Text","content":"Boolean expression. Returns true if the column is contained\nwithin the right hand operand."},{"id":"text-449","heading":"Text","content":"contient(other, **kw)"},{"id":"text-450","heading":"Text","content":"Boolean expression. Returns true if the right hand operand,\nwhich can be an element or a range, is contained within the\ncolumn."},{"id":"text-451","heading":"Text","content":"not_extend_left_of(other)"},{"id":"text-452","heading":"Text","content":"Boolean expression. Returns true if the range in the column\ndoes not extend left of the range in the operand."},{"id":"text-453","heading":"Text","content":"not_extend_right_of(other)"},{"id":"text-454","heading":"Text","content":"Boolean expression. Returns true if the range in the column\ndoes not extend right of the range in the operand."},{"id":"text-455","heading":"Text","content":"overlaps(other)"},{"id":"text-456","heading":"Text","content":"Boolean expression. Returns true if the column overlaps\n(has points in common with) the right hand operand."},{"id":"text-457","heading":"Text","content":"strictly_left_of(other)"},{"id":"text-458","heading":"Text","content":"Boolean expression. Returns true if the column is strictly\nleft of the right hand operand."},{"id":"text-459","heading":"Text","content":"strictly_right_of(other)"},{"id":"text-460","heading":"Text","content":"Boolean expression. Returns true if the column is strictly\nright of the right hand operand."},{"id":"text-461","heading":"Text","content":"Attention\nThe range type DDL support should work with any PostgreSQL DBAPI\ndriver, however the data types returned may vary. If you are using\npsycopg2, it’s recommended to upgrade to version 2.5 or later\nbefore using these column types."},{"id":"text-462","heading":"Text","content":"When instantiating models that use these column types, you should pass\nwhatever data type is expected by the DBAPI driver you’re using for\nthe column type. Pour psycopg2 these are\npsycopg2.extras.NumericRange,\npsycopg2.extras.DateRange,\npsycopg2.extras.DateTimeRange et\npsycopg2.extras.DateTimeTZRange or the class you’ve\nregistered with psycopg2.extras.register_range.\nPar exemple:"},{"id":"text-463","heading":"Text","content":"de psycopg2.extras importation DateTimeRange\nde sqlalchemy.dialects.postgresql importation TSRANGE"},{"id":"text-464","heading":"Text","content":"class RoomBooking(Base):"},{"id":"text-465","heading":"Text","content":"__tablename__ = 'room_booking'"},{"id":"text-466","heading":"Text","content":"room = Column(Integer(), primary_key=True)\n pendant = Column(TSRANGE())"},{"id":"text-467","heading":"Text","content":"booking = RoomBooking(\n room=101,\n pendant=DateTimeRange(datetime(2013, 3, 23), None)\n)"},{"id":"text-468","heading":"Text","content":"PostgreSQL Constraint Types\nSQLAlchemy supports PostgreSQL EXCLUDE constraints via the\nExcludeConstraint class:"},{"id":"text-469","heading":"Text","content":"class sqlalchemy.dialects.postgresql.ExcludeConstraint(*elements, **kw)"},{"id":"text-470","heading":"Text","content":"Bases: sqlalchemy.schema.ColumnCollectionConstraint\nA table-level EXCLUDE constraint.\nDefines an EXCLUDE constraint as described in the postgres\ndocumentation."},{"id":"text-471","heading":"Text","content":"__init__(*elements, **kw)"},{"id":"text-472","heading":"Text","content":"Créé un ExcludeConstraint object.\nE.g.:"},{"id":"text-473","heading":"Text","content":"const = ExcludeConstraint(\n (Column('period'), '&&'),\n (Column('group'), '='),\n where=(Column('group') != 'some group')\n)"},{"id":"text-474","heading":"Text","content":"The constraint is normally embedded into the Table construct\ndirectly, or added later using append_constraint():"},{"id":"text-475","heading":"Text","content":"some_table = Table(\n 'some_table', metadata,\n Column('id', Integer, primary_key=True),\n Column('period', TSRANGE()),\n Column('group', Chaîne)\n)"},{"id":"text-476","heading":"Text","content":"some_table.append_constraint(\n ExcludeConstraint(\n (some_table.c.period, '&&'),\n (some_table.c.group, '='),\n where=some_table.c.group != 'some group',\n name='some_table_excl_const'\n )\n)"},{"id":"text-477","heading":"Text","content":"Paramètres"},{"id":"text-478","heading":"Text","content":"*elements – A sequence of two tuples of the form (column, operator) where\n“column” is a SQL expression element or a raw SQL string, most\ntypically a Column object, and “operator” is a string\ncontaining the operator to use. In order to specify a column name\nwhen a Column object is not available, while ensuring\nthat any necessary quoting rules take effect, an ad-hoc\nColumn ou sql.expression.column() object should be\nused."},{"id":"text-479","heading":"Text","content":"name – Optional, the in-database name of this constraint."},{"id":"text-480","heading":"Text","content":"deferrable – Optional bool. If set, emit DEFERRABLE or NOT DEFERRABLE when\nissuing DDL for this constraint."},{"id":"text-481","heading":"Text","content":"initialement – Optional string. If set, emit INITIALLY when issuing DDL\nfor this constraint."},{"id":"text-482","heading":"Text","content":"using – Optional string. If set, emit USING when issuing DDL\nfor this constraint. Defaults to ‘gist’."},{"id":"text-483","heading":"Text","content":"where – \nOptional SQL expression construct or literal SQL string.\nIf set, emit WHERE \n when issuing DDL\nfor this constraint."},{"id":"text-484","heading":"Text","content":"Attention\nle ExcludeConstraint.where argument to ExcludeConstraint can be passed as a Python string argument, which will be treated as trusted SQL text and rendered as given. DO NOT PASS UNTRUSTED INPUT TO THIS PARAMETER."},{"id":"text-485","heading":"Text","content":"Par exemple:\nde sqlalchemy.dialects.postgresql importation ExcludeConstraint, TSRANGE"},{"id":"text-486","heading":"Text","content":"class RoomBooking(Base):"},{"id":"text-487","heading":"Text","content":"__tablename__ = 'room_booking'"},{"id":"text-488","heading":"Text","content":"room = Column(Integer(), primary_key=True)\n pendant = Column(TSRANGE())"},{"id":"text-489","heading":"Text","content":"__table_args__ = (\n ExcludeConstraint(('room', '='), ('during', '&&')),\n )"},{"id":"text-490","heading":"Text","content":"PostgreSQL DML Constructs"},{"id":"text-491","heading":"Text","content":"sqlalchemy.dialects.postgresql.dml.insérer(table, values=None, inline=False, bind=None, prefixes=None, returning=None, return_defaults=False, **dialect_kw)"},{"id":"text-492","heading":"Text","content":"Construct a new Insert object.\nThis constructor is mirrored as a public API function; voir insert() for a full usage and argument description."},{"id":"text-493","heading":"Text","content":"class sqlalchemy.dialects.postgresql.dml.Insert(table, values=None, inline=False, bind=None, prefixes=None, returning=None, return_defaults=False, **dialect_kw)"},{"id":"text-494","heading":"Text","content":"Bases: sqlalchemy.sql.expression.Insert\nPostgreSQL-specific implementation of INSERT.\nAdds methods for PG-specific syntaxes such as ON CONFLICT."},{"id":"text-495","heading":"Text","content":"excluded"},{"id":"text-496","heading":"Text","content":"Provide the excluded namespace for an ON CONFLICT statement\nPG’s ON CONFLICT clause allows reference to the row that would\nbe inserted, known as excluded. This attribute provides\nall columns in this row to be referenceable."},{"id":"text-497","heading":"Text","content":"on_conflict_do_nothing(constraint=None, index_elements=None, index_where=None)"},{"id":"text-498","heading":"Text","content":"Specifies a DO NOTHING action for ON CONFLICT clause.\nle constraint et index_elements arguments\nare optional, but only one of these can be specified."},{"id":"text-499","heading":"Text","content":"Paramètres"},{"id":"text-500","heading":"Text","content":"constraint – The name of a unique or exclusion constraint on the table,\nor the constraint object itself if it has a .name attribute."},{"id":"text-501","heading":"Text","content":"index_elements – A sequence consisting of string column names, Column\nobjects, or other column expression objects that will be used\nto infer a target index."},{"id":"text-502","heading":"Text","content":"index_where – \nAdditional WHERE criterion that can be used to infer a\nconditional target index."},{"id":"text-503","heading":"Text","content":"on_conflict_do_update(constraint=None, index_elements=None, index_where=None, set_=None, where=None)"},{"id":"text-504","heading":"Text","content":"Specifies a DO UPDATE SET action for ON CONFLICT clause.\nEither the constraint ou index_elements argument is\nrequired, but only one of these can be specified."},{"id":"text-505","heading":"Text","content":"Paramètres"},{"id":"text-506","heading":"Text","content":"constraint – The name of a unique or exclusion constraint on the table,\nor the constraint object itself if it has a .name attribute."},{"id":"text-507","heading":"Text","content":"index_elements – A sequence consisting of string column names, Column\nobjects, or other column expression objects that will be used\nto infer a target index."},{"id":"text-508","heading":"Text","content":"index_where – Additional WHERE criterion that can be used to infer a\nconditional target index."},{"id":"text-509","heading":"Text","content":"set_ – \nRequired argument. A dictionary or other mapping object\nwith column names as keys and expressions or literals as values,\nspecifying the SET actions to take.\nIf the target Column specifies a “.key” attribute distinct\nfrom the column name, that key should be used."},{"id":"text-510","heading":"Text","content":"Attention\nThis dictionary does ne pas take into account\nPython-specified default UPDATE values or generation functions,\ne.g. those specified using Column.onupdate.\nThese values will not be exercised for an ON CONFLICT style of\nUPDATE, unless they are manually specified in the\nInsert.on_conflict_do_update.set_ dictionary."},{"id":"text-511","heading":"Text","content":"where – \nOptional argument. If present, can be a literal SQL\nstring or an acceptable expression for a WHERE clause\nthat restricts the rows affected by DO UPDATE SET. Rows\nnot meeting the WHERE condition will not be updated\n(effectively a DO NOTHING for those rows)."},{"id":"text-512","heading":"Text","content":"psycopg2\nSupport for the PostgreSQL database via the psycopg2 driver."},{"id":"text-513","heading":"Text","content":"DBAPI\nDocumentation and download information (if applicable) for psycopg2 is available at:\nhttp://pypi.python.org/pypi/psycopg2/"},{"id":"text-514","heading":"Text","content":"Connecting\nConnect String:"},{"id":"text-515","heading":"Text","content":"postgresql+psycopg2://user:password@host:port/dbname[?key=value&key=value...]"},{"id":"text-516","heading":"Text","content":"psycopg2 Connect Arguments\npsycopg2-specific keyword arguments which are accepted by\ncreate_engine() sont:"},{"id":"text-517","heading":"Text","content":"server_side_cursors: Enable the usage of “server side cursors” for SQL\nstatements which support this feature. What this essentially means from a\npsycopg2 point of view is that the cursor is created using a name, e.g.\nconnection.cursor('some name'), which has the effect that result rows\nare not immediately pre-fetched and buffered after statement execution, but\nare instead left on the server and only retrieved as needed. SQLAlchemy’s\nResultProxy uses special row-buffering\nbehavior when this feature is enabled, such that groups of 100 rows at a\ntime are fetched over the wire to reduce conversational overhead.\nNote that the Connection.execution_options.stream_results\nexecution option is a more targeted\nway of enabling this mode on a per-execution basis."},{"id":"text-518","heading":"Text","content":"use_native_unicode: Enable the usage of Psycopg2 “native unicode” mode\nper connection. True by default."},{"id":"text-519","heading":"Text","content":"isolation_level: This option, available for all PostgreSQL dialects,\ncomprend le AUTOCOMMIT isolation level when using the psycopg2\ndialect."},{"id":"text-520","heading":"Text","content":"client_encoding: sets the client encoding in a libpq-agnostic way,\nusing psycopg2’s set_client_encoding() method."},{"id":"text-521","heading":"Text","content":"executemany_mode, executemany_batch_page_size,\nexecutemany_values_page_size: Allows use of psycopg2\nextensions for optimizing “executemany”-stye queries. See the referenced\nsection below for details."},{"id":"text-522","heading":"Text","content":"use_batch_mode: this is the previous setting used to affect “executemany”\nmode and is now deprecated."},{"id":"text-523","heading":"Text","content":"Unix Domain Connections\npsycopg2 supports connecting via Unix domain connections. When the hôte\nportion of the URL is omitted, SQLAlchemy passes None to psycopg2,\nwhich specifies Unix-domain communication rather than TCP/IP communication:"},{"id":"text-524","heading":"Text","content":"create_engine("postgresql+psycopg2://user:password@/dbname")"},{"id":"text-525","heading":"Text","content":"By default, the socket file used is to connect to a Unix-domain socket\ndans /tmp, or whatever socket directory was specified when PostgreSQL\nwas built. This value can be overridden by passing a pathname to psycopg2,\nusing hôte as an additional keyword argument:"},{"id":"text-526","heading":"Text","content":"create_engine("postgresql+psycopg2://user:password@/dbname?host=/var/lib/postgresql")"},{"id":"text-527","heading":"Text","content":"Empty DSN Connections / Environment Variable Connections\nThe psycopg2 DBAPI can connect to PostgreSQL by passing an empty DSN to the\nlibpq client library, which by default indicates to connect to a localhost\nPostgreSQL database that is open for “trust” connections. This behavior can be\nfurther tailored using a particular set of environment variables which are\nprefixed with PG_..., which are consumed by libpq to take the place of\nany or all elements of the connection string.\nFor this form, the URL can be passed without any elements other than the\ninitial scheme:"},{"id":"text-528","heading":"Text","content":"engine = create_engine('postgresql+psycopg2://')"},{"id":"text-529","heading":"Text","content":"In the above form, a blank “dsn” string is passed to the psycopg2.connect()\nfunction which in turn represents an empty DSN passed to libpq."},{"id":"text-530","heading":"Text","content":"New in version 1.3.2: support for parameter-less connections with psycopg2."},{"id":"text-531","heading":"Text","content":"Voir également\nEnvironment Variables –\nPostgreSQL documentation on how to use PG_...\nenvironment variables for connections."},{"id":"text-532","heading":"Text","content":"Per-Statement/Connection Execution Options\nThe following DBAPI-specific options are respected when used with\nConnection.execution_options(), Executable.execution_options(),\nQuery.execution_options(), in addition to those not specific to DBAPIs:"},{"id":"text-533","heading":"Text","content":"isolation_level – Set the transaction isolation level for the lifespan\nd'un Connection (can only be set on a connection, not a statement\nor query). See Psycopg2 Transaction Isolation Level."},{"id":"text-534","heading":"Text","content":"stream_results – Enable or disable usage of psycopg2 server side\ncursors – this feature makes use of “named” cursors in combination with\nspecial result handling methods so that result rows are not fully buffered.\nSi None or not set, the server_side_cursors option of the\nMoteur est utilisé."},{"id":"text-535","heading":"Text","content":"max_row_buffer – when using stream_results, an integer value that\nspecifies the maximum number of rows to buffer at a time. This is\ninterpreted by the BufferedRowResultProxy, and if omitted the\nbuffer will grow to ultimately store 1000 rows at a time."},{"id":"text-536","heading":"Text","content":"Psycopg2 Fast Execution Helpers\nModern versions of psycopg2 include a feature known as\nFast Execution Helpers , which\nhave been shown in benchmarking to improve psycopg2’s executemany()\nperformance, primarily with INSERT statements, by multiple orders of magnitude.\nSQLAlchemy allows this extension to be used for all executemany() style\ncalls invoked by an Moteur when used with multiple parameter\nensembles, which includes the use of this feature both by the\nCore as well as by the ORM for inserts of objects with non-autogenerated\nprimary key values, by adding the executemany_mode flag to\ncreate_engine():"},{"id":"text-537","heading":"Text","content":"engine = create_engine(\n "postgresql+psycopg2://scott:tiger@host/dbname",\n executemany_mode='batch')"},{"id":"text-538","heading":"Text","content":"Changed in version 1.3.7: – le use_batch_mode flag has been superseded\nby a new parameter executemany_mode which provides support both for\npsycopg2’s execute_batch helper as well as the execute_values\nhelper."},{"id":"text-539","heading":"Text","content":"Possible options for executemany_mode include:"},{"id":"text-540","heading":"Text","content":"None – By default, psycopg2’s extensions are not used, and the usual\ncursor.executemany() method is used when invoking batches of statements."},{"id":"text-541","heading":"Text","content":"'batch' – Uses psycopg2.extras.execute_batch so that multiple copies\nof a SQL query, each one corresponding to a parameter set passed to\nexecutemany(), are joined into a single SQL string separated by a\nsemicolon. This is the same behavior as was provided by the\nuse_batch_mode=True flag."},{"id":"text-542","heading":"Text","content":"'values'– For Core insert() constructs only (including those\nemitted by the ORM automatically), the psycopg2.extras.execute_values\nextension is used so that multiple parameter sets are grouped into a single\nINSERT statement and joined together with multiple VALUES expressions. Cette\nmethod requires that the string text of the VALUES clause inside the\nINSERT statement is manipulated, so is only supported with a compiled\ninsert() construct where the format is predictable. For all other\nconstructs, including plain textual INSERT statements not rendered by the\nSQLAlchemy expression language compiler, the\npsycopg2.extras.execute_batch method is used. It is therefore important\nto note that “values” mode implies that “batch” mode is also used for\nall statements for which “values” mode does not apply."},{"id":"text-543","heading":"Text","content":"For both strategies, the executemany_batch_page_size et\nexecutemany_values_page_size arguments control how many parameter sets\nshould be represented in each execution. Because “values” mode implies a\nfallback down to “batch” mode for non-INSERT statements, there are two\nindependent page size arguments. For each, the default value of None means\nto use psycopg2’s defaults, which at the time of this writing are quite low at\n100. For the execute_values method, a number as high as 10000 may prove\nto be performant, whereas for execute_batch, as the number represents\nfull statements repeated, a number closer to the default of 100 is likely\nmore appropriate:"},{"id":"text-544","heading":"Text","content":"engine = create_engine(\n "postgresql+psycopg2://scott:tiger@host/dbname",\n executemany_mode='values',\n executemany_values_page_size=10000, executemany_batch_page_size=500)"},{"id":"text-545","heading":"Text","content":"Changed in version 1.3.7: – Added support for\npsycopg2.extras.execute_values. le use_batch_mode flag is\nsuperseded by the executemany_mode flag."},{"id":"text-546","heading":"Text","content":"Unicode with Psycopg2\nBy default, the psycopg2 driver uses the psycopg2.extensions.UNICODE\nextension, such that the DBAPI receives and returns all strings as Python\nUnicode objects directly – SQLAlchemy passes these values through without\nchange. Psycopg2 here will encode/decode string values based on the\ncurrent “client encoding” setting; by default this is the value in\nle postgresql.conf file, which often defaults to SQL_ASCII.\nTypically, this can be changed to utf8, as a more useful default:"},{"id":"text-547","heading":"Text","content":"# postgresql.conf file"},{"id":"text-548","heading":"Text","content":"# client_encoding = sql_ascii # actually, defaults to database\n # encoding\nclient_encoding = utf8"},{"id":"text-549","heading":"Text","content":"A second way to affect the client encoding is to set it within Psycopg2\nlocally. SQLAlchemy will call psycopg2’s\npsycopg2:connection.set_client_encoding() method\non all new connections based on the value passed to\ncreate_engine() using the client_encoding parameter:"},{"id":"text-550","heading":"Text","content":"# set_client_encoding() setting;\n# works for *all* PostgreSQL versions\nengine = create_engine("postgresql://user:pass@host/dbname",\n client_encoding='utf8')"},{"id":"text-551","heading":"Text","content":"This overrides the encoding specified in the PostgreSQL client configuration.\nWhen using the parameter in this way, the psycopg2 driver emits\nSET client_encoding TO 'utf8' on the connection explicitly, and works\nin all PostgreSQL versions.\nNote that the client_encoding setting as passed to create_engine()\nest not the same as the more recently added client_encoding parameter\nnow supported by libpq directly. This is enabled when client_encoding\nis passed directly to psycopg2.connect(), and from SQLAlchemy is passed\nusing the create_engine.connect_args parameter:"},{"id":"text-552","heading":"Text","content":"engine = create_engine(\n "postgresql://user:pass@host/dbname",\n connect_args='client_encoding': 'utf8')"},{"id":"text-553","heading":"Text","content":"# using the query string is equivalent\nengine = create_engine("postgresql://user:pass@host/dbname?client_encoding=utf8")"},{"id":"text-554","heading":"Text","content":"The above parameter was only added to libpq as of version 9.1 of PostgreSQL,\nso using the previous method is better for cross-version support."},{"id":"text-555","heading":"Text","content":"Disabling Native Unicode\nSQLAlchemy can also be instructed to skip the usage of the psycopg2\nUNICODE extension and to instead utilize its own unicode encode/decode\nservices, which are normally reserved only for those DBAPIs that don’t\nfully support unicode directly. Passing use_native_unicode=False à\ncreate_engine() will disable usage of psycopg2.extensions.UNICODE.\nSQLAlchemy will instead encode data itself into Python bytestrings on the way\nin and coerce from bytes on the way back,\nusing the value of the create_engine() encoding parameter, which\ndefaults to utf-8.\nSQLAlchemy’s own unicode encode/decode functionality is steadily becoming\nobsolete as most DBAPIs now support unicode fully."},{"id":"text-556","heading":"Text","content":"Bound Parameter Styles\nThe default parameter style for the psycopg2 dialect is “pyformat”, where\nSQL is rendered using %(paramname)s style. This format has the limitation\nthat it does not accommodate the unusual case of parameter names that\nactually contain percent or parenthesis symbols; as SQLAlchemy in many cases\ngenerates bound parameter names based on the name of a column, the presence\nof these characters in a column name can lead to problems.\nThere are two solutions to the issue of a schema.Column that contains\none of these characters in its name. One is to specify the\nschema.Column.key for columns that have such names:"},{"id":"text-557","heading":"Text","content":"measurement = Table('measurement', metadata,\n Column('Size (meters)', Integer, clé='size_meters')\n)"},{"id":"text-558","heading":"Text","content":"Above, an INSERT statement such as measurement.insert() will use\nsize_meters as the parameter name, and a SQL expression such as\nmeasurement.c.size_meters > dix will derive the bound parameter name\nfrom the size_meters key as well."},{"id":"text-559","heading":"Text","content":"Changed in version 1.0.0: – SQL expressions will use Column.key\nas the source of naming when anonymous bound parameters are created\nin SQL expressions; previously, this behavior only applied to\nTable.insert() et Table.update() parameter names."},{"id":"text-560","heading":"Text","content":"The other solution is to use a positional format; psycopg2 allows use of the\n“format” paramstyle, which can be passed to\ncreate_engine.paramstyle:"},{"id":"text-561","heading":"Text","content":"engine = create_engine(\n 'postgresql://scott:tiger@localhost:5432/test', paramstyle='format')"},{"id":"text-562","heading":"Text","content":"With the above engine, instead of a statement like:"},{"id":"text-563","heading":"Text","content":"INSERT INTO measurement ("Size (meters)") VALUES (%(Taille (meters))s)\n'Size (meters)': 1"},{"id":"text-564","heading":"Text","content":"we instead see:"},{"id":"text-565","heading":"Text","content":"INSERT INTO measurement ("Size (meters)") VALUES (%s)\n(1, )"},{"id":"text-566","heading":"Text","content":"Where above, the dictionary style is converted into a tuple with positional\nstyle."},{"id":"text-567","heading":"Text","content":"Transactions\nThe psycopg2 dialect fully supports SAVEPOINT and two-phase commit operations."},{"id":"text-568","heading":"Text","content":"Psycopg2 Transaction Isolation Level\nAs discussed in Transaction Isolation Level,\nall PostgreSQL dialects support setting of transaction isolation level\nboth via the isolation_level parameter passed to create_engine(),\nas well as the isolation_level argument used by\nConnection.execution_options(). When using the psycopg2 dialect, these\noptions make use of psycopg2’s set_isolation_level() connection method,\nrather than emitting a PostgreSQL directive; this is because psycopg2’s\nAPI-level setting is always emitted at the start of each transaction in any\nCas.\nThe psycopg2 dialect supports these constants for isolation level:"},{"id":"text-569","heading":"Text","content":"READ COMMITTED"},{"id":"text-570","heading":"Text","content":"READ UNCOMMITTED"},{"id":"text-571","heading":"Text","content":"REPEATABLE READ"},{"id":"text-572","heading":"Text","content":"SERIALIZABLE"},{"id":"text-573","heading":"Text","content":"AUTOCOMMIT"},{"id":"text-574","heading":"Text","content":"NOTICE logging\nThe psycopg2 dialect will log PostgreSQL NOTICE messages\nvia the sqlalchemy.dialects.postgresql logger. When this logger\nis set to the logging.INFO level, notice messages will be logged:"},{"id":"text-575","heading":"Text","content":"importation logging"},{"id":"text-576","heading":"Text","content":"logging.getLogger('sqlalchemy.dialects.postgresql').setLevel(logging.INFO)"},{"id":"text-577","heading":"Text","content":"Above, it is assumed that logging is configured externally. If this is not\nthe case, configuration such as logging.basicConfig() must be utilized:"},{"id":"text-578","heading":"Text","content":"importation logging"},{"id":"text-579","heading":"Text","content":"logging.basicConfig() # log messages to stdout\nlogging.getLogger('sqlalchemy.dialects.postgresql').setLevel(logging.INFO)"},{"id":"text-580","heading":"Text","content":"HSTORE type\nle psycopg2 DBAPI includes an extension to natively handle marshalling of\nthe HSTORE type. The SQLAlchemy psycopg2 dialect will enable this extension\nby default when psycopg2 version 2.4 or greater is used, and\nit is detected that the target database has the HSTORE type set up for use.\nIn other words, when the dialect makes the first\nconnection, a sequence like the following is performed:"},{"id":"text-581","heading":"Text","content":"Request the available HSTORE oids using\npsycopg2.extras.HstoreAdapter.get_oids().\nIf this function returns a list of HSTORE identifiers, we then determine\nque le HSTORE extension is present.\nThis function is skipped if the version of psycopg2 installed is\nless than version 2.4."},{"id":"text-582","heading":"Text","content":"If the use_native_hstore flag is at its default of True, et\nwe’ve detected that HSTORE oids are available, the\npsycopg2.extensions.register_hstore() extension is invoked for all\nles liaisons."},{"id":"text-583","heading":"Text","content":"le register_hstore() extension has the effect of all Python\ndictionaries being accepted as parameters regardless of the type of target\ncolumn in SQL. The dictionaries are converted by this extension into a\ntextual HSTORE expression. If this behavior is not desired, disable the\nuse of the hstore extension by setting use_native_hstore à Faux comme\nfollows:"},{"id":"text-584","heading":"Text","content":"engine = create_engine("postgresql+psycopg2://scott:tiger@localhost/test",\n use_native_hstore=Faux)"},{"id":"text-585","heading":"Text","content":"le HSTORE type is still supported when the\npsycopg2.extensions.register_hstore() extension is not used. It merely\nmeans that the coercion between Python dictionaries and the HSTORE\nstring format, on both the parameter side and the result side, will take\nplace within SQLAlchemy’s own marshalling logic, and not that of psycopg2\nwhich may be more performant."},{"id":"text-586","heading":"Text","content":"pg8000\nSupport for the PostgreSQL database via the pg8000 driver."},{"id":"text-587","heading":"Text","content":"DBAPI\nDocumentation and download information (if applicable) for pg8000 is available at:\nhttps://pythonhosted.org/pg8000/"},{"id":"text-588","heading":"Text","content":"Connecting\nConnect String:"},{"id":"text-589","heading":"Text","content":"postgresql+pg8000://user:password@host:port/dbname[?key=value&key=value...]"},{"id":"text-590","heading":"Text","content":"Remarque\nThe pg8000 dialect is not tested as part of SQLAlchemy’s continuous\nintegration and may have unresolved issues. The recommended PostgreSQL\ndialect is psycopg2."},{"id":"text-591","heading":"Text","content":"Unicode\npg8000 will encode / decode string values between it and the server using the\nPostgreSQL client_encoding parameter; by default this is the value in\nle postgresql.conf file, which often defaults to SQL_ASCII.\nTypically, this can be changed to utf-8, as a more useful default:"},{"id":"text-592","heading":"Text","content":"#client_encoding = sql_ascii # actually, defaults to database\n # encoding\nclient_encoding = utf8"},{"id":"text-593","heading":"Text","content":"le client_encoding can be overridden for a session by executing the SQL:\nSET CLIENT_ENCODING TO ‘utf8’;\nSQLAlchemy will execute this SQL on all new connections based on the value\npassed to create_engine() using the client_encoding parameter:"},{"id":"text-594","heading":"Text","content":"engine = create_engine(\n "postgresql+pg8000://user:pass@host/dbname", client_encoding='utf8')"},{"id":"text-595","heading":"Text","content":"pg8000 Transaction Isolation Level\nThe pg8000 dialect offers the same isolation level settings as that\nof the psycopg2 dialect:"},{"id":"text-596","heading":"Text","content":"READ COMMITTED"},{"id":"text-597","heading":"Text","content":"READ UNCOMMITTED"},{"id":"text-598","heading":"Text","content":"REPEATABLE READ"},{"id":"text-599","heading":"Text","content":"SERIALIZABLE"},{"id":"text-600","heading":"Text","content":"AUTOCOMMIT"},{"id":"text-601","heading":"Text","content":"New in version 0.9.5: support for AUTOCOMMIT isolation level when using\npg8000."},{"id":"text-602","heading":"Text","content":"psycopg2cffi\nSupport for the PostgreSQL database via the psycopg2cffi driver."},{"id":"text-603","heading":"Text","content":"DBAPI\nDocumentation and download information (if applicable) for psycopg2cffi is available at:\nhttp://pypi.python.org/pypi/psycopg2cffi/"},{"id":"text-604","heading":"Text","content":"Connecting\nConnect String:"},{"id":"text-605","heading":"Text","content":"postgresql+psycopg2cffi://user:password@host:port/dbname[?key=value&key=value...]"},{"id":"text-606","heading":"Text","content":"psycopg2cffi is an adaptation of psycopg2, using CFFI for the C\ncouche. This makes it suitable for use in e.g. PyPy. Documentation\nis as per psycopg2."},{"id":"text-607","heading":"Text","content":"py-postgresql\nSupport for the PostgreSQL database via the py-postgresql driver."},{"id":"text-608","heading":"Text","content":"DBAPI\nDocumentation and download information (if applicable) for py-postgresql is available at:\nhttp://python.projects.pgfoundry.org/"},{"id":"text-609","heading":"Text","content":"Connecting\nConnect String:"},{"id":"text-610","heading":"Text","content":"postgresql+pypostgresql://user:password@host:port/dbname[?key=value&key=value...]"},{"id":"text-611","heading":"Text","content":"Remarque\nThe pypostgresql dialect is not tested as part of SQLAlchemy’s continuous\nintegration and may have unresolved issues. The recommended PostgreSQL\ndriver is psycopg2."},{"id":"text-612","heading":"Text","content":"pygresql\nSupport for the PostgreSQL database via the pygresql driver."},{"id":"text-613","heading":"Text","content":"DBAPI\nDocumentation and download information (if applicable) for pygresql is available at:\nhttp://www.pygresql.org/"},{"id":"text-614","heading":"Text","content":"Connecting\nConnect String:"},{"id":"text-615","heading":"Text","content":"postgresql+pygresql://user:password@host:port/dbname[?key=value&key=value...]"},{"id":"text-616","heading":"Text","content":"Remarque\nThe pygresql dialect is not tested as part of SQLAlchemy’s continuous\nintegration and may have unresolved issues. The recommended PostgreSQL\ndialect is psycopg2."},{"id":"text-617","heading":"Text","content":"zxjdbc\nSupport for the PostgreSQL database via the zxJDBC for Jython driver."},{"id":"text-618","heading":"Text","content":"DBAPI\nDrivers for this database are available at:\nhttp://jdbc.postgresql.org/"},{"id":"text-619","heading":"Text","content":"Connecting\nConnect String:"},{"id":"text-620","heading":"Text","content":"postgresql+zxjdbc://scott:tiger@localhost/db"},{"id":"text-621","heading":"Text","content":"Click to rate this post!\n \n [Total: 0 Average: 0]"}],"media":{"primary_image":""},"relations":[{"rel":"canonical","href":"https://tutos-gameserver.fr/2019/10/21/postgresql-documentation-sqlalchemy-1-3-bien-choisir-son-serveur-d-impression/"},{"rel":"alternate","href":"https://tutos-gameserver.fr/2019/10/21/postgresql-documentation-sqlalchemy-1-3-bien-choisir-son-serveur-d-impression/llm","type":"text/html"},{"rel":"alternate","href":"https://tutos-gameserver.fr/2019/10/21/postgresql-documentation-sqlalchemy-1-3-bien-choisir-son-serveur-d-impression/llm.json","type":"application/json"},{"rel":"llm-manifest","href":"https://tutos-gameserver.fr/llm-endpoints-manifest.json","type":"application/json"}],"http_headers":{"X-LLM-Friendly":"1","X-LLM-Schema":"1.1.0","Content-Security-Policy":"default-src 'none'; img-src * data:; style-src 'unsafe-inline'"},"license":"CC BY-ND 4.0","attribution_required":true,"allow_cors":false}