python-docs-fr/library/sqlite3.po

# 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-05-22 23:13+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:13
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:20
#, fuzzy
msgid ""
"The 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:24
#, 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` ::"

#: library/sqlite3.rst:31
#, 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."

#: library/sqlite3.rst:34
#, 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 ::"

#: library/sqlite3.rst:53
msgid ""
"The saved data is persistent: it can be reloaded in a subsequent session "
"even after restarting the Python interpreter::"
msgstr ""

#: library/sqlite3.rst:60
#, 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."

#: library/sqlite3.rst:65
msgid "This example uses the iterator form::"
msgstr "Cet exemple utilise la forme itérateur ::"

#: library/sqlite3.rst:78
#, 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:87
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:107
msgid "https://www.sqlite.org"
msgstr "https://www.sqlite.org"

#: library/sqlite3.rst:106
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:110
msgid "https://www.w3schools.com/sql/"
msgstr "https://www.w3schools.com/sql/"

#: library/sqlite3.rst:110
msgid "Tutorial, reference and examples for learning SQL syntax."
msgstr "Tutoriel, référence et exemples pour apprendre la syntaxe SQL."

#: library/sqlite3.rst:112
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:113
msgid "PEP written by Marc-André Lemburg."
msgstr "PEP écrite par Marc-André Lemburg."

#: library/sqlite3.rst:119
msgid "Module functions and constants"
msgstr "Fonctions et constantes du module"

#: library/sqlite3.rst:124
msgid ""
"String constant stating the supported DB-API level. Required by the DB-API. "
"Hard-coded to ``\"2.0\"``."
msgstr ""

#: library/sqlite3.rst:129
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:135
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:142
msgid ""
"The version number of this module, as a string. This is not the version of "
"the SQLite library."
msgstr ""
"Le numéro de version de ce module, sous forme de chaîne. Ce n'est pas la "
"version de la bibliothèque SQLite."

#: library/sqlite3.rst:148
msgid ""
"The version number of this module, as a tuple of integers. This is not the "
"version of the SQLite library."
msgstr ""
"Le numéro de version de ce module, sous forme d'un *n*-uplet d'entiers. Ce "
"n'est pas la version de la bibliothèque SQLite."

#: library/sqlite3.rst:154
msgid "The version number of the run-time SQLite library, as a string."
msgstr ""
"Le numéro de version de la bibliothèque d'exécution SQLite, sous forme de "
"chaîne."

#: library/sqlite3.rst:159
msgid ""
"The version number of the run-time SQLite library, as a tuple of integers."
msgstr ""
"Le numéro de version de la bibliothèque d'exécution SQLite, sous forme "
"d'entier."

#: library/sqlite3.rst:164
msgid ""
"Integer constant required by the DB-API 2.0, stating the level of thread "
"safety the :mod:`sqlite3` module supports. This attribute is set based on "
"the default `threading mode <https://sqlite.org/threadsafe.html>`_ the "
"underlying SQLite library is compiled with. The SQLite threading modes are:"
msgstr ""

#: library/sqlite3.rst:169
msgid ""
"**Single-thread**: In this mode, all mutexes are disabled and SQLite is "
"unsafe to use in more than a single thread at once."
msgstr ""

#: library/sqlite3.rst:171
msgid ""
"**Multi-thread**: In this mode, SQLite can be safely used by multiple "
"threads provided that no single database connection is used simultaneously "
"in two or more threads."
msgstr ""

#: library/sqlite3.rst:174
msgid ""
"**Serialized**: In serialized mode, SQLite can be safely used by multiple "
"threads with no restriction."
msgstr ""

#: library/sqlite3.rst:177
msgid ""
"The mappings from SQLite threading modes to DB-API 2.0 threadsafety levels "
"are as follows:"
msgstr ""

#: library/sqlite3.rst:181
msgid "SQLite threading mode"
msgstr ""

#: library/sqlite3.rst:181
msgid "`threadsafety`_"
msgstr ""

#: library/sqlite3.rst:181
msgid "`SQLITE_THREADSAFE`_"
msgstr ""

#: library/sqlite3.rst:181
msgid "DB-API 2.0 meaning"
msgstr ""

#: library/sqlite3.rst:184
msgid "single-thread"
msgstr ""

#: library/sqlite3.rst:184
msgid "0"
msgstr ""

#: library/sqlite3.rst:184
msgid "Threads may not share the module"
msgstr ""

#: library/sqlite3.rst:187
#, fuzzy
msgid "multi-thread"
msgstr "Fils d'exécution"

#: library/sqlite3.rst:190
msgid "1"
msgstr ""

#: library/sqlite3.rst:187
msgid "2"
msgstr ""

#: library/sqlite3.rst:187
msgid "Threads may share the module, but not connections"
msgstr ""

#: library/sqlite3.rst:190
msgid "serialized"
msgstr ""

#: library/sqlite3.rst:190
msgid "3"
msgstr ""

#: library/sqlite3.rst:190
msgid "Threads may share the module, connections and cursors"
msgstr ""

#: library/sqlite3.rst:197
msgid "Set *threadsafety* dynamically instead of hard-coding it to ``1``."
msgstr ""

