changed:
-
<h1>Pysqlite</h1>
<p>Databáze jsou pro větší i menší programy velkým přínosem. Umožňují rychlejší přístup k datům a rychlejší zapisování. Od pythonu 2.5 je součástí standardní distribuce modul <a href='http://www.python.org/doc/2.5/lib/module-sqlite3.html'>sqlite3</a> (pokud používáte nižší verzi pythona, stáhněte si knihovnu na <a href='http://oss.itsystementwicklung.de/trac/pysqlite/'>oficiálních stránkách</a>), který toto umožňuje.</p>
<p>Tento modul byl napsán Gerhardem Häringen a poskytuje SQL rozhraní DB-API 2.0.</p>
<h2>Vytvoření spojení</h2>
<p>K vytvoření spojení se používá funkce <code>connect</code>. </p>
<pre>
#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
db = sqlite.connect("db")
db.commit()
db.close()
</pre>
<p>Funkce <code>connect</code> nejprve projde aktuální pracovní adresář a za předpokladu, že nalezne soubor <code>db.txt</code>, připojí se k němu. Pokud tento soubor neexistuje, bude vytvořen. Pomocí metody <code>commit()</code> se změny provedené na databázi uloží. Spojení se uzavírá pomocí metody <code>close</code>. </p>
<p>Databáze se pochopitelně může jmenovat jakkoliv, ale je zde jedno speciální pojmenování:</p>
<pre>
db = sqlite.connect(":memory:")
</pre>
<p>Předchozí příklad vytvoří databázi v RAMce. </p>
<h3>Vytvoření tabulky</h3>
<p>Jakmile otevřeme spojení s databází, můžeme na ní vykonávat standardní SQL příkazy pomocí metody <code>execute</code>:</p>
<pre>
#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
db = sqlite.connect("db")
db.execute("create table osoby(jmeno, prijmeni)") 
db.commit()
db.close()
</pre>
<h3>Zapisování do databáze</h3>
<p>Zapisování do tabulky se také pochopitelně provádí pomocí metody <code>execute</code>:</p>
<pre>
#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
db = sqlite.connect("db")
db.execute("create table osoby(jmeno, prijmeni)") 
db.execute("insert into osoby(jmeno, prijmeni) values('Jakub', 'Vojáček')")
db.commit()
db.close()
</pre>
<p>Při zapisování jsme jako hodnoty použili <code>'Jakub', 'Vojáček'</code>. V opravdovém programu ale budeme většinou chtít zapisovat hodnotu nějakých proměnných. Dalo by se to vyřešit takto:</p>
<pre>
jmeno = 'Jakub'
prijmeni = 'Vojáček'
db.execute("insert into osoby(jmeno, prijmeni) values('%s', '%s')" % (jmeno, prijmeni))
</pre>
<p>Předchozí způsob sice funguje, ale není to doporučený způsob, protože je zranitelný vůči SQL injekci. Pysqlite poskytuje dva možné způsob, jak vložit proměnné do sql příkazu:</p>
<pre>
jmeno = 'Jakub'
prijmeni = 'Vojáček'
db.execute("insert into osoby(jmeno, prijmeni) values(?, ?)", (jmeno, prijmeni))
</pre>
<p>Další způsob je:</p>
<pre>
jmeno = 'Jakub'
prijmeni = 'Vojáček'
db.execute("insert into osoby(jmeno, prijmeni) values(:jmeno, :prijmeni)", {"jmeno" : jmeno, "prijmeni" : prijmeni})
</pre>
<h3>Čtení dat z databáze</h3>
<p>Pro přečtení dat z databáze se opět používá metoda <code>execute</code>:</p>
<pre>
#-*- coding: utf-8 -*-
#Předpokládá se, že v tabulce osoby máte uloženy nějaké údaje
from sqlite3 import dbapi2 as sqlite
db = sqlite.connect("db")
vystup = db.execute("select * from osoby")
print vystup
db.commit()
db.close()
</pre>
<p>Místo očekávaného výstupu na nás vybaflo <code>&lt;sqlite3.Cursor object at 0x00A43560&gt;</code>. To pro nás ale pochopitelně není žádná překážka. Nyní je více možností, jak získat data. Buď můžeme použít metodu <code>fetchall</code>, nebo využít toho, že <code>vystup</code> je iterovatelný. </p>
<pre>
vystup = db.execute("select * from osoby")
print vystup.fetchall()
#Výstup:
[(u'Jakub', u'Voj\xe1\u010dek'), (u'Pavel', u'Kosina')]
</pre>
<p>Výstup je nyní daleko srozumitelnější. Ještě si ukážeme druhý způsob, jak přečíst data z databáze:</p>
<pre>
#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
db = sqlite.connect("db")
vystup = db.execute("select * from osoby")
for zaznam in vystup:
    print zaznam
