Python’da veritabanı: sqlite3

Standart `sqlite3` modülüyle çalışmak: bağlantı ve imleç, `CREATE`/`INSERT`/`SELECT`, SQL enjeksiyonunu önleyen parametreler, `executemany`, `row_factory`, işlemler ve `with`, küçük bir kütüphane uygulaması ve SQLAlchemy’ye ilk bakış.

  • İleri
  • 22 dk
  • 12 soru
  • Ders 37 / 66

Bu derste öğreneceklerin

  • Bir veritabanına bağlanmak, tablo oluşturmak, satır eklemek ve sorgu sonuçlarını okumak
  • Değerleri yalnızca parametrelerle geçirmek ve SQL enjeksiyonunun nasıl çalıştığını açıklamak
  • executemany, fetchone/fetchall ve sqlite3.Row ile verimli çalışmak
  • Birbirine bağlı değişiklikleri bir with conn: işleminde birleştirmek

Bir okul kütüphanesi listesini bir JSON dosyasında tutuyor. Bir kitabı bulmak için bütün dosyayı okursun, bir kitabı değiştirmek için hepsini yeniden yazarsın, yazma yarıda kesilirse dosya bozulur. Bu sorunları bir veritabanı çözer, SQLite ise en basitidir: sunucu gerektirmez, bütün veritabanı tek bir dosyadır ve Python’a sqlite3 modülü olarak dahildir. SQLite telefonlarda, tarayıcılarda ve binlerce programda çalışır. SQL kursunda sorguları elle yazmıştın; şimdi onları bir Python programı çalıştıracak.

Bağlantı ve imleçTanım

Bağlantı (sqlite3.connect(...)) bir veritabanıyla açık bir bağdır: işlemleri yönetir (commit, rollback) ve kapatılmalıdır. İmleç (conn.cursor()) bir sorguyu çalıştırır ve sonuç satırlarını tek tek verir. conn.execute(...) bir imleci kendisi oluşturup döndüren kısa yoldur.

Bağlanma ve ilk tablo

sqlite3.connect('library.db') dosyayı açar (yoksa oluşturur), sqlite3.connect(':memory:') ise bellekte geçici bir veritabanı oluşturur; bağlantı kapanınca kaybolur ve örnekler için idealdir. SQL metnini execute çalıştırır. Değişiklikler conn.commit() çağrılana kadar onaylanmaz. INTEGER PRIMARY KEY sütunu yeni satırları kendisi numaralar, cur.lastrowid de bu numarayı gösterir.

Python
import sqlite3

conn = sqlite3.connect(':memory:')
cur = conn.cursor()
cur.execute('''
    CREATE TABLE books (
        id     INTEGER PRIMARY KEY,
        title  TEXT NOT NULL,
        author TEXT NOT NULL,
        year   INTEGER,
        copies INTEGER DEFAULT 1
    )
''')
cur.execute("INSERT INTO books (title, author, year) VALUES ('Ali and Nino', 'Kurban Said', 1937)")
print(cur.lastrowid, cur.rowcount)
conn.commit()

cur.execute('SELECT id, title, year, copies FROM books')
print(cur.fetchall())
conn.close()
Beklenen çıktı
1 1
[(1, 'Ali and Nino', 1937, 1)]
lastrowid 1’dir (yeni kitabın id değeri), rowcount ise değişen satır sayısıdır. copies verilmediği için DEFAULT 1 kullanıldı. Sonuç bir demet listesidir.
  1. Bağlan

    conn = sqlite3.connect('library.db'); dosya yoksa oluşturulur.

  2. Parametrelerle çalıştır

    conn.execute('... WHERE id = ?', (book_id,)); değerler yalnızca parametre olarak.

  3. Oku

    fetchone(), fetchall() ya da imleç üzerinde döngü.

  4. Onayla

    conn.commit() ya da bir with conn: bloğu.

  5. Kapat

    İş bitince conn.close().

PythonSQLite
NoneNULL
intINTEGER
floatREAL
strTEXT
bytesBLOB
Tarihleri ISO metni olarak sakla ('2026-10-03'): doğru sıralanır ve SQL’in tarih fonksiyonlarıyla çalışır.