#: library/sqlite3.rst:215
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`."

#: library/sqlite3.rst:205
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."

#: library/sqlite3.rst:218
#, 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*."

#: library/sqlite3.rst:231
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é."

#: library/sqlite3.rst:234
msgid ""
"*database* is a :term:`path-like object` giving the pathname (absolute or "
"relative to the current  working directory) of the database file to be "
"opened. You can use ``\":memory:\"`` to open a database connection to a "
"database that resides in RAM instead of on disk."
msgstr ""

#: library/sqlite3.rst:239
msgid ""
"When a database is accessed by multiple connections, and one of the "
"processes modifies the database, the SQLite database is locked until that "
"transaction is committed. The *timeout* parameter specifies how long the "
"connection should wait for the lock to go away until raising an exception. "
"The default for the timeout parameter is 5.0 (five seconds)."
msgstr ""

#: library/sqlite3.rst:245
msgid ""
"For the *isolation_level* parameter, please see the :attr:`~Connection."
"isolation_level` property of :class:`Connection` objects."
msgstr ""

#: library/sqlite3.rst:248
msgid ""
"SQLite natively supports only the types TEXT, INTEGER, REAL, BLOB and NULL. "
"If you want to use other types you must add support for them yourself. The "
"*detect_types* parameter and the using custom **converters** registered with "
"the module-level :func:`register_converter` function allow you to easily do "
"that."
msgstr ""

#: library/sqlite3.rst:253
msgid ""
"*detect_types* defaults to 0 (i. e. off, no type detection), you can set it "
"to any combination of :const:`PARSE_DECLTYPES` and :const:`PARSE_COLNAMES` "
"to turn type detection on. Due to SQLite behaviour, types can't be detected "
"for generated fields (for example ``max(data)``), even when *detect_types* "
"parameter is set. In such case, the returned type is :class:`str`."
msgstr ""

#: library/sqlite3.rst:259
msgid ""
"By default, *check_same_thread* is :const:`True` and only the creating "
"thread may use the connection. If set :const:`False`, the returned "
"connection may be shared across multiple threads. When using multiple "
"threads with the same connection writing operations should be serialized by "
"the user to avoid data corruption."
msgstr ""

#: library/sqlite3.rst:264
msgid ""
"By default, the :mod:`sqlite3` module uses its :class:`Connection` class for "
"the connect call.  You can, however, subclass the :class:`Connection` class "
"and make :func:`connect` use your class instead by providing your class for "
"the *factory* parameter."
msgstr ""

#: library/sqlite3.rst:269
msgid "Consult the section :ref:`sqlite3-types` of this manual for details."
msgstr ""

#: library/sqlite3.rst:271
msgid ""
"The :mod:`sqlite3` module internally uses a statement cache to avoid SQL "
"parsing overhead. If you want to explicitly set the number of statements "
"that are cached for the connection, you can set the *cached_statements* "
"parameter. The currently implemented default is to cache 128 statements."
msgstr ""

#: library/sqlite3.rst:276
msgid ""
"If *uri* is :const:`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:\"``.  The path can be a "
"relative or absolute file path.  The query string allows us to pass "
"parameters to SQLite. Some useful URI tricks include::"
msgstr ""

#: library/sqlite3.rst:295
msgid ""
"More information about this feature, including a list of recognized "
"parameters, can be found in the `SQLite URI documentation <https://www."
"sqlite.org/uri.html>`_."
msgstr ""

#: library/sqlite3.rst:299
msgid ""
"Raises an :ref:`auditing event <auditing>` ``sqlite3.connect`` with argument "
"``database``."
msgstr ""

#: library/sqlite3.rst:300
msgid ""
"Raises an :ref:`auditing event <auditing>` ``sqlite3.connect/handle`` with "
"argument ``connection_handle``."
msgstr ""

#: library/sqlite3.rst:302
msgid "Added the *uri* parameter."
msgstr ""

#: library/sqlite3.rst:305
msgid ""
"*database* can now also be a :term:`path-like object`, not only a string."
msgstr ""

#: library/sqlite3.rst:308
msgid "Added the ``sqlite3.connect/handle`` auditing event."
msgstr ""

#: library/sqlite3.rst:314
msgid ""
"Registers a callable to convert a bytestring from the database into a custom "
"Python type. The callable will be invoked for all database values that are "
"of the type *typename*. Confer the parameter *detect_types* of the :func:"
"`connect` function for how the type detection works. Note that *typename* "
"and the name of the type in your query are matched in case-insensitive "
"manner."
msgstr ""

#: library/sqlite3.rst:323
msgid ""
"Registers a callable to convert the custom Python type *type* into one of "
"SQLite's supported types. The callable *callable* accepts as single "
"parameter the Python value, and must return a value of the following types: "
"int, float, str or bytes."
msgstr ""

#: library/sqlite3.rst:331
msgid ""
"Returns :const:`True` if the string *sql* contains one or more complete SQL "
"statements terminated by semicolons. It does not verify that the SQL is "
"syntactically correct, only that there are no unclosed string literals and "
"the statement is terminated by a semicolon."
msgstr ""

#: library/sqlite3.rst:336
msgid ""
"This can be used to build a shell for SQLite, as in the following example:"
msgstr ""

#: library/sqlite3.rst:344
msgid ""
"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 :const:`True`. Afterwards, you "
"will get tracebacks from callbacks on :data:`sys.stderr`. Use :const:`False` "
"to disable the feature again."
msgstr ""

#: library/sqlite3.rst:350
msgid ""
"Register an :func:`unraisable hook handler <sys.unraisablehook>` for an "
"improved debug experience::"
msgstr ""