vystup = db.execute("select * from osoby")
print 
for jmeno, prijmeni in vystup:
    print jmeno, prijmeni
db.commit()
db.close()
</pre>
<p>V tomto případě je výstup:</p>
<pre>
(u'Jakub', u'Voj\xe1\u010dek')
(u'Pavel', u'Kosina')

Jakub Vojáček
Pavel Kosina
</pre>
<h2>Další funkce</h2>
<p>Nyní se dá říci, že už znáte všechny základní funkce této knihovny. Nicméně tento modul umí několik dalších funkcí, které by vám mohli ušetřit práci.</p>
<h3>executescript(sql_skript)</h3>
<p>Pomocí tohoto příkazu se dá spustit více SQL příkazů najednou. </p>
<pre>
#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
db = sqlite.connect("db")
db.executescript('''
create table osoby(jmeno, prijmeni);
insert into osoby values('jakub', 'vojacek');
create table mesta(jmeno);
insert into mesta values('Praha');
insert into mesta values('Brno');
''')
db.commit()
db.close()
</pre>
<h3>executemany(sql, sekvence)</h3>
<p>Provede sql příkaz pro všechny části dané sekvence.</p>
<pre>
#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite

class Cisla:
    def __init__(self):
        self.cislo = 0
    def __iter__(self):
        return self
    def next(self):
        if self.cislo == 100:
            raise StopIteration
        self.cislo = self.cislo + 1
        return (self.cislo, )

db = sqlite.connect("db")
db.execute("create table cisla(cislo)")
cisla = Cisla()
db.executemany("insert into cisla values(?)", cisla)
for cislo in db.execute("select * from cisla"):
    print cislo
db.commit()
db.close()
</pre>
<h3>fetchone()</h3>
<p>Pokud víte, že SELECT vrátil pouze jeden řádek tabulky, můžete použít metodu <code>fetchone</code> místo <code>fetchall()</code>. Jediný rozdíl je v tom, že <code>fetchone</code> vrací n-tici, zatímco <code>fetchall</code> vrací seznam n-tic:</p>
<pre>
#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
db = sqlite.connect("db")
db.execute("create table cisla(cislo)")
db.executescript('''
insert into cisla values(1);
insert into cisla values(2);
''')
vystup = db.execute("select * from cisla where cislo = 1")
print vystup.fetchone()
vystup = db.execute("select * from cisla where cislo = 1")
print vystup.fetchall()
db.commit()
db.close()
</pre>
<h2>Datové typy</h2>
<p>Do databáze pochopitelně nemůžete uložit instance Tkinteru apod. V následující tabulce naleznete seznam všech povolených datových typů + jak je reprezentuje SQLite.</p>
<table border = '1' width = '100%'>
	<tr>
		<td><strong>Python</strong></td>
		<td><strong>SQL</strong></td>
	</tr>
	<tr>
		<td>None</td>
		<td>NULL</td>
	</tr>
	<tr>
		<td>int</td>
		<td>INTEGRER</td>
	</tr>
<tr>
		<td>long</td>
		<td>INTEGRER</td>
	</tr>
<tr>
		<td>float</td>
		<td>REAL</td>
	</tr>
<tr>
		<td>str</td>
		<td>TEXT</td>
	</tr>
<tr>
		<td>unicode</td>
		<td>Text</td>
	</tr>
<tr>
		<td>buffer</td>
		<td>BLOB</td>
	</tr>