Okumaya devam etmek için ücretsiz kaydol

Dersin geri kalan bölümleri, test ve notlar Educora hesabıyla açılır. Kayıt bir dakika sürer; ilerlemen tüm cihazlarında saklanır.

Dize birleştirme değil, parametreler

Kullanıcının girdiği değeri SQL metnine f-string ile yapıştırmak en tehlikeli hatadır. Değerde bir kesme işareti varsa dizeyi kapatır ve geri kalanı SQL kodu olarak okunur; buna SQL enjeksiyonu denir. Parametreli bir sorguda metinde yalnızca ? yer tutucuları bulunur, değerler ayrı gider ve asla kod olarak okunmaz.

Python
import sqlite3

conn = sqlite3.connect(':memory:')
conn.execute('CREATE TABLE users (name TEXT, password TEXT)')
conn.executemany('INSERT INTO users VALUES (?, ?)', [('aysel', 'x7!kL'), ('murad', 'p@ss9')])


def login_unsafe(name, password):
    sql = f"SELECT name FROM users WHERE name = '{name}' AND password = '{password}'"
    return conn.execute(sql).fetchall()


def login_safe(name, password):
    sql = 'SELECT name FROM users WHERE name = ? AND password = ?'
    return conn.execute(sql, (name, password)).fetchall()


attack = "' OR '1'='1"
print(login_unsafe('aysel', 'wrong'))
print(login_unsafe('aysel', attack))
print(login_safe('aysel', attack))
print(login_safe('aysel', 'x7!kL'))
Beklenen çıktı
[]
[('aysel',), ('murad',)]
[]
[('aysel',)]
Parolalar örneği kısa tutmak için açık saklanıyor; gerçek uygulamalar yalnızca parola özetlerini saklar. Saldırı dizesiyle güvensiz sorgu bütün kullanıcıları döndürdü.

Örnek: adım adım enjeksiyon

Problem

password = "' OR '1'='1" iken login_unsafe hangi SQL’i çalıştırır ve neden herkes girer?

Çözümü gösterÇözümü gizle

Çözüm

1) Yerine koyduktan sonra: WHERE name = 'aysel' AND password = '' OR '1'='1'.
2) AND, OR işlecinden önce değerlendirilir: (name = 'aysel' AND password = '') OR '1'='1'.
3) '1'='1' her satır için doğrudur; yani koşul bütün satırlar için doğrudur ve sorgu bütün kullanıcıları döndürür.
4) ? ile ' OR '1'='1 metni parola olarak karşılaştırılır; böyle bir parola yoktur, sonuç [] olur.

İki yer tutucu üslubu vardır: ? değerleri bir demetten sırayla, :name ise bir sözlükten ada göre alır. Dikkat: tek değerli bir demet virgülle yazılır: (author,). Virgülsüz (author) yalnızca parantez içinde bir dizedir ve Python onun her harfini ayrı bir parametre sayar. Yer tutucular yalnızca değerler içindir; tablo ve sütun adları parametreyle geçirilemez.

Python
import sqlite3

conn = sqlite3.connect(':memory:')
conn.execute('CREATE TABLE books (title TEXT, author TEXT, year INTEGER)')
conn.executemany('INSERT INTO books VALUES (:title, :author, :year)', [
    {'title': 'Animal Farm', 'author': 'George Orwell', 'year': 1945},
    {'title': 'Nineteen Eighty-Four', 'author': 'George Orwell', 'year': 1949},
    {'title': 'Robinson Crusoe', 'author': 'Daniel Defoe', 'year': 1719},
])
author = 'George Orwell'
print(conn.execute('SELECT title FROM books WHERE author = ? ORDER BY year', (author,)).fetchall())
print(conn.execute('SELECT title FROM books WHERE year > :after', {'after': 1900}).fetchall())

try:
    conn.execute('SELECT title FROM books WHERE author = ?', (author))
except sqlite3.ProgrammingError as e:
    print('ProgrammingError:', e)
