forked from AFPy/python-docs-fr
1930 lines
69 KiB
Plaintext
1930 lines
69 KiB
Plaintext
# 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: 2022-10-18 15:46+0200\n"
|
||
"PO-Revision-Date: 2019-03-26 15:55+0100\n"
|
||
"Last-Translator: Julien Palard <julien@palard.fr>\n"
|
||
"Language-Team: FRENCH <traductions@lists.afpy.org>\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 2.0.6\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 <sqlite3-tutorial>` 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 <sqlite3-reference>` 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 <sqlite3-howtos>` 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 <sqlite3-explanation>` 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() <Connection."
|
||
"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() <Connection.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(...) <Cursor.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 <flexible typing_>`_ "
|
||
"de SQLite, spécifier les types de données est facultatif. Exécutez "
|
||
"l’instruction ``CREATE TABLE`` en appelant :meth:`cur.execute(…) <Cursor."
|
||
"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(...) <Cursor."
|
||
"execute>`, assign the result to ``res``, and call :meth:`res.fetchone() "
|
||
"<Cursor.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 "
|
||
"<The Schema Table_>`_ pour plus de détails). Exécutez cette requête en "
|
||
"appelant :meth:`cur.execute(…) <Cursor.execute>`, affectez le résultat à "
|
||
"``res``, et appelez :meth:`res.fetchone() <Cursor.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(...) <Cursor."
|
||
"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(…) <Cursor.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() <Connection."
|
||
"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 <sqlite3-controlling-"
|
||
"transactions>` pour plus de détails). Appelez :meth:`con.commit() "
|
||
"<Connection.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(...) <Cursor.execute>` to "
|
||
"assign the result to ``res``, and call :meth:`res.fetchall() <Cursor."
|
||
"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(…) <Cursor.execute>` pour affecter le résultat à ``res``, et "
|
||
"appelez :meth:`res.fetchall() <Cursor.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 <list>` 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(...) <Cursor."
|
||
"executemany>`:"
|
||
msgstr ""
|
||
"Maintenant, insérez trois lignes supplémentaires en appelant :meth:`cur."
|
||
"executemany(…) <Cursor.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 <tut-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 <tut-formatting>` pour lier les valeurs Python aux instructions "
|
||
"SQL, afin d’éviter les `injections SQL`_ (voir :ref:`placeholder SQL "
|
||
"<sqlite3-placeholders>` 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() <Connection.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() <Connection.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 <sqlite3-howtos>` pour une lecture plus poussée:"
|
||
|
||
#: library/sqlite3.rst:238
|
||
msgid ":ref:`sqlite3-placeholders`"
|
||
msgstr ":ref:`placeholders sqlite3 <sqlite3-placeholders>`"
|
||
|
||
#: library/sqlite3.rst:239
|
||
msgid ":ref:`sqlite3-adapters`"
|
||
msgstr ":ref:`adaptateurs sqlite3 <sqlite3-adapters>`"
|
||
|
||
#: library/sqlite3.rst:240
|
||
msgid ":ref:`sqlite3-converters`"
|
||
msgstr ":ref:`convertisseurs sqlite3 <sqlite3-converters>`"
|
||
|
||
#: library/sqlite3.rst:514
|
||
msgid ":ref:`sqlite3-connection-context-manager`"
|
||
msgstr ""
|
||
":ref:`gestionnaire de contexte de connexion sqlite3 <sqlite3-connection-"
|
||
"context-manager>`"
|
||
|
||
#: library/sqlite3.rst:243
|
||
msgid ""
|
||
":ref:`sqlite3-explanation` for in-depth background on transaction control."
|
||
msgstr ""
|
||
":ref:`explications sqlite3 <sqlite3-explanation>` pour un contexte détaillé "
|
||
"du contrôle de transaction."
|
||
|
||
#: library/sqlite3.rst:248
|
||
msgid "Reference"
|
||
msgstr "Référence"
|
||
|
||
#: library/sqlite3.rst:256
|
||
#, fuzzy
|
||
msgid "Module functions"
|
||
msgstr "Fonctions et constantes du module"
|
||
|
||
#: library/sqlite3.rst:263
|
||
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:265
|
||
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:271
|
||
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:278
|
||
msgid ""
|
||
"Control whether and how data types not :ref:`natively supported by SQLite "
|
||
"<sqlite3-types>` 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 <sqlite3-types>` 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:292
|
||
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 <sqlite3-controlling-transactions>` pour "
|
||
"en savoir plus."
|
||
|
||
#: library/sqlite3.rst:300
|
||
msgid ""
|
||
"If ``True`` (default), only the creating thread may use the connection. If "
|
||
"``False``, the connection may be shared across multiple threads; if so, "
|
||
"write operations should be serialized by the user to avoid data corruption."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:306
|
||
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:310
|
||
msgid ""
|
||
"The number of statements that :mod:`!sqlite3` should internally cache for "
|
||
"this connection, to avoid parsing overhead. By default, 100 statements."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:315
|
||
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 <sqlite3-uri-tricks>`."
|
||
|
||
#: library/sqlite3.rst:0
|
||
#, fuzzy
|
||
msgid "Return type"
|
||
msgstr "Type Python"
|
||
|
||
#: library/sqlite3.rst:326
|
||
msgid ""
|
||
"Raises an :ref:`auditing event <auditing>` ``sqlite3.connect`` with argument "
|
||
"``database``."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:327
|
||
msgid ""
|
||
"Raises an :ref:`auditing event <auditing>` ``sqlite3.connect/handle`` with "
|
||
"argument ``connection_handle``."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:329
|
||
msgid "The *uri* parameter."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:332
|
||
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 <path-"
|
||
"like object>`, et pas seulement une chaîne de caractères."
|
||
|
||
#: library/sqlite3.rst:335
|
||
msgid "The ``sqlite3.connect/handle`` auditing event."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:340
|
||
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:346
|
||
#, fuzzy
|
||
msgid "For example:"
|
||
msgstr "Exemple :"
|
||
|
||
#: library/sqlite3.rst:355
|
||
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:361
|
||
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 ``sys.stderr``. Use ``False`` to disable the feature again."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:370
|
||
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 <sqlite3-types>`."
|
||
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 <sqlite3-types>`."
|
||
|
||
#: library/sqlite3.rst:378
|
||
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:386
|
||
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:393
|
||
#, fuzzy
|
||
msgid "Module constants"
|
||
msgstr "Fonctions et constantes du module"
|
||
|
||
#: library/sqlite3.rst:397
|
||
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:407
|
||
msgid ""
|
||
"This flag may be combined with :const:`PARSE_DECLTYPES` using the ``|`` "
|
||
"(bitwise or) operator."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:412
|
||
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:428
|
||
msgid ""
|
||
"This flag may be combined with :const:`PARSE_COLNAMES` using the ``|`` "
|
||
"(bitwise or) operator."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:435
|
||
msgid ""
|
||
"Flags that should be returned by the *authorizer_callback* callable passed "
|
||
"to :meth:`Connection.set_authorizer`, to indicate whether:"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:438
|
||
msgid "Access is allowed (:const:`!SQLITE_OK`),"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:439
|
||
msgid ""
|
||
"The SQL statement should be aborted with an error (:const:`!SQLITE_DENY`)"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:440
|
||
msgid ""
|
||
"The column should be treated as a ``NULL`` value (:const:`!SQLITE_IGNORE`)"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:444
|
||
msgid ""
|
||
"String constant stating the supported DB-API level. Required by the DB-API. "
|
||
"Hard-coded to ``\"2.0\"``."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:449
|
||
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:455
|
||
msgid ""
|
||
"The :mod:`!sqlite3` module supports both ``qmark`` and ``numeric`` DB-API "
|
||
"parameter styles, because that is what the underlying SQLite library "
|
||
"supports. However, the DB-API does not allow multiple values for the "
|
||
"``paramstyle`` attribute."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:462
|
||
#, fuzzy
|
||
msgid ""
|
||
"Version number of the runtime SQLite library as a :class:`string <str>`."
|
||
msgstr ""
|
||
"Le numéro de version de la bibliothèque d'exécution SQLite, sous forme de "
|
||
"chaîne."
|
||
|
||
#: library/sqlite3.rst:466
|
||
#, fuzzy
|
||
msgid ""
|
||
"Version number of the runtime SQLite library as a :class:`tuple` of :class:"
|
||
"`integers <int>`."
|
||
msgstr ""
|
||
"Le numéro de version de la bibliothèque d'exécution SQLite, sous forme "
|
||
"d'entier."
|
||
|
||
#: library/sqlite3.rst:471
|
||
msgid ""
|
||
"Integer constant required by the DB-API, stating the level of thread safety "
|
||
"the :mod:`!sqlite3` module supports. Currently hard-coded to ``1``, meaning "
|
||
"*\"Threads may share the module, but not connections.\"* However, this may "
|
||
"not always be true. You can check the underlying SQLite library's compile-"
|
||
"time threaded mode using the following query::"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:484
|
||
msgid ""
|
||
"Note that the `SQLITE_THREADSAFE levels <https://sqlite.org/compile."
|
||
"html#threadsafe>`_ do not match the DB-API 2.0 ``threadsafety`` levels."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:490
|
||
#, fuzzy
|
||
msgid ""
|
||
"Version number of this module as a :class:`string <str>`. 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:495
|
||
#, fuzzy
|
||
msgid ""
|
||
"Version number of this module as a :class:`tuple` of :class:`integers "
|
||
"<int>`. 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:502
|
||
#, fuzzy
|
||
msgid "Connection objects"
|
||
msgstr "Objets de connexions"
|
||
|
||
#: library/sqlite3.rst:506
|
||
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:513
|
||
msgid ":ref:`sqlite3-connection-shortcuts`"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:516
|
||
msgid "An SQLite database connection has the following attributes and methods:"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:520
|
||
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:527
|
||
msgid ""
|
||
"Commit any pending transaction to the database. If there is no open "
|
||
"transaction, this method is a no-op."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:532
|
||
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:537
|
||
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:544
|
||
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:550
|
||
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:556
|
||
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:562
|
||
msgid "Create or remove a user-defined SQL function."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:564
|
||
msgid "The name of the SQL function."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:567
|
||
msgid ""
|
||
"The number of arguments the SQL function can accept. If ``-1``, it may take "
|
||
"any number of arguments."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:571
|
||
msgid ""
|
||
"A callable that is called when the SQL function is invoked. The callable "
|
||
"must return :ref:`a type natively supported by SQLite <sqlite3-types>`. Set "
|
||
"to ``None`` to remove an existing SQL function."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:578
|
||
msgid ""
|
||
"If ``True``, the created SQL function is marked as `deterministic <https://"
|
||
"sqlite.org/deterministic.html>`_, which allows SQLite to perform additional "
|
||
"optimizations."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:0
|
||
msgid "Raises"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:583
|
||
msgid "If *deterministic* is used with SQLite versions older than 3.8.3."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:586
|
||
msgid "The *deterministic* parameter."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:627 library/sqlite3.rst:952 library/sqlite3.rst:1087
|
||
#: library/sqlite3.rst:1247
|
||
msgid "Example:"
|
||
msgstr "Exemple :"
|
||
|
||
#: library/sqlite3.rst:605
|
||
msgid "Create or remove a user-defined SQL aggregate function."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:607
|
||
msgid "The name of the SQL aggregate function."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:610
|
||
msgid ""
|
||
"The number of arguments the SQL aggregate function can accept. If ``-1``, it "
|
||
"may take any number of arguments."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:614
|
||
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 <sqlite3-types>`. 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:615
|
||
msgid "A class must implement the following methods:"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:617
|
||
msgid "``step()``: Add a row to the aggregate."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:618
|
||
msgid ""
|
||
"``finalize()``: Return the final result of the aggregate as :ref:`a type "
|
||
"natively supported by SQLite <sqlite3-types>`."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:621
|
||
msgid ""
|
||
"The number of arguments that the ``step()`` method must accept is controlled "
|
||
"by *n_arg*."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:624
|
||
msgid "Set to ``None`` to remove an existing SQL aggregate function."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:659
|
||
msgid ""
|
||
"Create a collation named *name* using the collating function *callable*. "
|
||
"*callable* is passed two :class:`string <str>` arguments, and it should "
|
||
"return an :class:`integer <int>`:"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:663
|
||
msgid "``1`` if the first is ordered higher than the second"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:664
|
||
msgid "``-1`` if the first is ordered lower than the second"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:665
|
||
msgid "``0`` if they are ordered equal"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:667
|
||
msgid "The following example shows a reverse sorting collation:"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:695
|
||
msgid "Remove a collation function by setting *callable* to ``None``."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:700
|
||
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:707
|
||
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:713
|
||
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:720
|
||
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:727
|
||
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:732
|
||
msgid ""
|
||
"If you want to clear any previously installed progress handler, call the "
|
||
"method with ``None`` for *progress_handler*."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:735
|
||
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:742
|
||
msgid ""
|
||
"Register callable *trace_callback* to be invoked for each SQL statement that "
|
||
"is actually executed by the SQLite backend."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:745
|
||
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 "
|
||
"<sqlite3-controlling-transactions>` of the :mod:`!sqlite3` module and the "
|
||
"execution of triggers defined in the current database."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:753
|
||
msgid "Passing ``None`` as *trace_callback* will disable the trace callback."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:756
|
||
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:766
|
||
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:775
|
||
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:782
|
||
msgid ""
|
||
"Raises an :ref:`auditing event <auditing>` ``sqlite3.enable_load_extension`` "
|
||
"with arguments ``connection``, ``enabled``."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:786
|
||
msgid "Added the ``sqlite3.enable_load_extension`` auditing event."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:829
|
||
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:833
|
||
msgid ""
|
||
"Raises an :ref:`auditing event <auditing>` ``sqlite3.load_extension`` with "
|
||
"arguments ``connection``, ``path``."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:837
|
||
msgid "Added the ``sqlite3.load_extension`` auditing event."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:842
|
||
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:860
|
||
msgid "Create a backup of an SQLite database."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:862
|
||
msgid ""
|
||
"Works even if the database is being accessed by other clients or "
|
||
"concurrently by the same connection."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:865
|
||
msgid "The database connection to save the backup to."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:868
|
||
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:874
|
||
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:883
|
||
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:890
|
||
msgid ""
|
||
"The number of seconds to sleep between successive attempts to back up "
|
||
"remaining pages."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:894
|
||
msgid "Example 1, copy an existing database into another:"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:913
|
||
msgid "Example 2, copy an existing database into a transient copy:"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:925
|
||
msgid ""
|
||
"This read-only attribute corresponds to the low-level SQLite `autocommit "
|
||
"mode`_."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:928
|
||
msgid ""
|
||
"``True`` if a transaction is active (there are uncommitted changes), "
|
||
"``False`` otherwise."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:935
|
||
msgid ""
|
||
"This attribute controls the :ref:`transaction handling <sqlite3-controlling-"
|
||
"transactions>` 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 "
|
||
"<sqlite3-controlling-transactions>` is performed."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:943
|
||
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:948
|
||
msgid ""
|
||
"A callable that accepts two arguments, a :class:`Cursor` object and the raw "
|
||
"row results as a :class:`tuple`, and returns a custom object representing an "
|
||
"SQLite row."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:965
|
||
msgid ""
|
||
"If returning a tuple doesn't suffice and you want name-based access to "
|
||
"columns, you should consider setting :attr:`row_factory` to the highly "
|
||
"optimized :class:`sqlite3.Row` type. :class:`Row` provides both index-based "
|
||
"and case-insensitive name-based access to columns with almost no memory "
|
||
"overhead. It will probably be better than your own custom dictionary-based "
|
||
"approach or even a db_row based solution."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:976
|
||
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:1016
|
||
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:1022
|
||
msgid "Cursor objects"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1024
|
||
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 <sqlite3-connection-shortcuts>`."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1031
|
||
msgid ""
|
||
"Cursor objects are :term:`iterators <iterator>`, 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:1056
|
||
msgid "A :class:`Cursor` instance has the following attributes and methods."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1063
|
||
msgid ""
|
||
"Execute SQL statement *sql*. Bind values to the statement using :ref:"
|
||
"`placeholders <sqlite3-placeholders>` that map to the :term:`sequence` or :"
|
||
"class:`dict` *parameters*."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1068
|
||
msgid ""
|
||
":meth:`execute` will only execute a single SQL statement. If you try to "
|
||
"execute more than one statement with it, it will raise a :exc:`Warning`. "
|
||
"Use :meth:`executescript` if you want to execute multiple SQL statements "
|
||
"with one call."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1073
|
||
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:1081
|
||
msgid ""
|
||
"Execute :ref:`parameterized <sqlite3-placeholders>` SQL statement *sql* "
|
||
"against all parameter sequences or mappings found in the sequence "
|
||
"*parameters*. It is also possible to use an :term:`iterator` yielding "
|
||
"parameters instead of a sequence. Uses the same implicit transaction "
|
||
"handling as :meth:`~Cursor.execute`."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1100
|
||
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:1106
|
||
msgid "*sql_script* must be a :class:`string <str>`."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1124
|
||
msgid ""
|
||
"If :attr:`~Connection.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:1132
|
||
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:1135
|
||
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:1141
|
||
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:1148
|
||
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:1155
|
||
msgid "Close the cursor now (rather than whenever ``__del__`` is called)."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1157
|
||
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:1166
|
||
msgid "Required by the DB-API. Does nothing in :mod:`!sqlite3`."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1170
|
||
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:1175
|
||
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() <Connection.cursor>` will have a :attr:`connection` attribute "
|
||
"that refers to *con*:"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1189
|
||
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:1193
|
||
msgid "It is set for ``SELECT`` statements without any matching rows as well."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1197
|
||
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:1205
|
||
msgid "Inserts into ``WITHOUT ROWID`` tables are not recorded."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1207
|
||
msgid "Added support for the ``REPLACE`` statement."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1212
|
||
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:1227
|
||
msgid "Row objects"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1231
|
||
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:1236
|
||
msgid "Two row objects compare equal if have equal columns and equal members."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1240
|
||
msgid ""
|
||
"Return a :class:`list` of column names as :class:`strings <str>`. "
|
||
"Immediately after a query, it is the first member of each tuple in :attr:"
|
||
"`Cursor.description`."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1244
|
||
msgid "Added support of slicing."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1264
|
||
msgid "PrepareProtocol objects"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1268
|
||
msgid ""
|
||
"The PrepareProtocol type's single purpose is to act as a :pep:`246` style "
|
||
"adaption protocol for objects that can :ref:`adapt themselves <sqlite3-"
|
||
"conform>` to :ref:`native SQLite types <sqlite3-types>`."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1276
|
||
msgid "Exceptions"
|
||
msgstr "Exceptions"
|
||
|
||
#: library/sqlite3.rst:1278
|
||
msgid "The exception hierarchy is defined by the DB-API 2.0 (:pep:`249`)."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1282
|
||
msgid ""
|
||
"This exception is raised by :mod:`!sqlite3` if an SQL query is not a :class:"
|
||
"`string <str>`, or if multiple statements are passed to :meth:`~Cursor."
|
||
"execute` or :meth:`~Cursor.executemany`. ``Warning`` is a subclass of :exc:"
|
||
"`Exception`."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1289
|
||
#, fuzzy
|
||
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 ""
|
||
"La classe de base des autres exceptions de ce module. C'est une sous-classe "
|
||
"de :exc:`Exception`."
|
||
|
||
#: library/sqlite3.rst:1295
|
||
msgid ""
|
||
"This exception is raised by :mod:`!sqlite3` for fetch across rollback, or "
|
||
"if :mod:`!sqlite3` is unable to bind parameters. ``InterfaceError`` is a "
|
||
"subclass of :exc:`Error`."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1301
|
||
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:1308
|
||
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:1314
|
||
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:1322
|
||
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:1327
|
||
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:1334
|
||
msgid ""
|
||
"Exception raised for :mod:`!sqlite3` API programming errors, for example "
|
||
"trying to operate on a closed :class:`Connection`, or trying to execute non-"
|
||
"DML statements with :meth:`~Cursor.executemany`. ``ProgrammingError`` is a "
|
||
"subclass of :exc:`DatabaseError`."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1341
|
||
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:1351
|
||
msgid "SQLite and Python types"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1353
|
||
msgid ""
|
||
"SQLite natively supports the following types: ``NULL``, ``INTEGER``, "
|
||
"``REAL``, ``TEXT``, ``BLOB``."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1356
|
||
msgid ""
|
||
"The following Python types can thus be sent to SQLite without any problem:"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1376
|
||
msgid "Python type"
|
||
msgstr "Type Python"
|
||
|
||
#: library/sqlite3.rst:1376
|
||
msgid "SQLite type"
|
||
msgstr "SQLite type"
|
||
|
||
#: library/sqlite3.rst:1378
|
||
msgid "``None``"
|
||
msgstr "``None``"
|
||
|
||
#: library/sqlite3.rst:1378
|
||
msgid "``NULL``"
|
||
msgstr "``NULL``"
|
||
|
||
#: library/sqlite3.rst:1380
|
||
msgid ":class:`int`"
|
||
msgstr ":class:`int`"
|
||
|
||
#: library/sqlite3.rst:1380
|
||
msgid "``INTEGER``"
|
||
msgstr "``INTEGER``"
|
||
|
||
#: library/sqlite3.rst:1382
|
||
msgid ":class:`float`"
|
||
msgstr ":class:`float`"
|
||
|
||
#: library/sqlite3.rst:1382
|
||
msgid "``REAL``"
|
||
msgstr "``REAL``"
|
||
|
||
#: library/sqlite3.rst:1367
|
||
msgid ":class:`str`"
|
||
msgstr ":class:`str`"
|
||
|
||
#: library/sqlite3.rst:1384
|
||
msgid "``TEXT``"
|
||
msgstr "``TEXT``"
|
||
|
||
#: library/sqlite3.rst:1387
|
||
msgid ":class:`bytes`"
|
||
msgstr ":class:`bytes`"
|
||
|
||
#: library/sqlite3.rst:1387
|
||
msgid "``BLOB``"
|
||
msgstr "``BLOB``"
|
||
|
||
#: library/sqlite3.rst:1373
|
||
msgid "This is how SQLite types are converted to Python types by default:"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1384
|
||
msgid "depends on :attr:`~Connection.text_factory`, :class:`str` by default"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1390
|
||
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 <sqlite3-adapters>`, and you can let the :mod:`!sqlite3` module "
|
||
"convert SQLite types to Python types via :ref:`converters <sqlite3-"
|
||
"converters>`."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1400
|
||
msgid "Default adapters and converters"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1402
|
||
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:1405
|
||
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:1409
|
||
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:1413
|
||
msgid "The following example demonstrates this."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1417
|
||
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:1423
|
||
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:1432
|
||
msgid "How-to guides"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1437
|
||
msgid "How to use placeholders to bind values in SQL queries"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1439
|
||
#, 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`_ (see the `xkcd webcomic <https://xkcd."
|
||
"com/327/>`_ for a humorous example of what can go wrong)::"
|
||
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:1448
|
||
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. 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 <sequence>`. For the named style, "
|
||
"it can be either a :term:`sequence <sequence>` or :class:`dict` instance. "
|
||
"The length of the :term:`sequence <sequence>` must match the number of "
|
||
"placeholders, or a :exc:`ProgrammingError` is raised. If a :class:`dict` is "
|
||
"given, it must contain keys for all named parameters. Any extra items are "
|
||
"ignored. Here's an example of both styles:"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1490
|
||
msgid "How to adapt custom Python types to SQLite values"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1492
|
||
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 <sqlite3-types>`."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1496
|
||
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:1508
|
||
msgid "How to write adaptable objects"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1510
|
||
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:1541
|
||
msgid "How to register adapter callables"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1543
|
||
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:1573
|
||
msgid "How to convert SQLite values to custom Python types"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1575
|
||
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:1580
|
||
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:1583
|
||
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:1588
|
||
msgid ""
|
||
"Converter functions are **always** passed a :class:`bytes` object, no matter "
|
||
"the underlying SQLite data type."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1597
|
||
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:1601
|
||
msgid "Implicit: set *detect_types* to :const:`PARSE_DECLTYPES`"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1602
|
||
msgid "Explicit: set *detect_types* to :const:`PARSE_COLNAMES`"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1603
|
||
msgid ""
|
||
"Both: set *detect_types* to ``sqlite3.PARSE_DECLTYPES | sqlite3."
|
||
"PARSE_COLNAMES``. Column names take precedence over declared types."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1607
|
||
msgid "The following example illustrates the implicit and explicit approaches:"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1658
|
||
msgid "Adapter and converter recipes"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1660
|
||
msgid "This section shows recipes for common adapters and converters."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1703
|
||
msgid "How to use connection shortcut methods"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1705
|
||
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:1746
|
||
msgid "How to use the connection context manager"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1748
|
||
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:1757
|
||
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:1762
|
||
msgid ""
|
||
"The context manager neither implicitly opens a new transaction nor closes "
|
||
"the connection."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1795
|
||
msgid "How to work with SQLite URIs"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1797
|
||
msgid "Some useful URI tricks include:"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1799
|
||
msgid "Open a database in read-only mode:"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1808
|
||
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:1818
|
||
msgid "Create a shared named in-memory database:"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1832
|
||
msgid ""
|
||
"More information about this feature, including a list of parameters, can be "
|
||
"found in the `SQLite URI documentation`_."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1841
|
||
#, fuzzy
|
||
msgid "Explanation"
|
||
msgstr "Exceptions"
|
||
|
||
#: library/sqlite3.rst:1846
|
||
msgid "Transaction control"
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1848
|
||
msgid ""
|
||
"The :mod:`!sqlite3` module does not adhere to the transaction handling "
|
||
"recommended by :pep:`249`."
|
||
msgstr ""
|
||
|
||
#: library/sqlite3.rst:1851
|
||
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:1864
|
||
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:1872
|
||
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:1876
|
||
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 <iterator>`, "
|
||
#~ "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 ""
|
||
#~ "Instead, use the DB-API's parameter substitution. Put ``?`` as a "
|
||
#~ "placeholder wherever you want to use a value, and then provide a tuple of "
|
||
#~ "values as the second argument to the cursor's :meth:`~Cursor.execute` "
|
||
#~ "method. (Other database modules may use a different placeholder, such as "
|
||
#~ "``%s`` or ``:1``.) For example::"
|
||
#~ 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 ::"
|
||
|
||
#~ 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*."
|
||
|
||
#~ msgid "Multithreading"
|
||
#~ msgstr "Fils d'exécution"
|