sqlite3 — DB-API 2.0 interface pro SQLite databases

2024-07-12

sqlite3 — DB-API 2.0 interface pro SQLite databases — Python 3.12.4 documenta

`sqlite3`- DB-API 2.0 interface pro SQLite databases
sqlite3 — DB-API 2.0 interface pro SQLite databases

Source codice: Lib/sqlite3/ Source code location：Lib/sqlite3/

SQLite bibliotheca C est quae praebet leve pondus database disci-basi quod separatum server processum non requirit ac dat accessum datorum utens nonstandardum variantium linguae SQL interrogationis. Aliquae applicationes SQLite pro interna notitia repositione uti possunt. Prototypum etiam fieri potest applicationis SQLite utens ac deinde codicem ad maiorem datorum portum ut PostgreSQL vel Oraculum.
SQLite bibliotheca lingua C est quae praebet leve pondus database disci-basi quod separatum server processum non requirit et datorum accessum admittit utens non-signum variantium linguae SQL interrogationis. Aliquae applicationes SQLite pro interna notitia repositione uti possunt. Praeterea SQLite uti potes ad prototypum applicationis ac deinde codicem ad magnam datorum migrationem ut PostgreSQL vel Oraculum.

Thesqlite3 moduli conscriptus est a Gerhard Häring. Praebet SQL interfaciei obsequium cum specificatione DB-API 2.0 descriptumPEP 249SQLite 3.7.15 vel recentior requirit.
sqlite3 moduli Scripsit Gerhard Häring. Interfacem SQL praebet conformis DB-API 2.0 specificationis per PEP 249 descriptae, et SQLite versio 3.7.15 vel altiorem requirit.

Hoc documentum quattuor praecipuas sectiones includit: Hoc documentum maxime includit quattuor sectiones principales quae sequuntur

Tutorialdocet quomodo utendisqlite3modulus.TutorialPars docet sqlite3 moduli uti.
Referencecuius moduli classes et functiones describit.
refer adsectio classes et functiones hoc modulo definitas describit.
Quam-ut ducibussingula tractare negotia propria.
Operatio duxSectiones singulas quomodo operas specificas pertractare.
Explicatiopraebet altissimam in transaction potestate.
explicare "Haec sectio altissimam introductionem praebet ad cognitionem rei transactionis.

Vide quoque

https://www.sqlite.org

Paginam SQLite; Documenta syntaxin describit et notitiae promptae rationes ad dialectum SQL sustinendam.
SQLite pagina interretialis; eius documentum syntaxin dialectorum SQL sustentatorum et figurarum notitiarum in promptu describitur.

SQL TutorialSQL Tutorial

Tutorialis, relatio et exempla discendi SQL syntaxin.
Tutorialia, references et exempla discendi SQL syntaxin.

PEP 249- Database API Specification 2.0 PEP 249 - Database API Specification 2.0

PEP scripsit Marc-André Lemburg.

TutorialTutorial

In hoc doceo, database of a creabis Mons Python movies usura basicsqlite3 functionality. Ponit intellectum fundamentalem notionum datorum, comprehendocursorsettransactions.
In hoc tutorial, basic sqlite3 functionis uteris ad creandum database de Monty Pythone movies. Hoc doceo induit te notionum datorum fundamentalium cognitionem habere, inter cursores et transactiones.

Primum opus est novum database creare et nexum datorum aperire ut permitteretsqlite3 laborare cum eo. Vocatiosqlite3.connect()nexum ad creare databasetutorial.dbin hodiernae operationis directorio, implicite creando si non est:
Primum, opus est novum database creare et nexum datorum aperire ut cum eo sqlite3 correspondere possit. Voca sqlite3.connect() creare nexum cum tutorial.db datorum in directorio currenti, implicite et leniter automatice creando, si non est:


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

Reversus estConnectionobjectconsignificat nexum ad on-orbis database.
Obiectum Connection (con in hoc casu nominatum) repraesentat nexum cum datorum in orbe.

Ut facere SQL constitutionibus etarcessere ex SQL queries, cursori database uti debebimus. Vocatiocon.cursor()creareCursor:
Ut propositiones SQL exequias et ex quaestionibus SQL proventum accipias, cursoribus database uti necesse est. Voca con.cursor() ad cursorem creandum:

cur = con.cursor()

Nunc nexum database et cursorem Comperto, mensam database creare possumusmovie cum columnis ad titulum, annum remissio, et recensionem viginti. Simplicitate uti possumus nominibus columnae in tabella declarationis - gratiarum actiotyping flexibile notam SQLite, speciei notitiae typorum libitum est. JudiciumCREATE TABLEdicitur per vocantemcur.execute(...):
Nunc ut nexum et cursorem datorum habemus, tabulam database nominatam pelliculam cum columnis creare possumus ut titulus, annus remissionis et score retractationis. Ad res simpliciores, nominibus columnae directe uti possumus in declaratione tabellae - speciei notitiarum specificans libitum est ob plumam flexibilem SQLite. TABULA DICTIO EXECUTE CREATIO vocando cur.execute(...)

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

Possumus cognoscere novam mensam per interrogationem factam essesqlite_mastermensa aedificata ad SQLite, quae nunc debet habere notammoviemensa definitionem (videSchema Tabula ad singularia). Fac ut quaestionem vocandocur.execute(...), eventum assignarereset vocares.fetchone ()inde versu arcessere;
Cognoscere possumus novam mensam creatam interrogationi SQLite aedificatam in mensa sqlite_magistri, quae nunc viscus contineat pro definitione tabulae cinematographicae (vide schema de singulis tabulis). Interroga interrogationem vocando cur.execute(...), eventum rei tribue, et res.fetchone voca, ut eventus consequantur ordines:

>>>


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

Videre possumus mensam creatam, sicut quaestio redit atuple nomen continens tabulae. Si querysqlite_masterin nulla mensaspam, res.fetchone()reddetNone:
Videre possumus tabulam feliciter creatam esse quod quaesitum reddidit tuplum in quo mensae nomen erat. Si quaesivimus sqlite_master de mensa non exsistente (ut spamma), res.fetchone() Nulla redibit.

>>>


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

Nunc duos ordines notitiarum SQL litterarum supplendas adiunge exsequendo anINSERTdicitur, iterum vocandocur.execute(...):
Nunc duos ordines notitiarum addas, dum ut SQL literae, enunciationem insertam exequendo (cur.execute(...) iterum vocando);


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

TheINSERTenuntiatio implicite aperit transactionem, quae debet committi antequam mutationes in database salventur (cfTransactio imperiumad singularia). Vocatiocon.commit ()in nexu rem committere rem:
Inserta enuntiatio implicite et statim incipit transactionem quae committenda est antequam mutationes fiunt ad database (vide Transaction Control for details). Voca con.commit() in nexu obiecto rem committe:

con.commit()

Cognoscere possumus notitia inserta recte exequendoSELECT quaesitum est. Utere nunc notacur.execute(...)effectus est assignarereset vocares.fetchall ()inde redire omnes ordines;
Data esse comprobare possumus recte inserta exsequendo interrogationem SELECTAM. Eventus tribue rei utendo nunc familiari cur.execute(...) et vocate res.fetchall() ut omnes eventus remittas ordines:

>>>


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

Effectus est aalbumduorumtuples, unum per ordinem, unumquodque continens illius ordinis;scorepretii.
Ita fit index duorum tupliorum, unus pro quolibet ordine, et quodlibet tuplum continens valorem ustulo illius ordinis.

Nunc tres plures ordines pone vocandocur.executemany(...):
Nunc tres plures ordines notitiarum adiiciam vocando 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.

Animadverto quod?placeholders sunt alligaredata ad nonnulla. Semper uti placeholders prolinea formattingligare Pythonem valores SQL dicta, vitareSQL iniectio impetus(videoQuomodo uti placeholders ad ligandum valores in SQL queries?ad plura).
Nota quod ? locatoris notitia ligare in interrogatione adhibetur. Semper placeholders loco chordae formatting ad ligandum valores Python in SQL declarationes ad vitandas SQL injectiones impetus (vide "Quam ligare valores utentes placeholders in SQL queries" pro more details).

Cognoscere possumus novos ordines insertos exsequendoSELECTquaesitum est, hoc tempus per interrogationis eventum iteratio:
Comprobare possumus novum ordinem insertum esse interrogationi SELECTAE exsecutioni, hoc tempore per eventum interrogationis iterandum:

>>>


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

Quisque ordo est duos itemtupleof*(year, title)exaequatis columnis selectae nonnullae.
Tuplum in unoquoque versu est duo elementa continens (annus, titulus), quod columnae in interrogatione delectum aequet.

Denique cognoscere database scriptum esse ad disci vocandocon.close ()claudere nexum exsistens, novum aperiens, novum cursorem creans, dein interrogationem datorum:
Denique vocandocon.close() ut nexum datorum exsistentem claudere ac efficere ut database scriptum in disco. Deinde, novam connexionem aperi, cursorem novum crea, et quaesitum datorum ad comprobandum data bene scripta esse.

>>>


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