</table>
<p>V následující tabulce naleznete, jak se datové typy SQLite reprezentují v Pythonu.</p>
<table border = '1' width = '100%'>
	<tr>
		<td><strong>SQL</strong></td>
		<td><strong>Python</strong></td>
	</tr>
	<tr>
		<td>NULL</td>
		<td>None</td>
	</tr>
	<tr>
		<td>INTEGRER</td>
		<td>int nebo long (záleží na velikosti)</td>
	</tr>
        <tr>
		<td>REAL</td>
		<td>float</td>
	</tr>
        <tr>
		<td>TEXT</td>
		<td>záleží na tom, jak je nastaveno <code>text_factory</code> (standardně je nastaveno unicode)</td>
	</tr>
        <tr>
		<td>BLOB</td>
		<td>buffer</td>
	</tr>
</table>
<h3>text_factory</h3>
<p>V předchozí tabulce jsem se zmínil o <code>text_factory</code>. Pomocí tohoto parametru lze určit, jaký datový typ bude vrácen po SELECTu na SQLite typ <code>TEXT</code>. </p>
<pre>
#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
db = sqlite.connect("db")
text = u"ěščřžýáíé"
print u"Původní typ: ", type(text)
vystup = db.execute("select ?", (text, ))
print u"Vrácený typ: ", type(vystup.fetchone()[0])
db.commit()
db.close()
</pre>
<p>Standardně se jedná o <code>unicode</code>, ale je možné, že budete chtít výstup změnit například na <code>str</code>:</p>
<pre>
#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
db = sqlite.connect("db")
db.text_factory = str
text = u"ěščřžýáíé"
print u"Původní typ: ", type(text)
vystup = db.execute("select ?", (text, ))
print u"Vrácený typ: ", type(vystup.fetchone()[0])
db.commit()
db.close()
</pre>
<p>Parametru <code>text_factory</code> můžeme pochopitelně přiřadit i jinou hodnotu než <code>str, unicode</code>. Může to být například vámi definovaná funkce:</p>
<pre>
#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
db = sqlite.connect("db")
db.text_factory = lambda x: unicode(x, "utf-8", "ignore")
text = u"\xe4\xf6\xfc".encode("latin1")
print u"Původní typ: ", type(text)
vystup = db.execute("select ?", (text, ))
print u"Vrácený typ: ", type(vystup.fetchone()[0])
db.commit()
db.close()
</pre>
<p>Pokud bychom nepoužili <code>lambda x: unicode(x, "utf-8", "ignore")</code>, ale pouze <code>unicode</code>, dostali bychom chybu:</p>
<pre>
Traceback (most recent call last):
  File "C:\Documents and Settings\Blujacker\Plocha\a.py", line 6, in &lt;module&gt;
    vystup = db.execute("select ?", (text, ))
OperationalError: Could not decode to UTF-8 column '?' with text 'äöü'
</pre>
<p>Tím, že jsme jako třetí parametr funkce <code>unicode</code> nastavili <code>"ignore"</code>, jsme pythonu řekli, aby znaky, které se mu nepodařilo dekódovat ignoroval.</p>
<p>Tento parametr může nabývat jedné speciální hodnoty: <code>OptimizedUnicode</code>. Pokud je <code>text_factory</code> rovna právě této hodnotě, tak python vrátí <code>unicode</code> pouze v případě, že se jedná o <code>non-ASCI</code> data. V ostatních případech vrátí <code>str</code>:</p>
<pre>
#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
from sqlite3 import OptimizedUnicode
db = sqlite.connect("db")
db.text_factory = OptimizedUnicode
text = u"str"
print u"Původní typ: ", type(text)
vystup = db.execute("select ?", (text, ))
print u"Vrácený typ: ", type(vystup.fetchone()[0])
db.commit()
db.close()
</pre>
<p>V předchozí ukázce nebylo třeba, aby vrácená data byla <code>unicode</code>.</p>
<pre>
#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
from sqlite3 import OptimizedUnicode
db = sqlite.connect("db")
db.text_factory = OptimizedUnicode
text = u"ěšč"
print u"Původní typ: ", type(text)
vystup = db.execute("select ?", (text, ))
print u"Vrácený typ: ", type(vystup.fetchone()[0])
db.commit()
db.close()
</pre>
<p>Datový typ výstupu je <code>unicode</code>.</p>
<h2>create_function</h2>
<p>Modul pysqlite podporuje vytváření vlastních funkcích, které pak můžete použít v SQL příkazu.</p>
<p>Funkce se vytvářejí pomocí metody <code>create_function(jmeno, pocet_parametru, funkce)</code>. Pomocí parametru <code>jmeno</code> můžete později zavolat danou <code>funkci</code.> z SQL příkazu. Proměnná <code>pocet_parametru</code> určuje, kolik parametru přijímá daná funkce.</p>
<pre>
#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
import md5
db = sqlite.connect("db")
def md5sum(t):
    return md5.md5(t).hexdigest()