#: library/sqlite3.rst:372
msgid "Connection Objects"
msgstr "Objets de connexions"

#: library/sqlite3.rst:376
msgid "An SQLite database connection has the following attributes and methods:"
msgstr ""

#: library/sqlite3.rst:380
msgid ""
"Get or set the current default isolation level. :const:`None` for autocommit "
"mode or one of \"DEFERRED\", \"IMMEDIATE\" or \"EXCLUSIVE\". See section :"
"ref:`sqlite3-controlling-transactions` for a more detailed explanation."
msgstr ""

#: library/sqlite3.rst:386
msgid ""
":const:`True` if a transaction is active (there are uncommitted changes), :"
"const:`False` otherwise.  Read-only attribute."
msgstr ""

#: library/sqlite3.rst:393
msgid ""
"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:399
msgid ""
"Open a :class:`Blob` handle to the :abbr:`BLOB (Binary Large OBject)` "
"located in table name *table*, column name *column*, and row index *row* of "
"database *name*. When *readonly* is :const:`True` the blob is opened without "
"write permissions. Trying to open a blob in a ``WITHOUT ROWID`` table will "
"raise :exc:`OperationalError`."
msgstr ""

#: library/sqlite3.rst:409
msgid ""
"The blob size cannot be changed using the :class:`Blob` class. Use the SQL "
"function ``zeroblob`` to create a blob with a fixed size."
msgstr ""

#: library/sqlite3.rst:416
msgid ""
"This method commits the current transaction. If you don't call this method, "
"anything you did since the last call to ``commit()`` is not visible from "
"other database connections. If you wonder why you don't see the data you've "
"written to the database, please check you didn't forget to call this method."
msgstr ""

#: library/sqlite3.rst:423
msgid ""
"This method rolls back any changes to the database since the last call to :"
"meth:`commit`."
msgstr ""

#: library/sqlite3.rst:428
msgid ""
"This closes the database connection. Note that this does not automatically "
"call :meth:`commit`. If you just close your database connection without "
"calling :meth:`commit` first, your changes will be lost!"
msgstr ""

#: library/sqlite3.rst:434
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:440
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:446
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:452
msgid ""
"Creates a user-defined function that you can later use from within SQL "
"statements under the function name *name*. *num_params* is the number of "
"parameters the function accepts (if *num_params* is -1, the function may "
"take any number of arguments), and *func* is a Python callable that is "
"called as the SQL function. If *deterministic* is true, the created function "
"is marked as `deterministic <https://sqlite.org/deterministic.html>`_, which "
"allows SQLite to perform additional optimizations. This flag is supported by "
"SQLite 3.8.3 or higher, :exc:`NotSupportedError` will be raised if used with "
"older versions."
msgstr ""

#: library/sqlite3.rst:462
msgid ""
"The function can return any of the types supported by SQLite: bytes, str, "
"int, float and ``None``."
msgstr ""

#: library/sqlite3.rst:465
msgid "The *deterministic* parameter was added."
msgstr ""

#: library/sqlite3.rst:485 library/sqlite3.rst:652 library/sqlite3.rst:875
msgid "Example:"
msgstr "Exemple :"

#: library/sqlite3.rst:475
msgid "Creates a user-defined aggregate function."
msgstr ""

#: library/sqlite3.rst:477
msgid ""
"The aggregate class must implement a ``step`` method, which accepts the "
"number of parameters *num_params* (if *num_params* is -1, the function may "
"take any number of arguments), and a ``finalize`` method which will return "
"the final result of the aggregate."
msgstr ""

#: library/sqlite3.rst:482
msgid ""
"The ``finalize`` method can return any of the types supported by SQLite: "
"bytes, str, int, float and ``None``."
msgstr ""

#: library/sqlite3.rst:492
msgid "Creates user-defined aggregate window function *name*."
msgstr ""

#: library/sqlite3.rst:494
msgid "*aggregate_class* must implement the following methods:"
msgstr ""

#: library/sqlite3.rst:496
msgid "``step``: adds a row to the current window"
msgstr ""

#: library/sqlite3.rst:497
msgid "``value``: returns the current value of the aggregate"
msgstr ""

#: library/sqlite3.rst:498
msgid "``inverse``: removes a row from the current window"
msgstr ""

#: library/sqlite3.rst:499
msgid "``finalize``: returns the final value of the aggregate"
msgstr ""

#: library/sqlite3.rst:501
msgid ""
"``step`` and ``value`` accept *num_params* number of parameters, unless "
"*num_params* is ``-1``, in which case they may take any number of "
"arguments.  ``finalize`` and ``value`` can return any of the types supported "
"by SQLite: :class:`bytes`, :class:`str`, :class:`int`, :class:`float`, and :"
"const:`None`.  Call :meth:`create_window_function` with *aggregate_class* "
"set to :const:`None` to clear window function *name*."
msgstr ""

#: library/sqlite3.rst:509
msgid ""
"Aggregate window functions are supported by SQLite 3.25.0 and higher. :exc:"
"`NotSupportedError` will be raised if used with older versions."
msgstr ""

#: library/sqlite3.rst:521
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:525
msgid "``1`` if the first is ordered higher than the second"
msgstr ""

#: library/sqlite3.rst:526
msgid "``-1`` if the first is ordered lower than the second"
msgstr ""

#: library/sqlite3.rst:527
msgid "``0`` if they are ordered equal"
msgstr ""