Beklenen çıktı
[('Animal Farm',), ('Nineteen Eighty-Four',)]
[('Animal Farm',), ('Nineteen Eighty-Four',)]
ProgrammingError: Incorrect number of bindings supplied. The current statement uses 1, and there are 13 supplied.
'George Orwell' 13 karakterdir; virgülsüz demet 13 parametre olarak geçirildi. executemany sözlük listesiyle :title, :author ve :year adlarını doldurdu.

Sonuçları okumak: fetch metotları ve row_factory

Bir imleç üzerinde dolaşılabilir: for row in conn.execute(...) satırları tek tek verir ve büyük sonuçlarda bellekten tasarruf eder. fetchone() bir sonraki satırı ya da satır kalmayınca None döndürür, fetchall() ise kalan bütün satırları liste olarak döndürür. executemany tek bir komutu listenin her elemanı için tekrarlar; binlerce satır eklemenin en hızlı yoludur. Varsayılan olarak satır bir demettir; conn.row_factory = sqlite3.Row atadıktan sonra sütunlara adla erişilebilir: row['title'], dict(row).

Python
import sqlite3

books = [
    ('Ali and Nino', 'Kurban Said', 1937, 3),
    ('The Little Prince', 'Antoine de Saint-Exupéry', 1943, 5),
    ('Robinson Crusoe', 'Daniel Defoe', 1719, 2),
    ('Animal Farm', 'George Orwell', 1945, 4),
    ('Nineteen Eighty-Four', 'George Orwell', 1949, 0),
]
conn = sqlite3.connect(':memory:')
conn.execute('CREATE TABLE books (id INTEGER PRIMARY KEY, title TEXT, author TEXT, year INTEGER, copies INTEGER)')
cur = conn.executemany('INSERT INTO books (title, author, year, copies) VALUES (?, ?, ?, ?)', books)
print('inserted:', cur.rowcount)

conn.row_factory = sqlite3.Row
for row in conn.execute('SELECT id, title, year FROM books WHERE year < ? ORDER BY year', (1940,)):
    print(row['id'], row['title'], row['year'])

row = conn.execute('''SELECT author, COUNT(*) AS n, SUM(copies) AS total FROM books
                      GROUP BY author ORDER BY n DESC, author LIMIT 1''').fetchone()
print(dict(row), row.keys())
print(conn.execute('SELECT title FROM books WHERE copies = 99').fetchone())
Beklenen çıktı
inserted: 5
3 Robinson Crusoe 1719
1 Ali and Nino 1937
{'author': 'George Orwell', 'n': 2, 'total': 4} ['author', 'n', 'total']
None
row_factory bağlantıya atanır ve sonraki sorguları etkiler. Uygun satır yoksa fetchone() None döndürür; bunu her zaman denetle.
Metot / öznitelikNe yapar
conn.execute(sql, params)bir komutu çalıştırır, imleç döndürür
conn.executemany(sql, seq)komutu dizinin her elemanı için tekrarlar
conn.executescript(text); ile ayrılmış birkaç komutu çalıştırır (parametresiz)
fetchone(), fetchall(), fetchmany(n)bir satır / hepsi / n satır
cur.lastrowid, cur.rowcountson eklenen satırın id değeri / değişen satır sayısı
conn.commit(), conn.rollback(), conn.close()onayla / geri al / kapat

İşlemler ve with

İşlem (transaction)Tanım

“Ya hepsi ya hiçbiri” ilkesiyle yürütülen bir değişiklikler grubu. COMMIT hepsini birden onaylar, ROLLBACK hepsini hiç olmamış gibi iptal eder. Para transferi klasik örnektir: bir hesaptan düşmek ve diğerine eklemek birlikte gerçekleşmelidir.

Varsayılan olarak sqlite3 modülü INSERT, UPDATE ve DELETE öncesinde işlemi kendisi açar, onu commit() ile bitirmek ise sana düşer. En rahat yol bir with conn: bloğudur: blok hatasız biterse COMMIT, bir istisna olursa ROLLBACK yapılır. Ama bağlantı açık kalır; onu close() ya da contextlib.closing ile kapat («Bağlam yöneticileri ve with deyimi» dersine bak). Kuramı SQL kursunun «İndeksler, görünümler ve işlemler» dersindedir.