Nunc creavisti SQLite database utens thesqlite3modulus, notitia inserta et valores ab eo restituit multipliciter.
quae nunc usus estsqlite3 Modulus datorum SQLite datorum et notitias ex eo inserit et dat variis modis [Retrieve? Valor.

Vide quoqueVide quoque

Quam-ut ducibusad ulteriorem lectionem; Quomodo ligandi valores utendi placeholders in SQL queries:
- Quomodo uti placeholders ad ligandum valores in SQL queries?
  Quomodo ligandi valores utendi placeholders in SQL queries:
- Quomodo accommodare morem Pythonis rationes ad valores SQLite
  Quomodo morem Python genus ad valorem SQLite accommodet;
- Quomodo convertendi SQLite valores ad usum Pythonis typi?
  Quomodo valorem SQLite convertere ad genus Pythonis consuetudinis:
- Quomodo utatur nexus contextui procurator
  Quomodo procurator contextus utendi nexus:
- Quomodo creare et uti row officinas
  Quomodo officinas creare et uti versu;
Explicatioin background in transaction in profundum imperium.
In altissimam background explicatio transactionis imperium;

ReferenceParameter Description：

OMNIBUS functionibus

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)

Aperi nexum database SQLite. Hoc munus nexum SQLite datorum aperire adhibetur.

Parametri:

database (semita sicut objectum ) - Via fasciculi datorum aperienda. Potes transire":memory:"creare anSQLite database existens in memoriaet aperi nexum ei.database (path-like object)
database (sicut objectum) — Haec via est ad lima database aperiendam.Potes transire":memory:"creare in memoriam database SQLite et aperire .database (sicut objectum) ei annexum.
timeout (supernatet) - Quot seconds nexum expectandum est antequam sublato anOperationalError cum mensa clausa est. Si alius iunctio aperit transactionem ad mensam modificandam, illa mensa claudetur donec negotium committatur. Default quinquesecundis.timeout (float) - Connexio iacit cum mensa clausa estOperationalError quot secundae exspectandae sunt. Si alius iunctio aperit transactionem ad mensam modificandam, mensa claudetur donec gestum committatur. Valor default quinque secundis est.
detect_types " " " " " " " " " (int) - Imperium an et quomodo genera notitia notpaternus auxilium SQLitespectantur ad figuras Python convertendas, conversis utens descriptis cumregister_converter () . Constitue eam cuilibet compositioni (utendo|, bitwise vel) of *PARSE_DECLTYPESetPARSE_COLNAMESut id. nomina columnae anteceditdeclaravit types si utraque vexilla sunt. Genera deprehendi non possunt pro generatae agris (exempli gratiamax(data)) etiam cumdetect_types " " " " " " " " "modulus positus;str****************************************** pro reddetur. Per defaltam (0) Deprehensio typus est erret.
detect_types (int)- Imperium an et quomodo data genera quae SQLite non sustinet, nativo usui invenianturregister_converter() Descripti conversi ad Pythonem genera convertendi sunt.pone eamPARSE_DECLTYPESetPARSE_COLNAMESaliqua iunctura (per bitwise vel *| ) Ad enable haec factura.Si utraque vexilla sunt, tuncList praeessetdicitur typus.Nam regiones generatae, hae species deprehendi non possunt (v.g.max(data)) Etiamsi setdetect_typesparametri;str typus. Per defaltam (0), genus detectionis debilitatum est.

Inserere hic
In hac Anglica paragrapho, quis est the subject of " suspiciuntur " ?
In hoc paragrapho Anglicano, subiectum "suspectae" est illae "notitiarum generum SQLite non nativo suffultae (notitia typi SQLite non native suffulti)".Quid est hoc, quod utendoregister_converter() Descripti conversis ad inveniendum et convertendum data genera non indigena SQLite ad typi Pythonis. Subiecta igitur sunt illae specierum notitiae specificae quae inveniendae et convertendae sunt.

solitudo_level " (str****************************************** | Nullus ) - Imperium legatum rei gerendae agendi ratio. VideConnection.isolation_leveletTransactio control per attributum solitation_level pro magis notitia. potest esse"DEFERRED"(default);"EXCLUSIVE"or *"IMMEDIATE" ; or *None ut disable foramen transactions implicite. Nullam efficitur nisiConnection.autocommitest profectus estLEGACY_TRANSACTION_CONTROL(per default).
isolation_level(String | None) - Imperium legatum transaction processus agendi.Pro maiori, videConnection.isolation_levelet "passisolation_levelProprietas Imperium transactionis ". Potest esse"DEFERRED"(valorem default)"EXCLUSIVE"or *"IMMEDIATE"; Aut profectus estNone ut disable implicite aperire transactions implicite.nisiConnection.autocommitSet quodLEGACY_TRANSACTION_CONTROLSecus haec occasus effectum non habet.
check_same_thread (bool) - SiTrue(default);ProgrammingError si nexus datorum, alio filo utatur quam illud quod creavit, elevabitur. SiFalse nexus in multiplici filorum accessione; operationes scribendas opus esse potest serialized ab utentis ad corruptionem notitiarum vitandam. Videthreadsafetypro magis notitia.
check_same_thread(valorem Boolean) - Si profectus estTrue(per annum), cum nexus datorum adhibetur filo alio quam filo quod creavit, elevabitur.ProgrammingError abnormis.Si profectus estFalse , multiplex stamina ad nexum accedere permittuntur; sed utentes necesse est ut serialize (continue) operationes scribant ad vitandam corruptionem notitiarum.Pro magis notitia videothreadsafetyinstructio.
officinas (Connection) - Ordo genus ofConnectionnexum cum creare, nisi defaltamConnectionclassis.
factory(Connexio) - Si non per defaultConnectiongenus, specificare consuetudinemConnection Genus nexum creare. Hic modulus sinit vos ut mores connexionis datorum customizetis secundum necessitates specificas vel extensiones.
cached_statements (int) - Numerus constitutionumsqlite3 Interne hanc connexionem recondere debet, ne parsing capitis. Per defaltam, 128 constitutiones.
cached_statements(int) – sqlite3 Numerus constitutionum quae interne ad hanc connexionem condiendi sunt ad vitandum caput parsing. Defalta 128 constitutiones condiuntur. Hic modulus sino te accommodare amplitudinem cache ad optimize perficiendi vel memoriae usum.
uri (bool) - Si profectus estTrue, database interpretatur URI cum lima semita et chorda interrogationis libitum. Consilium parsmustibe"file:" ac relativum vel absolutum. Investigatio chorda permittit parametri SQLite transitum, ut varios efficiatQuomodo operari cum SQLite URIs.
uri(bool) - Si profectus estTrue, seddatabase Interpretatur ut Uniform Resource Identifier (URI) cum lima iter et filum interrogationis libitum. Consilium pars URImusti est "lima:", via potest esse relativa vel absoluta. chordae quaeruntur parametri ad SQLite transiri permittunt, varias operandi vias cum SQLite URIs efficere. Hoc permittit ut optiones nexus datorum multiplicior datorum ut occasus solum legere modum, magnitudinem cache specificans, etc.
autocommit (bool) - ImperiumPEP 249 transaction tractantem mores. VideConnection.autocommitetTransaction imperium per autocommit attributumpro magis notitia.autocommitcurrently defaltis toLEGACY_TRANSACTION_CONTROL . Default erit mutareFalsein futurum Python dimittunt.
autocommit(bool) - Imperium transaction processus morum obsequio cum PEP 249.Pro maiori, videConnection.autocommit et "Imperium facere per attributum autocommit". nunc;autocommitIn default valorem profectus estLEGACY_TRANSACTION_CONTROL , quod significat transactionem legatum sequi mores Pythonis Database API specificatio (PEP 249).Sed in futura versione Pythonis, defectus in to mutabitFalse, quod significat transactiones non sponte committi per defaltam et utentem requirere ut initium et finem transactionis expresse moderetur.

Si vis, nota,*Parametri in functionibus definitionibus separatores inter rationes positionales et keywords adhibentur, significatioautocommitOmnes parametri postea keyword parametri erunt.

Redi genus:Redi genus：

Connection

erigit anauditing eventuuuuuuuu sqlite3.connectcum argument!database.
sqlite3.connect: Cum usuradatabaseParametri projecti cum datorum connexione.

erigit anauditing eventuuuuuuuu sqlite3.connect/handlecum argument!connection_handle.
sqlite3.connect/handle: nexum cum manubrio (connection_handle) quando creatur iacitur.

Mutata in versione 3.4: adieciturimodulo.
In versione 3.4: adiecituriParameter qui dat speciem fasciculi datorum utens URI forma.

Mutata in versione 3.7;databasenunc quoque esse potestsemita sicut objectumnon modo filo.
In versione 3.7;databaseParametri nunc possunt esse semita-similis obiecti pro chordis iustis.

Mutata in versione 3.10: adiecitsqlite3.connect/handlediendi eventu.
In versione 3.10: adiecitsqlite3.connect/handleEventus audit, qui utitur cum manubrio nexus creatur.

Mutata in versione 3.12: adiecitautocommitmodulo.
In versione 3.12: adiecitautocommitParametri qui subtiliorem potestatem in auto- committendi agendi ratione permittunt.

sqlite3.complete_statement(dicitur)

RediTruesi filumdicitur videtur continere vel SQL plenius diceres. Nulla syntactica verificationis vel parsingis cuiuscumque generis profertur, praeter recognitionem quod nullae sint litterae chordae clausae et enuntiatio semicolon terminatur.
si filumstatementvidetur continere vel perfectius SQL diceres, deinde redireTrue . Nulla syntaxin sanatio vel parsing fit praeter recognitionem quod nullae sunt chordae literae clausae et quod enuntiatio finitur cum semicolon.

Exempli gratia:Exemplum

>>>


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

Hoc munus utile esse potest per lineam initus mandatum determinare si textus ingressus videtur enuntiationem SQL integram formare, vel si additus initus ante vocationem indigeat.exequi ().
Hoc munus utile esse potest cum typing ad lineam mandatum, adiuvare potest determinare utrum textus ingressus speciem enuntiationis SQL completam spectet, an sit vocatus.execute()Num additional initus requiritur ante.