db.create_function("md5", 1, md5sum)
db.execute("create table hesla(heslo)")
db.execute("insert into hesla values(md5(?))", ("foo", ))
vystup = db.execute("select * from hesla")
print vystup.fetchone()[0]
db.commit()
db.close()
</pre>
<p>Výstup je <code>acbd18db4cc2f85cedef654fccc4a4d8</code>.</p>
<h2>create_aggregate</h2>
<p>Další funkce pysqlite je vytvoření vlastního agregátu. Děje se tak pomocí metody <code>create_aggregate(jmeno, pocet_parametru, trida)</code>. Daná <code>trida</code> musí mít definovanou metodu <code>step</code>, která bude přijímat <code>pocet_parametru</code> parametru. Dále musí být také definována metoda <code>finalize</code>, která vrátí konečný výsledek.</p>
<p>Jako příklad nám může posloužit například výpočet faktoriálu.</p>
<pre>
#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
db = sqlite.connect("db")
class Faktorial:
    def __init__(self):
        self.cislo = 1

    def step(self, hodnota):
        self.cislo = self.cislo * hodnota

    def finalize(self):
        return self.cislo

db.create_aggregate("faktorial", 1, Faktorial)
db.execute("create table cisla(cislo)")
db.executescript('''
insert into cisla values(1);
insert into cisla values(2);
insert into cisla values(3);
insert into cisla values(4);
insert into cisla values(5);
''')
vystup = db.execute("select faktorial(cislo) from cisla")
print vystup.fetchone()[0]
db.commit()
db.close()
</pre>
<p>Faktoriál čísla 5 je 120.</p>
<h2>create_collation</h2>
<p>Pysqlite umožňuje vytváření vlastních řadících mechanismů. Děje se to pomocí metody <code>create_collation(jmeno, funkce)</code>. Daná <code>funkce</code> musí přijímat dva parametry a měla by vrátit <code>-1</code>, pokud je první parametr řazen níže než druhý, <code>0</code> pokud jsou parametry na stejné úrovni a <code>1</code> pokud je první řazen výše než druhý.</p>
<pre>
#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
db = sqlite.connect("db")
def obrazene_razeni(parametr1, parametr2):
    return -cmp(parametr1, parametr2)
    
db.create_collation("obracene", obrazene_razeni)

db.execute("create table pismena(pismeno)")
db.executescript('''
insert into pismena values('a');
insert into pismena values('b');
insert into pismena values('c');
''')
vystup = db.execute("select pismeno from pismena order by pismeno collate obracene")
for pismeno in vystup:
    print pismeno