#: library/sqlite3.rst:529
msgid "The following example shows a reverse sorting collation:"
msgstr ""

#: library/sqlite3.rst:533
msgid "Remove a collation function by setting *callable* to :const:`None`."
msgstr ""

#: library/sqlite3.rst:535
msgid ""
"The collation name can contain any Unicode character.  Earlier, only ASCII "
"characters were allowed."
msgstr ""

#: library/sqlite3.rst:542
msgid ""
"You can call this method from a different thread to abort any queries that "
"might be executing on the connection. The query will then abort and the "
"caller will get an exception."
msgstr ""

#: library/sqlite3.rst:549
msgid ""
"This routine registers a callback. The callback is invoked for each attempt "
"to access a column of a table in the database. The callback should return :"
"const:`SQLITE_OK` if access is allowed, :const:`SQLITE_DENY` if the entire "
"SQL statement should be aborted with an error and :const:`SQLITE_IGNORE` if "
"the column should be treated as a NULL value. These constants are available "
"in the :mod:`sqlite3` module."
msgstr ""

#: library/sqlite3.rst:556
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 :const:`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 :const:`None` if this access attempt is directly from input SQL "
"code."
msgstr ""

#: library/sqlite3.rst:563
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:567
msgid ""
"Passing :const:`None` as *authorizer_callback* will disable the authorizer."
msgstr ""

#: library/sqlite3.rst:569
msgid "Added support for disabling the authorizer using :const:`None`."
msgstr ""

#: library/sqlite3.rst:575
msgid ""
"This routine registers a callback. The callback is 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:580
msgid ""
"If you want to clear any previously installed progress handler, call the "
"method with :const:`None` for *handler*."
msgstr ""

#: library/sqlite3.rst:583
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:590
msgid ""
"Registers *trace_callback* to be called for each SQL statement that is "
"actually executed by the SQLite backend."
msgstr ""

#: library/sqlite3.rst:593
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 sqlite3 module and the execution "
"of triggers defined in the current database."
msgstr ""

#: library/sqlite3.rst:601
msgid ""
"Passing :const:`None` as *trace_callback* will disable the trace callback."
msgstr ""

#: library/sqlite3.rst:604
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:614
msgid ""
"This routine allows/disallows the SQLite engine to load SQLite extensions "
"from shared libraries.  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:636
msgid "Loadable extensions are disabled by default. See [#f1]_."
msgstr ""

#: library/sqlite3.rst:621
msgid ""
"Raises an :ref:`auditing event <auditing>` ``sqlite3.enable_load_extension`` "
"with arguments ``connection``, ``enabled``."
msgstr ""

#: library/sqlite3.rst:625
msgid "Added the ``sqlite3.enable_load_extension`` auditing event."
msgstr ""

#: library/sqlite3.rst:632
msgid ""
"This routine loads an SQLite extension from a shared library.  You have to "
"enable extension loading with :meth:`enable_load_extension` before you can "
"use this routine."
msgstr ""

#: library/sqlite3.rst:638
msgid ""
"Raises an :ref:`auditing event <auditing>` ``sqlite3.load_extension`` with "
"arguments ``connection``, ``path``."
msgstr ""

#: library/sqlite3.rst:642
msgid "Added the ``sqlite3.load_extension`` auditing event."
msgstr ""

#: library/sqlite3.rst:647
msgid ""
"You can change this attribute to a callable that accepts the cursor and the "
"original row as a tuple and will return the real result row.  This way, you "
"can implement more advanced ways of returning results, such  as returning an "
"object that can also access columns by name."
msgstr ""

#: library/sqlite3.rst:656
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:668
msgid ""
"Using this attribute you can control what objects are returned for the "
"``TEXT`` data type. By default, this attribute is set to :class:`str` and "
"the :mod:`sqlite3` module will return :class:`str` objects for ``TEXT``. If "
"you want to return :class:`bytes` instead, you can set it to :class:`bytes`."
msgstr ""

#: library/sqlite3.rst:673
msgid ""
"You can also set it to any other callable that accepts a single bytestring "
"parameter and returns the resulting object."
msgstr ""

#: library/sqlite3.rst:676
msgid "See the following example code for illustration:"
msgstr ""

#: library/sqlite3.rst:683
msgid ""
"Returns the total number of database rows that have been modified, inserted, "
"or deleted since the database connection was opened."
msgstr ""

#: library/sqlite3.rst:689
msgid ""
"Returns an iterator to dump the database in an SQL text format.  Useful when "
"saving an in-memory database for later restoration.  This function provides "
"the same capabilities as the :kbd:`.dump` command in the :program:`sqlite3` "
"shell."
msgstr ""

#: library/sqlite3.rst:694
msgid "Example::"
msgstr "Exemple ::"

#: library/sqlite3.rst:708
msgid ""
"This method makes a backup of an SQLite database even while it's being "
"accessed by other clients, or concurrently by the same connection.  The copy "
"will be written into the mandatory argument *target*, that must be another :"
"class:`Connection` instance."
msgstr ""

#: library/sqlite3.rst:713
msgid ""
"By default, or when *pages* is either ``0`` or a negative integer, the "
"entire database is copied in a single step; otherwise the method performs a "
"loop copying up to *pages* pages at a time."
msgstr ""

#: library/sqlite3.rst:717
msgid ""
"If *progress* is specified, it must either be ``None`` or a callable object "
"that will be executed at each iteration with three integer arguments, "
"respectively the *status* of the last iteration, the *remaining* number of "
"pages still to be copied and the *total* number of pages."
msgstr ""

#: library/sqlite3.rst:722
msgid ""
"The *name* argument specifies the database name that will be copied: it must "
"be a string containing either ``\"main\"``, the default, to indicate the "
"main database, ``\"temp\"`` to indicate the temporary database or the name "
"specified after the ``AS`` keyword in an ``ATTACH DATABASE`` statement for "
"an attached database."
msgstr ""

#: library/sqlite3.rst:728
msgid ""
"The *sleep* argument specifies the number of seconds to sleep by between "
"successive attempts to backup remaining pages, can be specified either as an "
"integer or a floating point value."
msgstr ""

#: library/sqlite3.rst:732
msgid "Example 1, copy an existing database into another::"
msgstr ""

#: library/sqlite3.rst:746
msgid "Example 2, copy an existing database into a transient copy::"
msgstr ""

#: library/sqlite3.rst:759
msgid ""
"Get a connection run-time limit. *category* is the limit category to be "
"queried."
msgstr ""

#: library/sqlite3.rst:762
msgid "Example, query the maximum length of an SQL statement::"
msgstr ""

#: library/sqlite3.rst:774
msgid ""
"Set a connection run-time limit. *category* is the limit category to be set. "
"*limit* is the new limit. If the new limit is a negative number, the limit "
"is unchanged."
msgstr ""

#: library/sqlite3.rst:778
msgid ""
"Attempts to increase a limit above its hard upper bound are silently "
"truncated to the hard upper bound. Regardless of whether or not the limit "
"was changed, the prior value of the limit is returned."
msgstr ""

#: library/sqlite3.rst:782
msgid "Example, limit the number of attached databases to 1::"
msgstr ""

#: library/sqlite3.rst:793
msgid ""
"This method serializes a database into a :class:`bytes` object.  For an "
"ordinary on-disk database file, the serialization is just a copy of the disk "
"file.  For an in-memory database or a \"temp\" database, the serialization "
"is the same sequence of bytes which would be written to disk if that "
"database were backed up to disk."
msgstr ""

#: library/sqlite3.rst:799
msgid ""
"*name* is the database to be serialized, and defaults to the main database."
msgstr ""

#: library/sqlite3.rst:804
msgid ""
"This method is only available if the underlying SQLite library has the "
"serialize API."
msgstr ""

#: library/sqlite3.rst:812
msgid ""
"This method causes the database connection to disconnect from database "
"*name*, and reopen *name* as an in-memory database based on the "
"serialization contained in *data*.  Deserialization will raise :exc:"
"`OperationalError` if the database connection is currently involved in a "
"read transaction or a backup operation.  :exc:`DataError` will be raised if "
"``len(data)`` is larger than ``2**63 - 1``, and :exc:`DatabaseError` will be "
"raised if *data* does not contain a valid SQLite database."
msgstr ""

#: library/sqlite3.rst:823
msgid ""
"This method is only available if the underlying SQLite library has the "
"deserialize API."
msgstr ""

#: library/sqlite3.rst:832
msgid "Cursor Objects"
msgstr ""

#: library/sqlite3.rst:836
msgid "A :class:`Cursor` instance has the following attributes and methods."
msgstr ""

#: library/sqlite3.rst:843
msgid ""
"Executes an SQL statement. Values may be bound to the statement using :ref:"
"`placeholders <sqlite3-placeholders>`."
msgstr ""

#: library/sqlite3.rst:846
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:854
msgid ""
"Executes a :ref:`parameterized <sqlite3-placeholders>` SQL command against "
"all parameter sequences or mappings found in the sequence "
"*seq_of_parameters*. The :mod:`sqlite3` module also allows using an :term:"
"`iterator` yielding parameters instead of a sequence."
msgstr ""

#: library/sqlite3.rst:861
msgid "Here's a shorter example using a :term:`generator`:"
msgstr ""

#: library/sqlite3.rst:868
msgid ""
"This is a nonstandard convenience method for executing multiple SQL "
"statements at once. It issues a ``COMMIT`` statement first, then executes "
"the SQL script it gets as a parameter.  This method disregards :attr:"
"`isolation_level`; any transaction control must be added to *sql_script*."
msgstr ""

#: library/sqlite3.rst:873
msgid "*sql_script* can be an instance of :class:`str`."
msgstr ""

#: library/sqlite3.rst:882
msgid ""
"Fetches the next row of a query result set, returning a single sequence, or :"
"const:`None` when no more data is available."
msgstr ""

#: library/sqlite3.rst:888
msgid ""
"Fetches the next set of rows of a query result, returning a list.  An empty "
"list is returned when no more rows are available."
msgstr ""

#: library/sqlite3.rst:891
msgid ""
"The number of rows to fetch per call is specified by the *size* parameter. "
"If it is not given, the cursor's arraysize determines the number of rows to "
"be fetched. The method should try to fetch as many rows as indicated by the "
"size parameter. If this is not possible due to the specified number of rows "
"not being available, fewer rows may be returned."
msgstr ""

#: library/sqlite3.rst:897
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:904
msgid ""
"Fetches all (remaining) rows of a query result, returning a list.  Note that "
"the cursor's arraysize attribute can affect the performance of this "
"operation. An empty list is returned when no rows are available."
msgstr ""

#: library/sqlite3.rst:910
msgid "Close the cursor now (rather than whenever ``__del__`` is called)."
msgstr ""

#: library/sqlite3.rst:912
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:921
msgid "Required by the DB-API. Does nothing in :mod:`sqlite3`."
msgstr ""

#: library/sqlite3.rst:925
msgid ""
"Although the :class:`Cursor` class of the :mod:`sqlite3` module implements "
"this attribute, the database engine's own support for the determination of "
"\"rows affected\"/\"rows selected\" is quirky."
msgstr ""

#: library/sqlite3.rst:929
msgid ""
"For :meth:`executemany` statements, the number of modifications are summed "
"up into :attr:`rowcount`."
msgstr ""

#: library/sqlite3.rst:932
msgid ""
"As required by the Python DB API Spec, the :attr:`rowcount` attribute \"is "
"-1 in case no ``executeXX()`` has been performed on the cursor or the "
"rowcount of the last operation is not determinable by the interface\". This "
"includes ``SELECT`` statements because we cannot determine the number of "
"rows a query produced until all rows were fetched."
msgstr ""

#: library/sqlite3.rst:940
msgid ""
"This read-only attribute 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 :"
"const:`None`."
msgstr ""

#: library/sqlite3.rst:948
msgid "Inserts into ``WITHOUT ROWID`` tables are not recorded."
msgstr ""

#: library/sqlite3.rst:950
msgid "Added support for the ``REPLACE`` statement."
msgstr ""

#: library/sqlite3.rst:955
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:960
msgid ""
"This read-only attribute 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 :const:`None`."
msgstr ""

#: library/sqlite3.rst:964
msgid "It is set for ``SELECT`` statements without any matching rows as well."
msgstr ""

#: library/sqlite3.rst:968
msgid ""
"This read-only attribute provides the SQLite database :class:`Connection` "
"used by the :class:`Cursor` object.  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:981
msgid "Row Objects"
msgstr ""

#: library/sqlite3.rst:985
msgid ""
"A :class:`Row` instance serves as a highly optimized :attr:`~Connection."
"row_factory` for :class:`Connection` objects. It tries to mimic a tuple in "
"most of its features."
msgstr ""