Viderunsource()inLib/sqlite3/__main__.pyad usum realem-mundi.
In usu adhibitis, referre potesLib/sqlite3/__main__.pymediumrunsource()munus suum ad cognoscendum usum.

sqlite3.enable_callback_tracebacks(vexillum, /)

Admitte vel disable callback tracebacks. Defalta nulla vestigia in usoris definitis functionibus, aggregatis, convertentibus, authori- torem callbacks etc. Si vis deludere, vocare potes hoc munus cumvexillumset adTrue . Postea vestigia ex callbacks insys.stderr . UsusFalseut disable in pluma iterum.
Admitte vel inactivare callback tracking. Defalta, nulla vestigia in usoris definitis functionibus, aggregatis functionibus, convertentibus, licentia callbacks, etc.Si vis debug eos, vocare potes hoc munus ac reponereflagSet quodTrue .Postea poterissys.stderr Vestigium adepto notitia ex callback.ususFalseut disable haec factura iterum.

Nota

Errores in functione callback definitae usoris initium habent sicut exceptiones inexplicabiles. utere anunraisable hamo tractoad introspectionem callback defecit.
Errores in functione callbacko definitae usoris initium habent sicut exceptiones incomprehensibiles. Utere hamo unraisable tracto ad introspectionem in callbacks defecit.

Hoc significat, cum errores in callbacks functionum SQLite usoris definitae (ut functiones aggregatae, functiones scalares etc.) occurrunt), hi errores non coniecerunt ut exceptiones normales Pythonis et ab experimentis praeter caudices capi possunt. Sed ab SQLite vel Pythonis sqlite3 moduli capiuntur et aliquo modo initium faciunt (solent scripti ad signum vel vexillum erroris output), sed exsecutionem programmatis non interrumpunt (nisi error gravissimus est).

Has exceptiones incomprehensibiles ut inspicias et debug, potes "incomprehensibilem hamum tractantem" constituere. Hoc tracto munus est, quod Python vocat exceptionem incomprehensibilem, praeteriens exceptionis informationis ut modularis. Hoc modo, codicem scribere potes in functione processus processus ut aperias vel inspicias has exceptiones ut problema egritudo adiuvet.

Nota quaeso quod exsecutio specifica variari potest secundum Pythonis versionem et ad singula moduli sqlite3 exsequenda. Ideo commendatur ut ultimis documentis Pythonis, seu documentorum sqlite3 modulorum consulatur, quomodo tracto hamo incomprehensibili erigatur et utatur.

**sqlite3.register_adapter(type, nibh, /)**

Register annibh callableut Python genus aptettype in SQLite genus. Adaptor dicitur cum Pythone objecti generistypeut unicum ejus argumentum, et valorem ipsius a . reddere debettypus ut SQLite pater intelligit.
Subcriptio an ** adaptor ** callable objectum convertendi Pythonistype Genus ad typum accommodatum est quod SQLite patere intellegere potest.Hic nibh munus accipit atypeObjectum type appellatur ut unicum argumentum et reddere debet valorem figurae quam SQLite ingenitum sustinet.

Notandum quod”typetype" sit aliquantulus periculosum, quod typice non dicimus ad pythonis constructum-intype Res (i.e. rationes ipsae) directe in datorum reponuntur. Communius, obiectis Pythone (quae exempla consuetudinum generum esse possunt) in forma quam SQLite reponunt, volumus accommodare.Tamen ad litteram sumens sententiam, si opus est tibi ageretypeipsum obiectum (quamvis hoc in usu rarum est), necesse est scribere adaptatorem in aliquam formam converti quam SQLite reponunt, ut chorda nomen figurans repraesentans.

Sed causa communior est consuetudinis pythonis typi vel constructi in speciebus utdatetime、decimal.Decimaletc.) adaptatores scribe ut ab datorum SQLite recte reponi et recuperari possint.

Exempli gratia, si Python classis consuetudo estMyClasset vis suam instantiam reponere in database SQLite, scribere potes adaptatorem ad exemplum huius generis in chorda (vel alius generis) convertendi exemplum quod per SQLite condi potest, et tunc scribe convertentis ad convertendum hoc nervum retro converte. toMyClassexempli gratia.

Sed ad hanc quaestionem, si modo vis cum Pythone ageretypeobiecto (i.e. metadatae typo) scribere possis adaptor ad nomen generis (sicut chordae) reddendum, sed hoc plerumque non est usus communis ad thesaurizandas res in database.

sqlite3.register_converter(typename, converter, /)

Subcriptio theconverter callableut convertat SQLite objecta generistypename in Pythone objectum specifici generis. Invocatur converter pro omnibus SQLite valores generistypename ; Transiit abytes obiiciat, et redeat ad optatam Pythonis rationem. Consule modulodetect_types " " " " " " " " "of*connect ()ad informationem de quo genus deprehendendi operatur.
Subcriptio convertens objectum callable ** convertendi SQLite genera intypename Convertit Python obiectum speciei specifici.Nam omnia generatypenameHic convertor pro quolibet valore SQLite vocatur;bytes object as argument and should return object of the required Python type.Quomodo enim genus detectionis operatur, placere adconnect()Egetdetect_typesmodulo.

Nota:typenameet nomen generis in interrogatione tua casu-sensibiliter aequantur.
Notice：typenameNomen generis in interrogatione cum matching sensitiva non est.

OMNIBUS constantibus

sqlite3.LEGACY_TRANSACTION_CONTROL

Setautocommit ad hunc constantem stilum antiquum deligere (pre- Python 3.12) agendi modum agendi. VideTransactio control per attributum solitation_levelpro magis notitia.
Willautocommit Pone huic constanti stilum antiquum deligere (prae-Python 3.12) agendi modum agendi.Ad maiorem informationem, placere ad "Transire"isolation_levelProprietates transactiones control".

sqlite3.PARSE_COLNAMES

Hoc vexillum valorem addetect_types " " " " " " " " "parametriconnect () spectare munus convertentis utendo nomine generis, parsed ex nomine interrogationis columnae, sicut clavis convertentis dictionarii. Genus nomen est uncis quadratis involvi ([]).
Hoc vexillum valorem adconnect()Egetdetect_types Parameter ad munus convertentis inveniendum per interrogationem determinati nominis generis in columna nominis sicut clavis ad dictionary convertentis. Typus nomina uncis quadratis includi debent ([ ]).

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

Hoc vexillum potest esse cumPARSE_DECLTYPESusus est|(Bitwise vel) operator.
Hoc vexillum potest esse|(Bitwise VEL) operator ANDPARSE_DECLTYPESConiunctim.

sqlite3.PARSE_DECLTYPES

Hoc vexillum valorem addetect_types " " " " " " " " "parametriconnect () ad munus convertentis suspicere utens rationes declaratas pro unaquaque columna. Typi declarantur cum mensa datorum creetur.sqlite3 Videbit munus convertentis utens primo verbi generis declarati sicut clavis converter dictionary. Exempli gratia:
Hoc vexillum valorem adconnect()Egetdetect_types Parametri ad inveniendum convertentis munus utentem declaratum cuiusque columnae genus in database. Haec genera declarantur cum mensam datorum creando.sqlite3 Munus convertentis spectabitur utens primo verbo in typo declarati sicut clavis convertentis dictionary. Exempli gratia:


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

Hoc vexillum potest esse cumPARSE_COLNAMESusus est|(Bitwise vel) operator.

sqlite3.SQLITE_OK

sqlite3.SQLITE_DENY

sqlite3.SQLITE_IGNORE

Vexilla quae reddenda sunt aauthoriser_callback callableTransierunt toConnection.set_authorizer()ut num;
Transi toConnection.set_authorizer()of *authorizer_callbackVexilla ut munus callabile reddere debet ad indicandum;

