sqlite3 — DB-API 2.0-gränssnitt för SQLite-databaser

Källkod: Lib/sqlite3/

SQLite är ett C-bibliotek som tillhandahåller en lättviktig diskbaserad databas som inte kräver en separat serverprocess och som gör det möjligt att komma åt databasen med en icke-standardvariant av frågespråket SQL. Vissa applikationer kan använda SQLite för intern datalagring. Det är också möjligt att prototypa en applikation med SQLite och sedan porta koden till en större databas som PostgreSQL eller Oracle.

Modulen sqlite3 är skriven av Gerhard Häring. Den tillhandahåller ett SQL-gränssnitt som överensstämmer med DB-API 2.0-specifikationen som beskrivs av PEP 249 och kräver SQLite 3.15.2 eller nyare.

Detta dokument innehåller fyra huvudavsnitt:

• Handledning lär ut hur man använder modulen sqlite3.

• Referens beskriver de klasser och funktioner som denna modul definierar.

• Hur man gör-guider beskriver hur man hanterar specifika uppgifter.

• Förklaring ger en djupgående bakgrund till transaktionskontroll.

Se även

https://www.sqlite.org

SQLite-webbsidan; dokumentationen beskriver syntaxen och de tillgängliga datatyperna för den SQL-dialekt som stöds.

https://www.w3schools.com/sql/

Handledning, referens och exempel för att lära sig SQL-syntax.

PEP 249 - API-specifikation för databaser 2.0

PEP skriven av Marc-André Lemburg.

Handledning

I den här handledningen skapar du en databas med Monty Python-filmer med hjälp av grundläggande sqlite3-funktionalitet. Den förutsätter en grundläggande förståelse för databaskoncept, inklusive cursors och transactions.

Först måste vi skapa en ny databas och öppna en databasanslutning så att sqlite3 kan arbeta med den. Anropa sqlite3.connect() för att skapa en anslutning till databasen tutorial.db i den aktuella arbetskatalogen, och skapa den implicit om den inte finns:

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

Det returnerade Connection-objektet con representerar anslutningen till databasen på disken.

För att kunna utföra SQL-satser och hämta resultat från SQL-frågor måste vi använda en databascursor. Anropa con.cursor() för att skapa Cursor:

cur = con.cursor()

Nu när vi har en databasanslutning och en markör kan vi skapa en databastabell movie med kolumner för titel, utgivningsår och recensionspoäng. För enkelhetens skull kan vi bara använda kolumnnamn i tabelldeklarationen - tack vare SQLites flexible typing-funktion är det valfritt att ange datatyperna. Kör CREATE TABLE-satsen genom att anropa cur.execute(...):

cur.execute("CREATE TABLE film(titel, år, poäng)")

Vi kan verifiera att den nya tabellen har skapats genom att fråga tabellen qlite_master som är inbyggd i SQLite, som nu bör innehålla en post för tabelldefinitionen movie (se The Schema Table för detaljer). Exekvera frågan genom att anropa cur.execute(...), tilldela resultatet till res och anropa res.fetchone() för att hämta den resulterande raden:

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