db.commit()
db.close()
</pre>
<p>Vytvořili jsme "obrácené" řazení.</p>
<h2>Nastavování práv</h2>
<p>Pysqlite dovoluje nastavit, jaké operace jsou dovoleny a jaké zakázány. Složí k tomu funkce <code>set_authorizer(funkce)</code>. Daná <code>funkce</code> musí přijímat 5 parametrů: <code>action, arg1, arg2, dbname, source</code>.</p>
<p>První parametr <code>action</code> určuje o jaký typ operace se jedná. V následující tabulce naleznete ty nejdůležitější akce + hodnoty parametrů <code>arg1, arg2</code></p>
<table border = '1' width = '100%'>
	<tr>
		<td><strong>Akce</strong></td>
		<td><strong>Význam</strong></td>
                <td><strong>arg1</strong></td>
                <td><strong>arg2</strong></td>
	</tr>
	<tr>
		<td>sqlite.SQLITE_DELETE</td>
		<td>Smazání nějakého řádku tabulky</td>
		<td>tabulka, z které se mazalo</td>
		<td>None</td>
	</tr>
	<tr>
		<td>sqlite.SQLITE_CREATE_TABLE</td>
		<td>Vytvoření tabulky</td>
		<td>jméno vytvořené tabulky</td>
		<td>None</td>
	</tr>
        <tr>
		<td>sqlite.SQLITE_INSERT</td>
		<td>Vložení záznamu do tabulky</td>
		<td>jméno dané tabulky</td>
		<td>None</td>
	</tr>
        <tr>
		<td>sqlite.SQLITE_SELECT</td>
		<td>Přečtení dat z tabulky</td>
		<td>None</td>
		<td>None</td>
	</tr>
</table>
<p>Funkce musí vrátit, zda má uživatel právo právo provést daný příkaz. Pokud má, návratová hodnota je <code>sqlite.SQLITE_OK</code>, pokud nemá, tak je návratová hodnota rovna <code>sqlite.SQLITE_DENY</code>. Pokud bude vrácena hodnota <code>sqlite.SQLITE_DENY</code>, bude vyvolána vyjímka <code>sqlite3.DatabaseError: not authorized</code> a pokud nebude ošetřena, program spadne. Toto se dá obejít pomocí návratové hodnoty <code>sqlite.SQLITE_IGNORE</code>.</p>
<pre>
#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
db = sqlite.connect("db")
def authorizer_callback(action, arg1, arg2, dbname, source):
    if action == sqlite.SQLITE_DELETE and arg1 == "sql_master":
        print u"Nemáte právo mazat tabulky!"
        return sqlite.SQLITE_DENY
    elif action == sqlite.SQLITE_DELETE:
        print u"Nemáte právo mazat položky z tabulky!"
        return sqlite.SQLITE_DENY
    elif action == sqlite.SQLITE_INSERT and arg1 == "soukroma_tabulka":
        print u"Nemáte právo zapisovat do tabulky 'soukroma_tabulka'"
        return sqlite.SQLITE_IGNORE
    return sqlite.SQLITE_OK
    
db.set_authorizer(authorizer_callback)
db.execute("create table tabulka(polozka)")
db.execute("create table soukroma_tabulka(polozka)")
db.execute("insert into tabulka values('zkouska')")
db.execute("insert into soukroma_tabulka values('zkouska')")#Příkaz se neprovede, ale program běží dál
db.execute("delete from tabulka where polozka = 'zkouska'")#Příkaz se neprovede, ale program běží dál
db.execute("drop table tabulka")
print "Sem se program nikdy nedostane..."
db.commit()
db.close()
</pre>

<h2>Ukládání jiných datových typů</h2>
<p>Do databáze můžete, pokud se budete trochu snažit, uložit i jiné datové typy, než které jsem uváděl v předešlé tabulce. Správně řečeno, mi tam nemůžeme uložit jiné datové typy, ale můžeme naučit pysqlite jak daný objekt převést na některý z podporovaných datových typů. Mohli bychom chtít například uložit následující třídu:</p>
<pre>
class Bod:
    def __init__(self, x, y):
        self.x, self.y = x, y
</pre>
<p>Abychom tuto třídu mohli uložit, musíme jí přidat metodu <code>__conform__</code>, která vrátí převedenou hodnotu třídy. V našem případě by to tedy mohlo být například <code>"%f;%f" % (self.x, self.y)</code>.</p>
<pre>
#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
db = sqlite.connect("db")
class Bod:
    def __init__(self, x, y):
        self.x, self.y = x, y
    def __conform__(self, protocol):
        if protocol == sqlite.PrepareProtocol:
            return "%f;%f" % (self.x, self.y)