#: library/sqlite3.rst:989
msgid ""
"It supports mapping access by column name and index, iteration, "
"representation, equality testing and :func:`len`."
msgstr ""

#: library/sqlite3.rst:992
msgid ""
"If two :class:`Row` objects have exactly the same columns and their members "
"are equal, they compare equal."
msgstr ""

#: library/sqlite3.rst:997
msgid ""
"This method returns a list of column names. Immediately after a query, it is "
"the first member of each tuple in :attr:`Cursor.description`."
msgstr ""

#: library/sqlite3.rst:1000
msgid "Added support of slicing."
msgstr ""

#: library/sqlite3.rst:1003
msgid "Let's assume we initialize a table as in the example given above::"
msgstr ""

#: library/sqlite3.rst:1015
msgid "Now we plug :class:`Row` in::"
msgstr ""

#: library/sqlite3.rst:1045
#, fuzzy
msgid "Blob Objects"
msgstr "Objets de connexions"

#: library/sqlite3.rst:1051
msgid ""
"A :class:`Blob` instance is a :term:`file-like object` that can read and "
"write data in an SQLite :abbr:`BLOB (Binary Large OBject)`. Call :func:"
"`len(blob) <len>` to get the size (number of bytes) of the blob. Use indices "
"and :term:`slices <slice>` for direct access to the blob data."
msgstr ""