Vi kan se att tabellen har skapats, eftersom frågan returnerar en tuple som innehåller tabellens namn. Om vi frågar sqlite_master efter en icke-existerande tabell spam, kommer res.fetchone`() att returnera None:

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

Lägg nu till två rader med data som tillhandahålls som SQL-litteraler genom att köra en INSERT-sats, återigen genom att anropa cur.execute(...):

cur.execute("""")
    INSERT INTO film VALUES
        ('Monty Python och den heliga graalen', 1975, 8,2),
        ('Och nu till något helt annat', 1971, 7,5)
""")

Satsen INSERT öppnar implicit en transaktion, som måste bekräftas innan ändringarna sparas i databasen (se Kontroll av transaktioner för mer information). Anropa con.commit() på anslutningsobjektet för att bekräfta transaktionen:

con.commit()

Vi kan verifiera att data infogades korrekt genom att köra en SELECT-fråga. Använd den numera välkända cur.execute(...) för att tilldela resultatet till res, och anropa res.fetchall() för att returnera alla resulterande rader:

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

Resultatet är en list med två tuple, en per rad, som var och en innehåller den radens score-värde.

Nu ska du infoga ytterligare tre rader genom att anropa 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() # Kom ihåg att genomföra transaktionen efter att du har kört INSERT.

Observera att ?-platshållare används för att binda data till frågan. Använd alltid platshållare istället för string formatting för att binda Python-värden till SQL-satser, för att undvika SQL injection attacks (se Så här använder du platshållare för att binda värden i SQL-frågor för mer information).

Vi kan verifiera att de nya raderna infogades genom att köra en SELECT-fråga och den här gången iterera över resultaten av frågan:

>>> 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")

Varje rad är en tuple av (year, title) med två objekt som matchar de kolumner som valts i frågan.

Slutligen kontrollerar du att databasen har skrivits till disken genom att anropa con.close() för att stänga den befintliga anslutningen, öppna en ny, skapa en ny markör och sedan fråga databasen:

>>> 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()

Du har nu skapat en SQLite-databas med modulen sqlite3, lagt in data och hämtat värden från den på flera olika sätt.

Se även

• Hur man gör-guider för ytterligare läsning:

  • Så här använder du platshållare för att binda värden i SQL-frågor

  • Så här anpassar du anpassade Python-typer till SQLite-värden

  • Så här konverterar du SQLite-värden till anpassade Python-typer

  • Så här använder du kontexthanteraren för anslutningar

  • Så här skapar och använder du radfabriker

• Förklaring för djupgående bakgrund om transaktionskontroll.

Referens

Modulens funktioner

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)

Öppna en anslutning till en SQLite-databas.

Parametrar:

• database (path-like object) – Sökvägen till den databasfil som ska öppnas. Du kan skicka ":memory:" för att skapa en SQLite-databas som bara finns i minnet och öppna en anslutning till den.

• timeout (float) – Hur många sekunder anslutningen ska vänta innan den skickar ett OperationalError när en tabell är låst. Om en annan anslutning öppnar en transaktion för att ändra en tabell, kommer tabellen att vara låst tills transaktionen är genomförd. Standard fem sekunder.

• detect_types (int) – Kontrollera om och hur datatyper som inte natively supported by SQLite ska sökas upp för att konverteras till Python-typer, med hjälp av de konverterare som registrerats med register_converter(). Ställ in den på valfri kombination (med |, bitvis eller) av PARSE_DECLTYPES och PARSE_COLNAMES för att aktivera detta. Kolumnnamn har företräde framför deklarerade typer om båda flaggorna är inställda. Som standard (0) är typdetektering avaktiverad.

• isolation_level (str | None) – Styr beteendet för hantering av äldre transaktioner. Se Connection.isolation_level och Transaktionskontroll via attributet isolation_level (isoleringsnivå) för mer information. Kan vara "DEFERRED" (standard), "EXCLUSIVE" eller "IMMEDIATE"; eller None för att inaktivera implicit öppning av transaktioner. Har ingen effekt om inte Connection.autocommit är satt till LEGACY_TRANSACTION_CONTROL (standard).

• check_same_thread (bool) – Om True (standard), kommer ProgrammingError att uppstå om databasanslutningen används av en annan tråd än den som skapade den. Om False, kan anslutningen användas av flera trådar; skrivoperationer kan behöva serialiseras av användaren för att undvika datakorruption. Se threadsafety för mer information.

• factory (Connection) – En anpassad underklass av Connection för att skapa anslutningen med, om inte standardklassen Connection används.

• cached_statements (int) – Antalet satser som sqlite3 ska cacha internt för den här anslutningen för att undvika överbelastning vid parsning. Som standard 128 uttalanden.

• uri (bool) – Om värdet är True tolkas database som en URI med en filsökväg och en valfri frågesträng. Schemadelen måste vara "file:", och sökvägen kan vara relativ eller absolut. Frågesträngen gör det möjligt att skicka parametrar till SQLite, vilket möjliggör olika Så här arbetar du med SQLite URI:er.

• autocommit (bool) – Kontrollerar PEP 249 transaktionshanteringsbeteende. Se Connection.autocommit och Transaktionsstyrning via attributet autocommit för mer information. autocommit är för närvarande standardvärdet för LEGACY_TRANSACTION_CONTROL. Standardvärdet kommer att ändras till False i en framtida Python-version.

Typ av retur:

Connection

Utlöser en auditing event sqlite3.connect med argumentet database.

Utlöser en auditing event sqlite3.connect/handle med argumentet connection_handle.

Ändrad i version 3.4: Parametern uri har lagts till.

Ändrad i version 3.7: databas kan nu också vara en path-like object, inte bara en sträng.

Ändrad i version 3.10: Lagt till granskningshändelsen sqlite3.connect/handle.

Ändrad i version 3.12: Lagt till parametern autocommit.

Ändrad i version 3.13: Positionell användning av parametrarna timeout, detect_types, isolation_level, check_same_thread, factory, cached_statements och uri är föråldrad. De kommer att bli parametrar som endast innehåller nyckelord i Python 3.15.

sqlite3.complete_statement(statement)

Returnerar True om strängen statement verkar innehålla en eller flera kompletta SQL-satser. Ingen syntaktisk verifiering eller parsning av något slag utförs, annat än att kontrollera att det inte finns några oavslutade stränglitteraler och att satsen avslutas med ett semikolon.

Till exempel:

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

Denna funktion kan vara användbar vid kommandoradsinmatning för att avgöra om den inmatade texten verkar utgöra en komplett SQL-sats, eller om ytterligare inmatning behövs innan execute() anropas.

Se runsource() i Lib/sqlite3/__main__.py för verklig användning.

sqlite3.enable_callback_tracebacks(flag, /)

Aktivera eller inaktivera spårningar av callbacks. Som standard får du inga spårningar i användardefinierade funktioner, aggregat, omvandlare, auktoriseringsanrop etc. Om du vill felsöka dem kan du anropa den här funktionen med flag inställd på True. Efteråt kommer du att få spårningar från återkallelser på sys.stderr. Använd False för att inaktivera funktionen igen.

Anteckning

Fel i användardefinierade funktionsåterkallelser loggas som ovärderliga undantag. Använd en unraisable hook handler för introspektion av den misslyckade anropet.

sqlite3.register_adapter(type, adapter, /)

Registrera en adapter callable för att anpassa Python-typen type till en SQLite-typ. Adaptern anropas med ett Python-objekt av typen type som enda argument, och måste returnera ett värde av en typ som SQLite naturligt förstår.

sqlite3.register_converter(typename, converter, /)

Registrera konverteraren callable för att konvertera SQLite-objekt av typen typename till ett Python-objekt av en viss typ. Omvandlaren anropas för alla SQLite-värden av typen typename; den får ett bytes-objekt och ska returnera ett objekt av önskad Python-typ. Se parametern detect_types i connect() för information om hur typdetektering fungerar.

Obs: typename och namnet på typen i din fråga matchas case-insensitivt.

Modul konstanter

sqlite3.LEGACY_TRANSACTION_CONTROL

Sätt autocommit till denna konstant för att välja gammaldags (före Python 3.12) transaktionskontrollbeteende. Se Transaktionskontroll via attributet isolation_level (isoleringsnivå) för mer information.

sqlite3.PARSE_DECLTYPES

Skicka detta flaggvärde till parametern detect_types i connect() för att söka upp en konverteringsfunktion med hjälp av de deklarerade typerna för varje kolumn. Typerna deklareras när databastabellen skapas. sqlite3 söker upp en konverteringsfunktion med det första ordet i den deklarerade typen som nyckel i konverteringsordlistan. Till exempel

CREATE TABLE test(
   i heltal primärnyckel, ! kommer att leta upp en omvandlare med namnet "heltal"
   p punkt, ! kommer att leta upp en omvandlare med namnet "punkt"
   n nummer(10) ! kommer att leta upp en omvandlare som heter "nummer"
 )

Denna flagga kan kombineras med PARSE_COLNAMES med hjälp av operatorn | (bitvis eller).

Anteckning

Genererade fält (t.ex. MAX(p)) returneras som str. Använd PARSE_COLNAMES för att tvinga fram typer för sådana frågor.

sqlite3.PARSE_COLNAMES

Skicka detta flaggvärde till parametern detect_types i connect() för att söka efter en konverteringsfunktion genom att använda typnamnet, som tolkats från frågekolumnens namn, som nyckel i konverteringsordboken. Frågekolumnnamnet måste vara omslutet av dubbla citattecken (") och typnamnet måste vara omslutet av hakparenteser ([]).

SELECT MAX(p) som "p [punkt]" FROM test; ! kommer att leta upp omvandlare "punkt"

Denna flagga kan kombineras med PARSE_DECLTYPES med hjälp av operatorn | (bitvis eller).

sqlite3.SQLITE_OK

sqlite3.SQLITE_DENY

sqlite3.SQLITE_IGNORE

Flaggor som ska returneras av authorizer_callback callable som skickas till Connection.set_authorizer(), för att ange om:

• Åtkomst är tillåten (SQLITE_OK),

• SQL-satsen bör avbrytas med ett fel (SQLITE_DENY)

• Kolumnen ska behandlas som ett NULL-värde (SQLITE_IGNORE)

sqlite3.apilevel

Strängkonstant som anger den DB-API-nivå som stöds. Krävs av DB-API. Hårdkodad till "2.0".

sqlite3.paramstyle

Strängkonstant som anger vilken typ av parametermarkörsformatering som förväntas av modulen sqlite3. Krävs av DB-API. Hårdkodad till "qmark".

Anteckning

DB-API-parameterstilen named stöds också.

sqlite3.sqlite_version

Versionsnummer för SQLite-biblioteket för körning som en string.

sqlite3.sqlite_version_info

Versionsnummer för SQLite-biblioteket under körning som en tuple av integers.

sqlite3.threadsafety

Heltalskonstant som krävs av DB-API 2.0 och som anger vilken nivå av trådsäkerhet som sqlite3-modulen stöder. Detta attribut ställs in baserat på standard threading mode som det underliggande SQLite-biblioteket är kompilerat med. SQLites trådningslägen är:

1. En enda tråd: I detta läge är alla mutexar inaktiverade och SQLite är osäkert att använda i mer än en enda tråd samtidigt.

2. Multi-tråd: I det här läget kan SQLite användas säkert av flera trådar, förutsatt att ingen enskild databasanslutning används samtidigt i två eller flera trådar.

3. Serialiserad: I serialiserat läge kan SQLite användas av flera trådar utan några begränsningar.

Mappningarna från SQLites trådningslägen till DB-API 2.0:s trådningsnivåer är följande:

SQLite-läge för trådning	threadsafety	SQLITE_THREADSAFE	DB-API 2.0 betydelse
enkel tråd	0	0	Trådarna får inte dela modul
flertrådig	1	2	Trådar kan dela modul, men inte anslutningar
serialiserad	3	1	Trådar kan dela modul, anslutningar och markörer

Ändrad i version 3.11: Ställ in threadsafety dynamiskt istället för att hårdkoda det till 1.

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_ENABLE_LOAD_EXTENSION

sqlite3.SQLITE_DBCONFIG_ENABLE_QPSG

sqlite3.SQLITE_DBCONFIG_ENABLE_TRIGGER

sqlite3.SQLITE_DBCONFIG_ENABLE_VIEW

sqlite3.SQLITE_DBCONFIG_LEGACY_ALTER_TABLE

sqlite3.SQLITE_DBCONFIG_LEGACY_FILE_FORMAT

sqlite3.SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE

sqlite3.SQLITE_DBCONFIG_RESET_DATABASE

sqlite3.SQLITE_DBCONFIG_TRIGGER_EQP

sqlite3.SQLITE_DBCONFIG_TRUSTED_SCHEMA

sqlite3.SQLITE_DBCONFIG_WRITABLE_SCHEMA

Dessa konstanter används för metoderna Connection.setconfig() och getconfig().

Tillgängligheten för dessa konstanter varierar beroende på vilken version av SQLite Python kompilerades med.

Tillagd i version 3.12.

Se även

https://www.sqlite.org/c3ref/c_dbconfig_defensive.html

Dokument om SQLite: Alternativ för konfiguration av databasanslutning

Deprecated since version 3.12, removed in version 3.14: Konstanterna version och version_info.

Anslutningsobjekt

class sqlite3.Connection

Varje öppen SQLite-databas representeras av ett Connection-objekt, som skapas med sqlite3.connect(). Deras huvudsakliga syfte är att skapa Cursor-objekt och Kontroll av transaktioner.

Se även

• Så här använder du genvägsmetoder för anslutning

• Så här använder du kontexthanteraren för anslutningar

Ändrad i version 3.13: En ResourceWarning skickas ut om close() inte anropas innan ett Connection-objekt tas bort.

En SQLite-databasanslutning har följande attribut och metoder:

cursor(factory=Cursor)

Skapa och returnera ett Cursor-objekt. Metoden cursor accepterar en enda valfri parameter factory. Om den anges måste den vara en callable som returnerar en instans av Cursor eller dess subklasser.

blobopen(table, column, row, /, *, readonly=False, name='main')

Öppna ett Blob-handtag till en befintlig BLOB.

Parametrar:

• table (str) – Namnet på den tabell där blobben finns.

• column (str) – Namnet på den kolumn där blobben är placerad.

• row (str) – Namnet på den rad där blobben finns.

• readonly (bool) – Sätts till True om blobben ska öppnas utan skrivbehörighet. Standardvärdet är False.

• name (str) – Namnet på den databas där blobben finns. Standardvärdet är "main".

Höjer:

OperationalError – När man försöker öppna en blob i en tabell ”UTAN ROWID”.

Typ av retur:

Blob

Anteckning

Blobbstorleken kan inte ändras med hjälp av klassen Blob. Använd SQL-funktionen zeroblob för att skapa en blob med en fast storlek.

Tillagd i version 3.11.

commit()

Överför alla pågående transaktioner till databasen. Om autocommit är True, eller om det inte finns någon öppen transaktion, gör denna metod ingenting. Om autocommit är False, öppnas en ny transaktion implicit om en pågående transaktion bekräftades med denna metod.

rollback()

Rullar tillbaka till början av en väntande transaktion. Om autocommit är True, eller om det inte finns någon öppen transaktion, gör denna metod ingenting. Om autocommit är False, öppnas en ny transaktion implicit om en pågående transaktion rullades tillbaka med denna metod.

close()

Stänger databasanslutningen. Om autocommit är False, kommer alla väntande transaktioner att implicit rullas tillbaka. Om autocommit är True eller LEGACY_TRANSACTION_CONTROL, utförs ingen implicit transaktionskontroll. Var noga med att commit() innan du stänger för att undvika att förlora väntande ändringar.

execute(sql, parameters=(), /)

Skapa ett nytt Cursor-objekt och anropa execute() på det med de angivna sql och parametrarna. Returnera det nya cursor-objektet.

executemany(sql, parameters, /)

Skapa ett nytt Cursor-objekt och anropa executemany() på det med de angivna sql och parametrarna. Returnera det nya cursor-objektet.

executescript(sql_script, /)

Skapa ett nytt Cursor-objekt och anropa executescript() på det med det angivna sql_script. Returnera det nya cursor-objektet.

create_function(name, narg, func, *, deterministic=False)

Skapa eller ta bort en användardefinierad SQL-funktion.

Parametrar:

• name (str) – Namnet på SQL-funktionen.

• narg (int) – Antalet argument som SQL-funktionen kan acceptera. Om -1, kan den ta emot valfritt antal argument.

• func (callback | None) – En callable som anropas när SQL-funktionen anropas. Den anropbara funktionen måste returnera en typ som stöds av SQLite. Ställ in till None för att ta bort en befintlig SQL-funktion.

• deterministic (bool) – Om True, markeras den skapade SQL-funktionen som deterministisk, vilket gör att SQLite kan utföra ytterligare optimeringar.

Ändrad i version 3.8: Parametern deterministic har lagts till.

Exempel:

>>> 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()

Ändrad i version 3.13: Att skicka name, narg och func som nyckelordsargument är föråldrat. Dessa parametrar blir endast positionella i Python 3.15.

create_aggregate(name, n_arg, aggregate_class)

Skapa eller ta bort en användardefinierad SQL-aggregatfunktion.

Parametrar:

• name (str) – Namnet på SQL-aggregatfunktionen.

• n_arg (int) – Det antal argument som SQL-aggregatfunktionen kan acceptera. Om -1, kan den ta emot valfritt antal argument.

• aggregate_class (class | None) – En klass måste implementera följande metoder: * step(): Lägger till en rad i aggregatet. * finalize(): Returnerar aggregatets slutresultat som a type natively supported by SQLite. Antalet argument som metoden step() måste acceptera styrs av n_arg. Ställ in till None för att ta bort en befintlig SQL-aggregatfunktion.

Exempel:

klass MySum:
    def __init__(self):
        self.count = 0

    def step(self, värde):
        self.count += värde

    def finalize(self):
        return self.count

con = sqlite3.connect(":minne:")
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("VÄLJ mysum(i) FRÅN test")
print(cur.fetchone()[0])

con.close()

Ändrad i version 3.13: Att skicka name, n_arg och aggregate_class som nyckelordsargument är föråldrat. Dessa parametrar blir endast positionella i Python 3.15.

create_window_function(name, num_params, aggregate_class, /)

Skapa eller ta bort en användardefinierad aggregatfönsterfunktion.

Parametrar:

• name (str) – Namnet på den SQL-aggregatfönsterfunktion som ska skapas eller tas bort.

• num_params (int) – Antalet argument som funktionen SQL aggregate window kan acceptera. Om -1, kan den ta emot valfritt antal argument.

• aggregate_class (class | None) – En klass som måste implementera följande metoder: * step(): Lägg till en rad i det aktuella fönstret. * value(): Returnerar det aktuella värdet för aggregatet. * inverse(): Tar bort en rad från det aktuella fönstret. * finalize(): Returnerar slutresultatet av aggregatet som en typ som stöds av SQLite. Antalet argument som metoderna step() och value() måste acceptera styrs av num_params. Sätts till None för att ta bort en befintlig SQL aggregate window-funktion.

Höjer:

NotSupportedError – Om den används med en version av SQLite som är äldre än 3.25.0, som inte har stöd för aggregate window-funktioner.

Tillagd i version 3.11.

Exempel:

# Exempel hämtat från https://www.sqlite.org/windowfunctions.html#udfwinfunc
klass WindowSumInt:
    def __init__(self):
        self.count = 0

    def step(self, värde):
        """Lägg till en rad i det aktuella fönstret."""
        self.count += värde

    def value(self):
        """Returnera det aktuella värdet för aggregatet."""
        return self.count

    def inverse(self, värde):
        """Ta bort en rad från det aktuella fönstret."""
        self.count -= värde

    def finalize(self):
        """Returnera det slutliga värdet för aggregatet.

        Eventuella rensningsåtgärder bör placeras här.
        """
        returnera self.count


con = sqlite3.connect(":minne:")
cur = con.execute("CREATE TABLE test(x, y)")
värden = [
    ("a", 4),
    ("b", 5),
    ("c", 3),
    ("d", 8),
    ("e", 1),
]
cur.executemany("INSERT INTO test VALUES(?, ?)", värden)
con.create_window_function("sumint", 1, WindowSumInt)
cur.execute(""""
    SELECT x, sumint(y) OVER (
        ORDER BY x RADAR MELLAN 1 FÖREGÅENDE OCH 1 EFTERFÖLJANDE
    ) AS sum_y
    FROM test ORDER BY x
""")
print(cur.fetchall())
con.close()

create_collation(name, callable, /)

Skapa en kollationering med namnet namn med hjälp av kollationsfunktionen callable. callable får två sträng-argument, och den ska returnera en integer:

• 1 om den första är högre beställd än den andra

• -1 om den första är lägre ordnad än den andra

• 0 om de är ordnade lika

Följande exempel visar en omvänd sorteringskollation:

def collate_reverse(sträng1, sträng2):
    om sträng1 == sträng2:
        returnera 0
    elif sträng1 < sträng2:
        returnera 1
    annat:
        returnera -1

con = sqlite3.connect(":minne:")
con.create_collation("reverse", kollationering_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")
för rad i cur:
    print(rad)
con.close()

Ta bort en sorteringsfunktion genom att sätta callable till None.

Ändrad i version 3.11: Sorteringsnamnet kan innehålla vilket Unicode-tecken som helst. Tidigare var endast ASCII-tecken tillåtna.

interrupt()

Anropa den här metoden från en annan tråd för att avbryta eventuella frågor som körs på anslutningen. Avbrutna förfrågningar kommer att ge upphov till ett OperationalError.

set_authorizer(authorizer_callback)

Registrera callable authorizer_callback som ska anropas för varje försök att komma åt en kolumn i en tabell i databasen. Återkallelsen bör returnera en av SQLITE_OK, SQLITE_DENY, eller SQLITE_IGNORE för att signalera hur åtkomst till kolumnen ska hanteras av det underliggande SQLite-biblioteket.

Det första argumentet till callbacken anger vilken typ av operation som ska auktoriseras. Det andra och tredje argumentet kommer att vara argument eller None beroende på det första argumentet. Det fjärde argumentet är namnet på databasen (”main”, ”temp”, etc.) om tillämpligt. Det femte argumentet är namnet på den innersta trigger eller vy som är ansvarig för åtkomstförsöket eller None om åtkomstförsöket kommer direkt från SQL-kod.

Se SQLite-dokumentationen för information om möjliga värden för det första argumentet och betydelsen av det andra och tredje argumentet beroende på det första. Alla nödvändiga konstanter finns tillgängliga i modulen sqlite3.

Om du anger None som authorizer_callback inaktiveras authorizer.

Ändrad i version 3.11: Lagt till stöd för att inaktivera authorizer med hjälp av None.

Ändrad i version 3.13: Att skicka authorizer_callback som ett nyckelordsargument är föråldrat. Parametern blir endast positionell i Python 3.15.

set_progress_handler(progress_handler, n)

Registrera callable progress_handler som ska anropas för varje n instruktioner i den virtuella SQLite-maskinen. Detta är användbart om du vill bli anropad från SQLite under långvariga operationer, t.ex. för att uppdatera ett GUI.

Om du vill ta bort alla tidigare installerade progress-handläggare anropar du metoden med None för progress_handler.

Om ett värde som inte är noll returneras från hanterarfunktionen kommer den aktuella frågan att avslutas och ett DatabaseError-undantag att skapas.

Ändrad i version 3.13: Att skicka progress_handler som ett nyckelordsargument är föråldrat. Parametern blir endast positionell i Python 3.15.

set_trace_callback(trace_callback)

Registrera callable trace_callback som ska anropas för varje SQL-sats som faktiskt körs av SQLite-backend.

Det enda argument som skickas till callbacken är det uttalande (som str) som körs. Returvärdet för återuppringningen ignoreras. Observera att backend inte bara kör satser som skickas till Cursor.execute()-metoderna. Andra källor inkluderar transaction management i sqlite3-modulen och exekveringen av triggers som definieras i den aktuella databasen.

Om du anger None som trace_callback inaktiveras spårningsuppringningen.

Anteckning

Undantag som uppstår i trace callback sprids inte. Som ett hjälpmedel för utveckling och felsökning kan du använda enable_callback_tracebacks() för att aktivera utskrift av spårningar från undantag som tas upp i trace callback.

Tillagd i version 3.3.

Ändrad i version 3.13: Att skicka trace_callback som ett nyckelordsargument är föråldrat. Parametern blir endast positionell i Python 3.15.

enable_load_extension(enabled, /)

Aktivera SQLite-motorn att ladda SQLite-tillägg från delade bibliotek om enabled är True; annars, avaktivera laddning av SQLite-tillägg. SQLite-tillägg kan definiera nya funktioner, aggregat eller helt nya implementeringar av virtuella tabeller. Ett välkänt tillägg är fulltext-söktillägget som distribueras med SQLite.

Anteckning

Modulen sqlite3 är inte byggd med stöd för laddningsbara tillägg som standard, eftersom vissa plattformar (särskilt macOS) har SQLite-bibliotek som är kompilerade utan denna funktion. För att få stöd för laddningsbara tillägg måste du skicka alternativet --enable-loadable-sqlite-extensions till configure.

Utlöser en auditing event sqlite3.enable_load_extension med argumenten connection, enabled.

Tillagd i version 3.2.

Ändrad i version 3.10: Lagt till granskningshändelsen sqlite3.enable_load_extension.

con.enable_load_extension(True)

# Ladda tillägget för fulltextsökning
con.execute("select load_extension('./fts3.so')")

# alternativt kan du ladda tillägget med hjälp av ett API-anrop:
# con.load_extension("./fts3.so")

# inaktivera laddning av tillägg igen
con.enable_load_extension(False)

# exempel från SQLite wiki
con.execute("CREATE VIRTUAL TABLE recipe USING fts3(namn, ingredienser)")
con.executescript(""""
    INSERT INTO recipe (namn, ingredienser) VALUES('broccoligryta', 'broccoli paprika ost tomater');
    INSERT INTO recept (namn, ingredienser) VALUES('pumpagryta', 'pumpa lök vitlök selleri');
    INSERT INTO recept (namn, ingredienser) VALUES('broccolipaj', 'broccoli ost lök mjöl');
    INSERT INTO recept (namn, ingredienser) VALUES('pumpapaj', 'pumpa socker mjöl smör');
    """)
for row in con.execute("SELECT rowid, name, ingredients FROM recipe WHERE name MATCH 'pie'"):
    print(rad)

load_extension(path, /, *, entrypoint=None)

Laddar ett SQLite-tillägg från ett delat bibliotek. Aktivera laddning av tillägg med enable_load_extension() innan du anropar den här metoden.

Parametrar:

• path (str) – Sökvägen till SQLite-tillägget.

• entrypoint (str | None) – Namn på ingångspunkten. Om None (standard) kommer SQLite att hitta på ett eget namn på ingångspunkten; se SQLite-dokumenten Loading an Extension för mer information.

Utlöser en auditing event sqlite3.load_extension med argumenten connection, path.

Tillagd i version 3.2.

Ändrad i version 3.10: Lagt till granskningshändelsen sqlite3.load_extension.

Ändrad i version 3.12: Parametern entrypoint har lagts till.

iterdump(*, filter=None)

Returnerar en iterator för att dumpa databasen som SQL-källkod. Användbart när du sparar en databas i minnet för senare återställning. Liknar kommandot .dump i skalet sqlite3.

Parametrar:

filter (str | None) – Ett valfritt LIKE-mönster för databasobjekt som ska dumpas, t.ex. prefix_%. Om None (standard) kommer alla databasobjekt att inkluderas.

Exempel:

# Konvertera filen example.db till SQL-dumpfilen dump.sql
con = sqlite3.connect('exempel.db')
med open('dump.sql', 'w') som f:
    för rad i con.iterdump():
        f.write('%s\n' % line)
con.close()

Se även

Hur man hanterar textkodningar som inte är UTF-8

Ändrad i version 3.13: Parametern filter har lagts till.

backup(target, *, pages=-1, progress=None, name='main', sleep=0.250)

Skapa en säkerhetskopia av en SQLite-databas.

Fungerar även om databasen nås av andra klienter eller samtidigt med samma anslutning.

Parametrar:

• target (Connection) – Den databasanslutning som säkerhetskopian ska sparas i.

• pages (int) – Antalet sidor som ska kopieras åt gången. Om det är lika med eller mindre än 0 kopieras hela databasen i ett enda steg. Standardvärdet är -1.

• progress (callback | None) – Om den är inställd på en callable, anropas den med tre heltalsargument för varje backup-iteration: status för den senaste iterationen, det återstående antalet sidor som fortfarande ska kopieras och det totala antalet sidor. Standardvärdet är None.

• name (str) – Namnet på den databas som ska säkerhetskopieras. Antingen "main" (standard) för huvuddatabasen, "temp" för den tillfälliga databasen eller namnet på en anpassad databas som bifogats med SQL-satsen ATTACH DATABASE.

• sleep (float) – Antalet sekunder som ska gå mellan två på varandra följande försök att säkerhetskopiera återstående sidor.

Exempel 1, kopiera en befintlig databas till en annan:

def progress(status, återstående, totalt):
    print(f'Kopierade {total-remaining} av {total} sidor...')

src = sqlite3.connect('exempel.db')
dst = sqlite3.connect('backup.db')
med dst:
    src.backup(dst, sidor=1, framsteg=framsteg)
dst.close()
src.close()

Exempel 2, kopiera en befintlig databas till en tillfällig kopia:

src = sqlite3.connect('exempel.db')
dst = sqlite3.connect(':minne:')
src.backup(dst)
dst.close()
src.close()

Tillagd i version 3.7.

Se även

Hur man hanterar textkodningar som inte är UTF-8

getlimit(category, /)

Få en gräns för anslutningens körtid.

Parametrar:

category (int) – Den SQLite-gränskategori som ska frågas.

Typ av retur:

int

Höjer:

ProgrammingError – Om category inte känns igen av det underliggande SQLite-biblioteket.

Exempel, fråga om den maximala längden på en SQL-sats för Connection` con (standardvärdet är 1000000000):

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