bod = Bod(4.0, -3.2)
vysledek = db.execute("select ?", (bod,))
print vysledek.fetchone()[0]        
db.commit()
db.close()
</pre>
<p>Je zde ještě jedno možné řešení. Řešení v němž bychom nemuseli vytvářet metodu <code>__conform__</code>. My můžeme zaregistrovat adaptér pomocí metody <code>register_adapter(objekt, funkce)</code>:</p>
<pre>
#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite

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

def uprav_bod(bod):
    return "%f;%f" % (bod.x, bod.y)
sqlite.register_adapter(Bod, uprav_bod)

db = sqlite.connect("db")
bod = Bod(4.0, -3.2)
vysledek = db.execute("select ?", (bod,))
print vysledek.fetchone()[0]        
db.commit()
db.close()
</pre>
<p>Pozor, <code>objekt</code> (tedy první parametr metody <code>register_adapter</code>) musí vždy dědit z <code>object</code>.</p>
<h2>Přeměna SQLite datových typů</h2>
<p>V jedné z předchozích tabulek bylo jasně vidět, že SQLite vrací výsledky v následujících datových typech: <code>None</code>, <code>int</code>, <code>long</code>, <code>float</code>, <code>buffer</code> a <code>unicode</code>. My můžeme pysqlite naučit, jak vrátit i jiný datový typ. V předchozím příkladě jsme ukládali třídu <code>Bod</code> do databáze jako řetězec a jako řetězec jsme ji také četli. My ale můžeme pomocí metody <code>register_converter(jmeno, funkce)</code> donutit pysqlite aby vrátila jeho správnou reprezentaci (tedy instanci třídy Bod).</p>
<pre>
#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite

class Bod(object):
    def __init__(self, x, y):
        self.x, self.y = x, y
    def __repr__(self):
        return u"Bod(%f;%f)" % (self.x, self.y)
def uprav_bod(bod):
    return "%f;%f" % (bod.x, bod.y)
def premen_bod(s):
    x, y = map(float, s.split(";"))
    return Bod(x, y)
sqlite.register_adapter(Bod, uprav_bod)
sqlite.register_converter("bod", premen_bod)

db = sqlite.connect("db", detect_types=sqlite.PARSE_DECLTYPES)
bod = Bod(4.0, -3.2)
print bod
db.execute('create table test(bod bod)')
db.execute("insert into test values(?)", (bod, ))
vysledek = db.execute("select bod from test")
print vysledek.fetchone()[0]
db.commit()
db.close()
</pre>
<p>Všimněte si, že když se otevírá spojení s databází, tak je přítomen navíc jeden parametr, se kterým jsme se zatím nesetkali. Tento parametr zajišťuje, aby fungovalo převádění proměnných.</p>
<h3>Další informace</h3>
<p>Další informace o této knihovně naleznete v <a href='http://oss.itsystementwicklung.de/download/pysqlite/doc/usage-guide.html'>dokumentaci pysqlite</a> a <a href='http://www.python.org/doc/2.5/lib/module-sqlite3.html'>oficiální dokumentaci pythona</a>.</p>

#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
db = sqlite.connect("db")
db.commit()
db.close()

db = sqlite.connect(":memory:")

#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
db = sqlite.connect("db")
db.execute("create table osoby(jmeno, prijmeni)") 
db.commit()
db.close()

#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
db = sqlite.connect("db")
db.execute("create table osoby(jmeno, prijmeni)") 
db.execute("insert into osoby(jmeno, prijmeni) values('Jakub', 'Vojáček')")
db.commit()
db.close()

jmeno = 'Jakub'
prijmeni = 'Vojáček'
db.execute("insert into osoby(jmeno, prijmeni) values('%s', '%s')" % (jmeno, prijmeni))

jmeno = 'Jakub'
prijmeni = 'Vojáček'
db.execute("insert into osoby(jmeno, prijmeni) values(?, ?)", (jmeno, prijmeni))

jmeno = 'Jakub'
prijmeni = 'Vojáček'
db.execute("insert into osoby(jmeno, prijmeni) values(:jmeno, :prijmeni)", {"jmeno" : jmeno, "prijmeni" : prijmeni})