Python
import sqlite3

conn = sqlite3.connect(':memory:')
conn.execute('''CREATE TABLE accounts (
    name TEXT PRIMARY KEY,
    balance INTEGER NOT NULL CONSTRAINT non_negative CHECK (balance >= 0))''')
with conn:
    conn.executemany('INSERT INTO accounts VALUES (?, ?)', [('Aysel', 100), ('Murad', 50)])


def transfer(src, dst, amount):
    try:
        with conn:    # one transaction: COMMIT on success, ROLLBACK on an error
            conn.execute('UPDATE accounts SET balance = balance + ? WHERE name = ?', (amount, dst))
            conn.execute('UPDATE accounts SET balance = balance - ? WHERE name = ?', (amount, src))
        print(f'{src} -> {dst}: {amount} OK')
    except sqlite3.IntegrityError as e:
        print(f'{src} -> {dst}: {amount} cancelled ({e})')


transfer('Aysel', 'Murad', 30)
transfer('Murad', 'Aysel', 500)
print(conn.execute('SELECT * FROM accounts ORDER BY name').fetchall())
conn.close()
Beklenen çıktı
Aysel -> Murad: 30 OK
Murad -> Aysel: 500 cancelled (CHECK constraint failed: non_negative)
[('Aysel', 70), ('Murad', 80)]
İkinci transferde Aysel 500 aldı, sonra Murad’ın bakiyesi eksiye düşecekti ve CHECK kısıtlaması IntegrityError verdi. with bir ROLLBACK yaptı; bu yüzden Aysel’e çoktan yazılmış 500 de iptal edildi.

Mini uygulama: kütüphane

Bütün parçaları birleştirelim. connect dosyayı açar ve tabloları CREATE TABLE IF NOT EXISTS ile hazırlar, borrow ise kitabın stok sayısını denetler, azaltır ve ödünç kaydını tek bir işlemde yazar. Sonunda bağlantı kapatılır ve yeniden açılır: veriler dosyada kalmıştır.

Python
import sqlite3


def connect(path):
    conn = sqlite3.connect(path)
    conn.row_factory = sqlite3.Row
    conn.executescript('''
        CREATE TABLE IF NOT EXISTS books (id INTEGER PRIMARY KEY, title TEXT UNIQUE NOT NULL,
                                          copies INTEGER NOT NULL CHECK (copies >= 0));
        CREATE TABLE IF NOT EXISTS loans (book_id INTEGER REFERENCES books (id), reader TEXT NOT NULL);
    ''')
    return conn


def borrow(conn, title, reader):
    with conn:
        book = conn.execute('SELECT id, copies FROM books WHERE title = ?', (title,)).fetchone()
        if book is None or book['copies'] == 0:
            return f'{reader}: {title!r} is not available'
        conn.execute('UPDATE books SET copies = copies - 1 WHERE id = ?', (book['id'],))
        conn.execute('INSERT INTO loans VALUES (?, ?)', (book['id'], reader))
    return f'{reader} borrowed {title!r}'


conn = connect('library.db')
with conn:
    conn.executemany('INSERT INTO books (title, copies) VALUES (?, ?)',
                     [('Ali and Nino', 1), ('The Little Prince', 2)])
for reader, title in [('Aysel', 'Ali and Nino'), ('Murad', 'Ali and Nino'), ('Leyla', 'Dune')]:
    print(borrow(conn, title, reader))
conn.close()

conn = connect('library.db')     # a new connection: the data is still in the file
sql = '''SELECT b.title, b.copies, COUNT(l.reader) AS loans
         FROM books b LEFT JOIN loans l ON l.book_id = b.id GROUP BY b.id ORDER BY b.title'''
for row in conn.execute(sql):
    print(dict(row))
conn.close()
Beklenen çıktı
Aysel borrowed 'Ali and Nino'
Murad: 'Ali and Nino' is not available
Leyla: 'Dune' is not available
{'title': 'Ali and Nino', 'copies': 0, 'loans': 1}
{'title': 'The Little Prince', 'copies': 2, 'loans': 0}
LEFT JOIN ödünç verilmemiş kitapları da gösterir (loans 0). Tarayıcıda library.db her çalıştırmada boş bir klasörde yeniden oluşturulur.