Tillagd i version 3.11.

setlimit(category, limit, /)

Ställ in en gräns för anslutningens körtid. Försök att öka en gräns över dess hårda övre gräns avkortas tyst till den hårda övre gränsen. Oavsett om gränsen har ändrats eller inte, returneras det tidigare värdet för gränsen.

Parametrar:

• category (int) – Den SQLite-gränskategori som ska ställas in.

• limit (int) – Värdet på den nya gränsen. Om värdet är negativt är den aktuella gränsen oförändrad.

Typ av retur:

int

Höjer:

ProgrammingError – Om category inte känns igen av det underliggande SQLite-biblioteket.

Exempel: begränsa antalet anslutna databaser till 1 för Connection con (standardgränsen är 10):

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

Tillagd i version 3.11.

getconfig(op, /)

Fråga efter ett booleskt alternativ för konfiguration av anslutningen.

Parametrar:

op (int) – En SQLITE_DBCONFIG-kod.

Typ av retur:

bool

Tillagd i version 3.12.

setconfig(op, enable=True, /)

Ange ett booleskt alternativ för konfiguration av anslutningen.

Parametrar:

• op (int) – En SQLITE_DBCONFIG-kod.

• enable (bool) – True om konfigurationsalternativet ska vara aktiverat (standard); False om det ska vara inaktiverat.