#: library/sqlite3.rst:1056
msgid ""
"Use the :class:`Blob` as a :term:`context manager` to ensure that the blob "
"handle is closed after use."
msgstr ""

#: library/sqlite3.rst:1063
msgid "Close the blob."
msgstr ""

#: library/sqlite3.rst:1065
msgid ""
"The blob will be unusable from this point onward.  An :class:`~sqlite3."
"Error` (or subclass) exception will be raised if any further operation is "
"attempted with the blob."
msgstr ""

#: library/sqlite3.rst:1071
msgid ""
"Read *length* bytes of data from the blob at the current offset position. If "
"the end of the blob is reached, the data up to :abbr:`EOF (End of File)` "
"will be returned.  When *length* is not specified, or is negative, :meth:"
"`~Blob.read` will read until the end of the blob."
msgstr ""

#: library/sqlite3.rst:1079
msgid ""
"Write *data* to the blob at the current offset.  This function cannot change "
"the blob length.  Writing beyond the end of the blob will raise :exc:"
"`ValueError`."
msgstr ""

#: library/sqlite3.rst:1085
msgid "Return the current access position of the blob."
msgstr ""

#: library/sqlite3.rst:1089
msgid ""
"Set the current access position of the blob to *offset*.  The *origin* "
"argument defaults to :data:`os.SEEK_SET` (absolute blob positioning). Other "
"values for *origin* are :data:`os.SEEK_CUR` (seek relative to the current "
"position) and :data:`os.SEEK_END` (seek relative to the blob’s end)."
msgstr ""

#: library/sqlite3.rst:1099
msgid "Exceptions"
msgstr "Exceptions"

#: library/sqlite3.rst:1103
msgid "A subclass of :exc:`Exception`."
msgstr ""

#: library/sqlite3.rst:1107
msgid ""
"The base class of the other exceptions in this module.  It is a subclass of :"
"exc:`Exception`."
msgstr ""