#-*- coding: utf-8 -*-
#Předpokládá se, že v tabulce osoby máte uloženy nějaké údaje
from sqlite3 import dbapi2 as sqlite
db = sqlite.connect("db")
vystup = db.execute("select * from osoby")
print vystup
db.commit()
db.close()

vystup = db.execute("select * from osoby")
print vystup.fetchall()
#Výstup:
[(u'Jakub', u'Voj\xe1\u010dek'), (u'Pavel', u'Kosina')]

#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
db = sqlite.connect("db")
vystup = db.execute("select * from osoby")
for zaznam in vystup:
    print zaznam
vystup = db.execute("select * from osoby")
print 
for jmeno, prijmeni in vystup:
    print jmeno, prijmeni
db.commit()
db.close()

(u'Jakub', u'Voj\xe1\u010dek')
(u'Pavel', u'Kosina')

Jakub Vojáček
Pavel Kosina

#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
db = sqlite.connect("db")
db.executescript('''
create table osoby(jmeno, prijmeni);
insert into osoby values('jakub', 'vojacek');
create table mesta(jmeno);
insert into mesta values('Praha');
insert into mesta values('Brno');
''')
db.commit()
db.close()

#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite

class Cisla:
    def __init__(self):
        self.cislo = 0
    def __iter__(self):
        return self
    def next(self):
        if self.cislo == 100:
            raise StopIteration
        self.cislo = self.cislo + 1
        return (self.cislo, )

db = sqlite.connect("db")
db.execute("create table cisla(cislo)")
cisla = Cisla()
db.executemany("insert into cisla values(?)", cisla)
for cislo in db.execute("select * from cisla"):
    print cislo
db.commit()
db.close()

#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
db = sqlite.connect("db")
db.execute("create table cisla(cislo)")
db.executescript('''
insert into cisla values(1);
insert into cisla values(2);
''')
vystup = db.execute("select * from cisla where cislo = 1")
print vystup.fetchone()
vystup = db.execute("select * from cisla where cislo = 1")
print vystup.fetchall()
db.commit()
db.close()

#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
db = sqlite.connect("db")
text = u"ěščřžýáíé"
print u"Původní typ: ", type(text)
vystup = db.execute("select ?", (text, ))
print u"Vrácený typ: ", type(vystup.fetchone()[0])
db.commit()
db.close()

#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
db = sqlite.connect("db")
db.text_factory = str
text = u"ěščřžýáíé"
print u"Původní typ: ", type(text)
vystup = db.execute("select ?", (text, ))
print u"Vrácený typ: ", type(vystup.fetchone()[0])
db.commit()
db.close()

#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
db = sqlite.connect("db")
db.text_factory = lambda x: unicode(x, "utf-8", "ignore")
text = u"\xe4\xf6\xfc".encode("latin1")
print u"Původní typ: ", type(text)
vystup = db.execute("select ?", (text, ))
print u"Vrácený typ: ", type(vystup.fetchone()[0])
db.commit()
db.close()

Traceback (most recent call last):
  File "C:\Documents and Settings\Blujacker\Plocha\a.py", line 6, in <module>
    vystup = db.execute("select ?", (text, ))
OperationalError: Could not decode to UTF-8 column '?' with text 'äöü'

#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
from sqlite3 import OptimizedUnicode
db = sqlite.connect("db")
db.text_factory = OptimizedUnicode
text = u"str"
print u"Původní typ: ", type(text)
vystup = db.execute("select ?", (text, ))
print u"Vrácený typ: ", type(vystup.fetchone()[0])
db.commit()
db.close()

#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
from sqlite3 import OptimizedUnicode
db = sqlite.connect("db")
db.text_factory = OptimizedUnicode
text = u"ěšč"
print u"Původní typ: ", type(text)
vystup = db.execute("select ?", (text, ))
print u"Vrácený typ: ", type(vystup.fetchone()[0])
db.commit()
db.close()

#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
import md5
db = sqlite.connect("db")
def md5sum(t):
    return md5.md5(t).hexdigest()
db.create_function("md5", 1, md5sum)
db.execute("create table hesla(heslo)")
db.execute("insert into hesla values(md5(?))", ("foo", ))
vystup = db.execute("select * from hesla")
print vystup.fetchone()[0]
db.commit()
db.close()