Tillagd i version 3.12.

serialize(*, name='main')

Serialisera en databas till ett bytes-objekt. För en vanlig databasfil på disken är serialiseringen bara en kopia av diskfilen. För en databas i minnet eller en ”temp”-databas är serialiseringen samma sekvens av bytes som skulle skrivas till disken om databasen säkerhetskopierades till disk.

Parametrar:

name (str) – Namnet på den databas som ska serialiseras. Standardvärdet är "main".

Typ av retur:

bytes

Anteckning

Denna metod är endast tillgänglig om det underliggande SQLite-biblioteket har API:et serialize.

Tillagd i version 3.11.

deserialize(data, /, *, name='main')

Deserialiserar en serialized databas till en Connection. Den här metoden gör att databasanslutningen kopplar från databasen namn och öppnar namn igen som en databas i minnet baserat på serialiseringen i data.

Parametrar:

• data (bytes) – En serialiserad databas.

• name (str) – Databasnamnet som deserialiseringen ska göras till. Standardvärdet är "main".

Höjer:

• OperationalError – Om databasanslutningen för närvarande är involverad i en lästransaktion eller en säkerhetskopiering.

• DatabaseError – Om data inte innehåller en giltig SQLite-databas.

• OverflowError – Om len(data) är större än 2**63 - 1.

