sqlite3 — Interfaz DB-API 2.0 para bases de datos SQLite

sqlite3: interfaz DB-API 2.0 para bases de datos SQLite

2024-07-12

sqlite3: interfaz DB-API 2.0 para bases de datos SQLite — Documentación de Python 3.12.4

`sqlite3`— Interfaz DB-API 2.0 para bases de datos SQLite
sqlite3: interfaz DB-API 2.0 para bases de datos SQLite

Código fuente: Biblioteca SQLite3 Ubicación del código fuente:Lib/sqlite3/

SQLite es una biblioteca C que proporciona una base de datos liviana basada en disco que no requiere un proceso de servidor independiente y permite acceder a la base de datos mediante una variante no estándar del lenguaje de consulta SQL. Algunas aplicaciones pueden usar SQLite para el almacenamiento interno de datos. También es posible crear un prototipo de una aplicación utilizando SQLite y luego trasladar el código a una base de datos más grande, como PostgreSQL u Oracle.
SQLite es una biblioteca de lenguaje C que proporciona una base de datos liviana basada en disco que no requiere un proceso de servidor separado y permite acceder a la base de datos utilizando una variante no estándar del lenguaje de consulta SQL. Algunas aplicaciones pueden usar SQLite para el almacenamiento interno de datos. Además, puede utilizar SQLite para crear un prototipo de una aplicación y luego migrar el código a una base de datos grande como PostgreSQL u Oracle.

Elsqlite3El módulo fue escrito por Gerhard Häring. Proporciona una interfaz SQL compatible con la especificación DB-API 2.0 descrita porPEP249, y requiere SQLite 3.7.15 o más reciente.
módulo sqlite3 Escrito por Gerhard Häring. Proporciona una interfaz SQL que cumple con la especificación DB-API 2.0 descrita por PEP 249 y requiere SQLite versión 3.7.15 o superior.

Este documento incluye cuatro secciones principales: Este documento incluye principalmente las siguientes cuatro secciones principales

Tutorialenseña cómo utilizar elsqlite3módulo.TutorialLa parte enseña cómo utilizar el módulo sqlite3.
Referenciadescribe las clases y funciones que define este módulo.
Referirse aLa sección describe las clases y funciones definidas por este módulo.
Guías prácticasdetalla cómo manejar tareas específicas.
Manual de operacionesLas secciones detallan cómo manejar tareas específicas.
ExplicaciónProporciona información detallada sobre el control de transacciones.
explicarEsta sección proporciona una introducción detallada a los conocimientos previos del control de transacciones.

Ver también

https://www.sqlite.org

La página web de SQLite; la documentación describe la sintaxis y los tipos de datos disponibles para el dialecto SQL compatible.
La página web de SQLite; su documentación describe la sintaxis de los dialectos SQL soportados y los tipos de datos disponibles.

Tutorial de SQLTutorial de SQL

Tutorial, referencia y ejemplos para aprender la sintaxis SQL.
Tutoriales, referencias y ejemplos para aprender la sintaxis SQL.

PEP249- Especificación API de base de datos 2.0 PEP 249 - Especificación API de base de datos 2.0

PEP escrito por Marc-André Lemburg PEP escrito por Marc-André Lemburg.

TutorialTutorial

En este tutorial, creará una base de datos de Películas de Monty Python usando básicosqlite3funcionalidad. Supone una comprensión fundamental de los conceptos de bases de datos, incluidoscursoresyactas.
En este tutorial, utilizará la funcionalidad básica de sqlite3 para crear una base de datos sobre películas de Monty Python. Este tutorial asume que tiene conocimientos básicos de conceptos de bases de datos, incluidos cursores y transacciones.

Primero, necesitamos crear una nueva base de datos y abrir una conexión de base de datos para permitirsqlite3para trabajar con ello. Llamarsqlite3.conectar()Para crear una conexión a la base de datostutorial.dben el directorio de trabajo actual, creándolo implícitamente si no existe:
Primero, necesitamos crear una nueva base de datos y abrir una conexión a la base de datos para que sqlite3 pueda interactuar con ella. Llame a sqlite3.connect() para crear una conexión a la base de datos tutorial.db en el directorio de trabajo actual, creándola implícita y suavemente automáticamente si la base de datos no existe:


import sqlite3
con = sqlite3.connect("tutorial.db")

El retornoConexiónobjetoconRepresenta la conexión a la base de datos en disco.
El objeto Connection devuelto (llamado con en este caso) representa la conexión a la base de datos en el disco.

Con el fin de ejecutar sentencias SQL yObtener resultados de consultas SQLNecesitaremos utilizar un cursor de base de datos. Llamarcon.cursor()Para crear elCursor:
Para ejecutar declaraciones SQL y obtener resultados de consultas SQL, necesitamos utilizar cursores de base de datos. Llame a con.cursor() para crear un cursor:

cur = con.cursor()

Ahora que tenemos una conexión a la base de datos y un cursor, podemos crear una tabla de base de datos.moviecon columnas para el título, el año de lanzamiento y la puntuación de la reseña. Para simplificar, podemos usar nombres de columnas en la declaración de la tabla, gracias a laescritura flexiblecaracterística de SQLite, especificar los tipos de datos es opcional. Ejecute elCREATE TABLEdeclaración llamandocur.ejecutar(...):
Ahora que tenemos la conexión a la base de datos y el cursor, podemos crear una tabla de base de datos llamada película con columnas como título, año de lanzamiento y puntuación de reseña. Para simplificar las cosas, podemos usar los nombres de las columnas directamente en la declaración de la tabla; especificar el tipo de datos es opcional debido a la función de escritura flexible de SQLite. Ejecute la instrucción CREATE TABLE llamando a cur.execute(...):

cur.execute("CREATE TABLE movie(title, year, score)")

Podemos verificar que la nueva tabla ha sido creada consultando lasqlite_mastertabla incorporada a SQLite, que ahora debería contener una entrada para elmoviedefinición de tabla (verLa tabla de esquemaspara más detalles). Ejecute esa consulta llamandocur.ejecutar(...), asignar el resultado ares, y llamares.fetchone()Para obtener la fila resultante:
Podemos verificar que la nueva tabla se haya creado consultando la tabla sqlite_master incorporada de SQLite, que ahora debería contener entradas para la definición de la tabla de películas (consulte la tabla de esquema para obtener más detalles). Ejecute la consulta llamando a cur.execute(...), asigne los resultados a res y llame a res.fetchone() para obtener las filas de resultados:

>>>


>>> res = cur.execute("SELECT name FROM sqlite_master")
>>> res.fetchone()
('movie',)

Podemos ver que la tabla ha sido creada, ya que la consulta devuelve untuplaque contiene el nombre de la tabla. Si consultamossqlite_masterpara una mesa inexistentespam, res.fetchone()VolveráNone:
Podemos ver que la tabla se creó correctamente porque la consulta devolvió una tupla que contiene el nombre de la tabla. Si consultamos sqlite_master para una tabla inexistente (como spam), res.fetchone() devolverá Ninguno.

>>>


>>> res = cur.execute("SELECT name FROM sqlite_master WHERE name='spam'")
>>> res.fetchone() is None
True

Ahora, agregue dos filas de datos suministrados como literales SQL ejecutando unINSERTdeclaración, una vez más llamandocur.ejecutar(...):
Ahora, agregue dos filas de datos, proporcionadas como literales SQL, ejecutando una instrucción INSERT (llamando a cur.execute(...) nuevamente):


cur.execute("""
    INSERT INTO movie VALUES
        ('Monty Python and the Holy Grail', 1975, 8.2),
        ('And Now for Something Completely Different', 1971, 7.5)
""")

ElINSERTLa declaración abre implícitamente una transacción, que debe confirmarse antes de que los cambios se guarden en la base de datos (verControl de transaccionespara detalles). Llamarcon.commit()en el objeto de conexión para confirmar la transacción:
La instrucción INSERT inicia implícita y automáticamente una transacción que debe confirmarse antes de guardar los cambios en la base de datos (consulte Control de transacciones para obtener más detalles). Llame a con.commit() en el objeto de conexión para confirmar la transacción:

con.commit()

Podemos verificar que los datos se insertaron correctamente ejecutando unSELECTconsulta. Utilice la ya conocidacur.ejecutar(...)asignar el resultado ares, y llamares.fetchall()para devolver todas las filas resultantes:
Podemos verificar que los datos se insertaron correctamente ejecutando una consulta SELECT. Asigne los resultados a res usando el ahora familiar cur.execute(...) y llame a res.fetchall() para devolver todas las filas de resultados:

>>>


>>> res = cur.execute("SELECT score FROM movie")
>>> res.fetchall()
[(8.2,), (7.5,)]

El resultado es unlistaaaaaaaade dostuples, uno por fila, cada uno conteniendo la información de esa filascorevalor.
El resultado es una lista de dos tuplas, una para cada fila, y cada tupla contiene el valor de puntuación de esa fila.

Ahora, inserte tres filas más llamandocur.ejecutarmuchos(...):
Ahora, inserte tres filas más de datos llamando a cur.executemany(...):


data = [
    ("Monty Python Live at the Hollywood Bowl", 1982, 7.9),
    ("Monty Python's The Meaning of Life", 1983, 7.5),
    ("Monty Python's Life of Brian", 1979, 8.0),
]
cur.executemany("INSERT INTO movie VALUES(?, ?, ?)", data)
con.commit()  # Remember to commit the transaction after executing INSERT.

Darse cuenta de?Los marcadores de posición se utilizan para enlazardataa la consulta. Utilice siempre marcadores de posición en lugar deformato de cadenapara vincular valores de Python a declaraciones SQL, para evitarAtaques de inyección SQL(verCómo utilizar marcadores de posición para vincular valores en consultas SQLpara más detalles).
Tenga en cuenta que el marcador de posición ? se utiliza para vincular los datos a la consulta. Utilice siempre marcadores de posición en lugar de formato de cadena para vincular valores de Python en declaraciones SQL para evitar ataques de inyección SQL (consulte "Cómo vincular valores utilizando marcadores de posición en consultas SQL" para obtener más detalles).

Podemos verificar que las nuevas filas se insertaron ejecutando unSELECTconsulta, esta vez iterando sobre los resultados de la consulta:
Podemos verificar que la nueva fila ha sido insertada ejecutando una consulta SELECT, esta vez iteraremos sobre los resultados de la consulta:

>>>


>>> for row in cur.execute("SELECT year, title FROM movie ORDER BY year"):
...     print(row)
(1971, 'And Now for Something Completely Different')
(1975, 'Monty Python and the Holy Grail')
(1979, "Monty Python's Life of Brian")
(1982, 'Monty Python Live at the Hollywood Bowl')
(1983, "Monty Python's The Meaning of Life")

Cada fila contiene dos elementos.tuplade(year, title), coincidiendo con las columnas seleccionadas en la consulta.
Cada fila es una tupla que contiene dos elementos (año, título), que coincide con la columna seleccionada en la consulta.

Por último, verifique que la base de datos se haya escrito en el disco llamandocon.cerrar()Para cerrar la conexión existente, abrir una nueva, crear un nuevo cursor y luego consultar la base de datos:
Finalmente, llamandocon.close() para cerrar la conexión de la base de datos existente y asegurarse de que la base de datos se haya escrito en el disco. Luego, abra una nueva conexión, cree un nuevo cursor y consulte la base de datos para verificar que los datos se escribieron correctamente.

>>>


>>> con.close()
>>> new_con = sqlite3.connect("tutorial.db")
>>> new_cur = new_con.cursor()
>>> res = new_cur.execute("SELECT title, year FROM movie ORDER BY score DESC")
>>> title, year = res.fetchone()
>>> print(f'The highest scoring Monty Python movie is {title!r}, released in {year}')
The highest scoring Monty Python movie is 'Monty Python and the Holy Grail', released in 1975
>>> new_con.close()