#: library/sqlite3.rst:1112
msgid ""
"The numeric error code from the `SQLite API <https://sqlite.org/rescode."
"html>`_"
msgstr ""

#: library/sqlite3.rst:1119
msgid ""
"The symbolic name of the numeric error code from the `SQLite API <https://"
"sqlite.org/rescode.html>`_"
msgstr ""

#: library/sqlite3.rst:1126
msgid "Exception raised for errors that are related to the database."
msgstr ""

#: library/sqlite3.rst:1130
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:1135
msgid ""
"Exception raised for programming errors, e.g. table not found or already "
"exists, syntax error in the SQL statement, wrong number of parameters "
"specified, etc.  It is a subclass of :exc:`DatabaseError`."
msgstr ""

#: library/sqlite3.rst:1141
msgid ""
"Exception raised for errors that are related to the database's operation and "
"not necessarily under the control of the programmer, e.g. an unexpected "
"disconnect occurs, the data source name is not found, a transaction could "
"not be processed, etc.  It is a subclass of :exc:`DatabaseError`."
msgstr ""

#: library/sqlite3.rst:1148
msgid ""
"Exception raised in case a method or database API was used which is not "
"supported by the database, e.g. calling the :meth:`~Connection.rollback` "
"method on a connection that does not support transaction or has transactions "
"turned off.  It is a subclass of :exc:`DatabaseError`."
msgstr ""

#: library/sqlite3.rst:1159
msgid "SQLite and Python types"
msgstr ""

#: library/sqlite3.rst:1163
msgid "Introduction"
msgstr "Introduction"

#: library/sqlite3.rst:1165
msgid ""
"SQLite natively supports the following types: ``NULL``, ``INTEGER``, "
"``REAL``, ``TEXT``, ``BLOB``."
msgstr ""

#: library/sqlite3.rst:1168
msgid ""
"The following Python types can thus be sent to SQLite without any problem:"
msgstr ""

#: library/sqlite3.rst:1188
msgid "Python type"
msgstr "Type Python"

#: library/sqlite3.rst:1188
msgid "SQLite type"
msgstr "SQLite type"

#: library/sqlite3.rst:1190
msgid ":const:`None`"
msgstr ":const:`None`"

#: library/sqlite3.rst:1190
msgid "``NULL``"
msgstr "``NULL``"

#: library/sqlite3.rst:1192
msgid ":class:`int`"
msgstr ":class:`int`"

#: library/sqlite3.rst:1192
msgid "``INTEGER``"
msgstr "``INTEGER``"

#: library/sqlite3.rst:1194
msgid ":class:`float`"
msgstr ":class:`float`"

#: library/sqlite3.rst:1194
msgid "``REAL``"
msgstr "``REAL``"

#: library/sqlite3.rst:1179
msgid ":class:`str`"
msgstr ":class:`str`"

#: library/sqlite3.rst:1196
msgid "``TEXT``"
msgstr "``TEXT``"

#: library/sqlite3.rst:1199
msgid ":class:`bytes`"
msgstr ":class:`bytes`"

#: library/sqlite3.rst:1199
msgid "``BLOB``"
msgstr "``BLOB``"

#: library/sqlite3.rst:1185
msgid "This is how SQLite types are converted to Python types by default:"
msgstr ""

#: library/sqlite3.rst:1196
msgid "depends on :attr:`~Connection.text_factory`, :class:`str` by default"
msgstr ""

#: library/sqlite3.rst:1202
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 object "
"adaptation, and you can let the :mod:`sqlite3` module convert SQLite types "
"to different Python types via converters."
msgstr ""

#: library/sqlite3.rst:1209
msgid "Using adapters to store additional Python types in SQLite databases"
msgstr ""

#: library/sqlite3.rst:1211
msgid ""
"As described before, SQLite supports only a limited set of types natively. "
"To use other Python types with SQLite, you must **adapt** them to one of the "
"sqlite3 module's supported types for SQLite: one of NoneType, int, float, "
"str, bytes."
msgstr ""

#: library/sqlite3.rst:1216
msgid ""
"There are two ways to enable the :mod:`sqlite3` module to adapt a custom "
"Python type to one of the supported ones."
msgstr ""

#: library/sqlite3.rst:1221
msgid "Letting your object adapt itself"
msgstr ""

#: library/sqlite3.rst:1223
msgid ""
"This is a good approach if you write the class yourself. Let's suppose you "
"have a class like this::"
msgstr ""

#: library/sqlite3.rst:1230
msgid ""
"Now you want to store the point in a single SQLite column.  First you'll "
"have to choose one of the supported types to be used for representing the "
"point. Let's just use str and separate the coordinates using a semicolon. "
"Then you need to give your class a method ``__conform__(self, protocol)`` "
"which must return the converted value. The parameter *protocol* will be :"
"class:`PrepareProtocol`."
msgstr ""

#: library/sqlite3.rst:1240
msgid "Registering an adapter callable"
msgstr ""

#: library/sqlite3.rst:1242
msgid ""
"The other possibility is to create a function that converts the type to the "
"string representation and register the function with :meth:"
"`register_adapter`."
msgstr ""

#: library/sqlite3.rst:1247
msgid ""
"The :mod:`sqlite3` module has two default adapters for Python's built-in :"
"class:`datetime.date` and :class:`datetime.datetime` types.  Now let's "
"suppose we want to store :class:`datetime.datetime` objects not in ISO "
"representation, but as a Unix timestamp."
msgstr ""

