SQLite Tarih ve Saat: strftime, date(), datetime()

SQLite'da Aslında Tarih Tipi Yoktur

Postgres ya da MySQL'den gelen herkesin takıldığı nokta budur. SQLite'ın yalnızca beş depolama sınıfı vardır: NULL, INTEGER, REAL, TEXT, BLOB. Yani DATE, DATETIME veya TIMESTAMP diye bir şey yok. CREATE TABLE içinde created_at DATETIME yazabilirsiniz ve SQLite bunu kabul eder, ama değeri arka planda düz metin ya da sayı olarak saklar.

SQLite'ın size sunduğu şey, üç yaygın biçimi anlayan bir dizi sqlite tarih fonksiyonudur:

• ISO 8601 metin — '2026-04-23', '2026-04-23 10:15:00', '2026-04-23T10:15:00.123Z'.
• Unix timestamp — 1970-01-01 UTC'den bu yana geçen saniye sayısı, integer olarak tutulur.
• Jülyen gün numarası — MÖ 4714'ten bu yana geçen kesirli gün sayısı, real olarak tutulur.

Birini seçin ve hep ona sadık kalın. ISO 8601 metni hem en okunaklı olanı hem de string olarak doğru sıralandığı için varsayılan tercih budur.

SELECT date('now'),
       datetime('now'),
       strftime('%s', 'now'),
       julianday('now');

"Şu an"ı sormanın dört yolu — metin tarih, metin tarih-saat, Unix saniyesi ve Julian günü. Hepsi de aynı anı ifade eder.

Beş Tarih Fonksiyonu

SQLite, ihtiyacının neredeyse tamamını karşılayan beş hazır tarih fonksiyonu sunar:

• date(time, ...) — YYYY-MM-DD döndürür.
• time(time, ...) — HH:MM:SS döndürür.
• datetime(time, ...) — YYYY-MM-DD HH:MM:SS döndürür.
• julianday(time, ...) — gerçel sayı döndürür (tarih farkı hesaplamak için birebir).
• strftime(format, time, ...) — istediğiniz biçimde formatlanmış bir string döndürür.

Her biri ilk argüman olarak bir zaman değeri alır, ardından istediğiniz kadar değiştirici (modifier) string ekleyebilirsiniz.

SELECT date('2026-04-23 10:15:00')          AS just_date,
       time('2026-04-23 10:15:00')          AS just_time,
       datetime(1745402100, 'unixepoch')    AS from_unix,
       julianday('2026-04-23')              AS julian;

'unixepoch' ifadesine dikkat — bu, tarih fonksiyonlarına gelen tam sayının Julian günü değil, Unix timestamp olduğunu söyleme şeklin. Bunu yazmazsan SQLite sayıyı doğrudan Julian gün sayısı olarak yorumluyor.

strftime: Özel Tarih Formatları

İşin asıl yükünü çeken fonksiyon strftime. C veya Python'dan tanıdığınız % kodlarının aynısını burada da kullanabilirsiniz:

SELECT strftime('%Y-%m-%d',           'now') AS iso_date,
       strftime('%d/%m/%Y',           'now') AS european,
       strftime('%H:%M',              'now') AS hours_minutes,
       strftime('%Y-%m-%dT%H:%M:%fZ', 'now') AS iso_with_ms,
       strftime('%w',                 'now') AS day_of_week,
       strftime('%j',                 'now') AS day_of_year;

En sık kullanacağın kodlar:

• %Y — dört haneli yıl.
• %m — ay (01-12).
• %d — ayın günü (01-31).
• %H, %M, %S — saat, dakika, saniye.
• %w — haftanın günü (0=Pazar).
• %j — yılın kaçıncı günü (001-366).
• %s — Unix timestamp.
• %f — saniyenin ondalık kısmı (SS.SSS).

SQLite'ta bir tarihin belirli bir parçasını çekmek için de yine strftime kullanılır — ayrı bir EXTRACT ya da YEAR() fonksiyonu yoktur. İhtiyacın olan parçaya kadar formatlarsınız, sayı olarak lazımsa cast edersiniz:

SELECT strftime('%Y', '2026-04-23') AS year_text,
       CAST(strftime('%Y', '2026-04-23') AS INTEGER) AS year_num,
       CAST(strftime('%m', '2026-04-23') AS INTEGER) AS month_num;

strftime her zaman metin döndürür; sayısal karşılaştırma ya da aritmetik işlem yapmak istiyorsanız CAST(... AS INTEGER) ile sarmalamayı unutma.