Proje büyüdükçe SQL dizeleri, sütun adlarını elle kopyalamak ve satırları nesnelere çevirmek yorucu olur. SQLAlchemy aynı işi Python sınıflarıyla yapar ve SQLite’tan PostgreSQL’e geçince de aynı kod çalışmaya devam eder. Karşılaştır (ayrıntılar «SQLAlchemy: ORM ile veritabanı» dersinde):

sqlite3

rows = conn.execute(
    'SELECT title, year FROM books WHERE author = ? ORDER BY year',
    ('George Orwell',),
).fetchall()

SQLAlchemy

stmt = (select(Book.title, Book.year)
        .where(Book.author == 'George Orwell')
        .order_by(Book.year))
rows = session.execute(stmt).all()
İkisi de parametreli SQL gönderir; ORM’de Book tabloyu tanımlayan bir sınıftır, session ise bağlantıyı ve işlemi yönetir.

Alıştırma

products listesini tek bir executemany çağrısıyla tabloya ekle. Sonra fiyatı 10’dan az olan ve stokta bulunan (stock > 0) ürünlerin adını ve fiyatını en ucuzdan başlayarak seç ve her satırı name: price biçiminde yazdır. Sınır değerini (10) parametre olarak geçir.

Alıştırma · Python
import sqlite3

products = [('pen', 1.5, 120), ('notebook', 3.2, 0), ('backpack', 45.0, 7),
            ('ruler', 0.8, 60), ('calculator', 18.9, 12)]
conn = sqlite3.connect(':memory:')
conn.execute('CREATE TABLE products (name TEXT, price REAL, stock INTEGER)')
# 1) insert all products with one executemany call
# 2) select name and price of the products cheaper than 10 that are in stock, cheapest first
# 3) print every row as "name: price"
Beklenen çıktı
ruler: 0.8
pen: 1.5

Alıştırma

sell(name, qty) tek bir işlemde sales tablosuna bir satış satırı eklemeli ve stock içindeki miktarı azaltmalı. Stok 0’ın altına düşecekse (CHECK hatası) hiçbir şey değişmemeli ve fonksiyon False döndürmeli; başarıda True döndürmeli.

Alıştırma · Python
import sqlite3

conn = sqlite3.connect(':memory:')
conn.execute('CREATE TABLE stock (name TEXT PRIMARY KEY, qty INTEGER CHECK (qty >= 0))')
conn.execute('CREATE TABLE sales (name TEXT, qty INTEGER)')
conn.executemany('INSERT INTO stock VALUES (?, ?)', [('pen', 5), ('ruler', 2)])
conn.commit()


def sell(name, qty):
    # in ONE transaction: add a row to sales and reduce the stock;
    # if the stock would drop below 0, nothing may change and the function returns False
    return False


print(sell('pen', 3), sell('ruler', 5), sell('pen', 2))
print(conn.execute('SELECT * FROM stock ORDER BY name').fetchall())
print(conn.execute('SELECT * FROM sales').fetchall())
Beklenen çıktı
True False True
[('pen', 0), ('ruler', 2)]
[('pen', 3), ('pen', 2)]

Unutma

  • sqlite3.connect(path) bir dosyayı, ':memory:' geçici bir veritabanını açar; conn.execute bir imleç döndürür.
  • Değerleri her zaman ? ya da :name parametreleriyle geçir; tek değerli demet (x,) biçimindedir.
  • fetchone() (ya da None), fetchall() veya imleç üzerinde döngü; sqlite3.Row sütunlara adla erişim sağlar.
  • executemany birçok satırı tek çağrıyla ekler.
  • with conn: başarıda onaylar, hatada geri alır ama bağlantıyı kapatmaz; commit() olmadan close() değişiklikleri kaybeder.
Bu derste bir hata ya da yanlışlık mı gördün?

Kendini test et

12 soru. Her doğru cevap XP kazandırır.

Soru 1 / 12

Soru 1 / 12. sqlite3.connect(':memory:') ne oluşturur?