#: library/sqlite3.rst:1256
msgid "Converting SQLite values to custom Python types"
msgstr ""

#: library/sqlite3.rst:1258
msgid ""
"Writing an adapter lets you send custom Python types to SQLite. But to make "
"it really useful we need to make the Python to SQLite to Python roundtrip "
"work."
msgstr ""

#: library/sqlite3.rst:1261
msgid "Enter converters."
msgstr ""

#: library/sqlite3.rst:1263
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:1266
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:1271
msgid ""
"Converter functions **always** get called with a :class:`bytes` object, no "
"matter under which data type you sent the value to SQLite."
msgstr ""

#: library/sqlite3.rst:1280
msgid ""
"Now you need to make the :mod:`sqlite3` module know that what you select "
"from the database is actually a point. There are two ways of doing this:"
msgstr ""

#: library/sqlite3.rst:1283
msgid "Implicitly via the declared type"
msgstr ""

#: library/sqlite3.rst:1285
msgid "Explicitly via the column name"
msgstr ""

#: library/sqlite3.rst:1287
msgid ""
"Both ways are described in section :ref:`sqlite3-module-contents`, in the "
"entries for the constants :const:`PARSE_DECLTYPES` and :const:"
"`PARSE_COLNAMES`."
msgstr ""

#: library/sqlite3.rst:1290
msgid "The following example illustrates both approaches."
msgstr ""

#: library/sqlite3.rst:1296
msgid "Default adapters and converters"
msgstr ""

#: library/sqlite3.rst:1298
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:1301
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:1305
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:1309
msgid "The following example demonstrates this."
msgstr ""

#: library/sqlite3.rst:1313
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:1319
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:1327
msgid "Controlling Transactions"
msgstr ""

#: library/sqlite3.rst:1329
msgid ""
"The underlying ``sqlite3`` library operates in ``autocommit`` mode by "
"default, but the Python :mod:`sqlite3` module by default does not."
msgstr ""

#: library/sqlite3.rst:1332
msgid ""
"``autocommit`` mode means that statements that modify the database take "
"effect immediately.  A ``BEGIN`` or ``SAVEPOINT`` statement disables "
"``autocommit`` mode, and a ``COMMIT``, a ``ROLLBACK``, or a ``RELEASE`` that "
"ends the outermost transaction, turns ``autocommit`` mode back on."
msgstr ""

#: library/sqlite3.rst:1337
msgid ""
"The Python :mod:`sqlite3` module by default issues a ``BEGIN`` statement "
"implicitly before a Data Modification Language (DML) statement (i.e. "
"``INSERT``/``UPDATE``/``DELETE``/``REPLACE``)."
msgstr ""

#: library/sqlite3.rst:1341
msgid ""
"You can control which kind of ``BEGIN`` statements :mod:`sqlite3` implicitly "
"executes via the *isolation_level* parameter to the :func:`connect` call, or "
"via the :attr:`isolation_level` property of connections. If you specify no "
"*isolation_level*, a plain ``BEGIN`` is used, which is equivalent to "
"specifying ``DEFERRED``.  Other possible values are ``IMMEDIATE`` and "
"``EXCLUSIVE``."
msgstr ""

#: library/sqlite3.rst:1348
msgid ""
"You can disable the :mod:`sqlite3` module's implicit transaction management "
"by setting :attr:`isolation_level` to ``None``.  This will leave the "
"underlying ``sqlite3`` library operating in ``autocommit`` mode.  You can "
"then completely control the transaction state by explicitly issuing "
"``BEGIN``, ``ROLLBACK``, ``SAVEPOINT``, and ``RELEASE`` statements in your "
"code."
msgstr ""

#: library/sqlite3.rst:1354
msgid ""
"Note that :meth:`~Cursor.executescript` disregards :attr:`isolation_level`; "
"any transaction control must be added explicitly."
msgstr ""

#: library/sqlite3.rst:1357
msgid ""
":mod:`sqlite3` used to implicitly commit an open transaction before DDL "
"statements.  This is no longer the case."
msgstr ""

#: library/sqlite3.rst:1363
msgid "Using :mod:`sqlite3` efficiently"
msgstr ""

#: library/sqlite3.rst:1367
msgid "Using shortcut methods"
msgstr ""

#: library/sqlite3.rst:1369
msgid ""
"Using the nonstandard :meth:`execute`, :meth:`executemany` and :meth:"
"`executescript` methods of the :class:`Connection` object, 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:1381
msgid "Accessing columns by name instead of by index"
msgstr ""

#: library/sqlite3.rst:1383
msgid ""
"One useful feature of the :mod:`sqlite3` module is the built-in :class:"
"`sqlite3.Row` class designed to be used as a row factory."
msgstr ""

#: library/sqlite3.rst:1386
msgid ""
"Rows wrapped with this class can be accessed both by index (like tuples) and "
"case-insensitively by name:"
msgstr ""

#: library/sqlite3.rst:1393
msgid "Using the connection as a context manager"
msgstr ""

#: library/sqlite3.rst:1395
msgid ""
"Connection objects can be used as context managers that automatically commit "
"or rollback transactions.  In the event of an exception, the transaction is "
"rolled back; otherwise, the transaction is committed:"
msgstr ""

#: library/sqlite3.rst:1404
msgid "Footnotes"
msgstr "Notes"

#: library/sqlite3.rst:1405
msgid ""
"The 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 configure."
msgstr ""

#~ 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*."