From c2c85f28c095dc59b6569f126dbffcd6eae2ff5a Mon Sep 17 00:00:00 2001 From: finevine Date: Fri, 17 Feb 2023 17:27:17 +0000 Subject: [PATCH] FIRST sqlite3 commit closes #80 (#81) Co-authored-by: finevine Reviewed-on: https://git.afpy.org/AFPy/python-docs-fr/pulls/81 Co-authored-by: finevine Co-committed-by: finevine --- library/sqlite3.po | 182 +++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 166 insertions(+), 16 deletions(-) diff --git a/library/sqlite3.po b/library/sqlite3.po index 2d6f7b4b..0c459f29 100644 --- a/library/sqlite3.po +++ b/library/sqlite3.po @@ -6,14 +6,14 @@ 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: 2019-03-26 15:55+0100\n" +"PO-Revision-Date: 2023-02-17 18:06+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 2.0.6\n" +"X-Generator: Poedit 3.2.2\n" #: library/sqlite3.rst:2 msgid ":mod:`sqlite3` --- DB-API 2.0 interface for SQLite databases" @@ -52,27 +52,35 @@ msgstr "" #: library/sqlite3.rst:34 msgid "This document includes four main sections:" -msgstr "" +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" @@ -104,7 +112,7 @@ msgstr "PEP écrite par Marc-André Lemburg." #: library/sqlite3.rst:66 msgid "Tutorial" -msgstr "" +msgstr "Tutoriel" #: library/sqlite3.rst:68 msgid "" @@ -112,6 +120,10 @@ msgid "" "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 "" @@ -120,12 +132,19 @@ msgid "" "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 "" @@ -133,6 +152,9 @@ msgid "" "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 "" @@ -143,6 +165,14 @@ msgid "" "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 "" @@ -153,6 +183,13 @@ msgid "" "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 "" @@ -160,6 +197,10 @@ msgid "" "`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 "" @@ -167,6 +208,9 @@ msgid "" "``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 "" @@ -175,6 +219,11 @@ msgid "" "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 "" @@ -183,18 +232,27 @@ msgid "" "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 "" @@ -203,18 +261,28 @@ msgid "" "to bind Python values to SQL statements, to avoid `SQL injection attacks`_ " "(see :ref:`sqlite3-placeholders` for more details)." msgstr "" +"Remarquez que les placeholders ``?`` sont utilisés pour lier les ``data`` à " +"la requête. Utilisez toujours les placeholders 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 "" @@ -222,64 +290,76 @@ msgid "" "`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 "" +msgstr ":ref:`guide sqlite3 ` pour une lecture plus poussée:" #: library/sqlite3.rst:238 msgid ":ref:`sqlite3-placeholders`" -msgstr "" +msgstr ":ref:`placeholders sqlite3 `" #: library/sqlite3.rst:239 msgid ":ref:`sqlite3-adapters`" -msgstr "" +msgstr ":ref:`adaptateurs sqlite3 `" #: library/sqlite3.rst:240 msgid ":ref:`sqlite3-converters`" -msgstr "" +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 "" +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 "" +msgstr "Références" #: library/sqlite3.rst:257 -#, fuzzy msgid "Module functions" -msgstr "Fonctions et constantes du module" +msgstr "Fonctions du module" #: library/sqlite3.rst:264 msgid "Open a connection to an SQLite database." -msgstr "" +msgstr "Ouvrez une connexion à une base de données SQLite." #: library/sqlite3.rst:0 msgid "Parameters" -msgstr "" +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 "" @@ -288,6 +368,11 @@ msgid "" "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 "" @@ -301,6 +386,17 @@ msgid "" "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 "" @@ -310,6 +406,12 @@ msgid "" "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 "" @@ -319,18 +421,29 @@ msgid "" "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 "" @@ -340,6 +453,12 @@ msgid "" "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 @@ -366,6 +485,8 @@ msgstr "" 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." @@ -378,9 +499,13 @@ msgid "" "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 -#, fuzzy msgid "For example:" msgstr "Exemple :" @@ -390,6 +515,10 @@ msgid "" "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 "" @@ -399,12 +528,22 @@ msgid "" "*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 "" @@ -413,6 +552,10 @@ msgid "" "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 "" @@ -423,15 +566,22 @@ msgid "" "parameter *detect_types* of :func:`connect` for information regarding how " "type detection works." msgstr "" +"Enregistre le *convertisseur* appellable 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 -#, fuzzy msgid "Module constants" msgstr "Fonctions et constantes du module"