Modifier'lar: Operatöre gerek kalmadan tarih hesabı

SQLite'ta tarih işlemlerini bu kadar keyifli kılan asıl özellik bu. Zaman argümanından sonra istediğiniz kadar modifier (değiştirici) dizesi geçebilirsiniz; bunlar sırayla uygulanır:

SELECT date('2026-04-23', '+7 days')              AS week_later,
       date('2026-04-23', '-1 month')             AS month_earlier,
       datetime('now', '+2 hours', '+30 minutes') AS in_two_thirty,
       date('now', 'start of month')              AS first_of_month,
       date('now', 'start of month', '+1 month', '-1 day') AS last_of_month,
       date('now', 'weekday 0')                   AS next_sunday;

Sürekli kullanacağın modifier'lar şunlar:

• '+N days', '-N days' ve aynı şekilde hours, minutes, seconds, months, years.
• 'start of day', 'start of month', 'start of year' — tarihi ilgili sınıra yuvarlar.
• 'weekday N' — bir sonraki belirtilen güne ilerletir (0=Pazar).
• 'localtime' ve 'utc' — saat dilimleri arasında dönüşüm yapar.

"Ayın son günü" numarasını — ayın başına git, bir ay ekle, bir gün çıkar — ezberlemeye değer. SQLite'ta LAST_DAY diye bir fonksiyon yok ama modifier'ları zincirleyince aynı sonucu alıyorsunuz.

UTC ve Yerel Saat

'now' her zaman UTC döndürür. Yerel saati istiyorsanız açıkça belirtmeniz gerekir:

SELECT datetime('now')              AS utc_now,
       datetime('now', 'localtime') AS local_now,
       datetime('2026-04-23 10:00:00', 'utc') AS treated_as_local_then_utc;

'localtime' değiştiricisi UTC değerini sistemin yerel saat dilimine çevirir. 'utc' değiştiricisi ise tam tersini yapar: girdiyi yerel saat olarak kabul edip UTC'ye dönüştürür.

Güvenli alışkanlık şu: her şeyi UTC olarak sakla, sadece ekrana basarken yerel saate çevir. Saklama tarafında saat dilimlerini karıştırırsanız, yılda iki kez yaz saati uygulamasıyla birlikte ortaya çıkan, bulması zor hatalarla uğraşırsınız.

SQLite Tarih Karşılaştırma ve Aralık Filtreleme

Tarihleri ISO 8601 metin formatında saklıyorsanız, karşılaştırma ve BETWEEN ifadesi sorunsuz çalışır. Çünkü ISO 8601 sözlük sırasına göre sıralandığında kronolojik sırayla aynı sonucu verir. Zaten varsayılan format olmasının asıl sebebi de bu.

CREATE TABLE orders (
    id         INTEGER PRIMARY KEY,
    customer   TEXT,
    placed_at  TEXT NOT NULL  -- ISO 8601
);

INSERT INTO orders (customer, placed_at) VALUES
    ('Ada',   '2026-04-01 09:30:00'),
    ('Boris', '2026-04-15 14:00:00'),
    ('Carla', '2026-04-23 11:45:00'),
    ('Dmitri','2026-05-02 08:15:00');

SELECT customer, placed_at
FROM orders
WHERE placed_at >= '2026-04-01'
  AND placed_at <  '2026-05-01'
ORDER BY placed_at;

Yarı açık aralık (>= başlangıç, < bitiş) kullanmak çok faydalı bir alışkanlıktır — "30'unun gece yarısı dahil mi, değil mi?" sorusunu kökten ortadan kaldırır.

"Son 7 gün" için sınırı SQLite'a hesaplatın:

CREATE TABLE orders (
    id         INTEGER PRIMARY KEY,
    customer   TEXT,
    placed_at  TEXT NOT NULL
);

INSERT INTO orders (customer, placed_at) VALUES
    ('Ada',   datetime('now', '-2 days')),
    ('Boris', datetime('now', '-10 days')),
    ('Carla', datetime('now', '-1 day')),
    ('Dmitri',datetime('now', '-30 days'));

SELECT customer, placed_at
FROM orders
WHERE placed_at >= datetime('now', '-7 days')
ORDER BY placed_at DESC;

Tarih Farkı Hesaplama

SQLite'ta DATEDIFF diye bir fonksiyon yok. Ama merak etmeyin, aşağıdaki iki yöntem işinizi fazlasıyla görür:

SELECT julianday('2026-04-23') - julianday('2026-04-01')           AS days_between,
       (julianday('2026-04-23 18:00') - julianday('2026-04-23 09:00')) * 24 AS hours_between,
       strftime('%s', '2026-04-23 18:00') - strftime('%s', '2026-04-23 09:00') AS seconds_between;

julianday() farkları gün cinsinden (ondalıklı hassasiyetle) döner; yani 24 ile çarparsanız saati, 1440 ile çarparsanız dakikayı elde edersiniz. strftime('%s', ...) farkları ise saniye cinsindendir — tam sayı istediğinde işini görür.

Tam gün sayısı istiyorsanız CAST(... AS INTEGER) ondalıklı kısmı keser:

CREATE TABLE orders (
    id         INTEGER PRIMARY KEY,
    customer   TEXT,
    placed_at  TEXT NOT NULL
);

INSERT INTO orders (customer, placed_at) VALUES
    ('Ada',   datetime('now', '-2 days')),
    ('Boris', datetime('now', '-10 days')),
    ('Carla', datetime('now', '-1 day')),
    ('Dmitri',datetime('now', '-30 days'));

SELECT customer,
       CAST(julianday('now') - julianday(placed_at) AS INTEGER) AS days_ago
FROM orders
ORDER BY days_ago;

Tarihleri Saklamak: Bir Format Seç ve Ona Sadık Kal

Aklı başında üç seçenek var, sıklık sırasına göre:

1. ISO 8601 metni (TEXT). Dump çıktılarında okunabilir, düzgün sıralanır ve tüm sqlite tarih fonksiyonlarıyla sorunsuz çalışır. Varsayılan tercihiniz bu olsun.
2. Unix saniyeleri (INTEGER). Kompakt, karşılaştırmaları hızlı, zaman dilimi belirsizliği yok. Milyonlarca kaydınız varsa tercih edin. Geri okumak için datetime(col, 'unixepoch') kullanmanız gerekecek.
3. Julian day (REAL). Yoğun tarih aritmetiği yapmıyorsanız ve tek bir sütunda saniye altı hassasiyet istemiyorsanız genelde zahmete değmez.

Yapmamanız gereken şey ise aynı sütunda formatları karıştırmak. Tarih fonksiyonları her ikisini de sessizce kabul eder; ama indeksler, sıralamalar ve karşılaştırmalar size saçma sonuçlar üretir.

-- Eklemede otomatik dolan varsayılanlar:
CREATE TABLE events (
    id          INTEGER PRIMARY KEY,
    name        TEXT NOT NULL,
    happened_at TEXT NOT NULL DEFAULT (datetime('now'))
);

INSERT INTO events (name) VALUES ('kayıt'), ('giriş');

SELECT name, happened_at FROM events;

DEFAULT (datetime('now')), SQLite'taki DEFAULT CURRENT_TIMESTAMP karşılığıdır — hiç uygulama kodu yazmadan her yeni satıra anlık UTC zamanını basar.

Zaman Aralığına Göre Gruplama

Satırları aya, haftaya ya da saate göre kümelemek istediğinizde strftime tam olarak burada parlıyor:

CREATE TABLE orders (
    id         INTEGER PRIMARY KEY,
    customer   TEXT,
    placed_at  TEXT NOT NULL
);

INSERT INTO orders (customer, placed_at) VALUES
    ('Ada',   '2026-04-01 09:30:00'),
    ('Boris', '2026-04-15 14:00:00'),
    ('Carla', '2026-04-23 11:45:00'),
    ('Dmitri','2026-05-02 08:15:00'),
    ('Ezra',  '2026-05-20 17:00:00');

SELECT strftime('%Y-%m', placed_at) AS month,
       COUNT(*)                     AS order_count
FROM orders
GROUP BY month
ORDER BY month;

Aynı mantığı "saatlik sipariş sayısı", "haftanın gününe göre kayıt olanlar" veya "dakika başına olay sayısı" gibi sorgulara da uygulayabilirsiniz — ihtiyacınız olan ayrıntı düzeyini yakalayan bir format string seçin, ona göre gruplayın ve toplama yapın.

Sırada: Aggregate Fonksiyonlar

Madem gruplamadan bahsettik — yukarıdaki COUNT(*), SQLite'ın aggregate fonksiyonları arasında en basit olanıdır. Bir sonraki konuda bunların tamamına bakacağız: SUM, AVG, MIN, MAX ve birden çok satırı tek bir özet değere nasıl indirgediklerine.