Anteckning

Denna metod är endast tillgänglig om det underliggande SQLite-biblioteket har API:et deserialize.

Tillagd i version 3.11.

autocommit

Detta attribut styr transaktionsbeteendet i enlighet med PEP 249. autocommit har tre tillåtna värden:

• False: Välj PEP 249-kompatibelt transaktionsbeteende, vilket innebär att sqlite3 säkerställer att en transaktion alltid är öppen. Använd commit() och rollback() för att stänga transaktioner.

  Detta är det rekommenderade värdet för autocommit.

• True: Använd SQLites autocommit-läge. commit() och rollback() har ingen effekt i detta läge.

• LEGACY_TRANSACTION_CONTROL: Pre-Python 3.12 (ej:pep:249-kompatibel) transaktionskontroll. Se isolation_level för mer information.

  Detta är för närvarande standardvärdet för autocommit.

Om du ändrar autocommit till False öppnas en ny transaktion, och om du ändrar den till True bekräftas alla pågående transaktioner.

Se Transaktionsstyrning via attributet autocommit för mer information.

Anteckning

Attributet isolation_level har ingen effekt om inte autocommit är LEGACY_TRANSACTION_CONTROL.

Tillagd i version 3.12.

in_transaction

Detta skrivskyddade attribut motsvarar SQLites autocommit mode på låg nivå.

True om en transaktion är aktiv (det finns ändringar som inte är bekräftade), False annars.

Tillagd i version 3.2.

isolation_level

Styr legacy transaction handling mode för sqlite3. Om inställningen är None öppnas aldrig transaktioner implicit. Om den är satt till en av "DEFERRED", "IMMEDIATE", eller "EXCLUSIVE", som motsvarar det underliggande SQLite transaction behaviour, utförs implicit transaktionshantering.

Om den inte åsidosätts av parametern isolation_level i connect(), är standardvärdet "", som är ett alias för "DEFERRED".

Anteckning

Att använda autocommit för att styra transaktionshantering rekommenderas framför att använda isolation_level. isolation_level har ingen effekt om inte autocommit är inställd på LEGACY_TRANSACTION_CONTROL (standard).

row_factory

Det ursprungliga row_factory för Cursor-objekt som skapas från den här anslutningen. Tilldelning av detta attribut påverkar inte row_factory för befintliga markörer som tillhör denna anslutning, endast nya. Är None som standard, vilket innebär att varje rad returneras som en tuple.

Se Så här skapar och använder du radfabriker för mer information.

text_factory

En callable som accepterar en bytes parameter och returnerar en textrepresentation av den. Den anropsbara funktionen anropas för SQLite-värden med datatypen TEXT. Som standard är detta attribut inställt på str.

Se Hur man hanterar textkodningar som inte är UTF-8 för mer information.

total_changes

Returnerar det totala antalet databasrader som har ändrats, infogats eller tagits bort sedan databasanslutningen öppnades.

Cursor-objekt

Ett Cursor-objekt representerar en database cursor som används för att exekvera SQL-satser och hantera kontexten för en hämtningsoperation. Cursors skapas med Connection.cursor(), eller genom att använda någon av connection shortcut methods.

Markörobjekt är iteratorer, vilket innebär att om du execute() en SELECT-fråga kan du helt enkelt iterera över markören för att hämta de resulterande raderna:

för rad i cur.execute("SELECT t FROM data"):
    print(rad)

class sqlite3.Cursor

En Cursor-instans har följande attribut och metoder.

execute(sql, parameters=(), /)

Exekvera en enda SQL-sats och bind eventuellt Python-värden med hjälp av placeholders.

Parametrar:

• sql (str) – En enda SQL-sats.

• parameters (dict | sequence) – Python-värden att binda till platshållare i sql. En dict om namngivna platshållare används. En sequence om icke namngivna platshållare används. Se Så här använder du platshållare för att binda värden i SQL-frågor.

Höjer:

ProgrammingError – När sql innehåller mer än en SQL-sats. När named placeholders används och parameters är en sekvens istället för en dict.

Om autocommit är LEGACY_TRANSACTION_CONTROL, isolation_level inte är None, sql är en INSERT, UPDATE, DELETE eller REPLACE-sats och det inte finns någon öppen transaktion, öppnas en transaktion implicit innan sql körs.

Ändrad i version 3.14: ProgrammingError sänds ut om named placeholders används och parameters är en sekvens istället för en dict.

Använd executescript() för att köra flera SQL-satser.

executemany(sql, parameters, /)

För varje objekt i parameters, kör upprepade gånger parameterized DML SQL-satsen sql.

Använder samma implicita transaktionshantering som execute().

Parametrar:

• sql (str) – En enda SQL DML-sats.

• parameters (iterable) – En iterable av parametrar att binda med platshållarna i sql. Se Så här använder du platshållare för att binda värden i SQL-frågor.

Höjer:

ProgrammingError – När sql innehåller mer än en SQL-sats eller inte är en DML-sats, När named placeholders används och objekten i parameters är sekvenser istället för dict.

Exempel:

rader = [
    ("rad1",),
    ("rad2",),
]
# cur är ett sqlite3.cursor-objekt
cur.executemany("INSERT INTO data VALUES(?)", rader)

Anteckning

Alla resulterande rader kasseras, inklusive DML-satser med RETURNING-klausuler.

Ändrad i version 3.14: ProgrammingError sänds ut om namngivna platshållare används och objekten i parameters är sekvenser istället för dicts.

executescript(sql_script, /)

Exekvera SQL-satserna i sql_script. Om autocommit är LEGACY_TRANSACTION_CONTROL och det finns en väntande transaktion, körs en implicit COMMIT-sats först. Ingen annan implicit transaktionskontroll utförs; eventuell transaktionskontroll måste läggas till i sql_script.

sql_script måste vara en sträng.

Exempel:

# cur är ett sqlite3.cursor-objekt
cur.executescript("""
    BEGIN;
    CREATE TABLE person(förnamn, efternamn, ålder);
    CREATE TABLE book(titel, författare, publicerad);
    CREATE TABLE publisher(namn, adress);
    COMMIT;
""")

fetchone()

Om row_factory är None, returneras nästa resultatuppsättning för radfrågor som en tuple. Annars skickas den till radfabriken och dess resultat returneras. Returnera None om inga fler data finns tillgängliga.

fetchmany(size=cursor.arraysize)

Returnerar nästa uppsättning rader i ett frågeresultat som en list. Returnerar en tom lista om inga fler rader är tillgängliga.

Antalet rader som ska hämtas per anrop specificeras av parametern size. Om size inte anges bestämmer arraysize antalet rader som ska hämtas. Om färre än size rader är tillgängliga returneras så många rader som är tillgängliga.

Observera att parametern size är förknippad med prestandafrågor. För optimal prestanda är det oftast bäst att använda arraysize-attributet. Om parametern size används är det bäst att den behåller samma värde från ett fetchmany()-anrop till nästa.

fetchall()

Returnerar alla (återstående) rader i ett sökresultat som en list. Returnerar en tom lista om inga rader är tillgängliga. Observera att attributet arraysize kan påverka prestandan för denna operation.