#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
db = sqlite.connect("db")
class Faktorial:
    def __init__(self):
        self.cislo = 1

    def step(self, hodnota):
        self.cislo = self.cislo * hodnota

    def finalize(self):
        return self.cislo

db.create_aggregate("faktorial", 1, Faktorial)
db.execute("create table cisla(cislo)")
db.executescript('''
insert into cisla values(1);
insert into cisla values(2);
insert into cisla values(3);
insert into cisla values(4);
insert into cisla values(5);
''')
vystup = db.execute("select faktorial(cislo) from cisla")
print vystup.fetchone()[0]
db.commit()
db.close()

#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
db = sqlite.connect("db")
def obrazene_razeni(parametr1, parametr2):
    return -cmp(parametr1, parametr2)
    
db.create_collation("obracene", obrazene_razeni)

db.execute("create table pismena(pismeno)")
db.executescript('''
insert into pismena values('a');
insert into pismena values('b');
insert into pismena values('c');
''')
vystup = db.execute("select pismeno from pismena order by pismeno collate obracene")
for pismeno in vystup:
    print pismeno
db.commit()
db.close()

#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
db = sqlite.connect("db")
def authorizer_callback(action, arg1, arg2, dbname, source):
    if action == sqlite.SQLITE_DELETE and arg1 == "sql_master":
        print u"Nemáte právo mazat tabulky!"
        return sqlite.SQLITE_DENY
    elif action == sqlite.SQLITE_DELETE:
        print u"Nemáte právo mazat položky z tabulky!"
        return sqlite.SQLITE_DENY
    elif action == sqlite.SQLITE_INSERT and arg1 == "soukroma_tabulka":
        print u"Nemáte právo zapisovat do tabulky 'soukroma_tabulka'"
        return sqlite.SQLITE_IGNORE
    return sqlite.SQLITE_OK
    
db.set_authorizer(authorizer_callback)
db.execute("create table tabulka(polozka)")
db.execute("create table soukroma_tabulka(polozka)")
db.execute("insert into tabulka values('zkouska')")
db.execute("insert into soukroma_tabulka values('zkouska')")#Příkaz se neprovede, ale program běží dál
db.execute("delete from tabulka where polozka = 'zkouska'")#Příkaz se neprovede, ale program běží dál
db.execute("drop table tabulka")
print "Sem se program nikdy nedostane..."
db.commit()
db.close()

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

#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite
db = sqlite.connect("db")
class Bod:
    def __init__(self, x, y):
        self.x, self.y = x, y
    def __conform__(self, protocol):
        if protocol == sqlite.PrepareProtocol:
            return "%f;%f" % (self.x, self.y)
bod = Bod(4.0, -3.2)
vysledek = db.execute("select ?", (bod,))
print vysledek.fetchone()[0]        
db.commit()
db.close()

#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite

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

def uprav_bod(bod):
    return "%f;%f" % (bod.x, bod.y)
sqlite.register_adapter(Bod, uprav_bod)

db = sqlite.connect("db")
bod = Bod(4.0, -3.2)
vysledek = db.execute("select ?", (bod,))
print vysledek.fetchone()[0]        
db.commit()
db.close()

#-*- coding: utf-8 -*-
from sqlite3 import dbapi2 as sqlite

class Bod(object):
    def __init__(self, x, y):
        self.x, self.y = x, y
    def __repr__(self):
        return u"Bod(%f;%f)" % (self.x, self.y)
def uprav_bod(bod):
    return "%f;%f" % (bod.x, bod.y)
def premen_bod(s):
    x, y = map(float, s.split(";"))
    return Bod(x, y)
sqlite.register_adapter(Bod, uprav_bod)
sqlite.register_converter("bod", premen_bod)

db = sqlite.connect("db", detect_types=sqlite.PARSE_DECLTYPES)
bod = Bod(4.0, -3.2)
print bod
db.execute('create table test(bod bod)')
db.execute("insert into test values(?)", (bod, ))
vysledek = db.execute("select bod from test")
print vysledek.fetchone()[0]
db.commit()
db.close()