Ahora ha creado una base de datos SQLite utilizando elsqlite3módulo, insertó datos y recuperó valores de él de múltiples maneras.
ahora has usadosqlite3 El módulo crea una base de datos SQLite e inserta y recupera datos de ella de diversas formas [¿Recuperar? 】El valor.

Ver tambiénVer también

Guías prácticasPara mayor información: Cómo vincular valores utilizando marcadores de posición en consultas SQL:
- Cómo utilizar marcadores de posición para vincular valores en consultas SQL
  Cómo vincular valores utilizando marcadores de posición en consultas SQL:
- Cómo adaptar tipos de Python personalizados a valores de SQLite
  Cómo adaptar un tipo de Python personalizado a un valor de SQLite:
- Cómo convertir valores de SQLite en tipos de Python personalizados
  Cómo convertir el valor de SQLite a un tipo de Python personalizado:
- Cómo utilizar el administrador de contexto de conexión
  Cómo utilizar el administrador de contexto de conexión:
- Cómo crear y utilizar fábricas de filas
  Cómo crear y utilizar fábricas de filas:
Explicaciónpara obtener información detallada sobre el control de transacciones.
Una explicación detallada de los antecedentes del control de transacciones:

ReferenciaDescripción de parámetros：

Funciones del módulo

sqlite3.connect(database, timeout=5.0, detect_types=0, isolation_level='DEFERRED', check_same_thread=True, factory=sqlite3.Connection, cached_statements=128, uri=False, *, autocommit=sqlite3.LEGACY_TRANSACTION_CONTROL)

Abrir una conexión a una base de datos SQLite. Esta función se utiliza para abrir una conexión a una base de datos SQLite.

Parámetros:

base de datos (objeto similar a una ruta) – La ruta al archivo de base de datos que se abrirá. Puede pasar":memory:"Para crear unBase de datos SQLite que existe solo en la memoriay abrir una conexión con él.database (path-like object)
base de datos (objeto similar a una ruta) — Esta es la ruta al archivo de base de datos que se va a abrir.Puedes pasar":memory:"para crear una base de datos SQLite en memoria y abrir una base de datos (objeto similar a una ruta) conectada a ella.
se acabó el tiempo (flotar) – Cuántos segundos debe esperar la conexión antes de generar unaError operacionalCuando una tabla está bloqueada. Si otra conexión abre una transacción para modificar una tabla, esa tabla se bloqueará hasta que se confirme la transacción. Valor predeterminado: cinco segundos.timeout (float) — La conexión se interrumpe cuando la mesa está bloqueadaOperationalError Cuantos segundos se deben esperar antes. Si otra conexión abre una transacción para modificar la tabla, la tabla se bloqueará hasta que se confirme la transacción. El valor predeterminado es cinco segundos.
detectar_tipos (En t) – Controlar si y cómo tipos de datos nosoportado de forma nativa por SQLitese buscan para convertirlos a tipos de Python, utilizando los convertidores registrados conregistrar_convertidor(). Configúrelo en cualquier combinación (usando|, bit a bit o) dePARSE_DECLTYPESyANALIZAR_NOMBRES_DE_COlumnaspara habilitar esto. Nombres de columnas tiene prioridad sobretipos declarados Si se configuran ambos indicadores, no se pueden detectar los tipos de los campos generados (por ejemplo,max(data)), incluso cuando eldetectar_tiposel parámetro está establecido;cadenase devolverá en su lugar. De forma predeterminada (0), la detección de tipos está deshabilitada.
detect_types (int)— Controla si se encuentran para su uso tipos de datos que SQLite no admite de forma nativa y cómoregister_converter() Los convertidores registrados los convierten a tipos de Python.configúrelo enPARSE_DECLTYPESyPARSE_COLNAMEScualquier combinación de (usando bit a bit o| ) para habilitar esta función.Si ambas banderas están configuradas, entoncesLista tendrá prioridad sobredeclaración tipo.Para las regiones generadas, estos tipos no se pueden detectar (p. ej.max(data)), incluso si está configuradodetect_typesparámetros; en su lugar, devolverástr tipo. De forma predeterminada (0), la detección de tipos está deshabilitada.

Insertalo aqui
En este párrafo en inglés, ¿quién es el tema de "are look up to"?
En este párrafo en inglés, el tema de "son buscados" son aquellos "tipos de datos que no son compatibles de forma nativa con SQLite (tipos de datos que no son compatibles de forma nativa con SQLite)".Esta oración significa que al usarregister_converter() Convertidores registrados para buscar y convertir tipos de datos que no son compatibles de forma nativa con SQLite a tipos de Python. Entonces, los sujetos son aquellos tipos de datos específicos que deben encontrarse y convertirse.

nivel de aislamiento (cadena | Ninguno) – Controlar el comportamiento de manejo de transacciones heredadas. VerConexión.nivel_de_aislamientoyControl de transacciones a través del atributo insulation_levelPara más información puede consultar"DEFERRED"(por defecto),"EXCLUSIVE"o"IMMEDIATE"; oNonepara deshabilitar la apertura de transacciones de forma implícita. No tiene efecto a menos queConexión.autocommitse establece enCONTROL DE TRANSACCIONES LEGAL(el valor por defecto).
isolation_level(Cadena | Ninguno) – Controlar el comportamiento del procesamiento de transacciones heredadas.Para más información, verConnection.isolation_levely "pasarisolation_levelOperación de Control de Propiedad". Puede ser"DEFERRED"(valor por defecto),"EXCLUSIVE"o"IMMEDIATE";o establecer enNone para deshabilitar la apertura implícita de transacciones implícitamente.A menos queConnection.autocommitEstablecer comoLEGACY_TRANSACTION_CONTROL(predeterminado); de lo contrario, esta configuración no tiene ningún efecto.
comprobar_mismo_hilo (Booleano) - SiTrue(por defecto),Error de programaciónse generará si la conexión a la base de datos la utiliza un hilo distinto del que la creó. SiFalseSe puede acceder a la conexión en varios subprocesos; es posible que el usuario deba serializar las operaciones de escritura para evitar la corrupción de datos. Verseguridad de roscapara más información.
check_same_thread(Valor booleano) – Si se establece enTrue(predeterminado), se generará cuando la conexión de la base de datos sea utilizada por un subproceso distinto del subproceso que la creó.ProgrammingError anormal.Si se establece enFalse , se permite que varios subprocesos accedan a la conexión, pero es posible que los usuarios necesiten serializar (continuamente) las operaciones de escritura para evitar la corrupción de datos.Para más información, verthreadsafetyinstrucción de.
fábrica (Conexión) – Una subclase personalizada deConexiónpara crear la conexión con, si no es la predeterminadaConexiónclase.
factory(Conexión) – Si no utiliza el valor predeterminadoConnectionclase, especifique una costumbreConnection Subclase para crear la conexión. Este parámetro le permite personalizar el comportamiento de la conexión de la base de datos según necesidades o extensiones específicas.
declaraciones en caché (En t) – El número de afirmaciones quesqlite3Debe almacenarse en caché internamente para esta conexión, a fin de evitar la sobrecarga de análisis. De manera predeterminada, 128 declaraciones.
cached_statements(En t) – sqlite3 La cantidad de declaraciones que se deben almacenar en caché internamente para esta conexión para evitar la sobrecarga de análisis. De forma predeterminada, se almacenan en caché 128 declaraciones. Este parámetro le permite ajustar el tamaño de la caché para optimizar el rendimiento o el uso de la memoria.
uri (Booleano) – Si se establece enTrue, base de datosse interpreta como una URI con una ruta de archivo y una cadena de consulta opcional. La parte del esquemadebeser"file:", y la ruta puede ser relativa o absoluta. La cadena de consulta permite pasar parámetros a SQLite, lo que permite variasCómo trabajar con las URI de SQLite.
uri(bool) – Si se establece enTrue,perodatabase Interpretado como un identificador uniforme de recursos (URI) con una ruta de archivo y una cadena de consulta opcional. El esquema parte del URI.debe es "archivo:", la ruta puede ser relativa o absoluta. Las cadenas de consulta permiten pasar parámetros a SQLite, lo que permite varias formas de trabajar con los URI de SQLite. Esto permite opciones de conexión de bases de datos más complejas, como configurar el modo de solo lectura, especificar el tamaño de la caché, etc.
confirmación automática (Booleano) - ControlPEP249comportamiento de manejo de transacciones. VerConexión.autocommityControl de transacciones a través del atributo autocommitpara más información.confirmación automáticaActualmente el valor predeterminado esCONTROL DE TRANSACCIONES LEGALEl valor predeterminado cambiará aFalseen una futura versión de Python.
autocommit(bool) – Controlar el comportamiento del procesamiento de transacciones de acuerdo con PEP 249.Para más información, verConnection.autocommit y "Control de transacciones a través del atributo de confirmación automática". Actualmente,autocommitEl valor predeterminado se establece enLEGACY_TRANSACTION_CONTROL , lo que significa que sigue el comportamiento de control de transacciones heredado de la especificación API de la base de datos Python (PEP 249).Sin embargo, en una versión futura de Python, el valor predeterminado cambiará aFalse, lo que significa que las transacciones no se confirman automáticamente de forma predeterminada y requieren que el usuario controle explícitamente el inicio y el final de la transacción.

Tenga en cuenta,*Los parámetros se utilizan en las definiciones de funciones como separadores entre argumentos posicionales y de palabras clave, es decirautocommitTodos los parámetros posteriores deben ser parámetros de palabras clave.

Tipo de retorno:Tipo de devolución：

Conexión

plantea unaevento de auditoría sqlite3.connectCon argumentodatabase.
sqlite3.connect: Cuando usasdatabaseParámetros arrojados al conectarse a la base de datos.

plantea unaevento de auditoría sqlite3.connect/handleCon argumentoconnection_handle.
sqlite3.connect/handle: Cuando la manija de conexión (connection_handle) se lanza cuando se crea.

Cambiado en la versión 3.4: Se agregó eluriparámetro.
En la versión 3.4: agregadouriParámetro que permite especificar el archivo de base de datos usando formato URI.

Cambiado en la versión 3.7:base de datosAhora también puede ser unobjeto similar a una ruta, no sólo una cadena.
En la versión 3.7:databaseLos parámetros ahora pueden ser un objeto similar a una ruta en lugar de solo cadenas.

Cambiado en la versión 3.10: Se agregó elsqlite3.connect/handleevento de auditoría.
En la versión 3.10: agregadosqlite3.connect/handleEvento de auditoría, que se activa cuando se crea el identificador de conexión.

Cambiado en la versión 3.12: Se agregó elconfirmación automáticaparámetro.
En la versión 3.12: agregadoautocommitParámetros que permiten un control más preciso sobre el comportamiento de confirmación automática de las transacciones.

declaración_completa_sqlite3(declaración)

DevolverTrueSi la cadenadeclaraciónParece contener una o más sentencias SQL completas. No se realiza ninguna verificación sintáctica ni análisis de ningún tipo, excepto comprobar que no haya cadenas literales sin cerrar y que la sentencia finalice con un punto y coma.
si cadenastatementparece contener una o más sentencias SQL completas, luego devuelveTrue . No se realiza ninguna validación o análisis de sintaxis aparte de verificar que no haya cadenas literales abiertas y que la declaración termine con un punto y coma.

Por ejemplo:Ejemplo

>>>


>>> sqlite3.complete_statement("SELECT foo FROM bar;")
True
>>> sqlite3.complete_statement("SELECT foo")
False

Esta función puede ser útil durante la entrada de la línea de comandos para determinar si el texto ingresado parece formar una declaración SQL completa o si se necesita una entrada adicional antes de llamar.ejecutar().
Esta función puede resultar útil al escribir en la línea de comando, para ayudar a determinar si el texto ingresado parece una declaración SQL completa o al llamarexecute()Si se requiere entrada adicional antes.

Verrunsource()enLib/sqlite3/__main__.pypara uso en el mundo real.
En aplicaciones prácticas, puede consultarLib/sqlite3/__main__.pymediorunsource()función para comprender su uso.

sqlite3.enable_callback_tracebacks(bandera, /)

Habilite o deshabilite los seguimientos de devolución de llamadas. De manera predeterminada, no obtendrá ningún seguimiento en funciones definidas por el usuario, agregados, convertidores, devoluciones de llamadas de autorizador, etc. Si desea depurarlos, puede llamar a esta función conbanderaajustado aTruePosteriormente, recibirás seguimientos de las devoluciones de llamadas ensistema.stderr. UsarFalsepara deshabilitar la función nuevamente.
Habilite o deshabilite el seguimiento de devolución de llamadas. De forma predeterminada, no obtendrá ningún rastreo en funciones definidas por el usuario, funciones agregadas, convertidores, devoluciones de llamadas de autorización, etc.Si desea depurarlos, puede llamar a esta función y reemplazarflagEstablecer comoTrue .Después podrássys.stderr Obtenga información de seguimiento de la devolución de llamada.usarFalsepara desactivar esta función nuevamente.

Nota

Los errores en las devoluciones de llamadas de funciones definidas por el usuario se registran como excepciones que no se pueden generar. Utilice unmanejador de gancho que no se puede levantarpara la introspección de la devolución de llamada fallida.
Los errores en las devoluciones de llamadas de funciones definidas por el usuario se registran como excepciones imposibles de detectar. Utilice un controlador de gancho que no se puede acceder para realizar una introspección en devoluciones de llamada fallidas.

Esto significa que cuando ocurren errores en las devoluciones de llamada de las funciones definidas por el usuario de SQLite (como funciones agregadas, funciones escalares, etc.), estos errores no se generan como excepciones normales de Python y pueden detectarse mediante bloques try-except. En cambio, son capturados por SQLite o el módulo sqlite3 de Python y registrados de alguna manera (generalmente escritos en el registro o en la salida de error estándar), pero no interrumpen la ejecución del programa (a menos que el error sea muy grave).

Para inspeccionar y depurar estas excepciones imposibles de detectar, puede configurar un "controlador de ganchos imposibles de detectar". Este controlador es una función que Python llama cuando ocurre una excepción no detectada y pasa la información de la excepción como parámetro. De esta manera, puede escribir código en la función del procesador para registrar o verificar estas excepciones para ayudar a diagnosticar el problema.

Tenga en cuenta que la implementación específica puede variar según la versión de Python y los detalles de implementación del módulo sqlite3. Por lo tanto, se recomienda consultar la documentación más reciente de Python o la documentación del módulo sqlite3 para aprender cómo configurar y utilizar el controlador de gancho incaptable.

**sqlite3.register_adapter(tipo, adaptador, /)**

Registrar unadaptador invocablepara adaptar el tipo de Pythontipoen un tipo SQLite. El adaptador se llama con un objeto Python de tipotipocomo único argumento y debe devolver un valor de atipo que SQLite entiende de forma nativa.
Registre un objeto invocable **adaptador** para convertir Pythontype El tipo se adapta a un tipo que SQLite pueda entender de forma nativa.Esta función de adaptador requiere untypeUn objeto de tipo se llama como único argumento y debe devolver un valor de un tipo que SQLite admita de forma nativa.

Cabe señalar que el "typetipo" puede ser un poco engañoso, porque normalmente no nos referimos a la función incorporada de Python.type Los objetos (es decir, los tipos mismos) se almacenan directamente en la base de datos. Más comúnmente, queremos adaptar objetos en Python (que pueden ser instancias de tipos personalizados) a un formato que SQLite pueda almacenar.Sin embargo, tomando la oración literalmente, si necesita lidiar contypeobjeto en sí (aunque esto es poco común en la práctica), necesitará escribir un adaptador para convertirlo en alguna forma que SQLite pueda almacenar, como una cadena que represente el nombre del tipo.

Sin embargo, un caso de uso más común es para tipos de Python personalizados o tipos integrados comodatetime、decimal.Decimaletc.) escriba adaptadores para que la base de datos SQLite pueda almacenarlos y recuperarlos correctamente.