close()

Stäng markören nu (i stället för när __del__ anropas).

Markören kommer att vara oanvändbar från och med nu; ett ProgrammingError undantag kommer att uppstå om någon operation försöker utföras med markören.

setinputsizes(sizes, /)

Krävs av DB-API. Gör ingenting i sqlite3.

setoutputsize(size, column=None, /)

Krävs av DB-API. Gör ingenting i sqlite3.

arraysize

Läs-/skrivattribut som styr antalet rader som returneras av fetchmany(). Standardvärdet är 1, vilket innebär att en enda rad hämtas per anrop.

connection

Skrivskyddat attribut som anger SQLite-databasen Connection som hör till markören. Ett Cursor-objekt som skapas genom anrop av con.cursor() kommer att ha ett connection-attribut som hänvisar till con:

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

description

Skrivskyddat attribut som tillhandahåller kolumnnamnen för den senaste frågan. För att vara kompatibel med Python DB API returneras en 7-tupel för varje kolumn där de sex sista posterna i varje tupel är None.

Den är också inställd för SELECT-satser utan några matchande rader.

lastrowid

Skrivskyddat attribut som anger rad-id för den senast infogade raden. Det uppdateras endast efter lyckade INSERT eller REPLACE-satser som använder metoden execute(). För andra satser, efter executemany() eller executescript(), eller om infogningen misslyckades, lämnas värdet på lastrowid oförändrat. Det initiala värdet för lastrowid är None.

Anteckning

Insättningar i tabellerna WITHOUT ROWID registreras inte.

Ändrad i version 3.6: Lagt till stöd för REPLACE-satsen.

rowcount

Skrivskyddat attribut som anger antalet ändrade rader för INSERT, UPDATE, DELETE och REPLACE-satser; är -1 för andra satser, inklusive CTE-frågor. Den uppdateras endast av metoderna execute() och executemany() efter att satsen har körts färdigt. Detta innebär att alla resulterande rader måste hämtas för att rowcount ska kunna uppdateras.

row_factory

Styr hur en rad som hämtas från denna Cursor representeras. Om None representeras en rad som en tuple. Kan sättas till den inkluderade sqlite3.Row; eller en callable som accepterar två argument, ett Cursor-objekt och tuple av radvärden, och returnerar ett anpassat objekt som representerar en SQLite-rad.

Standardvärdet är det värde som Connection.row_factory angavs till när Cursor skapades. Tilldelning av detta attribut påverkar inte Connection.row_factory för den överordnade anslutningen.

Se Så här skapar och använder du radfabriker för mer information.

Radobjekt

class sqlite3.Row

En Row-instans fungerar som en mycket optimerad row_factory för Connection-objekt. Den stöder iteration, jämlikhetstestning, len() och mapping-åtkomst via kolumnnamn och index.

Två Row-objekt jämförs lika om de har identiska kolumnnamn och värden.

Se Så här skapar och använder du radfabriker för mer information.

keys()

Returnerar en lista med kolumnnamn som strängar. Omedelbart efter en fråga är det den första medlemmen i varje tupel i Cursor.description.

Ändrad i version 3.5: Lagt till stöd för skivning.

Blob-objekt

class sqlite3.Blob

Tillagd i version 3.11.

En instans av Blob är ett filliknande objekt som kan läsa och skriva data i en SQLite BLOB. Anropa len(blob) för att få storleken (antal byte) på blobben. Använd index och slices för direktåtkomst till blob-data.

Använd Blob som en context manager för att säkerställa att blob-handtaget stängs efter användning.

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

# Skriv till vår blob med hjälp av två skrivoperationer:
med con.blobopen("test", "blob_col", 1) som blob:
    blob.write(b"hej, ")
    blob.write(b"värld.")
    # Ändra den första och sista byten i vår blob
    blob[0] = ord("H")
    blob[-1] = ord("!")

# Läs innehållet i vår blob
med con.blobopen("test", "blob_col", 1) som blob:
    hälsning = blob.read()

print(hälsning) # utdata "b'Hello, world!'"
con.close()

close()

Stäng blobben.

Blobben kommer att vara oanvändbar från denna punkt och framåt. Ett Error (eller underklass) undantag kommer att utlösas om någon ytterligare operation försöker utföras med blobben.

read(length=-1, /)

Läser längd byte data från blobben vid aktuell offsetposition. Om slutet av blobben nås, kommer data upp till EOF att returneras. Om längd inte specificeras eller är negativ, kommer read() att läsa till slutet av blobben.

write(data, /)

Skriv data till blobben vid aktuell offset. Denna funktion kan inte ändra blobbens längd. Skrivning bortom slutet av blobben kommer att ge upphov till ValueError.

tell()

Returnerar den aktuella accesspositionen för blobben.

seek(offset, origin=os.SEEK_SET, /)

Ställ in blobbens aktuella accessposition till offset. Argumentet origin är som standard os.SEEK_SET (absolut positionering av blobben). Andra värden för origin är os.SEEK_CUR (sökning relativt den aktuella positionen) och os.SEEK_END (sökning relativt blobbens slut).

PrepareProtocol-objekt

class sqlite3.PrepareProtocol

PrepareProtocol-typens enda syfte är att fungera som ett PEP 246-stilanpassningsprotokoll för objekt som kan anpassa sig till nativa SQLite-typer.

Undantag

Undantagshierarkin definieras av DB-API 2.0 (PEP 249).

exception sqlite3.Warning

Detta undantag görs för närvarande inte av modulen sqlite3, men kan göras av program som använder sqlite3, t.ex. om en användardefinierad funktion trunkerar data vid inmatning. Warning är en underklass till Exception.

exception sqlite3.Error

Basklassen för de andra undantagen i den här modulen. Använd denna för att fånga upp alla fel med en enda except-sats. Error är en underklass till Exception.

Om undantaget uppstod inom SQLite-biblioteket läggs följande två attribut till undantaget:

sqlite_errorcode

Den numeriska felkoden från SQLite API

Tillagd i version 3.11.

sqlite_errorname

Det symboliska namnet på den numeriska felkoden från SQLite API

Tillagd i version 3.11.

exception sqlite3.InterfaceError

Undantag för missbruk av SQLite C API på låg nivå. Med andra ord, om detta undantag tas upp, indikerar det förmodligen en bugg i modulen sqlite3. InterfaceError är en underklass till Error.

exception sqlite3.DatabaseError

Undantag för fel som är relaterade till databasen. Detta fungerar som basundantag för flera typer av databasfel. Det kan bara skapas implicit genom de specialiserade underklasserna. DatabaseError är en underklass till Error.

exception sqlite3.DataError

Undantag för fel som orsakas av problem med bearbetade data, t.ex. numeriska värden utanför intervallet och för långa strängar. DataError är en underklass till DatabaseError.

exception sqlite3.OperationalError

Undantag för fel som är relaterade till databasens funktion och inte nödvändigtvis under programmerarens kontroll. Till exempel, databassökvägen hittades inte, eller en transaktion kunde inte behandlas. OperationalError är en underklass till DatabaseError.

exception sqlite3.IntegrityError

Undantag som uppstår när databasens relationsintegritet påverkas, t.ex. när en kontroll av en främmande nyckel misslyckas. Det är en underklass till DatabaseError.

exception sqlite3.InternalError

Undantag som uppstår när SQLite stöter på ett internt fel. Om det uppstår kan det tyda på att det finns ett problem med SQLite-biblioteket under körning. InternalError är en underklass till DatabaseError.

exception sqlite3.ProgrammingError

Undantag för programmeringsfel i sqlite3 API, t.ex. fel antal bindningar till en fråga eller försök att använda en stängd Connection. ProgrammingError är en underklass till DatabaseError.

exception sqlite3.NotSupportedError

Undantag som uppstår om en metod eller databas-API inte stöds av det underliggande SQLite-biblioteket. Till exempel kan deterministic sättas till True i create_function(), om det underliggande SQLite-biblioteket inte stöder deterministiska funktioner. NotSupportedError är en underklass till DatabaseError.

SQLite- och Python-typer

SQLite har inbyggt stöd för följande typer: NULL, INTEGER, REAL, TEXT, BLOB.

Följande Python-typer kan alltså skickas till SQLite utan problem:

Python-typ	SQLite-typ
Ingen	NULL
int	INTEGER
float	REAL
str	TEXT
bytes	BLOB

Detta är hur SQLite-typer konverteras till Python-typer som standard:

SQLite-typ	Python-typ
NULL	Ingen
INTEGER	int
REAL	float
TEXT	beror på text_factory, str som standard
BLOB	bytes