Aditus licet (SQLITE_OK) Aditus permittitur (SQLITE_OK）
SQL constitutionis abortivi cum errore (SQLITE_DENY)
SQL constitutionis abortivi cum errore (SQLITE_DENY）
Columpna tractari debet ut aNULLvalorem (SQLITE_IGNORE)
Columnae tractari debent valores nullos (SQLITE_IGNORE）

sqlite3.apilevel

Stringe constantem enuntians DB-API subnixum gradu. Requiritur DB-API. Durus-coded to"2.0".
Hi duo linea constantes suntsqlite3Modulis definita, Python Database API specificationem sequuntur (DB-API).

sqlite3.paramstyle

Fila constantem declarans rationem parametri formatting a theca expectatasqlite3 modulus. Requiritur DB-API. Durus-coded to"qmark".
Hoc filum constant cificatsqlite3 Genus parametri formandi a modulo expectatur. Hoc postulatum est a DB-API (In programmandi Interface Database) specificationem.Est sicut hardcoded"qmark"significat, SQL quaerendo construendo, parametri notas interrogationibus notas repraesentari (?).

Nota

ThenamedStylus quoque parametri db-API sustentatur.

sqlite3.sqlite_version

Versionem numerus runtime SQLite bibliotheca ut afilum.
Numerus versionis SQLite bibliothecae runtime, in chorda forma expressa.

sqlite3.sqlite_version_info

Versionem numerus runtime SQLite bibliotheca ut atupleof*integri.
Numerus versionis bibliothecae SQLite runtime, ut tuplum integrorum expressit.

sqlite3.threadsafety

Integer semper requiritur ab DB-API 2.0, gradum sequelae tutandamsqlite3 moduli adstipulantur. Set hoc proprium est secundum defaltamthreading modus SQLite bibliotheca subjecta compilata est. SQLite modi staminei sunt:
Integer constans postulatum DB-API 2.0, indicanssqlite3 Fila tuta moduli gradu fulta. Haec proprietas secundum modum defaltam filo sequelam posita est bibliothecae SQLite subiectae cum compilata. SQLite modos filo comprehendunt:

Una-filaHoc modo omnes mutexes debiles sunt et SQLite in uno filo semel uti non tutum est.
Unius-filo: Hoc modo, omnes mutexes debiles sunt et SQLite in pluribus filis simul utendum non est tutum.
Multi-fila: Hoc modo, SQLite tuto a pluribus sequelis adhiberi potest, dummodo nulla nexus database una simul in duobus vel pluribus stamina adhibeatur.
Multi-fila: Hoc modo, SQLite tuto a pluribus sequelis adhiberi potest, dummodo nulla nexus database una simul duobus vel pluribus stamina adhibeatur.
Serialized: SQLite in modum serialized tuto adhiberi potest a pluribus sequelis sine restrictione.
Serialized: In modum serialized, SQLite tuto pluribus filis sine restrictionibus adhiberi potest.

Tabulae geographicae ab SQLite modorum filoriorum ad DB-API 2.0 gradus sequelae sunt hae:
Modus sequelae destinata SQLite ad DB-API 2.0 gradum securitatis sequelae sic est:

SQLite modus threading	threadsafety	SQLITE_THREADSAFE	DB-API 2.0 meaning
una-fila	0	0	Rei moduli participes non possunt
multi-fila	1	2	Fila moduli communicare possunt, sed hospites non sunt
serialized	3	1	Fila moduli, nexus et cursores communicare possunt

Mutata in versione 3.11: Ponethreadsafetydynamically pro durum-coding eam1.

sqlite3.version

Numerus huius moduli in versione afilum . Haec versio bibliothecae SQLite non est.
Numerus versionis huius moduli, ut filo expressus.hocnoNumerus versionis SQLite bibliothecae.

Deprecatus cum versione 3.12, in versione 3.14 removebitur: Hic assiduus usus est ad cogitandum numerum versionispysqlitesarcina, bibliotheca tertia-partim, quae mutationibus flumine usus estsqlite3 . Hodie nihil significatio aut utilitas fert.
Deprecatus ab versione 3.12, in versione 3.14 tollendus: Haec assidua ad reflectendum adhibebaturpysqliteVersio numeri involucrum;pysqliteTertia pars bibliothecae ad flumen est adpositasqlite3 Mutationes committere. Nihil autem significat realem significationem vel valorem practicum.

sqlite3.version_info

Numerus huius moduli in versione atupleof*integri . Haec versio bibliothecae SQLite non est.

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

Haec constantes sunt proConnection.setconfig()etgetconfig ()modis.
Haec constantes suntConnection.setconfig()etgetconfig()modum.

Prompta horum constantium variat secundum versionem SQLite Pythonis exaratam.
Prompta horum constantium pendet ex versione SQLite SQLite Pythonis cum SQLite digesta.

Additur in versione 3.12.

Vide quoque

Database Connection configurationis Options

SQLite docs: Database Connection configurationis Options

Connection objects

classissqlite3.Connection

Quodlibet apertum SQLite database repraesentatur per aConnectionobjectum, quod utens creatum estsqlite3.connect() . Praecipuum propositum creantisCursorres et *Transactio imperium.

Vide quoque

Connexio database SQLite habet sequentes attributa et modos:

cursor (officinas = Cursor)

Creare et redire aCursor objectum. cursor modum accipit unum ad libitum parametriofficinas . Si supplendum est, hoc erit a .callablereddens instantiaCursoraut subclasses eius.
Creat et redit aCursorobjectum.cursorModum accipit libitum unius parametrifactory .Si modulus iste provisus sit, oportet esse obiectum callabile quod redit aCursorvel instantia sui generis.

blobopen(mensa, columnaeae, row, /, , readonly = falsum, name='main'*)

Aperire aBlobtractamus existenti BLOB.

Parametri:

mensa (str******************************************) — Nomen tabellae ubi blob sita est.
Nomen tabellae quae BLOB data est.
columnaeae (str******************************************) - Nomen columnae ubi sita est STILLA.
Columna nomen continens BLOB data.
row (str******************************************) — Nomen ordinis ubi blob sita est.
Nomen ordinis (vel verius identificatorium versuum) quod continet BLOB notitia.
tantum legere (bool) - Set adTrue si blob aperiatur sine licentias scribe. Defaltis toFalse.
Si ad Verum positum, indicat BLOB aperiendum esse sine licentia scribendi. Defalta falsa est, quae permittit legere et scribere.
nomen (str****************************************** ) - Nomen datorum ubi blob sita est. Defaltis to"main".
Nomen datorum BLOB continens notitia. Defectus "principalis" est, quod est nomen database default in SQLite.

Erigit:

OperationalError- Cum conatur aperire STILLA inWITHOUT ROWIDmensa.
Dum quaerit sineROWFit cum data BLOB aperitur in tabula ID.

Redi genus:

Blob

Nota

STILLA magnitudine mutari non potest utendoBlob classis. Utere SQL munuszeroblobcreare STILLA cum certa magnitudine.

Additur in versione 3.11.

committere()

Committere aliquam rem pendentem ad database. SiautocommitisTrue aut nulla res aperta, haec ratio nihil agit. SiautocommitisFalseres nova implicite aperitur, si transactionem pendentem hac methodo commisisse.
Committere aliquem lite transactions ad database.siautocommit Verum est, vel nulla res aperta est, haec methodus nullam operationem facit.siautocommitFalsa est, et haec methodus rem pendentem committit, nova transactio implicite incipiet.

reverti ()

Revolvere initium alicujus rei pendentis. SiautocommitisTrue aut nulla res aperta, haec ratio nihil agit. SiautocommitisFalseimplicite res nova aperitur si transactionis pendenti hac methodo revolutus.
Revolvere ini- lite transactionum.siautocommit Verum est, vel nulla res aperta est, haec methodus nullam operationem facit.siautocommitFalsa est, et haec methodus rem pendentem revolvet, transactionis nova implicite incipiet.

claudere ()

Claudere nexum datorum. SiautocommitisFalse cuiuslibet pendentis transactionis implicite revolutus. SiautocommitisTrueor *LEGACY_TRANSACTION_CONTROL nulla re implicita moderatio afficitur. Fac tocommittere()ante claudendo vitare mutationes amissis pendenti.
Claudere nexum datorum.siautocommit Si falsae, quaecunque transactiones pendentes implicite revolventur.siautocommitest verum seuLEGACY_TRANSACTION_CONTROL (legatum transactionis imperium), transactiones implicitae potestas facienda non erit.Ante claudendo fac vocarecommit()mutationes amissis ne pendeat.

exsequi (sql, parametri (), /)

NovamCursorobjectum vocatexequi ()in ea cum datissqletparametri . Redde cursorem novum obiectum.
creare novumCursorobjectum appellantexecute()methodus transiens in datissql dictis et parametris.hoc reverteturCursorobjectum.

executmany (sql, parametri, /)

NovamCursorobjectum vocatexecutmany ()in ea cum datissqletparametri . Redde cursorem novum obiectum.
creare novumCursorobjectum appellantexecutemany()methodus transiens in datissql Dictorum et sequentiarum modulus. Hoc sinit plures ambitus statim exsecutioni mandari.hoc reverteturCursorobjectum.

executscript (sql_script, /)

NovamCursorobjectum vocatexecutscript ()in ea cum datissql_script . Redde cursorem novum obiectum.
creare novumCursorobjectum appellantexecutescript() methodus transiens in scripto data SQL. Haec exsecutio multarum SQL sententiarum permittit, a semicolonis in scripto separata.hoc reverteturCursorobjectum.

create_function(nomen, narg, func, , = falsum determinatic*)

Creare vel removere a user definitae SQL munus.
Creare vel removere a user definitae SQL munus.

Parametri:

nomen (str******************************************) - Nomen muneris SQL.
name- Nomen SQL functionis.
narg (int ) - Numerus argumentorum munus SQL accipere potest. Si-1quotlibet argumentis sumat.
narg (int) - Numerus argumentorum quas munus SQL accipere potest. Si -1, significat quodlibet numerum argumentorum accipere potest.
func (revocare | Nulla) - Acallable id appellatur cum munus SQL invocatur. Callable redire debetper genus paternus auxilium SQLite . Set adNoneSQL munus existentium ad removendum.
func Hoc callabile obiectum (callback) exsecutioni mandabitur cum munus SQL appellatur. Hoc obiectum callabile reddere debet typum a SQLite innixum. Si ad Nonam positi, functiones SQL existentes tolluntur.
determinatic (bool) - SiTrueSQL munus creatum ut alibideterminatic, quae SQLite permittit ut optimizationes augeantur.
deterministic(bool) - Si Verum, designatum SQL munus ut deterministicum, quod dat SQLite ad additional optimizations perficiendas.

Erigit:

NotSupportedError- Sideterminaticadhibetur cum SQLite versions antiquiorem 3.8.3.

Mutata in versione 3.8: adiecitdeterminaticmodulo.

Exemplum:

>>>


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

create_aggregate (nomen, n_arg, aggregate_class)

Aggregatum munus SQL creare vel removere a user definitae.
Aggregatum munus SQL creare vel removere a user definitae.

Parametri:

nomen (str******************************************) - Nomen muneris aggregati SQL.
name- Nomen muneris aggregati SQL.
n_arg (int ) - Numerus argumentorum munus aggregatum SQL accipere potest. Si-1quotlibet argumentis sumat.
Numerus parametrorum quem munus aggregatum SQL accipere potest. Si -1, significat quodlibet numerum argumentorum accipere potest.
aggregate_class (classisisisis | Nemo) -

Classis hos modos efficere debet:
Classis hos modos efficere debet:
- step(): aggregato ordine add.
- finalize(): Redde exitum aggregati sicutper genus paternus auxilium SQLite.
  finalize(): Haec methodus ad extremum aggregationis effectum reddere.
Numerus argumentorum quodstep()modum debet accipere refrenatn_arg.
step()Numerus parametrorum modus accipiendus est an_argtemperantia.

Set adNonead removendum munus aggregatum existentium SQL.
Set quodNonemunera SQL aggregatum existentium removere.

Exemplum:


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

create_window_function (nomen, num_params, aggregate_class, /)

Creare vel removere a user definitae universitatis fenestra munus.

Parametri:

nomen (str******************************************) - Nomen SQL fenestrae aggregati munus creandi vel removendi.
num_params (int ) - Numerus argumentorum munus fenestrae SQL aggregatum accipere potest. Si-1quotlibet argumentis sumat.
aggregate_class (classisisisis | Nemo) -

Genus quod sequentes modos efficere debet:
- step(): Versuram ad fenestram hodiernam adde.
- value(): Remitte praesentem valorem universitatis.
- inverse(): Aufer ordinem e fenestra currente.
- finalize(): Redde exitum aggregati sicutper genus paternus auxilium SQLite.
Numerus argumentorum quodstep()etvalue()modi debet accipere refrenatnum_params.

Set adNonead removendum munus universitatis fenestra existentium SQL.

Erigit:

NotSupportedError- Si usus cum versione SQLite maior quam 3.25.0, quae functiones fenestrarum aggregatum non sustinet.

Additur in versione 3.11.

Exemplum:

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

create_collation (nomen, callable, /)

Create collationem nominenomenper collationem munuscallable. callableTransierunt duofilumargumenta, et redire debetinteger:

1si prima superior secunda
-1si primo ordinetur infra secundo
0si aequales sunt

Hoc exemplum ostendit genus collationis contrarium:

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

Collatio munus ab occasu removerecallabletoNone.

Mutata in versione 3.11: Nomen collatio nullum characterem Unicode continere potest. Antea tantum ASCII concessum est.

interrumpere ()

Hanc methodum voca ex diverso filo ad abortum quaslibet interrogationes quae in nexu peragendas possunt. Abortus queries suscitabo anOperationalError.

set_authorizer(authoriser_callback)

Registercallable authoriser_callback invocari pro quolibet conatu datorum accedere ad columnam tabulae. Callback rediret unumSQLITE_OK, SQLITE_DENY, orSQLITE_IGNOREad significandum quomodo accessus ad columnam a bibliotheca SQLite subiecta tractanda sit.

Prima ratio ad callback significat quod genus operandi est auctoritate. Secundum et tertium argumentum erit argumentaNone secundum primum argumentum. 4 Argumentum est nomen datorum ("ma", "temp" etc. si locum habet. Argumentum 5 est nomen felis interioris vel sententiae quae pro accessu conatu velNonesi accessus hic temptatus est directe ex input SQL codice.

Quaeso consule documenta SQLite de valoribus possibilibus pro primo argumento et significatione secundi et tertii argumenti secundum primum. Omnia necessaria constantes sunt in promptusqlite3modulus.

TransiensNoneasauthoriser_callbackdisable auctor erit.

Mutata in versionem 3.11: adiecit auxilium inactivare auctor utensNone.

set_progress_handler (progress_handler, n)

Registercallable progress_handlerinvocari pro omnibusn instructiones SQLite apparatus virtualis. Hoc utile est si vis ab SQLite in operationibus diuturnis vocari, exempli gratia ad renovationem GUI.

Si vis purgare aliquem tractorem ante institutum progressum, voca modum cumNonefor*progress_handler.

Rediens valorem non-nullam e functione tracto terminabit interrogationem currently exsequentem et causam illam alereDatabaseErrorexceptio.

set_trace_callback(trace_callback)

Registercallable trace_callbackinvocari pro unoquoque SQL quod actu a SQLite backend.

Sola argumentatio ad callback dicitur (asstr****************************************** ) quod agitur. Reditus valor callback ignoratur. Nota quod backend non solum currunt propositiones ad theCursor.execute () modis. Alii fontes includunttransaction procuratiodesqlite3moduli et exsecutio triggers definitorum in hodierna database.

TransiensNoneastrace_callbackvestigium callback disable erit.

Nota

Exceptiones in vestigio callback elevatae non propagantur. In progressionem et debugging auxilium, utereenable_callback_tracebacks ()ad enable imprimendi tracebacks ex exceptionibus in vestigio callback.

Additur in versione 3.3.

enable_load_extension (enabled " ", /)

Admitte SQLite machinam extensiones SQLite onerare ex bibliothecis communibus ifenabled " "isTrue ; aliud, disallow extensiones SQLite loading. SQLite extensiones novas functiones, aggregationes vel integras novas exsecutiones mensae virtualis definire possunt. Extensio nota una est extensio fulltext-inquisitionis cum SQLite distributa.

Nota

Thesqlite3 modulus non aedificatur cum extensione onere per defaltam sustentationem, quia nonnullae tabulae (notabiliter macOS) habent bibliothecas SQLite, quae sine hoc pluma compilata sunt. Ut extensionem loadable subsidium, transire debes--enable-loadable-sqlite-extensionesoptio toconfigurare.

erigit anauditing eventuuuuuuuu sqlite3.enable_load_extensioncum argumentisconnection, enabled.

Additur in versione 3.2.

Mutata in versione 3.10: adiecitsqlite3.enable_load_extensiondiendi eventu.

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)

load_extension (iter, /, *, ingressum = nemo)

SQLite extensionem oneratis a bibliotheca communi. Admitte extensionem loading cumenable_load_extension ()antequam hunc modum vocant.

Parametri:

iter (str******************************************) - Via ad extensionem SQLite.
ingressum (str****************************************** | Nullus ) - Viscus punctum nomen. SiNone SQLite ascendet cum aculeo nomine proprio; videre SQLite soUicitudoExtensio Loadingfor retineo.

erigit anauditing eventuuuuuuuu sqlite3.load_extensioncum argumentisconnection, path.

Additur in versione 3.2.

Mutata in versione 3.10: adiecitsqlite3.load_extensiondiendi eventu.

Mutata in versione 3.12: adiecitingressummodulo.

iterdump ()

Redi aniterator ut effundite database ut SQL source code. Utile, cum salva memoria datorum in- datorum postea restitutionis. Similes sunt.dumpimperium insqlite3testam.

Exemplum:

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

Vide quoque

Quomodo tractandum textum encodings non-UTF-8

tergum (target, *, paginae=-1, profectum = nemo, name='main', somnus = 0.250)

Creare tergum SQLite database.

Operatur etiam si datorum accessio ab aliis clientibus vel simul nexu eodem accedat.

Parametri:

target (Connection) - Connexio database tergum ad salvandum.
paginae (int ) — Numerus paginarum ad tempus effingendum. Par vel minus0 totum datorum in uno gradu exscriptus est. Defaltis to-1.
progressus (revocare | Nulla) - Si ad acallableinvocatur cum tribus integris argumentis pro omni iteratione tergum: thestatusultimae iterationis, thereliquiaepaginarum numerus adhuc exscribendus est ac thetotal paginarum numero. Defaltis toNone.
nomen (str****************************************** ) - Nomen datorum ad tergum sursum. Aut"main"(Per default) ad principale database;"temp"ad tempus database, seu nomen consuetudinis datorum ut attachiatus utensATTACH DATABASESQL editio.
somnum (supernatet) – Numerus secundorum dormiendi inter continuas conatus paginas reliquas tergum sursum.

Exemplum I, effingo datorum existentis in alium:

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

Exemplum II, effingo datorum existentium in exemplum transitum:

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

Additur in versione 3.7.

Vide quoque

Quomodo tractandum textum encodings non-UTF-8

getlimit (genus, /)

Connexionem ut runtime terminum.

Parametri:

genus (int) - TheSQLite modus genusqueried.

Redi genus:

int

Erigit:

ProgrammingError- SigenusSQLite bibliotheca subiecta non agnoscitur.

Exempli gratia, investigatio maximi longitudinis propositionis SQL proConnection con(defalta est 1000000000);

>>>

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

Additur in versione 3.11.

setlimit(genus, limit, /)

Set runtime nexum terminum. Terminum augere nititur superne ligatus Durus supra tacite truncatus ad dura superne ligatus. Quantumvis utrum terminus mutatus sit necne, prior valor termini redditur.

Parametri:

genus (int) - TheSQLite modus genusapponendum.
limit (int ) - Valor novi limitis. Si negativa, modus hic non mutatur.

Redi genus:

int

Erigit:

ProgrammingError- SigenusSQLite bibliotheca subiecta non agnoscitur.

Exempli gratia, circumscribere numerum databases affixa ad 1 forConnection con(per default terminus est X);

>>>

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

Additur in versione 3.11.

getconfig (op, /)

Quaeris optio configurationis nexus boolean.

Parametri:

op (int) - ASQLITE_DBCONFIG codice.

Redi genus:

bool

Additur in versione 3.12.

setconfig(op, enable = verus, /)

Connexionis configuratione optionis pone Boolean.

Parametri:

op (int) - ASQLITE_DBCONFIG codice.
da " (bool) – Truesi optio configurationis effici possit (per annum);Falsesi erret.

Additur in versione 3.12.

serialize(*, name='main')

Serialize database into abytes objectum. Ad fasciculum database ordinarium in disco, serialization fasciculi orbis exemplar est. Pro in-memoria datorum vel "temp" datorum, eadem series bytes serialization est quae scriberetur in disco si database in disco subnixum erant.

Parametri:

nomen (str****************************************** ) - Nomen database serialized. Defaltis to"main".

Redi genus:

bytes

Nota

Haec methodus tantum praesto est si bibliotheca SQLite subiecta serialize API habet.

Additur in versione 3.11.

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

Deserialize aserializeddatabase in aConnection . Haec methodus facit nexum datorum ad disiungendum a databasenomenEt rescissanomensicut in-memoria database fundatur in serialization continebatdata.

Parametri:

data (bytes) - A database serialized.
nomen (str****************************************** ) - Nomen datorum deserialize in. Defaltis to"main".

Erigit:

OperationalError- Si nexus database in negotio legenti vel tergum operationis involvit.
DatabaseError- Sidatavalidum SQLite database non continet.
OverflowError- Silen(data)est maior quam2**63 - 1.

Nota

Haec methodus tantum praesto est si bibliotheca SQLite subiecta deserialize API habet.

Additur in versione 3.11.

autocommit

Hoc proprium imperiumPEP 249-compliant gestum.autocommithas tres permisit values:

False: SelectPEP 249-compliant gestum, quasisqlite3 semper aperta res efficit. Ususcommittere()etreverti ()claudere arbitrantur.

Hoc est suadetur valorem ofautocommit.
True: SQLite usus estautocommit modus. committere()etreverti ()hoc modo nullum habent effectum.
LEGACY_TRANSACTION_CONTROL: Pre- Python 3.12 (non-PEP 249 -compliant) res gestae. Videsolitudo_level "ad plura.

Hoc est currently per default valoremautocommit.

MutatioautocommittoFalsenovam rem aperiet, eamque mutabitTrueet aliquo lite transactionem committere.

VideTransaction imperium per autocommit attributumad plura.

Nota

Thesolitudo_level "proprium non habet effectum nisiautocommitisLEGACY_TRANSACTION_CONTROL.

Additur in versione 3.12.

in_transaction

Hoc solum legitur attributum, correspondet humili gradu SQLiteautocommit modus.

Truesi negotium est activum (sunt mutationes inconcussae);Falsesecus.

Additur in versione 3.2.

solitudo_level "

Imperiumlegatum transaction pertractatio modusof*sqlite3 . Si profectus estNone transactiones numquam implicite aperiuntur. Set si uni"DEFERRED", "IMMEDIATE", or"EXCLUSIVE"Respondens underlyingSQLite mores transaction, implicitam rem procuratioconficitur.

Si non overrided asolitudo_level "parametriconnect ()Defalta est""quod est alias for"DEFERRED".

Nota

utensautocommitad imperium transaction pertractatio commendatur in usuraisolation_level. isolation_levelnon habet effectum, nisiautocommitest profectus estLEGACY_TRANSACTION_CONTROL(per default).

row_factory " " " " " " " " " " " "

Initialisrow_factory " " " " " " " " " " " "for*Cursor ex hoc nexu obiecti creata. Tribuens huic attributo non afficitrow_factory cursores ad hunc nexum pertinentes, tantum novos. IsNoneper defaltam, id est uterque ordo redditur sicut atuple.

VideQuomodo creare et uti row officinasad plura.

text_factory

Acallablequi accipit a *bytes modulus et textum repraesentativum reddit. Vocabilis invocatur pro valores SQLite cumTEXT notitia generis. Defalta, hoc attributum eststr******************************************.

VideQuomodo tractandum textum encodings non-UTF-8ad plura.

total_changes

Redi numerum ordinum datorum qui mutatae, insertae vel deletae sunt quia nexus datorum apertus est.

Cursor objects

ACursorobjectum repraesentatdatabase cursor quae SQL constitutiones exequi solebant et contextum actionis adductae administrant. Cursores creantur usuraConnection.cursor()aut utendo aliquo eorumnexum brevis modi.

Cursor obiecti suntiterators, id est siexequi ()aSELECTinterrogatione, simpliciter iterare potes per cursorem ad ordines inde adducendos:
for row in cur.execute("SELECT t FROM data"):
    print(row)

classissqlite3.Cursor

ACursorinstantia habet sequentia attributa et modos.

exsequi (sql, parametri (), /)

Fac unam SQL sententiam, optione Pythonis valores ligandi utendiplaceholders.

Parametri:

sql (str******************************************) - Unius SQL editio.
parametri (dict | series) - Python valores ligandi ad placeholders insql . Adict si nominati placeholders sunt usi. Sequentia si innominati placeholders adhibentur. VideQuomodo uti placeholders ad ligandum valores in SQL queries?.

Erigit:

ProgrammingError- Sisqlplus quam SQL dicitur.

SiautocommitisLEGACY_TRANSACTION_CONTROL, solitudo_level "non estNone, sqlestINSERT, UPDATE, DELETE, orREPLACEconstitutio, nulla aperta transactio, transactio implicite aperitur ante executionemsql.

Deprecatus cum versione 3.12, in versione 3.14 tolletur;DeprecationWarningemittitur if *nominatur placeholderssunt etparametrisequentia pro *dict . Pythone Satus 3.14;ProgrammingErroret leva- tione.

Ususexecutscript ()facere plures SQL diceres.

executmany (sql, parametri, /)

Nam omnis item inparametri, Saepe exequiparameterizedDML SQL constitutionissql.

Utitur eodem implicita re pertractatioexequi ().

Parametri:

sql (str******************************************) - Unius SQL DML constitutio.
parametri (iterabile) - Iterabile parametri ligare cum placeholders insql . VideQuomodo uti placeholders ad ligandum valores in SQL queries?.

Erigit:

ProgrammingError- Sisqlplus quam unam SQL enuntiationem continet, vel editio DML non est.

Exemplum:

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

Nota

Ordines inde abiecti sunt, cum DML constitutionibus comprehendunturREDITUS clausulis.

Deprecatus cum versione 3.12, in versione 3.14 tolletur;DeprecationWarningemittitur if *nominatur placeholderssunt ac items inparametrisunt sequentia pro *dict s. Pythone Satus 3.14;ProgrammingErroret leva- tione.

executscript (sql_script, /)

Exequi SQL constitutionibussql_script . SiautocommitisLEGACY_TRANSACTION_CONTROLet pendente transactione, impliciteCOMMIT dicitur prius fit. Nulla alia re implicita temperantia peragitur; aliqua re imperium addendum estsql_script.

sql_scriptoportet esse *filum.

Exemplum:

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

arcesse ()

Sirow_factory " " " " " " " " " " " "isNone, redde proximum ordinem interrogationis proventuum quem ad modum atuple . Alioquin, transi ad officinam remigandi et exitum suum redde. RediNonesi non plus data est available.

arcessmany (mole = cursor.arraysize)

Reddere proximum ordinem ordinum quaesiti proventuum aalbum . Remitte inanis indicem si non plures ordines in promptu sunt.

Numerus ordinum ad arcessendum per vocationem specificatur amagnitudine modulo. Simagnitudinenon datur;arraysize""""" numerum ordinum arcessendos esse decernit. Si paucioribus quammagnitudineordines in promptu sunt, quot ordines in promptu sunt.

Notae sunt considerationes perficiendi cum thecamagnitudine modulo. Ad optimal effectus, optime solet uti attributis vestit. Simagnitudineparameter adhibetur, tum optimum est eandem ab uno retinere valoremarcessmany ()vocatis ad prox.

arcessal ()

Redi omnes ordines quaesiti effectus ut aalbum . Indicem inanem redde si nullus ordines in promptu sunt. Nota quodarraysize"""""attributum potest ad hanc operationem pertinere.

claudere ()

Claudere cursor nunc (quam si__del__appellatur).

Ex hoc porro loco cursor inutile erit; aProgrammingErrorexceptio erit, si aliqua operatio cum cursore attentata sit.

setinputsizes (magnitudinum, /)

Requiritur DB-API. Nihil facitsqlite3.

setoutputsize (magnitudine, columna = None, /)

Requiritur DB-API. Nihil facitsqlite3.

arraysize"""""

Legere / scribere attributum quod regit numerum ordinum rediitarcessmany () . Valor defectus 1 est qui significat unum ordinem per vocationem adduci posse.

nexum

Read solum attributum quod praebet SQLite databaseConnection ad cursorem pertinens. ACursorres creata per vocantemcon.cursor()erit a *nexumattributum quod refers tocon:

>>>

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

description

Lege solum attributum quod columnae nomina praebet interrogationis ultimae. Ut cum Pythone DB API stare possit, redit ad singulas columnas 7 tuplas ubi sex ultimae cuiusque tuplae sunt.None.

Propositum estSELECTdictis sine ullo ordine ordine congruens pariter.

lastrowid

Lege solum tribuere quod praebet versui id postremi versu inserto. Tantum updated cum prospereINSERTor *REPLACEstatements usura theexequi () modum. Aliis constitutionibus postexecutmany ()or *executscript (), vel, si de- miserit, valor ipsiuslastrowid nihil mutatum. ValoremlastrowidisNone.

Nota

adiicitWITHOUT ROWIDtabulae non referuntur.

Mutata in versione 3.6: additur pro auxilioREPLACEeditio.

rowcount

Read solum attributum quod praebet numerum mutatio ordines forINSERT, UPDATE, DELETE, etREPLACE effata; is-1 pro aliis constitutionibus, etiam CTE queries. Tantum updated perexequi ()etexecutmany () modos, postquam dictum est, percurramus. Id est, ordines aliquos consequens esse, ut per ordinem arcessianturrowcountrenovari.

row_factory " " " " " " " " " " " "

Imperium quomodo ordo inde petitusCursor figuratur. SiNone, a versu exprimiturtuple . Potest posuit in inclusasqlite3.Row ; aut *callablequod duas rationes admittit, aCursorobject ettupleof row values, and returns a custom object representing an SQLite row.

Defaltis ad quodConnection.row_factorypositus cumCursor creatus est. Tribuens huic attributo non afficitConnection.row_factoryparentis nexum.

VideQuomodo creare et uti row officinasad plura.

Row obiecti

classissqlite3.Row

ARowexempli causa optimizedrow_factory " " " " " " " " " " " "for*Connection obiicit. Sustinet iterationem, aequalitatem probatio;len (), etmappingaccess by column name and index.

duoRowobiecta comparant aequalia si identitatem columnae habeant nomina et valores.

VideQuomodo creare et uti row officinasad plura.

claves ()

Redi aalbumde columna nomina aschordis . Statim post interrogationem primum membrum cuiusque tuplum estCursor.description.

Mutata in versione 3.5: subsidium dividendi addidit.

Blob obiecti

classissqlite3.Blob

Additur in versione 3.11.

ABlobexempli gratia est a *file-sicut object qui legere et scribere potest data in SQLite BLOB. Vocatiolen (blob) ut magnitudinem (numerum bytes) blob. Utere indices etcrustaeper directum accessum ad blob data.

UtiBlobut a *context procuratorut post usum blob manubrium clauditur.

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

claudere ()

Claudere blob.

Blob inutile erit ex hoc loco. AnError(vel genus) excipitur exceptio, si aliqua operatio ulterior cum blob attentatur.

legere(longitudo = -1, /)

Legerelongitudo bytes notitiarum a blob ad current offset positus. Si ad extremum blob perventum est, notitia usque ad EOF reddetur. cumlongitudonon specificata, seu negativa;legere()leget usque ad finem STILLA.

scribentes injustitiam (data, /)

Scriberedata ad STILLA ad current offset. Hoc munus blob longitudinem mutare non potest. Scribendo extra finem STILLA suscitabitValueError.

dic ()

Redi ad current situ blob accessum.

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

Constitue hodiernam accessum situ ad STILLAoffset . Theoriginisisratio defaltis toos.SEEK_SET (absolute blob positioning). Aliae valores fororiginisissuntos.SEEK_CUR(Quaerere ad current situ) etos.SEEK_END(rela- tivum quaerere finem STIRPis).

PrepareProtocol objects

classissqlite3.PrepareProtocol

PraepareProtocol generis unius consilii est agere ut aPEP 246style adaptionem protocol ad obiecta quae canaptet setopatria SQLite types.

Exceptiones

Hierarchia exceptio definitur per DB-API 2.0 (PEP 249).

exceptiosqlite3.Warning

Haec exceptio non est currently sublatasqlite3moduli, sed per applicationes utendosqlite3exempli gratia, si munus usoris definitum datas truncatas inserendo.Warninggenus est *Exceptio.

exceptiosqlite3.Error

Basis generis ceterae in hoc modulo exceptae sunt. Hoc utere ut omnes errores caperent cum unonisieditio.Errorgenus est *Exceptio.

Si exceptio intra SQLite bibliothecam orta est, duo sequentia attributa adduntur exceptioni;

sqlite_errorcode

Error numerorum ex codiceSQLite API

Additur in versione 3.11.

sqlite_errorname

Nomen symbolicum numerici erroris e codiceSQLite API

Additur in versione 3.11.

exceptiosqlite3.InterfaceError

Exceptio quae abusus est in humili gradu SQLite C API. Aliis verbis, si haec excipitur, cimex verisimiliter indicatsqlite3modulus.InterfaceErrorgenus est *Error.

exceptiosqlite3.DatabaseError

Exceptio elevetur pro erroribus qui relatis datorum. Haec exceptione turpissima est pluribus generibus errorum datorum. Implicite tantum elevatur per subclasses speciales.DatabaseErrorgenus est *Error.

exceptiosqlite3.DataError

Exceptio pro erroribus causatis per problemata cum notitia processus processit, sicut valores numerorum ex range, et chordis quae nimis longi sunt.DataErrorgenus est *DatabaseError.

exceptiosqlite3.OperationalError

Exceptio pro erroribus excitata quae operationi datorum referuntur et non necessario sub dicione programmatis. Exempli gratia, via datorum non invenitur, aut negotium discursum non potest.OperationalErrorgenus est *DatabaseError.

exceptiosqlite3.IntegrityError

Exceptio elevatur cum integritas relationis datorum afficitur, eg clavem alienam perscriptio deficit. Est genus ofDatabaseError.

exceptiosqlite3.InternalError

Exceptio sublata cum SQLite errorem internum incurrit. Si hoc elevatur, indicabit problema SQLite in bibliotheca runtime esse.InternalErrorgenus est *DatabaseError.

exceptiosqlite3.ProgrammingError

Exceptio erexit insqlite3API Errores programmandi, exempli gratia, numerum ligamentorum quaesiti iniquum supplent vel in operto operari conaturConnection. ProgrammingErrorgenus est *DatabaseError.

exceptiosqlite3.NotSupportedError

Exceptio quae in casu methodo seu API datorum datorum SQLite bibliotheca subiecta non praebetur. Exempli gratia, obitusdeterminatictoTrueincreate_function ()si bibliotheca SQLite subjecta functiones deterministicas non sustinet.NotSupportedErrorgenus est *DatabaseError.

SQLite et pythonem genera

SQLite nativo sequentes sustinet;NULL, INTEGER, REAL, TEXT, BLOB.

Typi Python sequentes sic SQLite sine ullius problematis mitti possunt;

Python genus	SQLite genus
`None`	`NULL`
int	`INTEGER`
supernatet	`REAL`
str******************************************	`TEXT`
bytes	`BLOB`

Hoc modo SQLite genera ad Pythonem rationes per defaltam convertuntur:

SQLite genus	Python genus
`NULL`	`None`
`INTEGER`	int
`REAL`	supernatet
`TEXT`	dependettext_factory, str******************************************per defaltam
`BLOB`	bytes

Genus systematissqlite3modulus est extensibilis duobus modis: Python etiam genera in SQLite database via condere potesobject adaptors, et potessqlite3modulus conversus SQLite ad Python types viaconverters.

Default adaptors et converters (deprecatus)

Nota

Defalta adaptors et conversis deprecatur ut Pythonis 3.12. Sed utereAdaptor et converter recipeset sartor eos ad necessitates vestras.

Deprecatus default adaptors et converters consistunt:

Adaptordatetime.dateobiicit tochordisinISO 8601format.
Adaptordatetime.datetimeobiecti ad chordas in ISO 8601 format.
Conversus fordeclaravit"Date" types todatetime.dateobiicit.
A converter declaravit "indicium" genera todatetime.datetime obiicit. Partes fractiones mutilae ad 6 digitos erunt (microsecond precisione).

Nota

Default " indicationis" convertentis exsertiones UTC ignorat in datorum datorum et semper redit rusticusdatetime.datetime objectum. Ad conservandam UTC exsertiones in indicatione temporis, aut convertentium debiles relinquat, aut convertentem notas notas subcriptio cumregister_converter ().

Deprecatus cum versione 3.12.

Imperium-linea interface

Thesqlite3modulus invocari potest ut scriptum, utente interprete's-m transibit, ut simplex SQLite testam praebeat. Argumentum subscriptio haec est:

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

Type.quitvel CTRL-D exire testa.

-h, --help

Print cli auxilium.

-v, --version

SQLite impressio bibliothecae versionis subest.

Additur in versione 3.12.

Quam-ut ducibus

Quomodo uti placeholders ad ligandum valores in SQL queries?

SQL operationes plerumque indigent valoribus Pythonis variabilibus uti. Sed cave ne operationibus chordae Pythonis utaris ad quaestiones convocandas, sicut vulnerabiles suntSQL iniectio impetus . Verbi gratia, oppugnator potest simpliciter claudere unum textum et injicereOR TRUEomnes ordines eligere:

>>>

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

Pro modulo substitutionis DB-API utere. Varium in chorda quaesitum inserere, in chorda placetentorem uti, et valores actuales in interrogationem substitue, eos praebendo.tuplevalues ad secundum argumentum de cursor'sexequi ()modum.

An SQL enuntiatio uno e duobus generibus positorum uti potest: notis interrogationis (qmark style) vel nominatis locatoribus (stylo nominato). Nam qmark style,parametrioportet esse *seriesquorum longitudo aequare debet numero placeholders , vel aProgrammingError sublimatur. Pro nomine dicta;parametridebet esse instantia a *dict (vel genus), quae claves pro omnibus parametris nominatis contineri debet; quid extra items neglecta sunt. Utriusque generis exemplum est hic:

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

PEP 249numerorum placeholders suntnot subnixa. Si usus, locatores nominatos interpretabuntur.

Quomodo accommodare morem Pythonis rationes ad valores SQLite

SQLite tantum limitata copia notitiarum typi native sustinet. Morem Pythonis typi in SQLite databases condere;accommodaread unumPython types SQLite pater intelligit.

Dupliciter modis Python obiectis SQLite generibus accommodare: rem tuam ad se accommodare, vel ad rem uterenibh callable . Hoc potius est supra illud. Bibliothecam enim, quae typum consuetudinis exportat, potest sensum efficere ut id genus se accommodet. Ut elit applicatio, plus sensus potest capere directum imperium subcriptio consuetudinum functionum adaptorum.

Quomodo scribere aptabilia

Puta nos aPointgenus, quod est par coordinatarum;xety , in coordinatione Cartesiana. Coniugatio coordinata ut chorda textualis in datorum reponetur, semicolon adhibita ad coordinatas separandas. Hoc potest impleri addendo a__conform__(self, protocol) modum, quo ad valorem accommodatum refert. Obiectum Transierunt toprotocolerit generisParaProtocol.

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

Quomodo subcriptio nibh callables

Altera possibilitas est creare munus quod Python obiectum in SQLite-compatible speciei convertit. Munus hoc potest postea uti descripseruntregister_adapter ().

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

Quomodo convertendi SQLite valores ad usum Pythonis typi?

Scribens nibh sinit te convertee*consuetudo Python typesto SQLite notula. Posse convertie*SQLite valuestoconsuetudo Pythonis typi utimurconverters.

Eamus adPoint classis. Condidimus coordinatas x et y per semicolonas separatas ut chordas in SQLite.

Primum munus convertentis definiemus quod chorda ut modulus acceptat et construatPointobjectum est.

Nota

Munera converter suntsemperTransierunt a *bytesobjectum, nulla materia subjecta SQLite data typo.

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

Nunc opus est diceresqlite3 cum valorem datum SQLite convertat. Hoc fit cum connectens database, utens thedetect_types " " " " " " " " "parametriconnect () . Tres sunt optiones:

Implicitum: setdetect_types " " " " " " " " "toPARSE_DECLTYPES
Explicit: setdetect_types " " " " " " " " "toPARSE_COLNAMES
Utrumque: setdetect_types " " " " " " " " "tosqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES . Nomina columnae potiores typos declarati.

Hoc exemplum implicitum et explicitum illustrat aditus;

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

Adaptor et converter recipes

Haec sectio ostendit recipes pro adaptatoribus communibus et convertentibus.

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)

Quomodo ad connexionem modi brevis

Using theexequi (), executmany (), etexecutscript ()modiConnectiongenus, codice tuo brevius scribi potest quod creare non habes (saepe superfluum)Cursor obiectis expressis. SedCursor res implicite creatae sunt et hae modi compendiaria obiecti cursorem reddunt. Hoc modo facere potesSELECTdicitur et iterare super eam directe utendo tantum una voce super "Connectionobjectum.

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

Quomodo utatur nexus contextui procurator

AConnection objectum adhiberi potest ut procurator contextus qui sponte committat vel revolvitur aperta negotia, cum corpus contextus relinquat procurator. Si corpuscum propositio sine exceptione finitur, transactio committitur. Si hoc commissum defecerit, vel si corpuswith res nihili facit exceptio, transactio revolvitur. SiautocommitisFalseres nova implicite aperitur post patrationem vel revolutionem.

Si nulla res aperta est relinquens corpuswithdicitur vel *autocommitisTrueprocurator contextus nihil agit.

Nota

Procurator contextus novam transactionem nec implicite aperit nec nexum claudit. Si procurator contextus claudendi opus est, considera utenscontextlib.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()

Quomodo operari cum SQLite URIs

URI aliquas dolis utiles includunt:

Aperi database in lege solum modus:

>>>

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

Ne implicite novum fasciculum datorum crees, si iam non est; suscitaboOperationalErrorsi potuit creare novum documentum;

>>>

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

Create in memoriam database-communi nomine:

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

Plura de hoc pluma, in indice parametrorum, inveniuntur in theSQLite URI documenta.

Quomodo creare et uti row officinas

Per defaltam,sqlite3significat ordinem atuple . Si a *tuplenon convenit tuis necessitatibus, uti potessqlite3.Rowgenus vel consuetudorow_factory " " " " " " " " " " " ".

dumrow_factoryexistit attributum tumCursoretConnectioncommendaturConnection.row_factorysic omnes cursores e nexu creati eodem versu fabricae utentur.

Rowpraebet accessum ad columnas indices et casus insensibiles nominati, minimam memoriam supra caput et effectum impulsum super atuple . UtiRowut ordo officinas, assignarerow_factorytribuere;

>>>

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

Queries nunc reverteturRowobiicit:

>>>

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

TheFROMclausula omitti potest in theSELECT editio, ut in supra gr. In hoc casu SQLite unum ordinem reddit cum columnis per expressions, ut literalibus, datis aliases definitis.expr AS alias.

Morem creare potesrow_factory " " " " " " " " " " " "redeuntem ordinem adict, nominibus columnae ad valores decisis;

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

Utendo, queries nunc revertere adictloco *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()

Sequenti ordine officinas redit anomine tuple:

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()adhiberi potest sic:

>>>

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

Cum aliquibus congruis referendo, praedicta recipe ad usum accommodari possuntdataclassaut alia consuetudine, loco a .namedtuple.

Quomodo tractandum textum encodings non-UTF-8

Per defaltam,sqlite3ususstr******************************************SQLite ad aptet cum valuesTEXT notitia generis. Hoc bene operatur in textu utf-8 inscripto, sed potest deficere in aliis scriptionibus et invalidis UTF-8. Vos can mostext_factoryut talibus tractandis.

Propter SQLite'styping flexibile, non raro occurrit cum columnis tabularumTEXT typum notitiae datae non-UTF-8 descriptas continentes, vel etiam datas arbitrarias. Ad demonstrandum, ponamus habemus database cum ISO-8859-2 (Latin-2) textum encoded, exempli gratia tabulam dictionary dictionary. Posito nunc habemus aConnectionexempli gratiaconhuic datorum adnectitur, textum Latinum-II encoded uti possumustext_factory:

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

Nam irritum UTF-8 vel arbitraria data in conditurTEXTtabulae columnae, hac arte uti potes, a thesi mutuatoUnicode HOWTO:

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

Nota

Thesqlite3modulus API chordas in quibus surrogatas non sustinet.

Vide quoque

Unicode HOWTO

Explicatio

Transactio imperium

sqlite3plures rationes offert regendi utrum, quando et quomodo transactiones datorum aperiantur et claudantur.Transaction imperium per autocommit attributumCommendatur dumTransactio control per attributum solitation_levelretinet praecellens Python 3.12 mores.

Transactio imperium per the`autocommit`attributum

Commendatur modus gubernandi res mores est perConnection.autocommitattributum, quod potissimum adhibeaturautocommitparametriconnect ().

Ut suggesserantautocommittoFalsequod importatPEP 249 negotium gestum —compliant. Hoc significat:

sqlite3ut semper aperta res efficit, utconnect (), Connection.commit(), etConnection.rollback ()implicite novam transactionem aperiet (immediate post unum pendens claudendo, pro duobus posterioribus).sqlite3ususBEGIN DEFERREDdicta cum foramen transactions.
Transactiones faciendae expresse utenscommit().
Transactions debet revolvi expressis verbis utensrollback().
Reversi implicatus fit, si database estclaudere ()-ed cum lite mutationes.

SetautocommittoTruead enable SQLite scriptorautocommit modus . Hoc modo,Connection.commit()etConnection.rollback () effectum non habent. Nota quod SQLite scriptor autocommit modus est distinctus aPEP 249-compliantConnection.autocommit tribuere; ususConnection.in_transactionad investigandum humili gradu SQLite autocommit modum.

SetautocommittoLEGACY_TRANSACTION_CONTROLexcedere transaction imperium mores adConnection.isolation_level tribuunt. VideTransactio control per attributum solitation_levelpro magis notitia.

Transactio imperium per the`isolation_level`attributum

Nota

Commendatur modus gubernandi transactions est via theautocommit tribuunt. VideTransaction imperium per autocommit attributum.

SiConnection.autocommitest profectus estLEGACY_TRANSACTION_CONTROL(Per default), transaction mores regitur utensConnection.isolation_level tribuunt. Aliter,isolation_leveleffectum non habet.

Si nexum attributumsolitudo_level "non estNone, novae operationes implicite prius aperiunturexequi ()etexecutmany ()executINSERT, UPDATE, DELETE, orREPLACE effata; pro aliis constitutionibus, nulla implicita tractatio peragitur. Uticommittere()etreverti () modos respective committere et pendere transactiones revolvere. Potes eligere underlyingSQLite mores transaction- hoc est, utrum et quod genusBEGINconstitutionibussqlite3implicite facit - per thesolitudo_level "tribuunt.

Sisolitudo_level "est profectus estNone nullae res implicitae omnino aperiuntur. Hoc relinquit in bibliotheca SQLite subiectaautocommit modus , sed etiam permittit utentem ad suam rem praestandam pertractatio expressa SQL declarationibus utens. SQLite bibliothecam autocommit modus underlying potest queried usura thein_transactiontribuunt.

Theexecutscript ()modus implicite committit aliquem transactionem pendens ante executionem scriptæ SQL datae, cuiuscumque valorissolitudo_level ".

Mutata in versione 3.6;sqlite3 ad committere apertam rem implicite coram DDL diceres. Hoc iam non est.

Mutata in versione 3.12: Commendatur modus moderandi transactions nunc per theautocommittribuunt.

Technology sharing