Por ejemplo, si tiene una clase Python personalizadaMyClassy desea almacenar su instancia en una base de datos SQLite, puede escribir un adaptador para convertir una instancia de esta clase en una cadena (u otro tipo) que pueda ser almacenada por SQLite, y luego escribir un convertidor para convertir Convertir esta cadena nuevamente aMyClassinstancia.

Sin embargo, para esta pregunta, si solo quieres trabajar con Pythontypeobjeto (es decir, los metadatos del tipo), puede escribir un adaptador para devolver el nombre del tipo (como una cadena), pero esto generalmente no es una práctica común para almacenar objetos en una base de datos.

sqlite3.register_converter(escribe un nombre, convertidor, /)

Registrar elconvertidor invocablepara convertir objetos SQLite de tipoescribe un nombreen un objeto Python de un tipo específico. El convertidor se invoca para todos los valores SQLite de tipoescribe un nombre; se pasa unabytesobjeto y debe devolver un objeto del tipo Python deseado. Consulte el parámetrodetectar_tiposdeconectar()para obtener información sobre cómo funciona la detección de tipos.
Registre un objeto invocable **convertidor** para convertir tipos SQLite entypename Convierte un objeto en un objeto Python de un tipo específico.Para todo tipotypenameEste convertidor se llama para cualquier valor de SQLite y recibe un;bytes objeto como argumento y debe devolver un objeto del tipo de Python requerido.Para saber cómo funciona la detección de tipos, consulteconnect()Funcionaldetect_typesparámetro.

Nota:escribe un nombrey el nombre del tipo en su consulta se comparan sin distinguir entre mayúsculas y minúsculas.
Aviso：typenameEl nombre del tipo en la consulta no distingue entre mayúsculas y minúsculas cuando coincide.

Constantes del módulo

sqlite3.CONTROL_DE_TRANSACCIONES_LEGALIZADO

Colocarconfirmación automáticaa esta constante para seleccionar el comportamiento de control de transacciones de estilo antiguo (anterior a Python 3.12). VerControl de transacciones a través del atributo insulation_levelpara más información.
Voluntadautocommit Establezca esta constante para seleccionar el comportamiento de control de transacciones de estilo antiguo (anterior a Python 3.12).Para obtener más información, consulte "Pasarisolation_levelLas propiedades controlan las transacciones".

sqlite3.PARSE_NOMBRES_DE_COLM

Pase este valor de bandera a ladetectar_tiposparámetro deconectar()para buscar una función de conversión utilizando el nombre del tipo, analizado a partir del nombre de la columna de consulta, como clave del diccionario de conversión. El nombre del tipo debe estar entre corchetes ([]).
Pase este valor de bandera aconnect()Funcionaldetect_types Parámetro para encontrar la función del convertidor consultando el nombre del tipo resuelto en el nombre de la columna como clave del diccionario del convertidor. Los nombres de los tipos deben estar entre corchetes ([]).

SELECT p as "p [point]" FROM test;  ! will look up converter "point"

Esta bandera se puede combinar conPARSE_DECLTYPESutilizando el|operador (o bit a bit).
Esta bandera se puede utilizar|Operador (bit a bit OR) ANDPARSE_DECLTYPESEn conjunto con.

sqlite3.PARSE_DECLTYPES

Pase este valor de bandera a ladetectar_tiposparámetro deconectar()para buscar una función de conversión utilizando los tipos declarados para cada columna. Los tipos se declaran cuando se crea la tabla de la base de datos.sqlite3buscará una función de conversión utilizando la primera palabra del tipo declarado como clave del diccionario de conversión. Por ejemplo:
Pase este valor de bandera aconnect()Funcionaldetect_types Parámetros para encontrar la función de conversión utilizando el tipo declarado de cada columna en la base de datos. Estos tipos se declaran al crear la tabla de la base de datos.sqlite3 La función del convertidor se buscará utilizando la primera palabra del tipo declarado como clave del diccionario del convertidor. Por ejemplo:


CREATE TABLE test(
   i integer primary key,  ! will look up a converter named "integer"
   p point,                ! will look up a converter named "point"
   n number(10)            ! will look up a converter named "number"
 )

Esta bandera se puede combinar conANALIZAR_NOMBRES_DE_COlumnasutilizando el|operador (o bit a bit).

sqlite3.SQLITE_OK

sqlite3.SQLITE_DENY

sqlite3.SQLITE_IGNORE

Banderas que deben ser devueltas por eldevolución de llamada del autorizador invocablepasó aConexión.set_authorizer(), para indicar si:
Pasar aConnection.set_authorizer()deauthorizer_callbackBanderas que la función invocable debería devolver para indicar:

Se permite el acceso (SQLITE_OK), se permite el acceso (SQLITE_OK）
La instrucción SQL debe cancelarse con un error (SQLITE_DENY)
La instrucción SQL debería cancelarse con un error (SQLITE_DENY）
La columna debe ser tratada como unaNULLvalor (SQLITE_IGNORE)
Las columnas deben tratarse como valores NULL (SQLITE_IGNORE）

nivel de API de SQLite3

Constante de cadena que indica el nivel de DB-API compatible. Requerida por DB-API. Codificada de forma fija"2.0".
Estas dos constantes de cadena sonsqlite3Definidos en módulos, siguen la especificación API de base de datos de Python (DB-API).

estilo de parámetro sqlite3

Constante de cadena que indica el tipo de formato de marcador de parámetro esperado por elsqlite3módulo. Requerido por la DB-API. Codificado de forma fija"qmark".
Esta constante de cadena especificasqlite3 El tipo de formato de marcador de parámetro esperado por el módulo. Esto es requerido por la especificación DB-API (Interfaz de programación de aplicaciones de base de datos).Está codificado como"qmark", significa que al construir consultas SQL, los marcadores de parámetros deben representarse mediante signos de interrogación (?).

Nota

ElnamedTambién se admite el estilo de parámetro DB-API.

sqlite3.sqlite_version

Número de versión de la biblioteca SQLite en tiempo de ejecución comocadena.
El número de versión de la biblioteca de tiempo de ejecución de SQLite, expresado en forma de cadena.

sqlite3.información_de_versión_de_sqlite

Número de versión de la biblioteca SQLite en tiempo de ejecución comotupladenúmeros enteros.
El número de versión de la biblioteca de tiempo de ejecución de SQLite, expresado como una tupla de números enteros.

seguridad de subprocesos de sqlite3

Constante entera requerida por DB-API 2.0, que indica el nivel de seguridad del hilo.sqlite3El módulo admite este atributo. Este atributo se establece en función del valor predeterminado.modo de enhebradoLa biblioteca SQLite subyacente está compilada con los siguientes modos de subprocesamiento:
Constante entera requerida por DB-API 2.0, que indicasqlite3 El nivel de seguridad del subproceso admitido por el módulo. Esta propiedad se establece de acuerdo con el modo de subprocesamiento predeterminado con el que se compiló la biblioteca SQLite subyacente. Los modos de subprocesamiento de SQLite incluyen:

De un solo hilo:En este modo, todos los mutex están deshabilitados y no es seguro usar SQLite en más de un hilo a la vez.
Un solo subproceso: en este modo, todos los mutex están deshabilitados y SQLite no es seguro para ser utilizado por varios subprocesos al mismo tiempo.
Multihilo:En este modo, SQLite puede ser utilizado de forma segura por múltiples subprocesos siempre que no se utilice ninguna conexión de base de datos simultáneamente en dos o más subprocesos.
Multiproceso: en este modo, SQLite puede ser utilizado de forma segura por varios subprocesos, siempre que dos o más subprocesos no utilicen simultáneamente ninguna conexión de base de datos.
Serializado:En el modo serializado, SQLite puede ser utilizado de forma segura por múltiples subprocesos sin ninguna restricción.
Serializado: en modo serializado, SQLite puede ser utilizado de forma segura por múltiples subprocesos sin ninguna restricción.

Las asignaciones de los modos de subprocesos de SQLite a los niveles de seguridad de subprocesos de DB-API 2.0 son las siguientes:
El mapeo del modo de subproceso de SQLite al nivel de seguridad de subproceso DB-API 2.0 es el siguiente:

Modo de subprocesamiento de SQLite	seguridad de rosca	SQLITE_THREADSAFE	Significado de DB-API 2.0
de un solo hilo	0	0	Es posible que los hilos no compartan el módulo
multihilo	1	2	Los hilos pueden compartir el módulo, pero no las conexiones
serializado	3	1	Los hilos pueden compartir el módulo, las conexiones y los cursores.

Cambiado en la versión 3.11: Establecerseguridad de roscadinámicamente en lugar de codificarlo.1.

versión sqlite3

Número de versión de este módulo comocadenaEsta no es la versión de la biblioteca SQLite.
El número de versión de este módulo, expresado como una cadena.esteNoEl número de versión de la biblioteca SQLite.

Obsoleto desde la versión 3.12, se eliminará en la versión 3.14: Esta constante se usa para reflejar el número de versión delpysqlitepaquete, una biblioteca de terceros que se utiliza para enviar cambios asqlite3Hoy en día, no tiene ningún significado ni valor práctico.
En desuso desde la versión 3.12, se eliminará en la versión 3.14: esta constante se usó para reflejarpysqliteEl número de versión del paquete,pysqliteEs una biblioteca de terceros que se ha subido al upstream.sqlite3 Confirme los cambios. Ahora, no tiene significado real ni valor práctico.

sqlite3.información_de_versión

Número de versión de este módulo comotupladenúmeros enterosEsta no es la versión de la biblioteca SQLite.

sqlite3.SQLITE_DBCONFIG_DEFENSIVE

sqlite3.SQLITE_DBCONFIG_DQS_DDL

SQLITE3.SQLITE_DBCONFIG_DQS_DML

sqlite3.SQLITE_DBCONFIG_ENABLE_FKEY

sqlite3.SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER

sqlite3.SQLITE_DBCONFIG_HABILITAR_EXTENSIÓN_DE_CARGA

sqlite3.SQLITE_DBCONFIG_ENABLE_QPSG

sqlite3.ACTIVADOR DE ACTIVACIÓN DE SQLITE_DBCONFIG_ENABLE

sqlite3.SQLITE_DBCONFIG_HABILITAR_VISTA

sqlite3.SQLITE_DBCONFIG_LEGACY_ALTER_TABLE

sqlite3.FORMATO DE ARCHIVO LEGAL DE SQLITE_DBCONFIG

sqlite3.SQLITE_DBCONFIG_NO_CKPT_ON_CERRAR

sqlite3.SQLITE_DBCONFIG_RESET_DATABASE

sqlite3.SQLITE_DBCONFIG_TRIGGER_EQP

sqlite3.SQLITE_DBCONFIG_ESQUEMA_DE_CONFIANZA

sqlite3.ESQUEMA ESCRIBIBLE SQLITE_DBCONFIG

Estas constantes se utilizan para laConexión.setconfig()yobtener configuración()métodos.
Estas constantes se utilizanConnection.setconfig()ygetconfig()método.

La disponibilidad de estas constantes varía según la versión de SQLite con la que se compiló Python.
La disponibilidad de estas constantes depende de la versión de SQLite con la que se compiló SQLite Python.

Agregado en la versión 3.12.

Ver también

Opciones de configuración de la conexión a la base de datos

Documentación de SQLite: Opciones de configuración de la conexión a la base de datos

Objetos de conexión

clasesqlite3.Conexión

Cada base de datos SQLite abierta está representada por unaConnectionobjeto, que se crea utilizandosqlite3.conectar()Su propósito principal es crearCursorobjetos, yControl de transacciones.

Ver también

Una conexión de base de datos SQLite tiene los siguientes atributos y métodos:

cursor(fábrica=Cursor)

Crear y devolver unCursorobjeto. El método del cursor acepta un único parámetro opcionalfábricaSi se proporciona, debe ser uninvocabledevolviendo una instancia deCursoro sus subclases.
Crea y devuelve unCursorobjeto.cursorEl método acepta un único parámetro opcional.factory .Si se proporciona este parámetro, debe ser un objeto invocable que devuelva unCursoro una instancia de su subclase.

blobopen(mesa, columnaa, fila, /, , solo lectura=Falso, nombre='principal'*)

Abre unGotamanejar un BLOB existente.

Parámetros:

mesa (cadena) – El nombre de la tabla donde se encuentra el blob.
El nombre de la tabla que contiene datos BLOB.
columnaa (cadena) – El nombre de la columna donde se encuentra el blob.
Nombre de columna que contiene datos BLOB.
fila (cadena) – El nombre de la fila donde se encuentra el blob.
El nombre de la fila (o más exactamente el identificador de la fila) que contiene los datos BLOB.
solo lectura (Booleano) - Ajustado aTrueSi el blob debe abrirse sin permisos de escritura. El valor predeterminado esFalse.
Si se establece en Verdadero, indica que el BLOB debe abrirse sin permiso de escritura. El valor predeterminado es Falso, que permite leer y escribir.
nombre (cadena) – El nombre de la base de datos donde se encuentra el blob. El valor predeterminado es"main".
El nombre de la base de datos que contiene datos BLOB. El valor predeterminado es "principal", que es el nombre de la base de datos predeterminada en SQLite.

Aumenta:

Error operacional– Al intentar abrir un blob en unWITHOUT ROWIDmesa.
Al intentar sinFILAOcurre cuando se abren datos BLOB en la tabla de ID.

Tipo de retorno:

Gota

Nota

El tamaño del blob no se puede cambiar usando elGotaclase. Utilice la función SQLzeroblobpara crear un blob con un tamaño fijo.

Agregado en la versión 3.11.

comprometerse()

Confirmar cualquier transacción pendiente en la base de datos. Siconfirmación automáticaesTrue, o no hay ninguna transacción abierta, este método no hace nada. SiautocommitesFalse, se abre implícitamente una nueva transacción si se confirmó una transacción pendiente mediante este método.
Confirme cualquier transacción pendiente en la base de datos.siautocommit Es Verdadero o no hay ninguna transacción abierta, este método no realiza ninguna operación.siautocommites Falso y este método confirma una transacción pendiente, se iniciará implícitamente una nueva transacción.

Retroceder()

Regrese al inicio de cualquier transacción pendiente. Siconfirmación automáticaesTrue, o no hay ninguna transacción abierta, este método no hace nada. SiautocommitesFalse, se abre implícitamente una nueva transacción si una transacción pendiente se revirtió mediante este método.
Regrese al comienzo de cualquier transacción pendiente.siautocommit Es Verdadero o no hay ninguna transacción abierta, este método no realiza ninguna operación.siautocommites Falso y este método revierte una transacción pendiente, se iniciará implícitamente una nueva transacción.

cerca()

Cerrar la conexión a la base de datos. Siconfirmación automáticaesFalse, cualquier transacción pendiente se revierte implícitamente. SiautocommitesTrueoCONTROL DE TRANSACCIONES LEGAL, no se ejecuta ningún control de transacción implícito. Asegúrese decomprometerse()antes de cerrar para evitar perder los cambios pendientes.
Cierre la conexión de la base de datos.siautocommit Si es falso, cualquier transacción pendiente se revertirá implícitamente.siautocommites verdadero oLEGACY_TRANSACTION_CONTROL (control de transacciones heredado), no se realizará el control de transacciones implícito.Antes de cerrar asegúrese de llamarcommit()para evitar perder cambios pendientes.

ejecutar(sql, parámetros=(), /)

Crear un nuevoCursorobjeto y llamadaejecutar()en él con lo dadosqlyparámetros. Devuelve el nuevo objeto cursor.
crear un nuevoCursorobjeto y llamadaexecute()método, pasando lo dadosql declaraciones y parámetros.devolver esta nuevaCursorobjeto.

ejecutarmuchos(sql, parámetros, /)

Crear un nuevoCursorobjeto y llamadaejecutarmuchos()en él con lo dadosqlyparámetros. Devuelve el nuevo objeto cursor.
crear un nuevoCursorobjeto y llamadaexecutemany()método, pasando lo dadosql Declaraciones y secuencias de parámetros. Esto permite ejecutar múltiples conjuntos de parámetros a la vez.devolver esta nuevaCursorobjeto.

ejecutarscript(secuencia de comandos sql, /)

Crear un nuevoCursorobjeto y llamadaejecutarscript()en él con lo dadosecuencia de comandos sql. Devuelve el nuevo objeto cursor.
crear un nuevoCursorobjeto y llamadaexecutescript() método, pasando el script SQL proporcionado. Esto permite la ejecución de múltiples sentencias SQL, separadas por punto y coma en el script.devolver esta nuevaCursorobjeto.

crear_funcion(nombre, Narg, funciónión, , determinista=Falso*)

Crear o eliminar una función SQL definida por el usuario.
Cree o elimine una función SQL definida por el usuario.

Parámetros:

nombre (cadena) – El nombre de la función SQL.
name(cadena): el nombre de la función SQL.
Narg (En t) – La cantidad de argumentos que la función SQL puede aceptar. Si-1Puede tomar cualquier número de argumentos.
narg (int): el número de argumentos que la función SQL puede aceptar. Si -1, significa que puede aceptar cualquier número de argumentos.
funciónión (llamar de vuelta|Ninguno) – Ainvocableque se llama cuando se invoca la función SQL. El invocable debe devolverun tipo soportado de forma nativa por SQLite. Ajustado aNonepara eliminar una función SQL existente.
func (devolución de llamada | Ninguno): este objeto invocable (devolución de llamada) se ejecutará cuando se llame a la función SQL. Este objeto invocable debe devolver un tipo que SQLite admita de forma nativa. Si se establece en Ninguno, se eliminan las funciones SQL existentes.
determinista (Booleano) - SiTrue, la función SQL creada está marcada comodeterminista, lo que permite a SQLite realizar optimizaciones adicionales.
deterministic(bool): si es Verdadero, marca la función SQL creada como determinista, lo que permite a SQLite realizar optimizaciones adicionales.

Aumenta:

Error no compatible- Sideterministase utiliza con versiones de SQLite anteriores a 3.8.3.

Cambiado en la versión 3.8: Se agregó eldeterministaparámetro.

Ejemplo:

>>>


>>> import hashlib
>>> def md5sum(t):
...     return hashlib.md5(t).hexdigest()
>>> con = sqlite3.connect(":memory:")
>>> con.create_function("md5", 1, md5sum)
>>> for row in con.execute("SELECT md5(?)", (b"foo",)):
...     print(row)
('acbd18db4cc2f85cedef654fccc4a4d8',)
>>> con.close()

crear_agregado(nombre, n_arg, clase agregada)

Crear o eliminar una función de agregación SQL definida por el usuario.
Cree o elimine una función agregada de SQL definida por el usuario.

Parámetros:

nombre (cadena) – El nombre de la función de agregación de SQL.
name(cadena): el nombre de la función agregada de SQL.
n_arg (En t) – La cantidad de argumentos que la función de agregación SQL puede aceptar. Si-1Puede tomar cualquier número de argumentos.
El número de parámetros que una función agregada de SQL puede aceptar. Si -1, significa que puede aceptar cualquier número de argumentos.
clase agregada (clase|Ninguno) –

Una clase debe implementar los siguientes métodos:
Una clase debe implementar los siguientes métodos:
- step(): Agrega una fila al agregado.
- finalize():Devuelve el resultado final del agregado comoun tipo soportado de forma nativa por SQLite.
  finalize(): Este método se utiliza para devolver el resultado final de la agregación.
El número de argumentos que elstep()El método debe aceptar que está controlado porn_arg.
step()El número de parámetros que un método debe aceptar está dado porn_argcontrol.

Ajustado aNonepara eliminar una función de agregación SQL existente.
Establecer comoNonepara eliminar funciones agregadas de SQL existentes.

Ejemplo:


class MySum:
    def __init__(self):
        self.count = 0
 
    def step(self, value):
        self.count += value
 
    def finalize(self):
        return self.count
 
con = sqlite3.connect(":memory:")
con.create_aggregate("mysum", 1, MySum)
cur = con.execute("CREATE TABLE test(i)")
cur.execute("INSERT INTO test(i) VALUES(1)")
cur.execute("INSERT INTO test(i) VALUES(2)")
cur.execute("SELECT mysum(i) FROM test")
print(cur.fetchone()[0])
 
con.close()

función crear_ventana(nombre, num_parámetros, clase agregada, /)

Crear o eliminar una función de ventana agregada definida por el usuario.

Parámetros:

nombre (cadena) – El nombre de la función de ventana agregada de SQL que se creará o eliminará.
num_parámetros (En t) – La cantidad de argumentos que la función de ventana agregada de SQL puede aceptar. Si-1Puede tomar cualquier número de argumentos.
clase agregada (clase|Ninguno) –

Una clase que debe implementar los siguientes métodos:
- step():Agrega una fila a la ventana actual.
- value():Devuelve el valor actual del agregado.
- inverse():Elimina una fila de la ventana actual.
- finalize():Devuelve el resultado final del agregado comoun tipo soportado de forma nativa por SQLite.
El número de argumentos que elstep()yvalue()Los métodos deben aceptar que esté controlado pornum_parámetros.

Ajustado aNonepara eliminar una función de ventana agregada de SQL existente.

Aumenta:

Error no compatible– Si se utiliza con una versión de SQLite anterior a 3.25.0, que no admite funciones de ventana agregada.

Agregado en la versión 3.11.

Ejemplo:

# Example taken from https://www.sqlite.org/windowfunctions.html#udfwinfunc
class WindowSumInt:
    def __init__(self):
        self.count = 0

    def step(self, value):
        """Add a row to the current window."""
        self.count += value

    def value(self):
        """Return the current value of the aggregate."""
        return self.count

    def inverse(self, value):
        """Remove a row from the current window."""
        self.count -= value

    def finalize(self):
        """Return the final value of the aggregate.

        Any clean-up actions should be placed here.
        """
        return self.count


con = sqlite3.connect(":memory:")
cur = con.execute("CREATE TABLE test(x, y)")
values = [
    ("a", 4),
    ("b", 5),
    ("c", 3),
    ("d", 8),
    ("e", 1),
]
cur.executemany("INSERT INTO test VALUES(?, ?)", values)
con.create_window_function("sumint", 1, WindowSumInt)
cur.execute("""
    SELECT x, sumint(y) OVER (
        ORDER BY x ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING
    ) AS sum_y
    FROM test ORDER BY x
""")
print(cur.fetchall())
con.close()

crear_colección(nombre, invocable, /)

Crea una intercalación denominadanombreutilizando la función de cotejoinvocable. invocablese pasan doscadenaargumentos, y debería devolver unentero:

1Si el primero está ordenado más alto que el segundo
-1Si el primero está ordenado inferior al segundo
0Si están ordenados igual

El siguiente ejemplo muestra una intercalación de ordenamiento inverso:

def collate_reverse(string1, string2):
    if string1 == string2:
        return 0
    elif string1 < string2:
        return 1
    else:
        return -1

con = sqlite3.connect(":memory:")
con.create_collation("reverse", collate_reverse)

cur = con.execute("CREATE TABLE test(x)")
cur.executemany("INSERT INTO test(x) VALUES(?)", [("a",), ("b",)])
cur.execute("SELECT x FROM test ORDER BY x COLLATE reverse")
for row in cur:
    print(row)
con.close()

Eliminar una función de intercalación estableciendoinvocableaNone.

Modificado en la versión 3.11: el nombre de intercalación puede contener cualquier carácter Unicode. Antes, solo se permitían caracteres ASCII.

interrumpir()

Llame a este método desde un hilo diferente para cancelar cualquier consulta que pueda estar ejecutándose en la conexión. Las consultas canceladas generarán un errorError operacional.

establecer_autorizador(devolución de llamada del autorizador)

Registroinvocable devolución de llamada del autorizadorque se invocará cada vez que se intente acceder a una columna de una tabla en la base de datos. La devolución de llamada debe devolver uno deSQLITE_OK, SQLITE_DENY, oSQLITE_IGNOREpara indicar cómo debe gestionarse el acceso a la columna mediante la biblioteca SQLite subyacente.

El primer argumento de la devolución de llamada indica qué tipo de operación se debe autorizar. El segundo y tercer argumento serán argumentos oNonedependiendo del primer argumento. El cuarto argumento es el nombre de la base de datos (“principal”, “temp”, etc.) si corresponde. El quinto argumento es el nombre del disparador o vista más interno que es responsable del intento de acceso oNoneSi este intento de acceso es directamente desde el código SQL de entrada.

Consulte la documentación de SQLite sobre los posibles valores para el primer argumento y el significado del segundo y tercer argumento en función del primero. Todas las constantes necesarias están disponibles en lasqlite3módulo.

PasoNonecomodevolución de llamada del autorizadordeshabilitará el autorizador.

Cambiado en la versión 3.11: Se agregó soporte para deshabilitar el autorizador usandoNone.

establecer_controlador_de_progreso(manejador_de_progreso, norteorte)

Registroinvocable manejador_de_progresoser invocado para cadanorteorteinstrucciones de la máquina virtual SQLite. Esto es útil si desea recibir llamadas de SQLite durante operaciones de larga duración, por ejemplo, para actualizar una GUI.

Si desea borrar cualquier controlador de progreso previamente instalado, llame al método conNoneparamanejador_de_progreso.

Devolver un valor distinto de cero desde la función del controlador finalizará la consulta que se está ejecutando actualmente y provocará que se genere unError de la base de datosexcepción.

establecer_trace_callback(seguimiento_de_llamada)

Registroinvocable seguimiento_de_llamadaque debe invocarse para cada declaración SQL que realmente ejecuta el backend de SQLite.

El único argumento que se pasa a la devolución de llamada es la declaración (comocadena) que se está ejecutando. El valor de retorno de la devolución de llamada se ignora. Tenga en cuenta que el backend no solo ejecuta las instrucciones que se pasan alCursor.ejecutar()métodos. Otras fuentes incluyen laGestión de transaccionesdelsqlite3módulo y la ejecución de disparadores definidos en la base de datos actual.

PasoNonecomoseguimiento_de_llamadadeshabilitará la devolución de llamada de seguimiento.

Nota

Las excepciones generadas en la devolución de llamada de seguimiento no se propagan. Como ayuda para el desarrollo y la depuración, utilicehabilitar_callback_tracebacks()para habilitar la impresión de seguimientos de las excepciones generadas en la devolución de llamada de seguimiento.

Agregado en la versión 3.3.

habilitar_carga_extension(activado, /)

Habilite el motor SQLite para cargar extensiones SQLite desde bibliotecas compartidas siactivadoesTrue; de lo contrario, no se permite cargar extensiones de SQLite. Las extensiones de SQLite pueden definir nuevas funciones, agregados o implementaciones de tablas virtuales completamente nuevas. Una extensión conocida es la extensión de búsqueda de texto completo que se distribuye con SQLite.

Nota

Elsqlite3El módulo no está construido con soporte de extensión cargable de manera predeterminada, porque algunas plataformas (especialmente macOS) tienen bibliotecas SQLite que se compilan sin esta característica. Para obtener soporte de extensión cargable, debe pasar la--habilitar extensiones sqlite cargablesOpción aconfigurar.

plantea unaevento de auditoría sqlite3.enable_load_extensioncon argumentosconnection, enabled.

Agregado en la versión 3.2.

Cambiado en la versión 3.10: Se agregó elsqlite3.enable_load_extensionevento de auditoría.

con.enable_load_extension(True)

# Load the fulltext search extension
con.execute("select load_extension('./fts3.so')")

# alternatively you can load the extension using an API call:
# con.load_extension("./fts3.so")

# disable extension loading again
con.enable_load_extension(False)

# example from SQLite wiki
con.execute("CREATE VIRTUAL TABLE recipe USING fts3(name, ingredients)")
con.executescript("""
    INSERT INTO recipe (name, ingredients) VALUES('broccoli stew', 'broccoli peppers cheese tomatoes');
    INSERT INTO recipe (name, ingredients) VALUES('pumpkin stew', 'pumpkin onions garlic celery');
    INSERT INTO recipe (name, ingredients) VALUES('broccoli pie', 'broccoli cheese onions flour');
    INSERT INTO recipe (name, ingredients) VALUES('pumpkin pie', 'pumpkin sugar flour butter');
    """)
for row in con.execute("SELECT rowid, name, ingredients FROM recipe WHERE name MATCH 'pie'"):
    print(row)

cargar_extension(camino, /, *, punto de entrada=Ninguno)

Cargue una extensión SQLite desde una biblioteca compartida. Habilite la carga de extensiones conhabilitar_carga_extension()antes de llamar a este método.

Parámetros:

camino (cadena) – La ruta a la extensión SQLite.
punto de entrada (cadena | Ninguno) – Nombre del punto de entrada. SiNone(predeterminado), SQLite creará un nombre de punto de entrada propio; consulte la documentación de SQLiteCargando una extensiónpara detalles.

plantea unaevento de auditoría sqlite3.load_extensioncon argumentosconnection, path.

Agregado en la versión 3.2.

Cambiado en la versión 3.10: Se agregó elsqlite3.load_extensionevento de auditoría.

Cambiado en la versión 3.12: Se agregó elpunto de entradaparámetro.

volcado de iteración()

Devolver uniteradorpara volcar la base de datos como código fuente SQL. Útil cuando se guarda una base de datos en memoria para restaurarla más tarde. Similar a.dumpcomando en elsqlite3caparazón.

Ejemplo:

# Convert file example.db to SQL dump file dump.sql
con = sqlite3.connect('example.db')
with open('dump.sql', 'w') as f:
    for line in con.iterdump():
        f.write('%sn' % line)
con.close()

Ver también

Cómo manejar codificaciones de texto que no sean UTF-8

respaldo(objetivo, *, páginas=-1, progreso=Ninguno, nombre='principal', dormir=0.250)

Crear una copia de seguridad de una base de datos SQLite.

Funciona incluso si otros clientes acceden a la base de datos o si la misma conexión la accede simultáneamente.

Parámetros:

objetivo (Conexión) – La conexión de base de datos donde guardar la copia de seguridad.
páginas (En t) – El número de páginas que se copiarán a la vez. Si es igual o menor que0, se copia toda la base de datos en un solo paso. El valor predeterminado es-1.
progreso (llamar de vuelta| Ninguno) – Si se establece en uninvocable, se invoca con tres argumentos enteros para cada iteración de respaldo: elestadode la última iteración, larestantenúmero de páginas que aún quedan por copiar, y latotalNúmero de páginas. El valor predeterminado esNone.
nombre (cadena) – El nombre de la base de datos de la que se realizará la copia de seguridad."main"(predeterminado) para la base de datos principal,"temp"para la base de datos temporal, o el nombre de una base de datos personalizada tal como se adjunta mediante elATTACH DATABASESentencia SQL.
dormir (flotar) – La cantidad de segundos que se deben esperar entre intentos sucesivos de realizar copias de seguridad de las páginas restantes.

Ejemplo 1, copiar una base de datos existente en otra:

def progress(status, remaining, total):
    print(f'Copied {total-remaining} of {total} pages...')

src = sqlite3.connect('example.db')
dst = sqlite3.connect('backup.db')
with dst:
    src.backup(dst, pages=1, progress=progress)
dst.close()
src.close()

Ejemplo 2, copiar una base de datos existente en una copia transitoria:

src = sqlite3.connect('example.db')
dst = sqlite3.connect(':memory:')
src.backup(dst)
dst.close()
src.close()

Agregado en la versión 3.7.

Ver también

Cómo manejar codificaciones de texto que no sean UTF-8

obtener limite(categoría, /)

Obtener un límite de tiempo de ejecución de la conexión.

Parámetros:

categoría (En t) - ElCategoría límite de SQLitepara ser consultado.

Tipo de retorno:

En t

Aumenta:

Error de programación- Sicategoríano es reconocido por la biblioteca SQLite subyacente.

Ejemplo, consultar la longitud máxima de una declaración SQL paraConexión con(el valor predeterminado es 1000000000):

>>>

>>> con.getlimit(sqlite3.SQLITE_LIMIT_SQL_LENGTH)
1000000000

Agregado en la versión 3.11.

establecer límite(categoría, límite, /)

Establezca un límite de tiempo de ejecución de la conexión. Los intentos de aumentar un límite por encima de su límite superior estricto se truncan de forma silenciosa hasta el límite superior estricto. Independientemente de si se modificó o no el límite, se devuelve el valor anterior del límite.

Parámetros:

categoría (En t) - ElCategoría límite de SQLitepara ajustar.
límite (En t) – El valor del nuevo límite. Si es negativo, el límite actual no cambia.

Tipo de retorno:

En t

Aumenta:

Error de programación- Sicategoríano es reconocido por la biblioteca SQLite subyacente.

Por ejemplo, limite el número de bases de datos adjuntas a 1 paraConexión con(el límite predeterminado es 10):

>>>

>>> con.setlimit(sqlite3.SQLITE_LIMIT_ATTACHED, 1)
10
>>> con.getlimit(sqlite3.SQLITE_LIMIT_ATTACHED)
1

Agregado en la versión 3.11.

obtener configuración(En, /)

Consultar una opción de configuración de conexión booleana.

Parámetros:

En (En t) - ACódigo SQLITE_DBCONFIG.

Tipo de retorno:

Booleano

Agregado en la versión 3.12.

establecer configuración(En, habilitar=Verdadero, /)

Establezca una opción de configuración de conexión booleana.

Parámetros:

En (En t) - ACódigo SQLITE_DBCONFIG.
permitir (Booleano) – Truesi la opción de configuración debe estar habilitada (predeterminado);FalseSi debe desactivarse.

Agregado en la versión 3.12.

fabricar en serie(*, nombre='principal')

Serializar una base de datos en unabytesobjeto. En el caso de un archivo de base de datos en disco común, la serialización es simplemente una copia del archivo en disco. En el caso de una base de datos en memoria o una base de datos “temporal”, la serialización es la misma secuencia de bytes que se escribiría en el disco si se hiciera una copia de seguridad de esa base de datos en el disco.

Parámetros:

nombre (cadena) – El nombre de la base de datos que se serializará. El valor predeterminado es"main".

Tipo de retorno:

bytes

Nota

Este método solo está disponible si la biblioteca SQLite subyacente tiene la API de serialización.

Agregado en la versión 3.11.

deserializar(datos, /, *, nombre='principal')

Deserializar unserializadobase de datos en unaConexiónEste método hace que la conexión a la base de datos se desconecte de la base de datos.nombre, y volver a abrirnombrecomo una base de datos en memoria basada en la serialización contenida endatos.

Parámetros:

datos (bytes) – Una base de datos serializada.
nombre (cadena) – El nombre de la base de datos en la que se deserializará. El valor predeterminado es"main".

Aumenta:

Error operacional– Si la conexión de la base de datos está actualmente involucrada en una transacción de lectura o en una operación de copia de seguridad.
Error de la base de datos- Sidatosno contiene una base de datos SQLite válida.
Error de desbordamiento- Silen(datos)Es mas grande que2**63 - 1.

Nota

Este método solo está disponible si la biblioteca SQLite subyacente tiene la API de deserialización.

Agregado en la versión 3.11.

confirmación automática

Este atributo controlaPEP249- comportamiento transaccional conforme.autocommittiene tres valores permitidos:

False: SeleccionarPEP249- comportamiento transaccional conforme, lo que implica quesqlite3garantiza que una transacción esté siempre abierta. Utilicecomprometerse()yRetroceder()para cerrar transacciones.

Este es el valor recomendado deautocommit.
True:Utilice SQLitemodo de confirmación automática. comprometerse()yRetroceder()No tiene ningún efecto en este modo.
CONTROL DE TRANSACCIONES LEGAL: Pre-Python 3.12 (noPEP249-control de transacciones compatible. Vernivel de aislamientopara más detalles.

Este es actualmente el valor predeterminado deautocommit.

CambiandoautocommitaFalseabrirá una nueva transacción y la cambiará aTrueconfirmará cualquier transacción pendiente.

VerControl de transacciones a través del atributo autocommitpara más detalles.

Nota

Elnivel de aislamientoEl atributo no tiene efecto a menos queconfirmación automáticaesCONTROL DE TRANSACCIONES LEGAL.

Agregado en la versión 3.12.

en transacción

Este atributo de solo lectura corresponde al SQLite de bajo nivelmodo de confirmación automática.

TrueSi una transacción está activa (hay cambios no confirmados),Falsede lo contrario.

Agregado en la versión 3.2.

nivel de aislamiento

Controla elmodo de manejo de transacciones heredadodesqlite3. Si se establece enNone, las transacciones nunca se abren implícitamente. Si se establece en uno de"DEFERRED", "IMMEDIATE", o"EXCLUSIVE", correspondiente al subyacenteComportamiento de las transacciones de SQLite, gestión de transacciones implícitases interpretado.

Si no es anulado por elnivel de aislamientoparámetro deconectar(), el valor predeterminado es"", que es un alias para"DEFERRED".

Nota

Usandoconfirmación automáticaSe recomienda controlar el manejo de transacciones en lugar de usarisolation_level. isolation_levelno tiene efecto a menos queconfirmación automáticase establece enCONTROL DE TRANSACCIONES LEGAL(el valor por defecto).

fábrica de filas

La inicialfábrica de filasparaCursorobjetos creados a partir de esta conexión. La asignación a este atributo no afecta a larow_factoryde los cursores existentes que pertenecen a esta conexión, solo los nuevos.Nonede forma predeterminada, lo que significa que cada fila se devuelve como unatupla.

VerCómo crear y utilizar fábricas de filaspara más detalles.

fábrica de texto

Ainvocableque acepta unabytesparámetro y devuelve una representación de texto del mismo. El invocable se invoca para valores SQLite con elTEXTTipo de datos. De forma predeterminada, este atributo está configurado comocadena.

VerCómo manejar codificaciones de texto que no sean UTF-8para más detalles.

cambios totales

Devuelve el número total de filas de la base de datos que se han modificado, insertado o eliminado desde que se abrió la conexión a la base de datos.

Objetos del cursor

ACursorobjeto representa uncursor de base de datosque se utiliza para ejecutar sentencias SQL y administrar el contexto de una operación de búsqueda. Los cursores se crean utilizandoConexión.cursor(), o mediante el uso de cualquiera de losmétodos de acceso directo de conexión.

Los objetos del cursor soniteradores, lo que significa que siejecutar()aSELECTconsulta, puede simplemente iterar sobre el cursor para obtener las filas resultantes:
for row in cur.execute("SELECT t FROM data"):
    print(row)

claseCursor de sqlite3

ACursorLa instancia tiene los siguientes atributos y métodos.

ejecutar(sql, parámetros=(), /)

Ejecutar una única declaración SQL, vinculando opcionalmente valores de Python mediantemarcadores de posición.

Parámetros:

sql (cadena) – Una sola declaración SQL.
parámetros (dictadoadoadoadoadoadoadoadoadoado | secuencia) – Valores de Python para vincular a marcadores de posición ensql. Adictsi se utilizan marcadores de posición con nombre. Una secuencia si se utilizan marcadores de posición sin nombre. VerCómo utilizar marcadores de posición para vincular valores en consultas SQL.

Aumenta:

Error de programación- Sisqlcontiene más de una declaración SQL.

Siconfirmación automáticaesCONTROL DE TRANSACCIONES LEGAL, nivel de aislamientono esNone, sqles unINSERT, UPDATE, DELETE, oREPLACEdeclaración, y no hay ninguna transacción abierta, se abre implícitamente una transacción antes de ejecutarsesql.

Obsoleto desde la versión 3.12, se eliminará en la versión 3.14:Advertencia de desusose emite simarcadores de posición nombradosse utilizan yparámetroses una secuencia en lugar de unadictadoadoadoadoadoadoadoadoadoadoA partir de Python 3.14,Error de programaciónse elevará en su lugar.

Usarejecutarscript()para ejecutar múltiples sentencias SQL.

ejecutarmuchos(sql, parámetros, /)

Para cada artículo enparámetros, ejecutar repetidamente elparametrizadoSentencia SQL DMLsql.

Utiliza el mismo manejo de transacciones implícitas queejecutar().

Parámetros:

sql (cadena) – Una única declaración DML de SQL.
parámetros (iterable) – Un iterable de parámetros para enlazar con los marcadores de posición ensql. VerCómo utilizar marcadores de posición para vincular valores en consultas SQL.

Aumenta:

Error de programación- Sisqlcontiene más de una declaración SQL o no es una declaración DML.

Ejemplo:

rows = [
    ("row1",),
    ("row2",),
]
# cur is an sqlite3.Cursor object
cur.executemany("INSERT INTO data VALUES(?)", rows)

Nota

Se descartan todas las filas resultantes, incluidas las declaraciones DML conCláusulas de RETORNO.

Obsoleto desde la versión 3.12, se eliminará en la versión 3.14:Advertencia de desusose emite simarcadores de posición nombradosse utilizan y los artículos enparámetrosson secuencias en lugar dedictadoadoadoadoadoadoadoadoadoados. A partir de Python 3.14,Error de programaciónse elevará en su lugar.

ejecutarscript(secuencia de comandos sql, /)

Ejecutar las sentencias SQL ensecuencia de comandos sql. Si elconfirmación automáticaesCONTROL DE TRANSACCIONES LEGALy hay una transacción pendiente, una implícitaCOMMITLa instrucción se ejecuta primero. No se realiza ningún otro control de transacción implícito; cualquier control de transacción debe agregarse asecuencia de comandos sql.

secuencia de comandos sqldebe ser uncadena.

Ejemplo:

# cur is an sqlite3.Cursor object
cur.executescript("""
    BEGIN;
    CREATE TABLE person(firstname, lastname, age);
    CREATE TABLE book(title, author, published);
    CREATE TABLE publisher(name, address);
    COMMIT;
""")

buscar uno()

Sifábrica de filasesNone, devuelve el siguiente conjunto de resultados de consulta de fila como untuplaDe lo contrario, páselo a la fábrica de filas y devuelva su resultado. RegresarNoneSi no hay más datos disponibles.

buscarmuchos(tamaño=cursor.tamañomatriz)

Devuelve el siguiente conjunto de filas de un resultado de consulta como unlistaaaaaaaaDevuelve una lista vacía si no hay más filas disponibles.

El número de filas a obtener por llamada se especifica mediante eltamañoparámetro. Sitamañono se da,tamaño de matrizdetermina el número de filas que se obtendrán. Si son menos detamañoHay filas disponibles, se devuelven tantas filas como estén disponibles.

Tenga en cuenta que existen consideraciones de rendimiento involucradas con eltamañoparámetro. Para un rendimiento óptimo, normalmente es mejor utilizar el atributo arraysize. Si eltamañoSi se utiliza un parámetro, lo mejor es que conserve el mismo valor de uno en uno.buscarmuchos()llamar al siguiente.

buscartodo()

Devuelve todas las filas (restantes) de un resultado de consulta como unalistaaaaaaaa. Devuelve una lista vacía si no hay filas disponibles. Tenga en cuenta quetamaño de matrizEl atributo puede afectar el rendimiento de esta operación.

cerca()

Cierre el cursor ahora (en lugar de cuando lo desee)__del__se llama).

El cursor no se podrá utilizar a partir de este momento;Error de programaciónSe generará una excepción si se intenta realizar alguna operación con el cursor.

establecer tamaños de entrada(tamaños, /)

Requerido por la DB-API. No hace nada ensqlite3.

establecertamañodesalida(tamaño, columna=Ninguna, /)

Requerido por la DB-API. No hace nada ensqlite3.

tamaño de matriz

Atributo de lectura/escritura que controla el número de filas devueltas porbuscarmuchos()El valor predeterminado es 1, lo que significa que se obtendrá una sola fila por llamada.

conexión

Atributo de solo lectura que proporciona la base de datos SQLiteConexiónperteneciente al cursor. ACursorobjeto creado al llamarcon.cursor()tendrá unconexiónatributo que se refiere aestafa:

>>>

>>> con = sqlite3.connect(":memory:")
>>> cur = con.cursor()
>>> cur.connection == con
True
>>> con.close()

descripción

Atributo de solo lectura que proporciona los nombres de las columnas de la última consulta. Para mantener la compatibilidad con la API de Python DB, devuelve una tupla de 7 elementos para cada columna, donde se encuentran los últimos seis elementos de cada tupla.None.

Está previsto paraSELECTdeclaraciones sin filas coincidentes también.

última fila

Atributo de solo lectura que proporciona el ID de fila de la última fila insertada. Solo se actualiza después de una operación exitosa.INSERToREPLACEdeclaraciones que utilizan elejecutar()método. Para otras afirmaciones, despuésejecutarmuchos()oejecutarscript(), o si la inserción falló, el valor delastrowidse deja sin cambios. El valor inicial delastrowidesNone.

Nota

Se inserta enWITHOUT ROWIDLas tablas no se registran.

Cambiado en la versión 3.6: Se agregó soporte para elREPLACEdeclaración.

número de filas

Atributo de solo lectura que proporciona el número de filas modificadas paraINSERT, UPDATE, DELETE, yREPLACEdeclaraciones; es-1para otras declaraciones, incluidas las consultas CTE. Solo se actualiza por elejecutar()yejecutarmuchos()métodos, después de que la instrucción se haya ejecutado hasta su finalización. Esto significa que se deben recuperar todas las filas resultantes pararowcountPara actualizarse.

fábrica de filas

Controla cómo se obtiene una fila de esteCursorestá representado. SiNone, una fila se representa como unatuplaSe puede configurar en el incluidosqlite3.Fila; o uninvocableque acepta dos argumentos, aCursorobjeto y eltuplede valores de fila y devuelve un objeto personalizado que representa una fila de SQLite.

El valor predeterminado es quéConexión.row_factoryse estableció cuando elCursorSe creó. La asignación a este atributo no afectaConexión.row_factoryde la conexión principal.

VerCómo crear y utilizar fábricas de filaspara más detalles.

Objetos de fila

clasesqlite3.Fila

ARowLa instancia sirve como un sistema altamente optimizadofábrica de filasparaConexiónobjetos. Admite iteración, pruebas de igualdad,largo(), ycartografíaacceso por nombre de columna e índice.

DosRowLos objetos se comparan entre sí si tienen nombres de columna y valores idénticos.

VerCómo crear y utilizar fábricas de filaspara más detalles.

llaves()

Devolver unlistaaaaaaaade nombres de columnas comoinstrumentos de cuerdaInmediatamente después de una consulta, es el primer miembro de cada tupla enCursor.descripción.

Cambiado en la versión 3.5: Se agregó soporte para corte.

Objetos blob

clasesqlite3.Blob

Agregado en la versión 3.11.

AGotaLa instancia es unaobjeto similar a un archivoque puede leer y escribir datos en un BLOB de SQLite. Llamarlongitud (mancha)para obtener el tamaño (número de bytes) del blob. Utilice índices yRebanadaspara acceder directamente a los datos del blob.

Utilizar elGotacomo unadministrador de contextopara garantizar que el mango esté cerrado después del uso.

con = sqlite3.connect(":memory:")
con.execute("CREATE TABLE test(blob_col blob)")
con.execute("INSERT INTO test(blob_col) VALUES(zeroblob(13))")

# Write to our blob, using two write operations:
with con.blobopen("test", "blob_col", 1) as blob:
    blob.write(b"hello, ")
    blob.write(b"world.")
    # Modify the first and last bytes of our blob
    blob[0] = ord("H")
    blob[-1] = ord("!")

# Read the contents of our blob
with con.blobopen("test", "blob_col", 1) as blob:
    greeting = blob.read()

print(greeting)  # outputs "b'Hello, world!'"
con.close()

cerca()

Cierra el blob.

El blob no se podrá utilizar a partir de este momento.ErrorSe generará una excepción (o subclase) si se intenta cualquier otra operación con el blob.

leer(longitud=-1, /)

Leerlongitudbytes de datos del blob en la posición de desplazamiento actual. Si se alcanza el final del blob, se devolverán los datos hasta el EOF.longitudno se especifica o es negativo,leer()Leerá hasta el final del blob.

escribir(datos, /)

Escribirdatosal blob en el desplazamiento actual. Esta función no puede cambiar la longitud del blob. Escribir más allá del final del blob generará un errorError de valor.

decir()

Devuelve la posición de acceso actual del blob.

buscar(compensar, origen=os.SEEK_SET, /)

Establezca la posición de acceso actual del blob encompensar. ElorigenEl argumento predeterminado essistema operativo.SEEK_SET(posición absoluta del blob). Otros valores paraorigensonsistema operativo.SEEK_CUR(buscar en relación a la posición actual) yos.BUSCAR_FIN(buscar relativo al final del blob).

Objetos PrepareProtocol

clasesqlite3.PrepararProtocolo

El único propósito del tipo PrepareProtocol es actuar como unPEP246Protocolo de adaptación de estilo para objetos que puedenadaptarseatipos nativos de SQLite.

Excepciones

La jerarquía de excepciones está definida por DB-API 2.0 (PEP249).

excepciónsqlite3.Advertencia

Esta excepción no se plantea actualmente en elsqlite3módulo, pero puede ser generado por aplicaciones que utilicensqlite3, por ejemplo, si una función definida por el usuario trunca datos al insertarlos.Warninges una subclase deExcepción.

excepciónsqlite3.Error

La clase base de las demás excepciones de este módulo. Úsela para capturar todos los errores con una sola excepción.exceptoodeclaración.Errores una subclase deExcepción.

Si la excepción se originó dentro de la biblioteca SQLite, se agregan los siguientes dos atributos a la excepción:

código de error de sqlite

El código de error numérico delAPI de SQLite

Agregado en la versión 3.11.

nombre_error_sqlite

El nombre simbólico del código de error numérico delAPI de SQLite

Agregado en la versión 3.11.

excepciónError de interfaz de sqlite3

Se generó una excepción por uso indebido de la API C de SQLite de bajo nivel. En otras palabras, si se genera esta excepción, probablemente indica un error en lasqlite3módulo.InterfaceErrores una subclase deError.

excepciónsqlite3.Error de base de datos

Excepción generada para errores relacionados con la base de datos. Sirve como excepción base para varios tipos de errores de base de datos. Solo se genera de forma implícita a través de las subclases especializadas.DatabaseErrores una subclase deError.

excepciónError de datos de SQLite3

Se genera una excepción para errores causados por problemas con los datos procesados, como valores numéricos fuera de rango y cadenas demasiado largas.DataErrores una subclase deError de la base de datos.

excepciónsqlite3.Error operativo

Excepción generada por errores relacionados con el funcionamiento de la base de datos y que no necesariamente están bajo el control del programador. Por ejemplo, no se encuentra la ruta de la base de datos o no se pudo procesar una transacción.OperationalErrores una subclase deError de la base de datos.

excepciónError de integridad de sqlite3

Excepción que se genera cuando se ve afectada la integridad relacional de la base de datos, por ejemplo, falla una comprobación de clave externa. Es una subclase deError de la base de datos.

excepciónsqlite3.Error interno

Se genera una excepción cuando SQLite encuentra un error interno. Si se genera, puede indicar que hay un problema con la biblioteca SQLite en tiempo de ejecución.InternalErrores una subclase deError de la base de datos.

excepciónsqlite3.Error de programación

Se plantea una excepción parasqlite3Errores de programación de API, por ejemplo, proporcionar la cantidad incorrecta de enlaces a una consulta o intentar operar en una API cerrada.Conexión. ProgrammingErrores una subclase deError de la base de datos.

excepciónError de sqlite3.No compatible

Se genera una excepción en caso de que la biblioteca SQLite subyacente no admita un método o una API de base de datos. Por ejemplo, al configurardeterministaaTrueencrear_funcion(), si la biblioteca SQLite subyacente no admite funciones deterministas.NotSupportedErrores una subclase deError de la base de datos.

Tipos de SQLite y Python

SQLite admite de forma nativa los siguientes tipos:NULL, INTEGER, REAL, TEXT, BLOB.

Los siguientes tipos de Python se pueden enviar a SQLite sin ningún problema:

Tipo de Python	Tipo SQLite
`None`	`NULL`
En t	`INTEGER`
flotar	`REAL`
cadena	`TEXT`
bytes	`BLOB`

Así es como los tipos de SQLite se convierten a tipos de Python de forma predeterminada:

Tipo SQLite	Tipo de Python
`NULL`	`None`
`INTEGER`	En t
`REAL`	flotar
`TEXT`	depende defábrica de texto, cadenapor defecto
`BLOB`	bytes

El sistema de tipos de lasqlite3El módulo es extensible de dos maneras: puede almacenar tipos de Python adicionales en una base de datos SQLite a través deadaptadores de objetos, y puedes dejarlosqlite3módulo convierte tipos SQLite a tipos Python a través deconvertidores.

Adaptadores y convertidores predeterminados (en desuso)

Nota

Los adaptadores y convertidores predeterminados están obsoletos a partir de Python 3.12. En su lugar, utilice elRecetas de adaptadores y convertidoresy adaptarlos a sus necesidades.

Los adaptadores y convertidores predeterminados obsoletos consisten en:

Un adaptador parafecha y hora.fechaobjetos ainstrumentos de cuerdaenISO 8601formato.
Un adaptador parafecha y hora.fecha y horaobjetos a cadenas en formato ISO 8601.
Un convertidor paradeclaradoTipos de “fecha” afecha y hora.fechaobjetos.
Un convertidor para los tipos de “marca de tiempo” declarados afecha y hora.fecha y horaobjetos. Las partes fraccionarias se truncarán a 6 dígitos (precisión de microsegundos).

Nota

El convertidor de “marca de tiempo” predeterminado ignora las compensaciones UTC en la base de datos y siempre devuelve una ingenuafecha y hora.fecha y horaobjeto. Para conservar las compensaciones UTC en las marcas de tiempo, deje los convertidores deshabilitados o registre un convertidor que tenga en cuenta las compensaciones conregistrar_convertidor().

Obsoleto desde la versión 3.12.

Interfaz de línea de comandos

Elsqlite3El módulo se puede invocar como un script, utilizando el intérprete.-metroetroswitch, para proporcionar un shell SQLite simple. La firma del argumento es la siguiente:

python -m sqlite3 [-h] [-v] [filename] [sql]

Tipo.quito CTRL-D para salir del shell.

-h, --ayuda

Ayuda de la CLI de impresión.

-v, --versión

Imprima la versión de la biblioteca SQLite subyacente.

Agregado en la versión 3.12.

Guías prácticas

Cómo utilizar marcadores de posición para vincular valores en consultas SQL

Las operaciones SQL suelen necesitar utilizar valores de variables de Python. Sin embargo, tenga cuidado al utilizar las operaciones de cadena de Python para ensamblar consultas, ya que son vulnerables aAtaques de inyección SQLPor ejemplo, un atacante puede simplemente cerrar la comilla simple e inyectarOR TRUEPara seleccionar todas las filas:

>>>

>>> # Never do this -- insecure!
>>> symbol = input()
' OR TRUE; --
>>> sql = "SELECT * FROM stocks WHERE symbol = '%s'" % symbol
>>> print(sql)
SELECT * FROM stocks WHERE symbol = '' OR TRUE; --'
>>> cur.execute(sql)

En su lugar, utilice la sustitución de parámetros de DB-API. Para insertar una variable en una cadena de consulta, utilice un marcador de posición en la cadena y sustituya los valores reales en la consulta proporcionándolos como untuplade valores al segundo argumento del cursorejecutar()método.

Una sentencia SQL puede utilizar uno de dos tipos de marcadores de posición: signos de interrogación (estilo qmark) o marcadores de posición con nombre (estilo con nombre). Para el estilo qmark,parámetrosdebe ser unsecuenciacuya longitud debe coincidir con el número de marcadores de posición, o unError de programaciónse eleva. Para el estilo nombrado,parámetrosdebe ser una instancia de undictadoadoadoadoadoadoadoadoadoado(o una subclase), que debe contener claves para todos los parámetros nombrados; se ignoran los elementos adicionales. A continuación, se muestra un ejemplo de ambos estilos:

con = sqlite3.connect(":memory:")
cur = con.execute("CREATE TABLE lang(name, first_appeared)")

# This is the named style used with executemany():
data = (
    {"name": "C", "year": 1972},
    {"name": "Fortran", "year": 1957},
    {"name": "Python", "year": 1991},
    {"name": "Go", "year": 2009},
)
cur.executemany("INSERT INTO lang VALUES(:name, :year)", data)

# This is the qmark style used in a SELECT query:
params = (1972,)
cur.execute("SELECT * FROM lang WHERE first_appeared = ?", params)
print(cur.fetchall())
con.close()

Nota

PEP249Los marcadores de posición numéricos sonnocompatible. Si se utilizan, se interpretarán como marcadores de posición con nombre.

Cómo adaptar tipos de Python personalizados a valores de SQLite

SQLite admite solo un conjunto limitado de tipos de datos de forma nativa. Para almacenar tipos de Python personalizados en bases de datos SQLite,adaptarellos a uno de losTipos de Python que SQLite entiende de forma nativa.

Hay dos formas de adaptar objetos de Python a tipos de SQLite: dejar que el objeto se adapte por sí mismo o usar unadaptador invocableEste último tendrá prioridad sobre el primero. Para una biblioteca que exporta un tipo personalizado, puede tener sentido permitir que ese tipo se adapte por sí mismo. Como desarrollador de aplicaciones, puede tener más sentido tomar el control directo mediante el registro de funciones de adaptador personalizadas.

Cómo escribir objetos adaptables

Supongamos que tenemos unaPointclase que representa un par de coordenadas,xyy, en un sistema de coordenadas cartesianas. El par de coordenadas se almacenará como una cadena de texto en la base de datos, utilizando un punto y coma para separar las coordenadas. Esto se puede implementar agregando un__conform__(self, protocol)método que devuelve el valor adaptado. El objeto pasado aprotocoloserá de tipoPreparar protocolo.

class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __conform__(self, protocol):
        if protocol is sqlite3.PrepareProtocol:
            return f"{self.x};{self.y}"

con = sqlite3.connect(":memory:")
cur = con.cursor()

cur.execute("SELECT ?", (Point(4.0, -3.2),))
print(cur.fetchone()[0])
con.close()

Cómo registrar los adaptadores invocables

La otra posibilidad es crear una función que convierta el objeto Python a un tipo compatible con SQLite. Esta función puede luego registrarse usandoadaptador_de_registro().

class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y

def adapt_point(point):
    return f"{point.x};{point.y}"

sqlite3.register_adapter(Point, adapt_point)

con = sqlite3.connect(":memory:")
cur = con.cursor()

cur.execute("SELECT ?", (Point(1.0, 2.5),))
print(cur.fetchone()[0])
con.close()

Cómo convertir valores de SQLite en tipos de Python personalizados

Escribir un adaptador le permite convertirdetipos de Python personalizadosaValores de SQLite. Para poder convertirdeValores de SQLiteatipos de Python personalizados que utilizamosconvertidores.

Volvamos a laPointclase. Almacenamos las coordenadas x e y separadas por punto y coma como cadenas en SQLite.

Primero, definiremos una función de conversión que acepta la cadena como parámetro y construye unaPointobjeto de ella.

Nota

Las funciones del convertidor sonsiemprePasó unabytesobjeto, sin importar el tipo de datos SQLite subyacente.

def convert_point(s):
    x, y = map(float, s.split(b";"))
    return Point(x, y)

Ahora tenemos que decirlosqlite3cuando debe convertir un valor SQLite determinado. Esto se hace al conectarse a una base de datos, utilizando eldetectar_tiposparámetro deconectar()Hay tres opciones:

Implícito: conjuntodetectar_tiposaPARSE_DECLTYPES
Explícito: conjuntodetectar_tiposaANALIZAR_NOMBRES_DE_COlumnas
Ambos: conjuntodetectar_tiposasqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES. Los nombres de columnas tienen prioridad sobre los tipos declarados.

El siguiente ejemplo ilustra los enfoques implícitos y explícitos:

class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __repr__(self):
        return f"Point({self.x}, {self.y})"

def adapt_point(point):
    return f"{point.x};{point.y}"

def convert_point(s):
    x, y = list(map(float, s.split(b";")))
    return Point(x, y)

# Register the adapter and converter
sqlite3.register_adapter(Point, adapt_point)
sqlite3.register_converter("point", convert_point)

# 1) Parse using declared types
p = Point(4.0, -3.2)
con = sqlite3.connect(":memory:", detect_types=sqlite3.PARSE_DECLTYPES)
cur = con.execute("CREATE TABLE test(p point)")

cur.execute("INSERT INTO test(p) VALUES(?)", (p,))
cur.execute("SELECT p FROM test")
print("with declared types:", cur.fetchone()[0])
cur.close()
con.close()

# 2) Parse using column names
con = sqlite3.connect(":memory:", detect_types=sqlite3.PARSE_COLNAMES)
cur = con.execute("CREATE TABLE test(p)")

cur.execute("INSERT INTO test(p) VALUES(?)", (p,))
cur.execute('SELECT p AS "p [point]" FROM test')
print("with column names:", cur.fetchone()[0])
cur.close()
con.close()

Recetas de adaptadores y convertidores

Esta sección muestra recetas para adaptadores y convertidores comunes.

import datetime
import sqlite3

def adapt_date_iso(val):
    """Adapt datetime.date to ISO 8601 date."""
    return val.isoformat()

def adapt_datetime_iso(val):
    """Adapt datetime.datetime to timezone-naive ISO 8601 date."""
    return val.isoformat()

def adapt_datetime_epoch(val):
    """Adapt datetime.datetime to Unix timestamp."""
    return int(val.timestamp())

sqlite3.register_adapter(datetime.date, adapt_date_iso)
sqlite3.register_adapter(datetime.datetime, adapt_datetime_iso)
sqlite3.register_adapter(datetime.datetime, adapt_datetime_epoch)

def convert_date(val):
    """Convert ISO 8601 date to datetime.date object."""
    return datetime.date.fromisoformat(val.decode())

def convert_datetime(val):
    """Convert ISO 8601 datetime to datetime.datetime object."""
    return datetime.datetime.fromisoformat(val.decode())

def convert_timestamp(val):
    """Convert Unix epoch timestamp to datetime.datetime object."""
    return datetime.datetime.fromtimestamp(int(val))

sqlite3.register_converter("date", convert_date)
sqlite3.register_converter("datetime", convert_datetime)
sqlite3.register_converter("timestamp", convert_timestamp)

Cómo utilizar métodos de acceso directo a la conexión

Utilizando elejecutar(), ejecutarmuchos(), yejecutarscript()métodos de laConexiónClase, su código se puede escribir de forma más concisa porque no tiene que crear los (a menudo superfluos)Cursorobjetos explícitamente. En cambio, elCursorLos objetos se crean de forma implícita y estos métodos de acceso directo devuelven los objetos del cursor. De esta forma, puedes ejecutar unSELECTdeclaración e iterarla directamente usando solo una única llamada en elConexiónobjeto.

# Create and fill the table.
con = sqlite3.connect(":memory:")
con.execute("CREATE TABLE lang(name, first_appeared)")
data = [
    ("C++", 1985),
    ("Objective-C", 1984),
]
con.executemany("INSERT INTO lang(name, first_appeared) VALUES(?, ?)", data)

# Print the table contents
for row in con.execute("SELECT name, first_appeared FROM lang"):
    print(row)

print("I just deleted", con.execute("DELETE FROM lang").rowcount, "rows")

# close() is not a shortcut method and it's not called automatically;
# the connection object should be closed manually
con.close()

Cómo utilizar el administrador de contexto de conexión

AConexiónEl objeto se puede utilizar como un administrador de contexto que confirma o revierte automáticamente las transacciones abiertas al salir del cuerpo del administrador de contexto. Si el cuerpo del objetoconLa declaración finaliza sin excepciones, la transacción se confirma. Si esta confirmación falla, o si el cuerpo de lawithSi la declaración genera una excepción no detectada, la transacción se revierte. Siconfirmación automáticaesFalse, se abre implícitamente una nueva transacción después de confirmar o revertir.

Si no hay ninguna transacción abierta al salir del cuerpo de lawithdeclaración, o siconfirmación automáticaesTrue, el administrador de contexto no hace nada.

Nota

El administrador de contexto no abre implícitamente una nueva transacción ni cierra la conexión. Si necesita un administrador de contexto de cierre, considere usarcontextlib.closing().

con = sqlite3.connect(":memory:")
con.execute("CREATE TABLE lang(id INTEGER PRIMARY KEY, name VARCHAR UNIQUE)")

# Successful, con.commit() is called automatically afterwards
with con:
    con.execute("INSERT INTO lang(name) VALUES(?)", ("Python",))

# con.rollback() is called after the with block finishes with an exception,
# the exception is still raised and must be caught
try:
    with con:
        con.execute("INSERT INTO lang(name) VALUES(?)", ("Python",))
except sqlite3.IntegrityError:
    print("couldn't add Python twice")

# Connection object used as context manager only commits or rollbacks transactions,
# so the connection object should be closed manually
con.close()

Cómo trabajar con las URI de SQLite

Algunos trucos de URI útiles incluyen:

Abrir una base de datos en modo de solo lectura:

>>>

>>> con = sqlite3.connect("file:tutorial.db?mode=ro", uri=True)
>>> con.execute("CREATE TABLE readonly(data)")
Traceback (most recent call last):
OperationalError: attempt to write a readonly database

No cree implícitamente un nuevo archivo de base de datos si aún no existe; se generará un error.Error operacionalSi no se puede crear un nuevo archivo:

>>>

>>> con = sqlite3.connect("file:nosuchdb.db?mode=rw", uri=True)
Traceback (most recent call last):
OperationalError: unable to open database file

Crear una base de datos en memoria compartida y con nombre:

db = "file:mem1?mode=memory&cache=shared"
con1 = sqlite3.connect(db, uri=True)
con2 = sqlite3.connect(db, uri=True)
with con1:
    con1.execute("CREATE TABLE shared(data)")
    con1.execute("INSERT INTO shared VALUES(28)")
res = con2.execute("SELECT data FROM shared")
assert res.fetchone() == (28,)

con1.close()
con2.close()

Puede encontrar más información sobre esta función, incluida una lista de parámetros, enDocumentación de URI de SQLite.

Cómo crear y utilizar fábricas de filas

Por defecto,sqlite3representa cada fila como unatuplaSi untupleno se adapta a tus necesidades, puedes utilizar elsqlite3.Filaclase o una costumbrefábrica de filas.

Mientrasrow_factoryexiste como atributo tanto en elCursory elConexión, se recomienda configurarConexión.row_factory, por lo que todos los cursores creados a partir de la conexión utilizarán la misma fábrica de filas.

RowProporciona acceso con nombre indexado y sin distinción entre mayúsculas y minúsculas a las columnas, con una sobrecarga de memoria mínima y un impacto en el rendimiento a lo largo de un tiempo.tuple. UsarRowComo fábrica de filas, asígnelo a larow_factoryatributo:

>>>

>>> con = sqlite3.connect(":memory:")
>>> con.row_factory = sqlite3.Row

Las consultas ahora regresanRowobjetos:

>>>

>>> res = con.execute("SELECT 'Earth' AS name, 6378 AS radius")
>>> row = res.fetchone()
>>> row.keys()
['name', 'radius']
>>> row[0]         # Access by index.
'Earth'
>>> row["name"]    # Access by name.
'Earth'
>>> row["RADIUS"]  # Column names are case-insensitive.
6378
>>> con.close()

Nota

ElFROMLa cláusula puede omitirse en laSELECTdeclaración, como en el ejemplo anterior. En tales casos, SQLite devuelve una sola fila con columnas definidas por expresiones, por ejemplo, literales, con los alias indicadosexpr AS alias.

Puedes crear un personalizadofábrica de filasque devuelve cada fila como unadictadoadoadoadoadoadoadoadoadoado, con nombres de columnas asignados a valores:

def dict_factory(cursor, row):
    fields = [column[0] for column in cursor.description]
    return {key: value for key, value in zip(fields, row)}

Al usarlo, las consultas ahora devuelven undicten lugar de untuple:

>>>

>>> con = sqlite3.connect(":memory:")
>>> con.row_factory = dict_factory
>>> for row in con.execute("SELECT 1 AS a, 2 AS b"):
...     print(row)
{'a': 1, 'b': 2}
>>> con.close()

La siguiente fábrica de filas devuelve unatupla nombrada:

from collections import namedtuple

def namedtuple_factory(cursor, row):
    fields = [column[0] for column in cursor.description]
    cls = namedtuple("Row", fields)
    return cls._make(row)

namedtuple_factory()Se puede utilizar de la siguiente manera:

>>>

>>> con = sqlite3.connect(":memory:")
>>> con.row_factory = namedtuple_factory
>>> cur = con.execute("SELECT 1 AS a, 2 AS b")
>>> row = cur.fetchone()
>>> row
Row(a=1, b=2)
>>> row[0]  # Indexed access.
1
>>> row.b   # Attribute access.
2
>>> con.close()

Con algunos ajustes, la receta anterior se puede adaptar para usarla en unclase de datos, o cualquier otra clase personalizada, en lugar de unatupla nombrada.

Cómo manejar codificaciones de texto que no sean UTF-8

Por defecto,sqlite3usoscadenapara adaptar los valores de SQLite con elTEXTtipo de datos. Esto funciona bien para texto codificado en UTF-8, pero puede fallar para otras codificaciones y UTF-8 no válido. Puede utilizar unfábrica de textopara manejar tales casos.

Debido a SQLiteescritura flexibleNo es raro encontrar columnas de tabla con elTEXTtipo de datos que contiene codificaciones que no son UTF-8, o incluso datos arbitrarios. Para demostrarlo, supongamos que tenemos una base de datos con texto codificado en ISO-8859-2 (Latin-2), por ejemplo, una tabla de entradas de diccionario checo-inglés. Supongamos que ahora tenemos unaConexióninstanciaconConectado a esta base de datos, podemos decodificar el texto codificado en Latin-2 usando estefábrica de texto:

con.text_factory = lambda data: str(data, encoding="latin2")

Para datos UTF-8 no válidos o arbitrarios almacenados enTEXTcolumnas de la tabla, puede utilizar la siguiente técnica, tomada prestada de laCÓMO USAR UNICODE:

con.text_factory = lambda data: str(data, errors="surrogateescape")

Nota

Elsqlite3El módulo API no admite cadenas que contengan sustitutos.

Ver también

CÓMO USAR UNICODE

Explicación

Control de transacciones

sqlite3ofrece múltiples métodos para controlar si, cuándo y cómo se abren y cierran las transacciones de la base de datos.Control de transacciones a través del atributo autocommitSe recomienda, mientrasControl de transacciones a través del atributo insulation_levelconserva el comportamiento anterior a Python 3.12.

Control de transacciones a través de la`autocommit`atributo

La forma recomendada de controlar el comportamiento de las transacciones es a través de:Conexión.autocommitatributo, que preferiblemente debe configurarse utilizando elconfirmación automáticaparámetro deconectar().

Se sugiere configurarconfirmación automáticaaFalse, lo que implicaPEP249-control de transacciones conforme a la normativa. Esto significa:

sqlite3garantiza que una transacción esté siempre abierta, por lo queconectar(), Conexión.commit(), yConexión.rollback()abrirá implícitamente una nueva transacción (inmediatamente después de cerrar la pendiente, para las dos últimas).sqlite3usosBEGIN DEFERREDDeclaraciones al abrir transacciones.
Las transacciones deben confirmarse explícitamente utilizandocommit().
Las transacciones deben revertirse explícitamente utilizandorollback().
Se realiza una reversión implícita si la base de datos estácerca()-ed con cambios pendientes.

Colocarconfirmación automáticaaTruepara habilitar SQLitemodo de confirmación automática. En este modo,Conexión.commit()yConexión.rollback()no tienen ningún efecto. Tenga en cuenta que el modo de confirmación automática de SQLite es distinto delPEP249-obedienteConexión.autocommitatributo; usoConexión.en_transacciónpara consultar el modo de confirmación automática de SQLite de bajo nivel.

Colocarconfirmación automáticaaCONTROL DE TRANSACCIONES LEGALdejar el control de las transacciones a cargo deConexión.nivel_de_aislamientoatributo. VerControl de transacciones a través del atributo insulation_levelpara más información.

Control de transacciones a través de la`isolation_level`atributo

Nota

La forma recomendada de controlar las transacciones es a través de laconfirmación automáticaatributo. VerControl de transacciones a través del atributo autocommit.

SiConexión.autocommitse establece enCONTROL DE TRANSACCIONES LEGAL(por defecto), el comportamiento de la transacción se controla mediante elConexión.nivel_de_aislamientoatributo. De lo contrario,isolation_levelno tiene efecto.

Si el atributo de conexiónnivel de aislamientono esNone, las nuevas transacciones se abren implícitamente antesejecutar()yejecutarmuchos()ejecutaINSERT, UPDATE, DELETE, oREPLACEdeclaraciones; para otras declaraciones, no se realiza ningún manejo de transacciones implícitas. Utilice elcomprometerse()yRetroceder()métodos para confirmar y revertir respectivamente las transacciones pendientes. Puede elegir el subyacenteComportamiento de las transacciones de SQLite— es decir, si y de qué tipoBEGINdeclaracionessqlite3se ejecuta implícitamente – a través de lanivel de aislamientoatributo.

Sinivel de aislamientose establece enNone, no se abre ninguna transacción de forma implícita. Esto deja la biblioteca SQLite subyacente enmodo de confirmación automática, pero también permite al usuario realizar su propio manejo de transacciones mediante instrucciones SQL explícitas. El modo de confirmación automática de la biblioteca SQLite subyacente se puede consultar medianteen transacciónatributo.

Elejecutarscript()El método confirma implícitamente cualquier transacción pendiente antes de la ejecución del script SQL dado, independientemente del valor denivel de aislamiento.

Cambiado en la versión 3.6:sqlite3Se utilizaba para confirmar implícitamente una transacción abierta antes de las instrucciones DDL. Esto ya no es así.

Cambiado en la versión 3.12: La forma recomendada de controlar las transacciones ahora es a través deconfirmación automáticaatributo.

Compartir tecnología