Typsystemet i modulen sqlite3 är utbyggbart på två sätt: du kan lagra ytterligare Python-typer i en SQLite-databas via object adapters, och du kan låta modulen sqlite3 konvertera SQLite-typer till Python-typer via converters.

Standardadaptrar och -omvandlare (föråldrad)

Anteckning

Standardadaptrarna och -omvandlarna är föråldrade från och med Python 3.12. Använd istället Adapter- och konverterrecept och skräddarsy dem efter dina behov.

De föråldrade standardadaptrarna och -konverterarna består av:

• En adapter för datetime.date-objekt till strings i ISO 8601-format.

• En adapter för datetime.datetime-objekt till strängar i ISO 8601-format.

• En omvandlare för declared ”date”-typer till datetime.date-objekt.

• En omvandlare för deklarerade ”timestamp”-typer till datetime.datetime-objekt. Bråkdelar kommer att trunkeras till 6 siffror (mikrosekundsprecision).

Anteckning

Standardomvandlaren ”timestamp” ignorerar UTC-offset i databasen och returnerar alltid ett naivt datetime.datetime-objekt. Om du vill bevara UTC-offset i tidsstämplar ska du antingen låta omvandlare vara inaktiverade eller registrera en offsetmedveten omvandlare med register_converter().

Föråldrad sedan version 3.12.

Kommandoradsgränssnitt

Modulen sqlite3 kan anropas som ett skript, med hjälp av tolkens switch -m, för att tillhandahålla ett enkelt SQLite-skal. Argumentsignaturen är som följer:

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

Skriv .quit eller CTRL-D för att avsluta skalet.

-h, --help

Skriv ut CLI-hjälp.

-v, --version

Skriv ut underliggande SQLite-biblioteksversion.

Tillagd i version 3.12.

Hur man gör-guider

Så här använder du platshållare för att binda värden i SQL-frågor

SQL-operationer behöver vanligtvis använda värden från Python-variabler. Var dock försiktig med att använda Pythons strängoperationer för att sätta ihop frågor, eftersom de är sårbara för SQL-injektionsattacker. Till exempel kan en angripare helt enkelt stänga det enkla citatet och injicera OR TRUE för att välja alla rader:

>>> # 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)

Använd istället DB-API:s parametersubstitution. Om du vill infoga en variabel i en frågesträng använder du en platshållare i strängen och ersätter de faktiska värdena i frågan genom att tillhandahålla dem som en tuple av värden till det andra argumentet i markörens execute()-metod.

En SQL-sats kan använda en av två typer av platshållare: frågetecken (qmark-stil) eller namngivna platshållare (named-stil). För qmark-stilen måste parameters vara en sequence vars längd måste motsvara antalet platshållare, annars uppstår ett ProgrammingError. För den namngivna stilen måste parameters vara en instans av en dict (eller en underklass), som måste innehålla nycklar för alla namngivna parametrar; eventuella extra objekt ignoreras. Här är ett exempel på båda stilarna:

con = sqlite3.connect(":minne:")
cur = con.execute("CREATE TABLE lang(namn, första_uppträdde)")

# Detta är den namngivna stil som används med executemany():
data = (
    {"namn": "C", "year": 1972},
    {"name": "Fortran", "år": 1957},
    {"name": "Python", "år": 1991},
    {"name": "Go", "år": 2009},
)
cur.executemany("INSERT INTO lang VALUES(:namn, :år)", data)

# Detta är den qmark-stil som används i en SELECT-fråga:
params = (1972,)
cur.execute("SELECT * FROM lang WHERE first_appeared = ?", params)
print(cur.fetchall())
con.close()

Anteckning

PEP 249 numeriska platshållare stöds inte. Om de används kommer de att tolkas som namngivna platshållare.

Så här anpassar du anpassade Python-typer till SQLite-värden

SQLite stöder endast en begränsad uppsättning datatyper. För att lagra anpassade Python-typer i SQLite-databaser, anpassa dem till en av Python-typer som SQLite förstår inbyggt.

Det finns två sätt att anpassa Python-objekt till SQLite-typer: att låta ditt objekt anpassa sig självt eller att använda en adapter callable. Det senare kommer att ha företräde framför det förra. För ett bibliotek som exporterar en anpassad typ kan det vara vettigt att låta den typen anpassa sig själv. Som applikationsutvecklare kan det vara mer meningsfullt att ta direkt kontroll genom att registrera anpassade adapterfunktioner.

Hur man skriver anpassningsbara objekt

Antag att vi har en Point-klass som representerar ett par koordinater, x och y, i ett kartesiskt koordinatsystem. Koordinatparet kommer att lagras som en textsträng i databasen, med ett semikolon för att separera koordinaterna. Detta kan implementeras genom att lägga till en metod __conform__(self, protocol) som returnerar det anpassade värdet. Objektet som skickas till protocol kommer att vara av typen PrepareProtocol.

klass Punkt:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __conform__(self, protokoll):
        om protokollet är sqlite3.PrepareProtocol:
            return f"{self.x};{self.y}"

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

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

Så här registrerar du adapterkallelser

Den andra möjligheten är att skapa en funktion som konverterar Python-objektet till en SQLite-kompatibel typ. Denna funktion kan sedan registreras med hjälp av register_adapter().

klass Punkt:
    def __init__(self, x, y):
        self.x, self.y = x, y

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

sqlite3.register_adapter(Punkt, adapt_point)

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

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

Så här konverterar du SQLite-värden till anpassade Python-typer

Genom att skriva en adapter kan du konvertera från anpassade Python-typer till SQLite-värden. För att kunna konvertera från SQLite-värden till anpassade Python-typer använder vi konverterare.

Låt oss gå tillbaka till Point-klassen. Vi lagrade x- och y-koordinaterna åtskilda med semikolon som strängar i SQLite.

Först definierar vi en konverteringsfunktion som tar emot en sträng som parameter och konstruerar ett Point-objekt från den.

Anteckning

Konverteringsfunktioner får alltid ett bytes-objekt, oavsett den underliggande SQLite-datatypen.

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

Vi måste nu tala om för sqlite3 när den ska konvertera ett givet SQLite-värde. Detta görs när du ansluter till en databas, med hjälp av parametern detect_types i connect(). Det finns tre alternativ:

• Implicit: sätt detect_types till PARSE_DECLTYPES

• Explicit: sätt detect_types till PARSE_COLNAMES

• Båda: sätt detect_types till sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES. Kolumnnamn har företräde framför deklarerade typer.

Följande exempel illustrerar de implicita och explicita tillvägagångssätten:

klass Punkt:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __repr__(self):
        return f"Punkt({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 Punkt(x, y)

# Registrera adapter och omvandlare
sqlite3.register_adapter(Punkt, adapt_point)
sqlite3.register_converter("point", convert_point)

# 1) Parsa med hjälp av deklarerade typer
p = Punkt(4,0, -3,2)
con = sqlite3.connect(":memory:", detect_types=sqlite3.PARSE_DECLTYPES)
cur = con.execute("CREATE TABLE test(p punkt)")

cur.execute("INSERT INTO test(p) VALUES(?)", (p,))
cur.execute("VÄLJ p FRÅN test")
print("med deklarerade typer:", cur.fetchone()[0])
cur.close()
con.close()

# 2) Parsa med hjälp av kolumnnamn
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 [punkt]" FROM test')
print("med kolumnnamn:", cur.fetchone()[0])
cur.close()
con.close()

Adapter- och konverterrecept

I detta avsnitt visas recept för vanliga adaptrar och konvertrar.

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.replace(tzinfo=None).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)

Så här använder du genvägsmetoder för anslutning

Med hjälp av metoderna execute(), executemany() och executescript() i klassen Connection kan din kod skrivas mer koncist eftersom du inte behöver skapa de (ofta överflödiga) Cursor-objekten explicit. Istället skapas Cursor-objekten implicit och dessa genvägsmetoder returnerar cursor-objekten. På så sätt kan du köra en SELECT-sats och iterera över den direkt med bara ett enda anrop på Connection-objektet.

# Skapa och fyll i tabellen.
con = sqlite3.connect(":minne:")
con.execute("CREATE TABLE lang(name, first_appeared)")
data = [
    ("C++", 1985),
    ("Objective-C", 1984),
]
con.executemany("INSERT INTO lang(name, first_appeared) VALUES(?, ?)", data)

# Skriv ut tabellinnehållet
for row in con.execute("SELECT name, first_appeared FROM lang"):
    print(rad)

print("Jag raderade just", con.execute("DELETE FROM lang").rowcount, "rows")

# close() är inte en genvägsmetod och den anropas inte automatiskt;
# anslutningsobjektet bör stängas manuellt
con.close()

Så här använder du kontexthanteraren för anslutningar

