# Copyright (C) 2001-2018, Python Software Foundation # For licence information, see README file. # msgid "" msgstr "" "Project-Id-Version: Python 3\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-02-12 21:25+0100\n" "PO-Revision-Date: 2023-03-20 09:40+0100\n" "Last-Translator: Julien Palard \n" "Language-Team: FRENCH \n" "Language: fr\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "X-Generator: Poedit 3.2.2\n" #: library/sqlite3.rst:2 msgid ":mod:`sqlite3` --- DB-API 2.0 interface for SQLite databases" msgstr ":mod:`sqlite3` — Interface DB-API 2.0 pour bases de données SQLite" #: library/sqlite3.rst:9 msgid "**Source code:** :source:`Lib/sqlite3/`" msgstr "**Code source :** :source:`Lib/sqlite3/`" #: library/sqlite3.rst:23 msgid "" "SQLite is a C library that provides a lightweight disk-based database that " "doesn't require a separate server process and allows accessing the database " "using a nonstandard variant of the SQL query language. Some applications can " "use SQLite for internal data storage. It's also possible to prototype an " "application using SQLite and then port the code to a larger database such as " "PostgreSQL or Oracle." msgstr "" "SQLite est une bibliothèque C qui fournit une base de données légère sur " "disque ne nécessitant pas de processus serveur et qui utilise une variante " "(non standard) du langage de requête SQL pour accéder aux données. Certaines " "applications peuvent utiliser SQLite pour le stockage de données internes. " "Il est également possible de créer une application prototype utilisant " "SQLite, puis de modifier le code pour utiliser une base de données plus " "robuste telle que PostgreSQL ou Oracle." #: library/sqlite3.rst:30 #, fuzzy msgid "" "The :mod:`!sqlite3` module was written by Gerhard Häring. It provides an " "SQL interface compliant with the DB-API 2.0 specification described by :pep:" "`249`, and requires SQLite 3.7.15 or newer." msgstr "" "Le module *sqlite3* a été écrit par Gerhard Häring. Il fournit une " "interface SQL conforme à la spécification DB-API 2.0 décrite par :pep:`249`." #: library/sqlite3.rst:34 msgid "This document includes four main sections:" msgstr "Ce document inclus 4 sections principales :" #: library/sqlite3.rst:36 msgid ":ref:`sqlite3-tutorial` teaches how to use the :mod:`!sqlite3` module." msgstr "" ":ref:`tutoriel sqlite3 ` explique comment utiliser le " "module :mod:`!sqlite3`." #: library/sqlite3.rst:37 msgid "" ":ref:`sqlite3-reference` describes the classes and functions this module " "defines." msgstr "" ":ref:`référence sqlite3 ` décrit les classes et les " "fonctions que ce module définit." #: library/sqlite3.rst:39 msgid ":ref:`sqlite3-howtos` details how to handle specific tasks." msgstr "" ":ref:`guide sqlite3 ` détaille comment gérer des tâches " "spécifiques." #: library/sqlite3.rst:40 msgid "" ":ref:`sqlite3-explanation` provides in-depth background on transaction " "control." msgstr "" ":ref:`explications sqlite3 ` propose un contexte " "détaillé du contrôle de transaction." #: library/sqlite3.rst:47 msgid "https://www.sqlite.org" msgstr "https://www.sqlite.org" #: library/sqlite3.rst:46 msgid "" "The SQLite web page; the documentation describes the syntax and the " "available data types for the supported SQL dialect." msgstr "" "Dans la page Web de SQLite, la documentation décrit la syntaxe et les types " "de données disponibles qui sont pris en charge par cette variante SQL." #: library/sqlite3.rst:50 msgid "https://www.w3schools.com/sql/" msgstr "https://www.w3schools.com/sql/" #: library/sqlite3.rst:50 msgid "Tutorial, reference and examples for learning SQL syntax." msgstr "Tutoriel, référence et exemples pour apprendre la syntaxe SQL." #: library/sqlite3.rst:52 msgid ":pep:`249` - Database API Specification 2.0" msgstr ":pep:`249` — Spécifications de l'API 2.0 pour la base de données" #: library/sqlite3.rst:53 msgid "PEP written by Marc-André Lemburg." msgstr "PEP écrite par Marc-André Lemburg." #: library/sqlite3.rst:66 msgid "Tutorial" msgstr "Tutoriel" #: library/sqlite3.rst:68 msgid "" "In this tutorial, you will create a database of Monty Python movies using " "basic :mod:`!sqlite3` functionality. It assumes a fundamental understanding " "of database concepts, including `cursors`_ and `transactions`_." msgstr "" "Dans ce tutoriel, vous allez créer une base de données des films des Monty " "Python en utilisant les fonctionnalités de base de :mod:`!sqlite3`. Cela " "nécessite une compréhension élémentaire des concepts des bases de données, " "notamment les `curseurs`_ et les `transactions`_." #: library/sqlite3.rst:73 msgid "" "First, we need to create a new database and open a database connection to " "allow :mod:`!sqlite3` to work with it. Call :func:`sqlite3.connect` to to " "create a connection to the database :file:`tutorial.db` in the current " "working directory, implicitly creating it if it does not exist:" msgstr "" "Tout d’abord, nous devons créer une nouvelle base de données et ouvrir une " "connexion à la base de données pour permettre à :mod:`!sqlite3` de " "travailler avec elle. Appelez :func:`sqlite3.connect` pour créer une " "connexion à la base de données :file:`tutorial.db` dans le répertoire de " "travail actuel, en la créant implicitement si elle n’existe pas :" #: library/sqlite3.rst:84 msgid "" "The returned :class:`Connection` object ``con`` represents the connection to " "the on-disk database." msgstr "" "L’objet :class:`Connection` renvoyé — ``con`` — représente la connexion à la " "base de données sur disque." #: library/sqlite3.rst:87 msgid "" "In order to execute SQL statements and fetch results from SQL queries, we " "will need to use a database cursor. Call :meth:`con.cursor() ` to create the :class:`Cursor`:" msgstr "" "Afin d’exécuter les instructions SQL et de récupérer les résultats des " "requêtes SQL, nous devrons utiliser un curseur de base de données. Appelez :" "meth:`con.cursor() ` pour créer la :class:`Cursor` :" #: library/sqlite3.rst:95 msgid "" "Now that we've got a database connection and a cursor, we can create a " "database table ``movie`` with columns for title, release year, and review " "score. For simplicity, we can just use column names in the table declaration " "-- thanks to the `flexible typing`_ feature of SQLite, specifying the data " "types is optional. Execute the ``CREATE TABLE`` statement by calling :meth:" "`cur.execute(...) `:" msgstr "" "Maintenant que nous avons une connexion à la base de données et un curseur, " "nous pouvons créer une table ``movie`` avec des colonnes pour le titre, " "l’année de sortie et la note de la critique. Pour plus de simplicité, nous " "pouvons simplement utiliser les noms des colonnes dans la déclaration de la " "table — grâce à la fonctionnalité de `typage flexible `_ " "de SQLite, spécifier les types de données est facultatif. Exécutez " "l’instruction ``CREATE TABLE`` en appelant :meth:`cur.execute(…) ` :" #: library/sqlite3.rst:111 msgid "" "We can verify that the new table has been created by querying the " "``sqlite_master`` table built-in to SQLite, which should now contain an " "entry for the ``movie`` table definition (see `The Schema Table`_ for " "details). Execute that query by calling :meth:`cur.execute(...) `, assign the result to ``res``, and call :meth:`res.fetchone() " "` to fetch the resulting row:" msgstr "" "Nous pouvons vérifier que la nouvelle table a été créée en interrogeant la " "table ``sqlite_master`` intégrée à SQLite, qui devrait maintenant contenir " "une entrée pour la définition de la table ``movie`` (voir `le schéma Table " "`_ pour plus de détails). Exécutez cette requête en " "appelant :meth:`cur.execute(…) `, affectez le résultat à " "``res``, et appelez :meth:`res.fetchone() ` pour récupérer " "la ligne résultante :" #: library/sqlite3.rst:125 msgid "" "We can see that the table has been created, as the query returns a :class:" "`tuple` containing the table's name. If we query ``sqlite_master`` for a non-" "existent table ``spam``, :meth:`!res.fetchone()` will return ``None``:" msgstr "" "Nous pouvons voir que la table a été créée, puisque la requête retourne un :" "class:`tuple` contenant le nom de la table. Si nous interrogeons " "``sqlite_master`` pour une table ``spam`` inexistante, :meth:`!res." "fetchone()`` retournera ``None`` :" #: library/sqlite3.rst:136 msgid "" "Now, add two rows of data supplied as SQL literals by executing an " "``INSERT`` statement, once again by calling :meth:`cur.execute(...) `:" msgstr "" "Maintenant, ajoutez deux lignes de données en tant que littéraux SQL en " "exécutant une instruction ``INSERT``, une fois encore en appelant :meth:`cur." "execute(…) ` :" #: library/sqlite3.rst:148 msgid "" "The ``INSERT`` statement implicitly opens a transaction, which needs to be " "committed before changes are saved in the database (see :ref:`sqlite3-" "controlling-transactions` for details). Call :meth:`con.commit() ` on the connection object to commit the transaction:" msgstr "" "L’instruction ``INSERT`` ouvre implicitement une transaction, qui doit être " "validée avant que les modifications ne soient enregistrées dans la base de " "données (voir :ref:`contrôle des transactions SQL ` pour plus de détails). Appelez :meth:`con.commit() " "` sur l’objet de connexion pour valider la transaction :" #: library/sqlite3.rst:158 msgid "" "We can verify that the data was inserted correctly by executing a ``SELECT`` " "query. Use the now-familiar :meth:`cur.execute(...) ` to " "assign the result to ``res``, and call :meth:`res.fetchall() ` to return all resulting rows:" msgstr "" "Nous pouvons vérifier que les données ont été insérées correctement en " "exécutant une requête ``SELECT``. Utilisez la désormais familière :meth:`cur." "execute(…) ` pour affecter le résultat à ``res``, et " "appelez :meth:`res.fetchall() ` pour retourner toutes les " "lignes résultantes :" #: library/sqlite3.rst:170 msgid "" "The result is a :class:`list` of two :class:`!tuple`\\s, one per row, each " "containing that row's ``score`` value." msgstr "" "Le résultat est une :class:`liste ` de deux :class:`!tuple`\\s, une " "par ligne, chacun contenant la valeur ``score`` de cette ligne." #: library/sqlite3.rst:173 msgid "" "Now, insert three more rows by calling :meth:`cur.executemany(...) `:" msgstr "" "Maintenant, insérez trois lignes supplémentaires en appelant :meth:`cur." "executemany(…) ` :" #: library/sqlite3.rst:186 msgid "" "Notice that ``?`` placeholders are used to bind ``data`` to the query. " "Always use placeholders instead of :ref:`string formatting ` " "to bind Python values to SQL statements, to avoid `SQL injection attacks`_ " "(see :ref:`sqlite3-placeholders` for more details)." msgstr "" "Remarquez que les marqueurs ``?`` sont utilisés pour lier les ``data`` à la " "requête. Utilisez toujours les marqueurs au lieu d’:ref:`expressions " "formatées ` pour lier les valeurs Python aux instructions " "SQL, afin d’éviter les `injections SQL`_ (voir :ref:`placeholder SQL " "` pour plus de détails)." #: library/sqlite3.rst:192 msgid "" "We can verify that the new rows were inserted by executing a ``SELECT`` " "query, this time iterating over the results of the query:" msgstr "" "Nous pouvons vérifier que les nouvelles lignes ont été insérées en exécutant " "une requête ``SELECT``, cette fois-ci en itérant sur les résultats de la " "requête :" #: library/sqlite3.rst:206 msgid "" "Each row is a two-item :class:`tuple` of ``(year, title)``, matching the " "columns selected in the query." msgstr "" "Chaque ligne est un :class:`tuple` de deux éléments ``(année, titre)``, " "correspondant aux colonnes sélectionnées dans la requête." #: library/sqlite3.rst:209 msgid "" "Finally, verify that the database has been written to disk by calling :meth:" "`con.close() ` to close the existing connection, opening a " "new one, creating a new cursor, then querying the database:" msgstr "" "Enfin, vérifiez que la base de données a été écrite sur le disque en " "appelant :meth:`con.close() ` pour fermer la connexion " "existante, en ouvrir une nouvelle, créer un nouveau curseur, puis interroger " "la base de données :" #: library/sqlite3.rst:224 msgid "" "You've now created an SQLite database using the :mod:`!sqlite3` module, " "inserted data and retrieved values from it in multiple ways." msgstr "" "Vous avez maintenant créé une base de données SQLite à l’aide du module :mod:" "`!sqlite3`, inséré des données et récupéré des valeurs de plusieurs façons." #: library/sqlite3.rst:236 msgid ":ref:`sqlite3-howtos` for further reading:" msgstr ":ref:`guide sqlite3 ` pour une lecture plus poussée:" #: library/sqlite3.rst:238 msgid ":ref:`sqlite3-placeholders`" msgstr ":ref:`placeholders sqlite3 `" #: library/sqlite3.rst:239 msgid ":ref:`sqlite3-adapters`" msgstr ":ref:`adaptateurs sqlite3 `" #: library/sqlite3.rst:240 msgid ":ref:`sqlite3-converters`" msgstr ":ref:`convertisseurs sqlite3 `" #: library/sqlite3.rst:557 msgid ":ref:`sqlite3-connection-context-manager`" msgstr "" ":ref:`gestionnaire de contexte de connexion sqlite3 `" #: library/sqlite3.rst:242 msgid ":ref:`sqlite3-howto-row-factory`" msgstr ":ref:`guide de fabrique de ligne sqlite3 `" #: library/sqlite3.rst:244 msgid "" ":ref:`sqlite3-explanation` for in-depth background on transaction control." msgstr "" ":ref:`explications sqlite3 ` pour un contexte détaillé " "du contrôle de transaction." #: library/sqlite3.rst:249 msgid "Reference" msgstr "Références" #: library/sqlite3.rst:257 msgid "Module functions" msgstr "Fonctions du module" #: library/sqlite3.rst:264 msgid "Open a connection to an SQLite database." msgstr "Ouvrez une connexion à une base de données SQLite." #: library/sqlite3.rst:0 msgid "Parameters" msgstr "Paramètres" #: library/sqlite3.rst:266 msgid "" "The path to the database file to be opened. Pass ``\":memory:\"`` to open a " "connection to a database that is in RAM instead of on disk." msgstr "" "Le chemin d’accès au fichier de la base de données à ouvrir. Passez ``\":" "memory:\"`` pour ouvrir une connexion à une base de données qui est dans la " "RAM plutôt que sur le disque." #: library/sqlite3.rst:272 msgid "" "How many seconds the connection should wait before raising an exception, if " "the database is locked by another connection. If another connection opens a " "transaction to modify the database, it will be locked until that transaction " "is committed. Default five seconds." msgstr "" "Le temps (en secondes) que la connexion doit attendre avant de lever une " "exception, si la base de données est verrouillée par une autre connexion. Si " "une autre connexion ouvre une transaction pour modifier la base de données, " "celle-ci sera verrouillée jusqu’à ce que cette transaction soit validée. Par " "défaut, cinq secondes." #: library/sqlite3.rst:279 msgid "" "Control whether and how data types not :ref:`natively supported by SQLite " "` are looked up to be converted to Python types, using the " "converters registered with :func:`register_converter`. Set it to any " "combination (using ``|``, bitwise or) of :const:`PARSE_DECLTYPES` and :const:" "`PARSE_COLNAMES` to enable this. Column names takes precedence over declared " "types if both flags are set. Types cannot be detected for generated fields " "(for example ``max(data)``), even when the *detect_types* parameter is set; :" "class:`str` will be returned instead. By default (``0``), type detection is " "disabled." msgstr "" "Contrôle si et comment les types de données non :ref:`nativement pris en " "charge par SQLite ` sont recherchés pour être convertis en " "types Python, en utilisant les convertisseurs enregistrés avec :func:" "`register_converter`. Définissez-le à n’importe quelle combinaison (en " "utilisant ``|``, opérateurs bit-à-bit OR) de :const:`PARSE_DECLTYPES` et :" "const:`PARSE_COLNAMES` pour activer ceci. Les noms de colonnes ont la " "priorité sur les types déclarés si les deux drapeaux sont activés. Les types " "ne peuvent pas être détectés pour les champs générés (par exemple " "``max(data)``), même si le paramètre *detect_types* est activé ; :class:" "`str` sera retourné à la place. Par défaut (``0``), la détection des types " "est désactivée." #: library/sqlite3.rst:293 msgid "" "The :attr:`~Connection.isolation_level` of the connection, controlling " "whether and how transactions are implicitly opened. Can be ``\"DEFERRED\"`` " "(default), ``\"EXCLUSIVE\"`` or ``\"IMMEDIATE\"``; or ``None`` to disable " "opening transactions implicitly. See :ref:`sqlite3-controlling-transactions` " "for more." msgstr "" "L’attribut :attr:`~Connection.isolation_level` de la connexion, contrôlant " "si et comment les transactions sont ouvertes implicitement. Peut être " "``\"DEFERRED\"`` (par défaut), ``\"EXCLUSIVE\"`` ou ``\"IMMEDIATE\"`` ; ou " "``None`` pour désactiver l’ouverture implicite des transactions. Voir :ref:" "`contrôle des transactions sqlite3 ` pour " "en savoir plus." #: library/sqlite3.rst:301 msgid "" "If ``True`` (default), :exc:`ProgrammingError` will be raised if the " "database connection is used by a thread other than the one that created it. " "If ``False``, the connection may be accessed in multiple threads; write " "operations may need to be serialized by the user to avoid data corruption. " "See :attr:`threadsafety` for more information." msgstr "" "Si ``True`` (par défaut), :exc:`ProgrammingError` sera levée si la connexion " "à la base de données est utilisée par un thread autre que celui qui l’a " "créée. Si ``False``, la connexion peut être utilisée par plusieurs threads ; " "les opérations d’écriture devront peut-être être sérialisées par " "l’utilisateur pour éviter la corruption des données. Voir :attr:`sécurité " "des threads ` pour plus d’informations." #: library/sqlite3.rst:310 msgid "" "A custom subclass of :class:`Connection` to create the connection with, if " "not the default :class:`Connection` class." msgstr "" "Une sous-classe personnalisée de :class:`Connection` pour créer la " "connexion, si ce n’est pas la classe par défaut :class:`Connection`." #: library/sqlite3.rst:314 msgid "" "The number of statements that :mod:`!sqlite3` should internally cache for " "this connection, to avoid parsing overhead. By default, 128 statements." msgstr "" "Le nombre d’instructions que :mod:`!sqlite3` doit mettre en cache en interne " "pour cette connexion, afin d’éviter les surcharges d’analyse. Par défaut, " "128 instructions." #: library/sqlite3.rst:319 msgid "" "If set to ``True``, *database* is interpreted as a :abbr:`URI (Uniform " "Resource Identifier)` with a file path and an optional query string. The " "scheme part *must* be ``\"file:\"``, and the path can be relative or " "absolute. The query string allows passing parameters to SQLite, enabling " "various :ref:`sqlite3-uri-tricks`." msgstr "" "Si elle a pour valeur ``True``, la base de données est interprétée comme un :" "abbr:`URI (Uniform Resource Identifier)` avec un chemin d’accès au fichier " "et une chaîne de requête facultative. La partie schéma *doit* être ``\"file:" "\"``, et le chemin peut être relatif ou absolu. La chaîne d’interrogation " "permet de passer des paramètres à SQLite, ce qui permet d’activer diverses :" "ref:`astuces d’URI sqlite3 `." #: library/sqlite3.rst:0 #, fuzzy msgid "Return type" msgstr "Type Python" #: library/sqlite3.rst:67 msgid "" "Raises an :ref:`auditing event ` ``sqlite3.connect`` with argument " "``database``." msgstr "" #: library/sqlite3.rst:68 msgid "" "Raises an :ref:`auditing event ` ``sqlite3.connect/handle`` with " "argument ``connection_handle``." msgstr "" #: library/sqlite3.rst:333 msgid "The *uri* parameter." msgstr "" #: library/sqlite3.rst:336 msgid "" "*database* can now also be a :term:`path-like object`, not only a string." msgstr "" "*database* peut maintenant aussi être un :term:`objet de type chemin `, et pas seulement une chaîne de caractères." #: library/sqlite3.rst:339 msgid "The ``sqlite3.connect/handle`` auditing event." msgstr "" #: library/sqlite3.rst:344 msgid "" "Return ``True`` if the string *statement* appears to contain one or more " "complete SQL statements. No syntactic verification or parsing of any kind is " "performed, other than checking that there are no unclosed string literals " "and the statement is terminated by a semicolon." msgstr "" "Renvoie ``True`` si la déclaration de la chaîne semble contenir une ou " "plusieurs déclarations SQL complètes. Aucune vérification syntaxique ou " "analyse syntaxique d’aucune sorte n’est effectuée, si ce n’est la " "vérification qu’il n’y a pas de chaîne littérale non fermée et que " "l’instruction se termine par un point-virgule." #: library/sqlite3.rst:350 msgid "For example:" msgstr "Exemple :" #: library/sqlite3.rst:359 msgid "" "This function may be useful during command-line input to determine if the " "entered text seems to form a complete SQL statement, or if additional input " "is needed before calling :meth:`~Cursor.execute`." msgstr "" "Cette fonction peut être utile pendant la saisie en ligne de commande pour " "déterminer si le texte saisi semble former une instruction SQL complète, ou " "si une saisie supplémentaire est nécessaire avant d’appeler :meth:`~Cursor." "execute`." #: library/sqlite3.rst:365 msgid "" "Enable or disable callback tracebacks. By default you will not get any " "tracebacks in user-defined functions, aggregates, converters, authorizer " "callbacks etc. If you want to debug them, you can call this function with " "*flag* set to ``True``. Afterwards, you will get tracebacks from callbacks " "on :data:`sys.stderr`. Use ``False`` to disable the feature again." msgstr "" "Activer ou désactiver les traces des fonctions de rappel. Par défaut, vous " "n’obtiendrez pas de traces de pile d’appels dans les fonctions définies par " "l’utilisateur, les agrégats, les convertisseurs, les fonctions de rappel des " "mécanismes d’autorisation, etc. Si vous voulez les déboguer, vous pouvez " "appeler cette fonction avec *flag* à ``True``. Ensuite, vous obtiendrez les " "traces des fonctions de rappel sur :data:`sys.stderr`. Utilisez ``False`` " "pour désactiver à nouveau cette fonctionnalité." #: library/sqlite3.rst:372 msgid "" "Register an :func:`unraisable hook handler ` for an " "improved debug experience:" msgstr "" "Enregistrez un :func:`gestionnaire de point d’entrée *non levable* ` (*unraisable* en anglais) pour une expérience de débogage " "améliorée :" #: library/sqlite3.rst:397 msgid "" "Register an *adapter* callable to adapt the Python type *type* into an " "SQLite type. The adapter is called with a Python object of type *type* as " "its sole argument, and must return a value of a :ref:`type that SQLite " "natively understands `." msgstr "" "Enregistre un *adaptateur* appelable pour adapter le type Python *type* en " "un type SQLite. L’adaptateur est appelé avec un objet Python de type *type* " "comme unique argument, et doit retourner une valeur d’un :ref:`type que " "SQLite comprend nativement `." #: library/sqlite3.rst:405 msgid "" "Register the *converter* callable to convert SQLite objects of type " "*typename* into a Python object of a specific type. The converter is invoked " "for all SQLite values of type *typename*; it is passed a :class:`bytes` " "object and should return an object of the desired Python type. Consult the " "parameter *detect_types* of :func:`connect` for information regarding how " "type detection works." msgstr "" "Enregistre le *convertisseur* appelable pour convertir les objets SQLite de " "type *typename* en un objet Python d’un type spécifique. Le convertisseur " "est invoqué pour toutes les valeurs SQLite de type *typename* ; on lui passe " "un objet :class:`bytes` et il doit retourner un objet du type Python désiré. " "Consultez le paramètre *detect_types* de :func:`connect` pour des " "informations sur le fonctionnement de la détection des types." #: library/sqlite3.rst:413 msgid "" "Note: *typename* and the name of the type in your query are matched case-" "insensitively." msgstr "" "Remarque : *typename* et le nom du type dans votre requête sont comparés " "sans tenir compte de la casse." #: library/sqlite3.rst:420 msgid "Module constants" msgstr "Fonctions et constantes du module" #: library/sqlite3.rst:424 msgid "" "Pass this flag value to the *detect_types* parameter of :func:`connect` to " "look up a converter function by using the type name, parsed from the query " "column name, as the converter dictionary key. The type name must be wrapped " "in square brackets (``[]``)." msgstr "" #: library/sqlite3.rst:434 msgid "" "This flag may be combined with :const:`PARSE_DECLTYPES` using the ``|`` " "(bitwise or) operator." msgstr "" #: library/sqlite3.rst:439 msgid "" "Pass this flag value to the *detect_types* parameter of :func:`connect` to " "look up a converter function using the declared types for each column. The " "types are declared when the database table is created. :mod:`!sqlite3` will " "look up a converter function using the first word of the declared type as " "the converter dictionary key. For example:" msgstr "" #: library/sqlite3.rst:455 msgid "" "This flag may be combined with :const:`PARSE_COLNAMES` using the ``|`` " "(bitwise or) operator." msgstr "" #: library/sqlite3.rst:462 msgid "" "Flags that should be returned by the *authorizer_callback* callable passed " "to :meth:`Connection.set_authorizer`, to indicate whether:" msgstr "" #: library/sqlite3.rst:465 msgid "Access is allowed (:const:`!SQLITE_OK`)," msgstr "" #: library/sqlite3.rst:466 msgid "" "The SQL statement should be aborted with an error (:const:`!SQLITE_DENY`)" msgstr "" #: library/sqlite3.rst:467 msgid "" "The column should be treated as a ``NULL`` value (:const:`!SQLITE_IGNORE`)" msgstr "" #: library/sqlite3.rst:471 msgid "" "String constant stating the supported DB-API level. Required by the DB-API. " "Hard-coded to ``\"2.0\"``." msgstr "" #: library/sqlite3.rst:476 msgid "" "String constant stating the type of parameter marker formatting expected by " "the :mod:`!sqlite3` module. Required by the DB-API. Hard-coded to " "``\"qmark\"``." msgstr "" #: library/sqlite3.rst:482 msgid "The ``named`` DB-API parameter style is also supported." msgstr "" #: library/sqlite3.rst:486 #, fuzzy msgid "" "Version number of the runtime SQLite library as a :class:`string `." msgstr "" "Le numéro de version de la bibliothèque d'exécution SQLite, sous forme de " "chaîne." #: library/sqlite3.rst:490 #, fuzzy msgid "" "Version number of the runtime SQLite library as a :class:`tuple` of :class:" "`integers `." msgstr "" "Le numéro de version de la bibliothèque d'exécution SQLite, sous forme " "d'entier." #: library/sqlite3.rst:495 msgid "" "Integer constant required by the DB-API 2.0, stating the level of thread " "safety the :mod:`!sqlite3` module supports. This attribute is set based on " "the default `threading mode `_ the " "underlying SQLite library is compiled with. The SQLite threading modes are:" msgstr "" #: library/sqlite3.rst:500 msgid "" "**Single-thread**: In this mode, all mutexes are disabled and SQLite is " "unsafe to use in more than a single thread at once." msgstr "" #: library/sqlite3.rst:502 msgid "" "**Multi-thread**: In this mode, SQLite can be safely used by multiple " "threads provided that no single database connection is used simultaneously " "in two or more threads." msgstr "" #: library/sqlite3.rst:505 msgid "" "**Serialized**: In serialized mode, SQLite can be safely used by multiple " "threads with no restriction." msgstr "" #: library/sqlite3.rst:508 msgid "" "The mappings from SQLite threading modes to DB-API 2.0 threadsafety levels " "are as follows:" msgstr "" #: library/sqlite3.rst:512 msgid "SQLite threading mode" msgstr "" #: library/sqlite3.rst:512 msgid "`threadsafety`_" msgstr "" #: library/sqlite3.rst:512 msgid "`SQLITE_THREADSAFE`_" msgstr "" #: library/sqlite3.rst:512 msgid "DB-API 2.0 meaning" msgstr "" #: library/sqlite3.rst:515 msgid "single-thread" msgstr "" #: library/sqlite3.rst:515 msgid "0" msgstr "" #: library/sqlite3.rst:515 msgid "Threads may not share the module" msgstr "" #: library/sqlite3.rst:518 #, fuzzy msgid "multi-thread" msgstr "Fils d'exécution" #: library/sqlite3.rst:521 msgid "1" msgstr "" #: library/sqlite3.rst:518 msgid "2" msgstr "" #: library/sqlite3.rst:518 msgid "Threads may share the module, but not connections" msgstr "" #: library/sqlite3.rst:521 msgid "serialized" msgstr "" #: library/sqlite3.rst:521 msgid "3" msgstr "" #: library/sqlite3.rst:521 msgid "Threads may share the module, connections and cursors" msgstr "" #: library/sqlite3.rst:528 msgid "Set *threadsafety* dynamically instead of hard-coding it to ``1``." msgstr "" #: library/sqlite3.rst:533 #, fuzzy msgid "" "Version number of this module as a :class:`string `. This is not the " "version of the SQLite library." msgstr "" "Le numéro de version de ce module, sous forme de chaîne. Ce n'est pas la " "version de la bibliothèque SQLite." #: library/sqlite3.rst:538 #, fuzzy msgid "" "Version number of this module as a :class:`tuple` of :class:`integers " "`. This is not the version of the SQLite library." msgstr "" "Le numéro de version de ce module, sous forme d'un *n*-uplet d'entiers. Ce " "n'est pas la version de la bibliothèque SQLite." #: library/sqlite3.rst:545 #, fuzzy msgid "Connection objects" msgstr "Objets de connexions" #: library/sqlite3.rst:549 msgid "" "Each open SQLite database is represented by a ``Connection`` object, which " "is created using :func:`sqlite3.connect`. Their main purpose is creating :" "class:`Cursor` objects, and :ref:`sqlite3-controlling-transactions`." msgstr "" #: library/sqlite3.rst:556 msgid ":ref:`sqlite3-connection-shortcuts`" msgstr "" #: library/sqlite3.rst:559 msgid "An SQLite database connection has the following attributes and methods:" msgstr "" #: library/sqlite3.rst:563 msgid "" "Create and return a :class:`Cursor` object. The cursor method accepts a " "single optional parameter *factory*. If supplied, this must be a callable " "returning an instance of :class:`Cursor` or its subclasses." msgstr "" #: library/sqlite3.rst:570 msgid "" "Open a :class:`Blob` handle to an existing :abbr:`BLOB (Binary Large " "OBject)`." msgstr "" #: library/sqlite3.rst:573 msgid "The name of the table where the blob is located." msgstr "" #: library/sqlite3.rst:576 msgid "The name of the column where the blob is located." msgstr "" #: library/sqlite3.rst:579 msgid "The name of the row where the blob is located." msgstr "" #: library/sqlite3.rst:582 msgid "" "Set to ``True`` if the blob should be opened without write permissions. " "Defaults to ``False``." msgstr "" #: library/sqlite3.rst:587 msgid "" "The name of the database where the blob is located. Defaults to ``\"main\"``." msgstr "" #: library/sqlite3.rst:0 msgid "Raises" msgstr "" #: library/sqlite3.rst:591 msgid "When trying to open a blob in a ``WITHOUT ROWID`` table." msgstr "" #: library/sqlite3.rst:598 msgid "" "The blob size cannot be changed using the :class:`Blob` class. Use the SQL " "function ``zeroblob`` to create a blob with a fixed size." msgstr "" #: library/sqlite3.rst:605 msgid "" "Commit any pending transaction to the database. If there is no open " "transaction, this method is a no-op." msgstr "" #: library/sqlite3.rst:610 msgid "" "Roll back to the start of any pending transaction. If there is no open " "transaction, this method is a no-op." msgstr "" #: library/sqlite3.rst:615 msgid "" "Close the database connection. Any pending transaction is not committed " "implicitly; make sure to :meth:`commit` before closing to avoid losing " "pending changes." msgstr "" #: library/sqlite3.rst:622 msgid "" "Create a new :class:`Cursor` object and call :meth:`~Cursor.execute` on it " "with the given *sql* and *parameters*. Return the new cursor object." msgstr "" #: library/sqlite3.rst:628 msgid "" "Create a new :class:`Cursor` object and call :meth:`~Cursor.executemany` on " "it with the given *sql* and *parameters*. Return the new cursor object." msgstr "" #: library/sqlite3.rst:634 msgid "" "Create a new :class:`Cursor` object and call :meth:`~Cursor.executescript` " "on it with the given *sql_script*. Return the new cursor object." msgstr "" #: library/sqlite3.rst:640 msgid "Create or remove a user-defined SQL function." msgstr "" #: library/sqlite3.rst:642 msgid "The name of the SQL function." msgstr "" #: library/sqlite3.rst:645 msgid "" "The number of arguments the SQL function can accept. If ``-1``, it may take " "any number of arguments." msgstr "" #: library/sqlite3.rst:649 msgid "" "A callable that is called when the SQL function is invoked. The callable " "must return :ref:`a type natively supported by SQLite `. Set " "to ``None`` to remove an existing SQL function." msgstr "" #: library/sqlite3.rst:656 msgid "" "If ``True``, the created SQL function is marked as `deterministic `_, which allows SQLite to perform additional " "optimizations." msgstr "" #: library/sqlite3.rst:661 msgid "If *deterministic* is used with SQLite versions older than 3.8.3." msgstr "" #: library/sqlite3.rst:664 msgid "The *deterministic* parameter." msgstr "" #: library/sqlite3.rst:705 library/sqlite3.rst:1019 library/sqlite3.rst:1383 #: library/sqlite3.rst:1404 msgid "Example:" msgstr "Exemple :" #: library/sqlite3.rst:683 msgid "Create or remove a user-defined SQL aggregate function." msgstr "" #: library/sqlite3.rst:685 msgid "The name of the SQL aggregate function." msgstr "" #: library/sqlite3.rst:688 msgid "" "The number of arguments the SQL aggregate function can accept. If ``-1``, it " "may take any number of arguments." msgstr "" #: library/sqlite3.rst:692 msgid "" "A class must implement the following methods: * ``step()``: Add a row to " "the aggregate. * ``finalize()``: Return the final result of the aggregate " "as :ref:`a type natively supported by SQLite `. The number " "of arguments that the ``step()`` method must accept is controlled by " "*n_arg*. Set to ``None`` to remove an existing SQL aggregate function." msgstr "" #: library/sqlite3.rst:693 msgid "A class must implement the following methods:" msgstr "" #: library/sqlite3.rst:695 msgid "``step()``: Add a row to the aggregate." msgstr "" #: library/sqlite3.rst:752 msgid "" "``finalize()``: Return the final result of the aggregate as :ref:`a type " "natively supported by SQLite `." msgstr "" #: library/sqlite3.rst:699 msgid "" "The number of arguments that the ``step()`` method must accept is controlled " "by *n_arg*." msgstr "" #: library/sqlite3.rst:702 msgid "Set to ``None`` to remove an existing SQL aggregate function." msgstr "" #: library/sqlite3.rst:737 msgid "Create or remove a user-defined aggregate window function." msgstr "" #: library/sqlite3.rst:739 msgid "The name of the SQL aggregate window function to create or remove." msgstr "" #: library/sqlite3.rst:742 msgid "" "The number of arguments the SQL aggregate window function can accept. If " "``-1``, it may take any number of arguments." msgstr "" #: library/sqlite3.rst:746 msgid "" "A class that must implement the following methods: * ``step()``: Add a row " "to the current window. * ``value()``: Return the current value of the " "aggregate. * ``inverse()``: Remove a row from the current window. * " "``finalize()``: Return the final result of the aggregate as :ref:`a type " "natively supported by SQLite `. The number of arguments that " "the ``step()`` and ``value()`` methods must accept is controlled by " "*num_params*. Set to ``None`` to remove an existing SQL aggregate window " "function." msgstr "" #: library/sqlite3.rst:747 msgid "A class that must implement the following methods:" msgstr "" #: library/sqlite3.rst:749 msgid "``step()``: Add a row to the current window." msgstr "" #: library/sqlite3.rst:750 msgid "``value()``: Return the current value of the aggregate." msgstr "" #: library/sqlite3.rst:751 msgid "``inverse()``: Remove a row from the current window." msgstr "" #: library/sqlite3.rst:755 msgid "" "The number of arguments that the ``step()`` and ``value()`` methods must " "accept is controlled by *num_params*." msgstr "" #: library/sqlite3.rst:758 msgid "Set to ``None`` to remove an existing SQL aggregate window function." msgstr "" #: library/sqlite3.rst:760 msgid "" "If used with a version of SQLite older than 3.25.0, which does not support " "aggregate window functions." msgstr "" #: library/sqlite3.rst:823 msgid "" "Create a collation named *name* using the collating function *callable*. " "*callable* is passed two :class:`string ` arguments, and it should " "return an :class:`integer `:" msgstr "" #: library/sqlite3.rst:827 msgid "``1`` if the first is ordered higher than the second" msgstr "" #: library/sqlite3.rst:828 msgid "``-1`` if the first is ordered lower than the second" msgstr "" #: library/sqlite3.rst:829 msgid "``0`` if they are ordered equal" msgstr "" #: library/sqlite3.rst:831 msgid "The following example shows a reverse sorting collation:" msgstr "" #: library/sqlite3.rst:859 msgid "Remove a collation function by setting *callable* to ``None``." msgstr "" #: library/sqlite3.rst:861 msgid "" "The collation name can contain any Unicode character. Earlier, only ASCII " "characters were allowed." msgstr "" #: library/sqlite3.rst:868 msgid "" "Call this method from a different thread to abort any queries that might be " "executing on the connection. Aborted queries will raise an exception." msgstr "" #: library/sqlite3.rst:875 msgid "" "Register callable *authorizer_callback* to be invoked for each attempt to " "access a column of a table in the database. The callback should return one " "of :const:`SQLITE_OK`, :const:`SQLITE_DENY`, or :const:`SQLITE_IGNORE` to " "signal how access to the column should be handled by the underlying SQLite " "library." msgstr "" #: library/sqlite3.rst:881 msgid "" "The first argument to the callback signifies what kind of operation is to be " "authorized. The second and third argument will be arguments or ``None`` " "depending on the first argument. The 4th argument is the name of the " "database (\"main\", \"temp\", etc.) if applicable. The 5th argument is the " "name of the inner-most trigger or view that is responsible for the access " "attempt or ``None`` if this access attempt is directly from input SQL code." msgstr "" #: library/sqlite3.rst:888 msgid "" "Please consult the SQLite documentation about the possible values for the " "first argument and the meaning of the second and third argument depending on " "the first one. All necessary constants are available in the :mod:`!sqlite3` " "module." msgstr "" #: library/sqlite3.rst:892 msgid "Passing ``None`` as *authorizer_callback* will disable the authorizer." msgstr "" #: library/sqlite3.rst:894 msgid "Added support for disabling the authorizer using ``None``." msgstr "" #: library/sqlite3.rst:900 msgid "" "Register callable *progress_handler* to be invoked for every *n* " "instructions of the SQLite virtual machine. This is useful if you want to " "get called from SQLite during long-running operations, for example to update " "a GUI." msgstr "" #: library/sqlite3.rst:905 msgid "" "If you want to clear any previously installed progress handler, call the " "method with ``None`` for *progress_handler*." msgstr "" #: library/sqlite3.rst:908 msgid "" "Returning a non-zero value from the handler function will terminate the " "currently executing query and cause it to raise an :exc:`OperationalError` " "exception." msgstr "" #: library/sqlite3.rst:915 msgid "" "Register callable *trace_callback* to be invoked for each SQL statement that " "is actually executed by the SQLite backend." msgstr "" #: library/sqlite3.rst:918 msgid "" "The only argument passed to the callback is the statement (as :class:`str`) " "that is being executed. The return value of the callback is ignored. Note " "that the backend does not only run statements passed to the :meth:`Cursor." "execute` methods. Other sources include the :ref:`transaction management " "` of the :mod:`!sqlite3` module and the " "execution of triggers defined in the current database." msgstr "" #: library/sqlite3.rst:926 msgid "Passing ``None`` as *trace_callback* will disable the trace callback." msgstr "" #: library/sqlite3.rst:929 msgid "" "Exceptions raised in the trace callback are not propagated. As a development " "and debugging aid, use :meth:`~sqlite3.enable_callback_tracebacks` to enable " "printing tracebacks from exceptions raised in the trace callback." msgstr "" #: library/sqlite3.rst:939 msgid "" "Enable the SQLite engine to load SQLite extensions from shared libraries if " "*enabled* is ``True``; else, disallow loading SQLite extensions. SQLite " "extensions can define new functions, aggregates or whole new virtual table " "implementations. One well-known extension is the fulltext-search extension " "distributed with SQLite." msgstr "" #: library/sqlite3.rst:948 msgid "" "The :mod:`!sqlite3` module is not built with loadable extension support by " "default, because some platforms (notably macOS) have SQLite libraries which " "are compiled without this feature. To get loadable extension support, you " "must pass the :option:`--enable-loadable-sqlite-extensions` option to :" "program:`configure`." msgstr "" #: library/sqlite3.rst:17 msgid "" "Raises an :ref:`auditing event ` ``sqlite3.enable_load_extension`` " "with arguments ``connection``, ``enabled``." msgstr "" #: library/sqlite3.rst:959 msgid "Added the ``sqlite3.enable_load_extension`` auditing event." msgstr "" #: library/sqlite3.rst:1002 msgid "" "Load an SQLite extension from a shared library located at *path*. Enable " "extension loading with :meth:`enable_load_extension` before calling this " "method." msgstr "" #: library/sqlite3.rst:5 msgid "" "Raises an :ref:`auditing event ` ``sqlite3.load_extension`` with " "arguments ``connection``, ``path``." msgstr "" #: library/sqlite3.rst:1010 msgid "Added the ``sqlite3.load_extension`` auditing event." msgstr "" #: library/sqlite3.rst:1015 msgid "" "Return an :term:`iterator` to dump the database as SQL source code. Useful " "when saving an in-memory database for later restoration. Similar to the ``." "dump`` command in the :program:`sqlite3` shell." msgstr "" #: library/sqlite3.rst:1033 msgid "Create a backup of an SQLite database." msgstr "" #: library/sqlite3.rst:1035 msgid "" "Works even if the database is being accessed by other clients or " "concurrently by the same connection." msgstr "" #: library/sqlite3.rst:1038 msgid "The database connection to save the backup to." msgstr "" #: library/sqlite3.rst:1041 msgid "" "The number of pages to copy at a time. If equal to or less than ``0``, the " "entire database is copied in a single step. Defaults to ``-1``." msgstr "" #: library/sqlite3.rst:1047 msgid "" "If set to a callable, it is invoked with three integer arguments for every " "backup iteration: the *status* of the last iteration, the *remaining* number " "of pages still to be copied, and the *total* number of pages. Defaults to " "``None``." msgstr "" #: library/sqlite3.rst:1056 msgid "" "The name of the database to back up. Either ``\"main\"`` (the default) for " "the main database, ``\"temp\"`` for the temporary database, or the name of a " "custom database as attached using the ``ATTACH DATABASE`` SQL statement." msgstr "" #: library/sqlite3.rst:1063 msgid "" "The number of seconds to sleep between successive attempts to back up " "remaining pages." msgstr "" #: library/sqlite3.rst:1067 msgid "Example 1, copy an existing database into another:" msgstr "" #: library/sqlite3.rst:1086 msgid "Example 2, copy an existing database into a transient copy:" msgstr "" #: library/sqlite3.rst:1098 msgid "Get a connection runtime limit." msgstr "" #: library/sqlite3.rst:1100 msgid "The `SQLite limit category`_ to be queried." msgstr "" #: library/sqlite3.rst:1142 msgid "If *category* is not recognised by the underlying SQLite library." msgstr "" #: library/sqlite3.rst:1108 msgid "" "Example, query the maximum length of an SQL statement for :class:" "`Connection` ``con`` (the default is 1000000000):" msgstr "" #: library/sqlite3.rst:1128 msgid "" "Set a connection runtime limit. Attempts to increase a limit above its hard " "upper bound are silently truncated to the hard upper bound. Regardless of " "whether or not the limit was changed, the prior value of the limit is " "returned." msgstr "" #: library/sqlite3.rst:1133 msgid "The `SQLite limit category`_ to be set." msgstr "" #: library/sqlite3.rst:1136 msgid "" "The value of the new limit. If negative, the current limit is unchanged." msgstr "" #: library/sqlite3.rst:1145 msgid "" "Example, limit the number of attached databases to 1 for :class:`Connection` " "``con`` (the default limit is 10):" msgstr "" #: library/sqlite3.rst:1162 msgid "" "Serialize a database into a :class:`bytes` object. For an ordinary on-disk " "database file, the serialization is just a copy of the disk file. For an in-" "memory database or a \"temp\" database, the serialization is the same " "sequence of bytes which would be written to disk if that database were " "backed up to disk." msgstr "" #: library/sqlite3.rst:1168 msgid "The database name to be serialized. Defaults to ``\"main\"``." msgstr "" #: library/sqlite3.rst:1176 msgid "" "This method is only available if the underlying SQLite library has the " "serialize API." msgstr "" #: library/sqlite3.rst:1184 msgid "" "Deserialize a :meth:`serialized ` database into a :class:" "`Connection`. This method causes the database connection to disconnect from " "database *name*, and reopen *name* as an in-memory database based on the " "serialization contained in *data*." msgstr "" #: library/sqlite3.rst:1190 msgid "A serialized database." msgstr "" #: library/sqlite3.rst:1193 msgid "The database name to deserialize into. Defaults to ``\"main\"``." msgstr "" #: library/sqlite3.rst:1197 msgid "" "If the database connection is currently involved in a read transaction or a " "backup operation." msgstr "" #: library/sqlite3.rst:1201 msgid "If *data* does not contain a valid SQLite database." msgstr "" #: library/sqlite3.rst:1204 msgid "If :func:`len(data) ` is larger than ``2**63 - 1``." msgstr "" #: library/sqlite3.rst:1209 msgid "" "This method is only available if the underlying SQLite library has the " "deserialize API." msgstr "" #: library/sqlite3.rst:1216 msgid "" "This read-only attribute corresponds to the low-level SQLite `autocommit " "mode`_." msgstr "" #: library/sqlite3.rst:1219 msgid "" "``True`` if a transaction is active (there are uncommitted changes), " "``False`` otherwise." msgstr "" #: library/sqlite3.rst:1226 msgid "" "This attribute controls the :ref:`transaction handling ` performed by :mod:`!sqlite3`. If set to ``None``, " "transactions are never implicitly opened. If set to one of ``\"DEFERRED\"``, " "``\"IMMEDIATE\"``, or ``\"EXCLUSIVE\"``, corresponding to the underlying " "`SQLite transaction behaviour`_, implicit :ref:`transaction management " "` is performed." msgstr "" #: library/sqlite3.rst:1234 msgid "" "If not overridden by the *isolation_level* parameter of :func:`connect`, the " "default is ``\"\"``, which is an alias for ``\"DEFERRED\"``." msgstr "" #: library/sqlite3.rst:1239 msgid "" "The initial :attr:`~Cursor.row_factory` for :class:`Cursor` objects created " "from this connection. Assigning to this attribute does not affect the :attr:" "`!row_factory` of existing cursors belonging to this connection, only new " "ones. Is ``None`` by default, meaning each row is returned as a :class:" "`tuple`." msgstr "" #: library/sqlite3.rst:1528 library/sqlite3.rst:1551 msgid "See :ref:`sqlite3-howto-row-factory` for more details." msgstr "" #: library/sqlite3.rst:1250 msgid "" "A callable that accepts a :class:`bytes` parameter and returns a text " "representation of it. The callable is invoked for SQLite values with the " "``TEXT`` data type. By default, this attribute is set to :class:`str`. If " "you want to return ``bytes`` instead, set *text_factory* to ``bytes``." msgstr "" #: library/sqlite3.rst:1290 msgid "" "Return the total number of database rows that have been modified, inserted, " "or deleted since the database connection was opened." msgstr "" #: library/sqlite3.rst:1297 #, fuzzy msgid "Cursor objects" msgstr "Objets de connexions" #: library/sqlite3.rst:1299 msgid "" "A ``Cursor`` object represents a `database cursor`_ which is used to execute " "SQL statements, and manage the context of a fetch operation. Cursors are " "created using :meth:`Connection.cursor`, or by using any of the :ref:" "`connection shortcut methods `." msgstr "" #: library/sqlite3.rst:1306 msgid "" "Cursor objects are :term:`iterators `, meaning that if you :meth:" "`~Cursor.execute` a ``SELECT`` query, you can simply iterate over the cursor " "to fetch the resulting rows:" msgstr "" #: library/sqlite3.rst:1331 msgid "A :class:`Cursor` instance has the following attributes and methods." msgstr "" #: library/sqlite3.rst:1338 msgid "" "Execute SQL a single SQL statement, optionally binding Python values using :" "ref:`placeholders `." msgstr "" #: library/sqlite3.rst:1342 msgid "A single SQL statement." msgstr "" #: library/sqlite3.rst:1345 msgid "" "Python values to bind to placeholders in *sql*. A :class:`!dict` if named " "placeholders are used. A :term:`!sequence` if unnamed placeholders are used. " "See :ref:`sqlite3-placeholders`." msgstr "" #: library/sqlite3.rst:1352 msgid "If *sql* contains more than one SQL statement." msgstr "" #: library/sqlite3.rst:1355 msgid "" "If :attr:`~Connection.isolation_level` is not ``None``, *sql* is an " "``INSERT``, ``UPDATE``, ``DELETE``, or ``REPLACE`` statement, and there is " "no open transaction, a transaction is implicitly opened before executing " "*sql*." msgstr "" #: library/sqlite3.rst:1360 msgid "Use :meth:`executescript` to execute multiple SQL statements." msgstr "" #: library/sqlite3.rst:1364 msgid "" "For every item in *parameters*, repeatedly execute the :ref:`parameterized " "` SQL statement *sql*." msgstr "" #: library/sqlite3.rst:1368 msgid "Uses the same implicit transaction handling as :meth:`~Cursor.execute`." msgstr "" #: library/sqlite3.rst:1370 msgid "A single SQL :abbr:`DML (Data Manipulation Language)` statement." msgstr "" #: library/sqlite3.rst:1373 msgid "" "An :term:`!iterable` of parameters to bind with the placeholders in *sql*. " "See :ref:`sqlite3-placeholders`." msgstr "" #: library/sqlite3.rst:1379 msgid "" "If *sql* contains more than one SQL statement, or is not a DML statment." msgstr "" #: library/sqlite3.rst:1396 msgid "" "Execute the SQL statements in *sql_script*. If there is a pending " "transaction, an implicit ``COMMIT`` statement is executed first. No other " "implicit transaction control is performed; any transaction control must be " "added to *sql_script*." msgstr "" #: library/sqlite3.rst:1402 msgid "*sql_script* must be a :class:`string `." msgstr "" #: library/sqlite3.rst:1420 msgid "" "If :attr:`~Cursor.row_factory` is ``None``, return the next row query result " "set as a :class:`tuple`. Else, pass it to the row factory and return its " "result. Return ``None`` if no more data is available." msgstr "" #: library/sqlite3.rst:1428 msgid "" "Return the next set of rows of a query result as a :class:`list`. Return an " "empty list if no more rows are available." msgstr "" #: library/sqlite3.rst:1431 msgid "" "The number of rows to fetch per call is specified by the *size* parameter. " "If *size* is not given, :attr:`arraysize` determines the number of rows to " "be fetched. If fewer than *size* rows are available, as many rows as are " "available are returned." msgstr "" #: library/sqlite3.rst:1437 msgid "" "Note there are performance considerations involved with the *size* " "parameter. For optimal performance, it is usually best to use the arraysize " "attribute. If the *size* parameter is used, then it is best for it to retain " "the same value from one :meth:`fetchmany` call to the next." msgstr "" #: library/sqlite3.rst:1444 msgid "" "Return all (remaining) rows of a query result as a :class:`list`. Return an " "empty list if no rows are available. Note that the :attr:`arraysize` " "attribute can affect the performance of this operation." msgstr "" #: library/sqlite3.rst:1451 msgid "Close the cursor now (rather than whenever ``__del__`` is called)." msgstr "" #: library/sqlite3.rst:1453 msgid "" "The cursor will be unusable from this point forward; a :exc:" "`ProgrammingError` exception will be raised if any operation is attempted " "with the cursor." msgstr "" #: library/sqlite3.rst:1462 msgid "Required by the DB-API. Does nothing in :mod:`!sqlite3`." msgstr "" #: library/sqlite3.rst:1466 msgid "" "Read/write attribute that controls the number of rows returned by :meth:" "`fetchmany`. The default value is 1 which means a single row would be " "fetched per call." msgstr "" #: library/sqlite3.rst:1471 msgid "" "Read-only attribute that provides the SQLite database :class:`Connection` " "belonging to the cursor. A :class:`Cursor` object created by calling :meth:" "`con.cursor() ` will have a :attr:`connection` attribute " "that refers to *con*:" msgstr "" #: library/sqlite3.rst:1485 msgid "" "Read-only attribute that provides the column names of the last query. To " "remain compatible with the Python DB API, it returns a 7-tuple for each " "column where the last six items of each tuple are ``None``." msgstr "" #: library/sqlite3.rst:1489 msgid "It is set for ``SELECT`` statements without any matching rows as well." msgstr "" #: library/sqlite3.rst:1493 msgid "" "Read-only attribute that provides the row id of the last inserted row. It is " "only updated after successful ``INSERT`` or ``REPLACE`` statements using " "the :meth:`execute` method. For other statements, after :meth:`executemany` " "or :meth:`executescript`, or if the insertion failed, the value of " "``lastrowid`` is left unchanged. The initial value of ``lastrowid`` is " "``None``." msgstr "" #: library/sqlite3.rst:1501 msgid "Inserts into ``WITHOUT ROWID`` tables are not recorded." msgstr "" #: library/sqlite3.rst:1503 msgid "Added support for the ``REPLACE`` statement." msgstr "" #: library/sqlite3.rst:1508 msgid "" "Read-only attribute that provides the number of modified rows for " "``INSERT``, ``UPDATE``, ``DELETE``, and ``REPLACE`` statements; is ``-1`` " "for other statements, including :abbr:`CTE (Common Table Expression)` " "queries. It is only updated by the :meth:`execute` and :meth:`executemany` " "methods." msgstr "" #: library/sqlite3.rst:1516 msgid "" "Control how a row fetched from this :class:`!Cursor` is represented. If " "``None``, a row is represented as a :class:`tuple`. Can be set to the " "included :class:`sqlite3.Row`; or a :term:`callable` that accepts two " "arguments, a :class:`Cursor` object and the :class:`!tuple` of row values, " "and returns a custom object representing an SQLite row." msgstr "" #: library/sqlite3.rst:1523 msgid "" "Defaults to what :attr:`Connection.row_factory` was set to when the :class:`!" "Cursor` was created. Assigning to this attribute does not affect :attr:" "`Connection.row_factory` of the parent connection." msgstr "" #: library/sqlite3.rst:1539 #, fuzzy msgid "Row objects" msgstr "Objets de connexions" #: library/sqlite3.rst:1543 msgid "" "A :class:`!Row` instance serves as a highly optimized :attr:`~Connection." "row_factory` for :class:`Connection` objects. It supports iteration, " "equality testing, :func:`len`, and :term:`mapping` access by column name and " "index." msgstr "" #: library/sqlite3.rst:1548 msgid "" "Two :class:`!Row` objects compare equal if they have identical column names " "and values." msgstr "" #: library/sqlite3.rst:1555 msgid "" "Return a :class:`list` of column names as :class:`strings `. " "Immediately after a query, it is the first member of each tuple in :attr:" "`Cursor.description`." msgstr "" #: library/sqlite3.rst:1559 msgid "Added support of slicing." msgstr "" #: library/sqlite3.rst:1566 #, fuzzy msgid "Blob objects" msgstr "Objets de connexions" #: library/sqlite3.rst:1572 msgid "" "A :class:`Blob` instance is a :term:`file-like object` that can read and " "write data in an SQLite :abbr:`BLOB (Binary Large OBject)`. Call :func:" "`len(blob) ` to get the size (number of bytes) of the blob. Use indices " "and :term:`slices ` for direct access to the blob data." msgstr "" #: library/sqlite3.rst:1577 msgid "" "Use the :class:`Blob` as a :term:`context manager` to ensure that the blob " "handle is closed after use." msgstr "" #: library/sqlite3.rst:1607 msgid "Close the blob." msgstr "" #: library/sqlite3.rst:1609 msgid "" "The blob will be unusable from this point onward. An :class:`~sqlite3." "Error` (or subclass) exception will be raised if any further operation is " "attempted with the blob." msgstr "" #: library/sqlite3.rst:1615 msgid "" "Read *length* bytes of data from the blob at the current offset position. If " "the end of the blob is reached, the data up to :abbr:`EOF (End of File)` " "will be returned. When *length* is not specified, or is negative, :meth:" "`~Blob.read` will read until the end of the blob." msgstr "" #: library/sqlite3.rst:1623 msgid "" "Write *data* to the blob at the current offset. This function cannot change " "the blob length. Writing beyond the end of the blob will raise :exc:" "`ValueError`." msgstr "" #: library/sqlite3.rst:1629 msgid "Return the current access position of the blob." msgstr "" #: library/sqlite3.rst:1633 msgid "" "Set the current access position of the blob to *offset*. The *origin* " "argument defaults to :data:`os.SEEK_SET` (absolute blob positioning). Other " "values for *origin* are :data:`os.SEEK_CUR` (seek relative to the current " "position) and :data:`os.SEEK_END` (seek relative to the blob’s end)." msgstr "" #: library/sqlite3.rst:1641 msgid "PrepareProtocol objects" msgstr "" #: library/sqlite3.rst:1645 msgid "" "The PrepareProtocol type's single purpose is to act as a :pep:`246` style " "adaption protocol for objects that can :ref:`adapt themselves ` to :ref:`native SQLite types `." msgstr "" #: library/sqlite3.rst:1653 msgid "Exceptions" msgstr "Exceptions" #: library/sqlite3.rst:1655 msgid "The exception hierarchy is defined by the DB-API 2.0 (:pep:`249`)." msgstr "" #: library/sqlite3.rst:1659 msgid "" "This exception is not currently raised by the :mod:`!sqlite3` module, but " "may be raised by applications using :mod:`!sqlite3`, for example if a user-" "defined function truncates data while inserting. ``Warning`` is a subclass " "of :exc:`Exception`." msgstr "" #: library/sqlite3.rst:1666 msgid "" "The base class of the other exceptions in this module. Use this to catch all " "errors with one single :keyword:`except` statement. ``Error`` is a subclass " "of :exc:`Exception`." msgstr "" #: library/sqlite3.rst:1670 msgid "" "If the exception originated from within the SQLite library, the following " "two attributes are added to the exception:" msgstr "" #: library/sqlite3.rst:1675 msgid "" "The numeric error code from the `SQLite API `_" msgstr "" #: library/sqlite3.rst:1682 msgid "" "The symbolic name of the numeric error code from the `SQLite API `_" msgstr "" #: library/sqlite3.rst:1689 msgid "" "Exception raised for misuse of the low-level SQLite C API. In other words, " "if this exception is raised, it probably indicates a bug in the :mod:`!" "sqlite3` module. ``InterfaceError`` is a subclass of :exc:`Error`." msgstr "" #: library/sqlite3.rst:1696 msgid "" "Exception raised for errors that are related to the database. This serves as " "the base exception for several types of database errors. It is only raised " "implicitly through the specialised subclasses. ``DatabaseError`` is a " "subclass of :exc:`Error`." msgstr "" #: library/sqlite3.rst:1703 msgid "" "Exception raised for errors caused by problems with the processed data, like " "numeric values out of range, and strings which are too long. ``DataError`` " "is a subclass of :exc:`DatabaseError`." msgstr "" #: library/sqlite3.rst:1709 msgid "" "Exception raised for errors that are related to the database's operation, " "and not necessarily under the control of the programmer. For example, the " "database path is not found, or a transaction could not be processed. " "``OperationalError`` is a subclass of :exc:`DatabaseError`." msgstr "" #: library/sqlite3.rst:1717 msgid "" "Exception raised when the relational integrity of the database is affected, " "e.g. a foreign key check fails. It is a subclass of :exc:`DatabaseError`." msgstr "" #: library/sqlite3.rst:1722 msgid "" "Exception raised when SQLite encounters an internal error. If this is " "raised, it may indicate that there is a problem with the runtime SQLite " "library. ``InternalError`` is a subclass of :exc:`DatabaseError`." msgstr "" #: library/sqlite3.rst:1729 msgid "" "Exception raised for :mod:`!sqlite3` API programming errors, for example " "supplying the wrong number of bindings to a query, or trying to operate on a " "closed :class:`Connection`. ``ProgrammingError`` is a subclass of :exc:" "`DatabaseError`." msgstr "" #: library/sqlite3.rst:1736 msgid "" "Exception raised in case a method or database API is not supported by the " "underlying SQLite library. For example, setting *deterministic* to ``True`` " "in :meth:`~Connection.create_function`, if the underlying SQLite library " "does not support deterministic functions. ``NotSupportedError`` is a " "subclass of :exc:`DatabaseError`." msgstr "" #: library/sqlite3.rst:1746 msgid "SQLite and Python types" msgstr "" #: library/sqlite3.rst:1748 msgid "" "SQLite natively supports the following types: ``NULL``, ``INTEGER``, " "``REAL``, ``TEXT``, ``BLOB``." msgstr "" #: library/sqlite3.rst:1751 msgid "" "The following Python types can thus be sent to SQLite without any problem:" msgstr "" #: library/sqlite3.rst:1771 msgid "Python type" msgstr "Type Python" #: library/sqlite3.rst:1771 msgid "SQLite type" msgstr "SQLite type" #: library/sqlite3.rst:1773 msgid "``None``" msgstr "" #: library/sqlite3.rst:1773 msgid "``NULL``" msgstr "``NULL``" #: library/sqlite3.rst:1775 msgid ":class:`int`" msgstr ":class:`int`" #: library/sqlite3.rst:1775 msgid "``INTEGER``" msgstr "``INTEGER``" #: library/sqlite3.rst:1777 msgid ":class:`float`" msgstr ":class:`float`" #: library/sqlite3.rst:1777 msgid "``REAL``" msgstr "``REAL``" #: library/sqlite3.rst:1762 msgid ":class:`str`" msgstr ":class:`str`" #: library/sqlite3.rst:1779 msgid "``TEXT``" msgstr "``TEXT``" #: library/sqlite3.rst:1782 msgid ":class:`bytes`" msgstr ":class:`bytes`" #: library/sqlite3.rst:1782 msgid "``BLOB``" msgstr "``BLOB``" #: library/sqlite3.rst:1768 msgid "This is how SQLite types are converted to Python types by default:" msgstr "" #: library/sqlite3.rst:1779 msgid "depends on :attr:`~Connection.text_factory`, :class:`str` by default" msgstr "" #: library/sqlite3.rst:1785 msgid "" "The type system of the :mod:`!sqlite3` module is extensible in two ways: you " "can store additional Python types in an SQLite database via :ref:`object " "adapters `, and you can let the :mod:`!sqlite3` module " "convert SQLite types to Python types via :ref:`converters `." msgstr "" #: library/sqlite3.rst:1795 msgid "Default adapters and converters" msgstr "" #: library/sqlite3.rst:1797 msgid "" "There are default adapters for the date and datetime types in the datetime " "module. They will be sent as ISO dates/ISO timestamps to SQLite." msgstr "" #: library/sqlite3.rst:1800 msgid "" "The default converters are registered under the name \"date\" for :class:" "`datetime.date` and under the name \"timestamp\" for :class:`datetime." "datetime`." msgstr "" #: library/sqlite3.rst:1804 msgid "" "This way, you can use date/timestamps from Python without any additional " "fiddling in most cases. The format of the adapters is also compatible with " "the experimental SQLite date/time functions." msgstr "" #: library/sqlite3.rst:1808 msgid "The following example demonstrates this." msgstr "" #: library/sqlite3.rst:1812 msgid "" "If a timestamp stored in SQLite has a fractional part longer than 6 numbers, " "its value will be truncated to microsecond precision by the timestamp " "converter." msgstr "" #: library/sqlite3.rst:1818 msgid "" "The default \"timestamp\" converter ignores UTC offsets in the database and " "always returns a naive :class:`datetime.datetime` object. To preserve UTC " "offsets in timestamps, either leave converters disabled, or register an " "offset-aware converter with :func:`register_converter`." msgstr "" #: library/sqlite3.rst:1827 msgid "How-to guides" msgstr "" #: library/sqlite3.rst:1832 msgid "How to use placeholders to bind values in SQL queries" msgstr "" #: library/sqlite3.rst:1834 #, fuzzy msgid "" "SQL operations usually need to use values from Python variables. However, " "beware of using Python's string operations to assemble queries, as they are " "vulnerable to `SQL injection attacks`_. For example, an attacker can simply " "close the single quote and inject ``OR TRUE`` to select all rows::" msgstr "" "Habituellement, vos opérations SQL utilisent les valeurs de variables " "Python. Vous ne devez pas assembler votre requête à l'aide des opérations " "sur les chaînes de caractères de Python, car cela n'est pas sûr. Cela rend " "votre programme vulnérable à une attaque par injection SQL (voir https://" "xkcd.com/327/ pour un exemple amusant de ce qui peut mal tourner) ::" #: library/sqlite3.rst:1847 #, fuzzy msgid "" "Instead, use the DB-API's parameter substitution. To insert a variable into " "a query string, use a placeholder in the string, and substitute the actual " "values into the query by providing them as a :class:`tuple` of values to the " "second argument of the cursor's :meth:`~Cursor.execute` method." msgstr "" "À la place, utilisez la capacité DB-API de substitution des paramètres. " "Placez un ``?`` comme indicateur partout où vous voulez utiliser une valeur, " "puis fournissez un *n*-uplet de valeurs comme second argument de la méthode :" "meth:`~Cursor.execute`. D'autres modules de base de données peuvent utiliser " "un espace réservé différent, tel que ``%s`` ou ``:1``. Par exemple ::" #: library/sqlite3.rst:1852 msgid "" "An SQL statement may use one of two kinds of placeholders: question marks " "(qmark style) or named placeholders (named style). For the qmark style, " "*parameters* must be a :term:`sequence` whose length must match the number " "of placeholders, or a :exc:`ProgrammingError` is raised. For the named " "style, *parameters* should be an instance of a :class:`dict` (or a " "subclass), which must contain keys for all named parameters; any extra items " "are ignored. Here's an example of both styles:" msgstr "" #: library/sqlite3.rst:1889 msgid "" ":pep:`249` numeric placeholders are *not* supported. If used, they will be " "interpreted as named placeholders." msgstr "" #: library/sqlite3.rst:1896 msgid "How to adapt custom Python types to SQLite values" msgstr "" #: library/sqlite3.rst:1898 msgid "" "SQLite supports only a limited set of data types natively. To store custom " "Python types in SQLite databases, *adapt* them to one of the :ref:`Python " "types SQLite natively understands `." msgstr "" #: library/sqlite3.rst:1902 msgid "" "There are two ways to adapt Python objects to SQLite types: letting your " "object adapt itself, or using an *adapter callable*. The latter will take " "precedence above the former. For a library that exports a custom type, it " "may make sense to enable that type to adapt itself. As an application " "developer, it may make more sense to take direct control by registering " "custom adapter functions." msgstr "" #: library/sqlite3.rst:1914 msgid "How to write adaptable objects" msgstr "" #: library/sqlite3.rst:1916 msgid "" "Suppose we have a :class:`!Point` class that represents a pair of " "coordinates, ``x`` and ``y``, in a Cartesian coordinate system. The " "coordinate pair will be stored as a text string in the database, using a " "semicolon to separate the coordinates. This can be implemented by adding a " "``__conform__(self, protocol)`` method which returns the adapted value. The " "object passed to *protocol* will be of type :class:`PrepareProtocol`." msgstr "" #: library/sqlite3.rst:1947 msgid "How to register adapter callables" msgstr "" #: library/sqlite3.rst:1949 msgid "" "The other possibility is to create a function that converts the Python " "object to an SQLite-compatible type. This function can then be registered " "using :func:`register_adapter`." msgstr "" #: library/sqlite3.rst:1979 msgid "How to convert SQLite values to custom Python types" msgstr "" #: library/sqlite3.rst:1981 msgid "" "Writing an adapter lets you convert *from* custom Python types *to* SQLite " "values. To be able to convert *from* SQLite values *to* custom Python types, " "we use *converters*." msgstr "" #: library/sqlite3.rst:1986 msgid "" "Let's go back to the :class:`!Point` class. We stored the x and y " "coordinates separated via semicolons as strings in SQLite." msgstr "" #: library/sqlite3.rst:1989 msgid "" "First, we'll define a converter function that accepts the string as a " "parameter and constructs a :class:`!Point` object from it." msgstr "" #: library/sqlite3.rst:1994 msgid "" "Converter functions are **always** passed a :class:`bytes` object, no matter " "the underlying SQLite data type." msgstr "" #: library/sqlite3.rst:2003 msgid "" "We now need to tell :mod:`!sqlite3` when it should convert a given SQLite " "value. This is done when connecting to a database, using the *detect_types* " "parameter of :func:`connect`. There are three options:" msgstr "" #: library/sqlite3.rst:2007 msgid "Implicit: set *detect_types* to :const:`PARSE_DECLTYPES`" msgstr "" #: library/sqlite3.rst:2008 msgid "Explicit: set *detect_types* to :const:`PARSE_COLNAMES`" msgstr "" #: library/sqlite3.rst:2009 msgid "" "Both: set *detect_types* to ``sqlite3.PARSE_DECLTYPES | sqlite3." "PARSE_COLNAMES``. Column names take precedence over declared types." msgstr "" #: library/sqlite3.rst:2013 msgid "The following example illustrates the implicit and explicit approaches:" msgstr "" #: library/sqlite3.rst:2064 msgid "Adapter and converter recipes" msgstr "" #: library/sqlite3.rst:2066 msgid "This section shows recipes for common adapters and converters." msgstr "" #: library/sqlite3.rst:2128 msgid "How to use connection shortcut methods" msgstr "" #: library/sqlite3.rst:2130 msgid "" "Using the :meth:`~Connection.execute`, :meth:`~Connection.executemany`, and :" "meth:`~Connection.executescript` methods of the :class:`Connection` class, " "your code can be written more concisely because you don't have to create the " "(often superfluous) :class:`Cursor` objects explicitly. Instead, the :class:" "`Cursor` objects are created implicitly and these shortcut methods return " "the cursor objects. This way, you can execute a ``SELECT`` statement and " "iterate over it directly using only a single call on the :class:`Connection` " "object." msgstr "" #: library/sqlite3.rst:2171 msgid "How to use the connection context manager" msgstr "" #: library/sqlite3.rst:2173 msgid "" "A :class:`Connection` object can be used as a context manager that " "automatically commits or rolls back open transactions when leaving the body " "of the context manager. If the body of the :keyword:`with` statement " "finishes without exceptions, the transaction is committed. If this commit " "fails, or if the body of the ``with`` statement raises an uncaught " "exception, the transaction is rolled back." msgstr "" #: library/sqlite3.rst:2182 msgid "" "If there is no open transaction upon leaving the body of the ``with`` " "statement, the context manager is a no-op." msgstr "" #: library/sqlite3.rst:2187 msgid "" "The context manager neither implicitly opens a new transaction nor closes " "the connection." msgstr "" #: library/sqlite3.rst:2220 msgid "How to work with SQLite URIs" msgstr "" #: library/sqlite3.rst:2222 msgid "Some useful URI tricks include:" msgstr "" #: library/sqlite3.rst:2224 msgid "Open a database in read-only mode:" msgstr "" #: library/sqlite3.rst:2233 msgid "" "Do not implicitly create a new database file if it does not already exist; " "will raise :exc:`~sqlite3.OperationalError` if unable to create a new file:" msgstr "" #: library/sqlite3.rst:2243 msgid "Create a shared named in-memory database:" msgstr "" #: library/sqlite3.rst:2257 msgid "" "More information about this feature, including a list of parameters, can be " "found in the `SQLite URI documentation`_." msgstr "" #: library/sqlite3.rst:2266 msgid "How to create and use row factories" msgstr "" #: library/sqlite3.rst:2268 msgid "" "By default, :mod:`!sqlite3` represents each row as a :class:`tuple`. If a :" "class:`!tuple` does not suit your needs, you can use the :class:`sqlite3." "Row` class or a custom :attr:`~Cursor.row_factory`." msgstr "" #: library/sqlite3.rst:2273 msgid "" "While :attr:`!row_factory` exists as an attribute both on the :class:" "`Cursor` and the :class:`Connection`, it is recommended to set :class:" "`Connection.row_factory`, so all cursors created from the connection will " "use the same row factory." msgstr "" #: library/sqlite3.rst:2278 msgid "" ":class:`!Row` provides indexed and case-insensitive named access to columns, " "with minimal memory overhead and performance impact over a :class:`!tuple`. " "To use :class:`!Row` as a row factory, assign it to the :attr:`!row_factory` " "attribute:" msgstr "" #: library/sqlite3.rst:2288 msgid "Queries now return :class:`!Row` objects:" msgstr "" #: library/sqlite3.rst:2303 msgid "" "You can create a custom :attr:`~Cursor.row_factory` that returns each row as " "a :class:`dict`, with column names mapped to values:" msgstr "" #: library/sqlite3.rst:2312 msgid "" "Using it, queries now return a :class:`!dict` instead of a :class:`!tuple`:" msgstr "" #: library/sqlite3.rst:2322 msgid "The following row factory returns a :term:`named tuple`:" msgstr "" #: library/sqlite3.rst:2333 msgid ":func:`!namedtuple_factory` can be used as follows:" msgstr "" #: library/sqlite3.rst:2348 msgid "" "With some adjustments, the above recipe can be adapted to use a :class:" "`~dataclasses.dataclass`, or any other custom class, instead of a :class:" "`~collections.namedtuple`." msgstr "" #: library/sqlite3.rst:2356 #, fuzzy msgid "Explanation" msgstr "Exceptions" #: library/sqlite3.rst:2361 msgid "Transaction control" msgstr "" #: library/sqlite3.rst:2363 msgid "" "The :mod:`!sqlite3` module does not adhere to the transaction handling " "recommended by :pep:`249`." msgstr "" #: library/sqlite3.rst:2366 msgid "" "If the connection attribute :attr:`~Connection.isolation_level` is not " "``None``, new transactions are implicitly opened before :meth:`~Cursor." "execute` and :meth:`~Cursor.executemany` executes ``INSERT``, ``UPDATE``, " "``DELETE``, or ``REPLACE`` statements; for other statements, no implicit " "transaction handling is performed. Use the :meth:`~Connection.commit` and :" "meth:`~Connection.rollback` methods to respectively commit and roll back " "pending transactions. You can choose the underlying `SQLite transaction " "behaviour`_ — that is, whether and what type of ``BEGIN`` statements :mod:`!" "sqlite3` implicitly executes – via the :attr:`~Connection.isolation_level` " "attribute." msgstr "" #: library/sqlite3.rst:2379 msgid "" "If :attr:`~Connection.isolation_level` is set to ``None``, no transactions " "are implicitly opened at all. This leaves the underlying SQLite library in " "`autocommit mode`_, but also allows the user to perform their own " "transaction handling using explicit SQL statements. The underlying SQLite " "library autocommit mode can be queried using the :attr:`~Connection." "in_transaction` attribute." msgstr "" #: library/sqlite3.rst:2387 msgid "" "The :meth:`~Cursor.executescript` method implicitly commits any pending " "transaction before execution of the given SQL script, regardless of the " "value of :attr:`~Connection.isolation_level`." msgstr "" #: library/sqlite3.rst:2391 msgid "" ":mod:`!sqlite3` used to implicitly commit an open transaction before DDL " "statements. This is no longer the case." msgstr "" #, fuzzy #~ msgid "" #~ "To use the module, start by creating a :class:`Connection` object that " #~ "represents the database. Here the data will be stored in the :file:" #~ "`example.db` file::" #~ msgstr "" #~ "Pour utiliser le module, vous devez d’abord créer une :class:`Connection` " #~ "qui représente la base de données. Dans cet exemple, les données sont " #~ "stockées dans le fichier :file:`example.db` ::" #, fuzzy #~ msgid "" #~ "The special path name ``:memory:`` can be provided to create a temporary " #~ "database in RAM." #~ msgstr "" #~ "Vous pouvez également fournir le nom spécial ``:memory:`` pour créer une " #~ "base de données dans la mémoire vive." #, fuzzy #~ msgid "" #~ "Once a :class:`Connection` has been established, create a :class:`Cursor` " #~ "object and call its :meth:`~Cursor.execute` method to perform SQL " #~ "commands::" #~ msgstr "" #~ "Une fois que vous avez une instance de :class:`Connection`, vous pouvez " #~ "créer un objet :class:`Cursor` et appeler sa méthode :meth:`~Cursor." #~ "execute` pour exécuter les commandes SQL ::" #, fuzzy #~ msgid "" #~ "To retrieve data after executing a SELECT statement, either treat the " #~ "cursor as an :term:`iterator`, call the cursor's :meth:`~Cursor.fetchone` " #~ "method to retrieve a single matching row, or call :meth:`~Cursor." #~ "fetchall` to get a list of the matching rows." #~ msgstr "" #~ "Pour récupérer des données après avoir exécuté une instruction *SELECT*, " #~ "vous pouvez considérer le curseur comme un :term:`itérateur `, " #~ "appeler la méthode du curseur :meth:`~Cursor.fetchone` pour récupérer une " #~ "seule ligne correspondante ou appeler :meth:`~Cursor.fetchall` pour " #~ "obtenir une liste des lignes correspondantes." #~ msgid "This example uses the iterator form::" #~ msgstr "Cet exemple utilise la forme itérateur ::" #~ msgid "" #~ "This constant is meant to be used with the *detect_types* parameter of " #~ "the :func:`connect` function." #~ msgstr "" #~ "Cette constante est destinée à être utilisée avec le paramètre " #~ "*detect_types* de la fonction :func:`connect`." #~ msgid "" #~ "Setting it makes the :mod:`sqlite3` module parse the declared type for " #~ "each column it returns. It will parse out the first word of the declared " #~ "type, i. e. for \"integer primary key\", it will parse out \"integer\", " #~ "or for \"number(10)\" it will parse out \"number\". Then for that column, " #~ "it will look into the converters dictionary and use the converter " #~ "function registered for that type there." #~ msgstr "" #~ "Si elle est définie, le module :mod:`sqlite3` analyse le type de donnée " #~ "déclarée pour chaque colonne. Il déduit le type du premier mot de la " #~ "déclaration, par exemple de *integer primary key* il gardera *integer*, " #~ "ou de *number(10)* il gardera *number*. Ensuite, pour cette colonne, il " #~ "utilisera une fonction de conversion du dictionnaire des convertisseurs." #, fuzzy #~ msgid "" #~ "Setting this makes the SQLite interface parse the column name for each " #~ "column it returns. It will look for a string formed [mytype] in there, " #~ "and then decide that 'mytype' is the type of the column. It will try to " #~ "find an entry of 'mytype' in the converters dictionary and then use the " #~ "converter function found there to return the value. The column name found " #~ "in :attr:`Cursor.description` does not include the type, i. e. if you use " #~ "something like ``'as \"Expiration date [datetime]\"'`` in your SQL, then " #~ "we will parse out everything until the first ``'['`` for the column name " #~ "and strip the preceding space: the column name would simply be " #~ "\"Expiration date\"." #~ msgstr "" #~ "Permet à l’interface SQLite d'analyser le nom pour chaque colonne. Il y " #~ "cherchera une chaîne comme ``[mytype]`` indiquant que la colonne est de " #~ "type ``mytype``. Il essaiera de trouver une entrée *mytype* dans le " #~ "dictionnaire, puis utilisera la fonction de conversion qui s'y trouve " #~ "pour renvoyer la valeur. Le nom de colonne donnée à :attr:`Cursor." #~ "description` n'est alors que le premier mot du nom de la colonne, par " #~ "exemple si vous utilisez ``'as \\\"x [datetime]\\\"'`` dans votre code " #~ "SQL, le nom de la colonne sera simplement *x*." #~ msgid "" #~ "Opens a connection to the SQLite database file *database*. By default " #~ "returns a :class:`Connection` object, unless a custom *factory* is given." #~ msgstr "" #~ "Ouvre une connexion à la base de données SQLite *database*. Par défaut, " #~ "cette commande renvoie un objet :class:`Connection`, sauf si *factory* " #~ "est donné." #~ msgid "Example::" #~ msgstr "Exemple ::" #~ msgid "Introduction" #~ msgstr "Introduction" #~ msgid ":const:`None`" #~ msgstr ":const:`None`" #~ msgid "Footnotes" #~ msgstr "Notes" #~ msgid "" #~ "The data you've saved is persistent and is available in subsequent " #~ "sessions::" #~ msgstr "" #~ "Les données que vous avez sauvegardées sont persistantes et disponibles " #~ "dans les sessions suivantes ::" #~ msgid "https://github.com/ghaering/pysqlite" #~ msgstr "https://github.com/ghaering/pysqlite" #~ msgid "" #~ "The pysqlite web page -- sqlite3 is developed externally under the name " #~ "\"pysqlite\"." #~ msgstr "" #~ "La page web de *pysqlite* — *sqlite3* est développée sur un site tiers " #~ "sous le nom *pysqlite*."