Ett Connection-objekt kan användas som en kontexthanterare som automatiskt commitar eller rullar tillbaka öppna transaktioner när kontexthanterarens kropp lämnas. Om with-satsens kropp avslutas utan undantag görs en commit av transaktionen. Om denna commit misslyckas, eller om with-satsen ger upphov till ett undantag som inte fångats upp, rullas transaktionen tillbaka. Om autocommit är False, öppnas en ny transaktion implicit efter commit eller rollback.

Om det inte finns någon öppen transaktion när man lämnar with-satsen, eller om autocommit är True, gör kontexthanteraren ingenting.

Anteckning

Kontexthanteraren varken öppnar implicit en ny transaktion eller stänger anslutningen. Om du behöver en stängande kontexthanterare, överväg att använda contextlib.closing().

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

# Lyckas, con.commit() anropas automatiskt efteråt
med con:
    con.execute("INSERT INTO lang(name) VALUES(?)", ("Python",))

# con.rollback() anropas efter att with-blocket avslutats med ett undantag,
# undantaget tas fortfarande upp och måste fångas upp
försök:
    med con:
        con.execute("INSERT INTO lang(namn) VALUES(?)", ("Python",))
except sqlite3.IntegrityError:
    print("kunde inte lägga till Python två gånger")

# Anslutningsobjektet som används som kontexthanterare överför eller återställer endast transaktioner,
# så anslutningsobjektet bör stängas manuellt
con.close()

Så här arbetar du med SQLite URI:er

Några användbara URI-trick inkluderar:

• Öppna en databas i skrivskyddat läge:

>>> 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
>>> con.close()

• Skapa inte implicit en ny databasfil om den inte redan finns; kommer att ge upphov till OperationalError om det inte går att skapa en ny fil:

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

• Skapa en delad namngiven databas i minnet:

db = "file:mem1?mode=memory&cache=shared"
con1 = sqlite3.connect(db, uri=True)
con2 = sqlite3.connect(db, uri=True)
med con1:
    con1.execute("CREATE TABLE shared(data)")
    con1.execute("INSERT INTO delad VALUES(28)")
res = con2.execute("VÄLJ data FRÅN delad")
assert res.fetchone() == (28,)

con1.stäng()
con2.close()

Mer information om den här funktionen, inklusive en lista med parametrar, finns i SQLite URI-dokumentation.

Så här skapar och använder du radfabriker

Som standard representerar sqlite3 varje rad som en tuple. Om en tuple inte passar dina behov kan du använda sqlite3.Row-klassen eller en anpassad row_factory.

Även om row_factory finns som attribut både för Cursor och Connection, rekommenderas att man anger Connection.row_factory, så att alla markörer som skapas från anslutningen använder samma radfabrik.

Row ger indexerad och skiftlägesokänslig namngiven åtkomst till kolumner, med minimal minnesbelastning och prestandapåverkan jämfört med en tuple. För att använda Row som en radfabrik, tilldela den till attributet row_factory:

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

Frågor returnerar nu Row-objekt:

>>> 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()

Anteckning

Klausulen FROM kan utelämnas i SELECT-satsen, som i exemplet ovan. I sådana fall returnerar SQLite en enda rad med kolumner som definieras av uttryck, t.ex. literaler, med de angivna alias expr AS alias.

Du kan skapa en egen row_factory som returnerar varje rad som en dict, med kolumnnamn mappade till värden:

def dict_factory(markör, rad):
    fields = [kolumn[0] för kolumn i cursor.description]
    return {nyckel: värde för nyckel, värde i zip(fält, rad)}

Med hjälp av den returnerar frågor nu en dict i stället för en tuple:

>>> 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()

Följande radfabrik returnerar en named tuple:

from collections import namedtuple

def namedtuple_factory(markör, rad):
    fields = [column[0] for column in cursor.description] (kolumn[0] för kolumn i cursor.description)
    cls = namedtuple("Rad", fält)
    return cls._make(rad)

namedtuple_factory() kan användas på följande sätt:

>>> 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()

Med några justeringar kan ovanstående recept anpassas så att man använder en dataclass, eller någon annan anpassad klass, i stället för en namedtuple.

Hur man hanterar textkodningar som inte är UTF-8

Som standard använder sqlite3 str för att anpassa SQLite-värden med datatypen TEXT. Detta fungerar bra för UTF-8-kodad text, men det kan misslyckas för andra kodningar och ogiltig UTF-8. Du kan använda en anpassad text_factory för att hantera sådana fall.

På grund av SQLites flexibla typning är det inte ovanligt att tabellkolumner med datatypen TEXT innehåller icke-UTF-8-kodningar eller till och med godtyckliga data. För att demonstrera, låt oss anta att vi har en databas med ISO-8859-2 (Latin-2) kodad text, till exempel en tabell med tjeckisk-engelska ordboksinlägg. Om vi antar att vi nu har en Connection-instans con ansluten till denna databas, kan vi avkoda den Latin-2-kodade texten med hjälp av denna text_factory:

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

För ogiltiga UTF-8 eller godtyckliga data som lagras i tabellkolumnerna TEXT kan du använda följande teknik, lånad från Unicode HOWTO:

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

Anteckning

Modulen sqlite3 har inte stöd för strängar som innehåller surrogat.

Se även

Unicode HOWTO

Förklaring

Kontroll av transaktioner

sqlite3 erbjuder flera metoder för att kontrollera om, när och hur databastransaktioner öppnas och stängs. Transaktionsstyrning via attributet autocommit rekommenderas, medan Transaktionskontroll via attributet isolation_level (isoleringsnivå) behåller beteendet från före Python 3.12.

Transaktionsstyrning via attributet autocommit

Det rekommenderade sättet att styra transaktionsbeteendet är genom attributet Connection.autocommit, som helst bör ställas in med hjälp av parametern autocommit i connect().

Det är rekommenderat att sätta autocommit till False, vilket innebär PEP 249-kompatibel transaktionskontroll. Detta innebär att:

• sqlite3 säkerställer att en transaktion alltid är öppen, så connect(), Connection.commit() och Connection.rollback() kommer implicit att öppna en ny transaktion (omedelbart efter att den väntande har stängts, för de två senare). sqlite3 använder BEGIN DEFERRED-satser när transaktioner öppnas.

• Transaktioner bör bekräftas uttryckligen med commit().

• Transaktioner bör rullas tillbaka uttryckligen med rollback().

• En implicit rollback utförs om databasen close()-ed med pågående ändringar.

Sätt autocommit till True för att aktivera SQLites autocommit-läge. I detta läge har Connection.commit() och Connection.rollback() ingen effekt. Observera att SQLites autocommit-läge skiljer sig från det PEP 249-kompatibla attributet Connection.autocommit; använd Connection.in_transaction för att fråga om SQLites autocommit-läge på låg nivå.

Sätt autocommit till LEGACY_TRANSACTION_CONTROL för att överlåta transaktionskontrollbeteendet till attributet Connection.isolation_level. Se Transaktionskontroll via attributet isolation_level (isoleringsnivå) för mer information.

Transaktionskontroll via attributet isolation_level (isoleringsnivå)

Anteckning

Det rekommenderade sättet att kontrollera transaktioner är via attributet autocommit. Se Transaktionsstyrning via attributet autocommit.

Om Connection.autocommit är satt till LEGACY_TRANSACTION_CONTROL (standard), styrs transaktionsbeteendet med attributet Connection.isolation_level. I annat fall har isolation_level ingen effekt.

Om anslutningsattributet isolation_level inte är None öppnas nya transaktioner implicit innan execute() och executemany() utför INSERT, UPDATE, DELETE eller REPLACE-satser; för andra satser utförs ingen implicit transaktionshantering. Använd metoderna commit() och rollback() för att binda respektive rulla tillbaka pågående transaktioner. Du kan välja det underliggande SQLite-transaktionsbeteendet - det vill säga om och vilken typ av BEGIN-satser som sqlite3 implicit utför - via attributet isolation_level.

Om isolation_level är satt till None, öppnas inga transaktioner alls implicit. Detta lämnar det underliggande SQLite-biblioteket i autocommit mode, men gör det också möjligt för användaren att utföra sin egen transaktionshantering med hjälp av explicita SQL-satser. Det underliggande SQLite-bibliotekets autocommit-läge kan efterfrågas med hjälp av attributet in_transaction.

Metoden executescript() binder implicit alla väntande transaktioner innan det angivna SQL-skriptet körs, oavsett värdet på isolation_level.

Ändrad i version 3.6: sqlite3 brukade implicit binda en öppen transaktion före DDL-satser. Detta är inte längre fallet.

Ändrad i version 3.12: Det rekommenderade sättet att kontrollera transaktioner är nu via attributet autocommit.