Şemayı değiştirmek: ALTER TABLE ve migration'lar

Şema değişikliklerini sürümlü dosyalarla yönetmek: SQLite ve PostgreSQL'de `ALTER TABLE`, SQLite'ın 12 adımlı tablo yeniden kurulumu, sürüm tablosu, up/down migration'ları, Flyway, Liquibase, Alembic, Prisma Migrate ve kesintisiz expand–contract yöntemi.

  • İleri
  • 22 dk
  • 12 soru
  • Ders 14 / 28

Bu derste öğreneceklerin

  • Migration'ların ve sürüm tablosunun neden gerektiğini açıklamak
  • SQLite'ta ALTER TABLE komutunun yapabildiklerini ve sınırlarını bilmek, gerisi için 12 adımlı yeniden kurulumu uygulamak
  • Up/down migration dosyaları yazmak ve araçları (Flyway, Liquibase, Alembic, Prisma Migrate) tanımak
  • Bir değişikliği expand–contract yöntemiyle kesintisiz planlamak

Bir ekipte üç programcı var. Biri kendi bilgisayarında customers tablosuna phone sütunu ekliyor, öteki bir sütunun adını değiştiriyor, üçüncüsü sunucuda bir şeyi elle düzeltiyor. Bir ay sonra test ve canlı veritabanları farklıdır ve kimse bunun nasıl olduğunu bilmez. Kod Git'te sürümlerle tutulur; şema da öyle tutulmalıdır. Migration'lar tam olarak bunu yapar: her değişiklik numaralı bir SQL dosyasıdır ve her veritabanı onlardan aynı sırayla geçer. «CREATE TABLE: veri tipleri ve kısıtlamalar» dersinde ALTER TABLE ... ADD COLUMN komutunu gördük; bu ders onun sınırlarını, sınırların ötesinde ne yapılacağını ve değişikliklerin ekipte nasıl yönetileceğini gösteriyor.

Migration'lar ve sürüm tablosu

MigrationTanım

Şemayı bir sürümden sonrakine geçiren, bir numarası (sürümü) olan ve kodla birlikte Git'te tutulan betik. Uygulanmış bir migration bir daha değiştirilmez.

Veritabanı hangi migration'ların uygulandığını kendisi hatırlar: bir sürüm tablosunda. Bir migration aracı her çalıştığında aynı algoritmayı izler:

  1. Dosyaları oku

    Klasördeki migration'ları sürüme göre sırala: V1, V2, V3…

  2. Veritabanına sor

    Uygulanmış sürümleri sürüm tablosundan oku.

  3. Bekleyenleri çalıştır

    Her yeni migration'ı kendi işleminde çalıştır; hata olursa dur.

  4. Kaydet

    Başarılı migration'ın sürümünü aynı işlem içinde tabloya yaz.

SQL
CREATE TABLE schema_migrations (
  version    INTEGER PRIMARY KEY,
  name       TEXT NOT NULL,
  applied_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
);
INSERT INTO schema_migrations (version, name) VALUES (1, 'create_shop_tables');

-- V2__add_customer_phone.sql
BEGIN;
ALTER TABLE customers ADD COLUMN phone TEXT;
INSERT INTO schema_migrations (version, name) VALUES (2, 'add_customer_phone');
COMMIT;

-- V3__add_orders_customer_index.sql
BEGIN;
CREATE INDEX idx_orders_customer ON orders (customer_id);
INSERT INTO schema_migrations (version, name) VALUES (3, 'add_orders_customer_index');
COMMIT;

SELECT version, name FROM schema_migrations ORDER BY version;
Beklenen çıktı
version | name
1 | create_shop_tables
2 | add_customer_phone
3 | add_orders_customer_index
Aracın işini elle tekrarlıyoruz: her migration ve kaydı aynı işlemde.

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.

SQLite'ta ALTER TABLE: ne olur, ne olmaz

SQLite'ta ALTER TABLE yalnızca dört iş yapar: tablonun adını değiştirir (RENAME TO), sütun ekler (ADD COLUMN), sütunun adını değiştirir (RENAME COLUMN, 3.25'ten beri) ve sütun siler (DROP COLUMN, 3.35'ten beri):

SQL
ALTER TABLE customers ADD COLUMN phone TEXT;
ALTER TABLE customers RENAME COLUMN joined_on TO signup_date;
ALTER TABLE customers DROP COLUMN phone;

SELECT group_concat(name, ', ') AS columns
FROM pragma_table_info('customers');
Beklenen çıktı
columns
id, name, city, country, signup_date
pragma_table_info, tablonun sütunlarını satır satır döndürür.

Her birinin koşulları vardır. Eklenen sütun PRIMARY KEY ya da UNIQUE olamaz; NOT NULL bir sütunun NULL olmayan bir varsayılan değeri olmalıdır; varsayılan değer sabit olmalıdır (CURRENT_TIMESTAMP olmaz). Bir sütun da birincil anahtarsa, UNIQUE ise, indekslenmişse, bir yabancı anahtarın parçasıysa ya da bir görünümde, tetikleyicide veya CHECK içinde kullanılıyorsa silinemez:

SQL
ALTER TABLE customers ADD COLUMN vip INTEGER NOT NULL;
Beklenen çıktı
Error: Cannot add a NOT NULL column with default value NULL
SQL
CREATE INDEX idx_customers_city ON customers (city);
ALTER TABLE customers DROP COLUMN city;
Beklenen çıktı
Error: error in index idx_customers_city after drop column: no such column: city
Önce indeksi silmek gerekir: DROP INDEX idx_customers_city;
DeğişiklikSQLitePostgreSQLMySQL 8
Sütun ekleevet, koşullarlaevetevet
Sütunun adını değiştirRENAME COLUMN (3.25+)RENAME COLUMNRENAME COLUMN
Sütun sil3.35+, koşullarlaevetevet
Tipi değiştirhayır → yeniden kurmaALTER COLUMN … TYPE … USINGMODIFY COLUMN
Var olan sütuna NOT NULL / CHECKhayır → yeniden kurmaSET NOT NULL, ADD CONSTRAINTMODIFY, ADD CONSTRAINT
İşlem içinde DDL (ROLLBACK geri alır)evetevethayır — DDL örtük COMMIT yapar

SQLite'ta 12 adımlı yeniden kurulum ve PostgreSQL yolu

Geri kalan her şey için (tipi değiştirmek, kısıtlama eklemek, birincil anahtarı değiştirmek) SQLite belgeleri tabloyu yeniden kurmayı öngörür: yeni biçimde bir tablo oluştur, veriyi kopyala, eskisini sil ve yenisinin adını değiştir. Belgelerdeki yöntem 12 adımdır:

  1. 1. Yabancı anahtarları kapat

    PRAGMA foreign_keys = OFF; işlemden önce, çünkü işlemin içinde bu pragma hiçbir şey yapmaz.

  2. 2. İşlemi başlat

    BEGIN; her şey ya tamamen olur ya hiç olmaz.

  3. 3. Bağımlı nesneleri not et

    SELECT sql FROM sqlite_schema WHERE tbl_name = 'X'; indeksler, tetikleyiciler, görünümler.

  4. 4–5. Yeni tablo ve kopyalama

    İstenen biçimde CREATE TABLE new_X (...), sonra INSERT INTO new_X SELECT ... FROM X.

  5. 6–7. Değiştir

    DROP TABLE X, sonra ALTER TABLE new_X RENAME TO X.

  6. 8–9. Bağımlıları geri kur

    İndeksleri, tetikleyicileri ve görünümleri yeniden oluştur (değişiklik bir görünümü etkiliyorsa onu da düzelt).

  7. 10. Denetle

    PRAGMA foreign_key_check; bozulmuş başvuruları listeler.

  8. 11–12. Bitir

    COMMIT, sonra PRAGMA foreign_keys = ON.

Ürünler tablosuna kurallar ekliyoruz: ad benzersiz, fiyat boş ya da negatif olamaz, stok varsayılan olarak 0:

SQL
PRAGMA foreign_keys = OFF;                         -- step 1
BEGIN;                                             -- step 2
CREATE TABLE new_products (                        -- step 4
  id       INTEGER PRIMARY KEY,
  name     TEXT NOT NULL UNIQUE,
  category TEXT,
  price    REAL NOT NULL CHECK (price >= 0),
  stock    INTEGER NOT NULL DEFAULT 0 CHECK (stock >= 0)
);
INSERT INTO new_products (id, name, category, price, stock)   -- step 5
SELECT id, name, category, price, stock FROM products;
DROP TABLE products;                               -- step 6
ALTER TABLE new_products RENAME TO products;       -- step 7
CREATE INDEX idx_products_category ON products (category);   -- step 8
PRAGMA foreign_key_check;                          -- step 10
COMMIT;                                            -- step 11
PRAGMA foreign_keys = ON;                          -- step 12

SELECT COUNT(*) AS rows_copied,
       (SELECT COUNT(*) FROM orders AS o
        JOIN products AS p ON p.id = o.product_id) AS orders_still_linked
FROM products;
Beklenen çıktı
rows_copied | orders_still_linked
10 | 12
10 ürün kopyalandı, 12 siparişin hepsi hâlâ kendi ürününe bağlı (id'ler korundu). Artık INSERT INTO products (name, price) VALUES ('Broken', -5) hata verir: CHECK constraint failed: price >= 0.

Neden eski tablonun adını değiştirmiyoruz?

Problem

Daha “doğal” görünen bir yol: ALTER TABLE products RENAME TO old_products, sonra yeni bir products oluştur, kopyala ve old_products tablosunu sil. Bunun nesi yanlış?

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

Çözüm

1) Günümüzün SQLite'ı bir tablonun adı değişince diğer tablolardaki başvuruları da günceller.
2) Bu yüzden orders.product_id artık REFERENCES "old_products"(id) olur (aşağıdaki örnek).
3) old_products silinince siparişler var olmayan bir tabloya başvurur; bağlantı kopar.
4) Belgelerdeki sıra (yeni tabloyu oluşturup onun adını değiştirmek) bu tuzaktan kaçar.
SQL
ALTER TABLE products RENAME TO old_products;

SELECT "from" AS column_name, "table" AS references_table
FROM pragma_foreign_key_list('orders')
ORDER BY column_name;
Beklenen çıktı
column_name | references_table
customer_id | customers
product_id | old_products

PostgreSQL'de yeniden kuruluma gerek yoktur: tipi bir USING dönüşümüyle değiştirebilir, NOT NULL koyabilir ve kısıtlama ekleyebilirsin. Büyük bir tabloda bir CHECK ya da yabancı anahtarı NOT VALID ile ekleyip sonra ayrıca VALIDATE CONSTRAINT çalıştırmak kilitleri kısaltır: yeni satırlar hemen denetlenir, eskileri ise yazmaları engellemeden. Kod PGlite'ta (PostgreSQL 18) denendi:

SQL
BEGIN;
ALTER TABLE customers
  ALTER COLUMN joined_on TYPE date USING joined_on::date,
  ALTER COLUMN city SET NOT NULL;
ALTER TABLE products
  ADD CONSTRAINT price_positive CHECK (price >= 0) NOT VALID;
ALTER TABLE products VALIDATE CONSTRAINT price_positive;
COMMIT;

SELECT column_name, data_type, is_nullable
FROM information_schema.columns
WHERE table_name = 'customers'
ORDER BY ordinal_position;

Beklenen çıktı

 column_name | data_type | is_nullable
-------------+-----------+-------------
 id          | integer   | NO
 name        | text      | NO
 city        | text      | NO
 joined_on   | date      | YES
(4 rows)

PostgreSQL'de DDL de işlemseldir: başarısız bir migration'ın yarım kalan değişiklikleri ROLLBACK ile tamamen geri alınır. MySQL'de ise her ALTER TABLE örtük olarak COMMIT yapar; bu yüzden yarıda kesilen bir migration veritabanını ara bir durumda bırakabilir.

SQL
BEGIN;
ALTER TABLE customers ADD COLUMN phone text;
DROP TABLE products;
ROLLBACK;

SELECT count(*) AS phone_columns,
       to_regclass('products') IS NOT NULL AS products_exists
FROM information_schema.columns
WHERE table_name = 'customers' AND column_name = 'phone';

Beklenen çıktı

 phone_columns | products_exists
---------------+-----------------
             0 | t
(1 row)
Sütun yok, silinen tablo yerinde.

Migration dosyaları: up, down ve araçlar

Geri alınabilir bir migration'ın iki bölümü vardır: up (ileri) ve down (geri). Örneğin golang-migrate aracı dosya çiftleri bekler:

SQL
-- 0004_customer_phone.up.sql
ALTER TABLE customers ADD COLUMN phone TEXT;
CREATE INDEX idx_customers_phone ON customers (phone);

-- 0004_customer_phone.down.sql
DROP INDEX idx_customers_phone;
ALTER TABLE customers DROP COLUMN phone;
Down dosyası, up dosyasını ters sırayla geri alır.

Ama down her zaman “geri” demek değildir: DROP COLUMN için yazılan down sütunu geri getirir ama veriyi getirmez. Bu yüzden birçok ekip yalnızca ileri (forward-only) çalışır: bir hatayı yeni bir migration ile düzeltir, riskli bir değişiklikten önce de yedek alır. Python'da Alembic aynı fikri fonksiyonlarla ifade eder:

Python
"""add phone to customers

Revision ID: 3a1f9c2b7d10
Revises: 9e4d2a6c1b55
"""
from alembic import op
import sqlalchemy as sa

revision = "3a1f9c2b7d10"
down_revision = "9e4d2a6c1b55"


def upgrade():
    op.add_column("customers", sa.Column("phone", sa.String(20), nullable=True))


def downgrade():
    op.drop_column("customers", "phone")
Bir Alembic dosyası: down_revision önceki migration'ı gösterir ve bir zincir oluşturur.
AraçEkosistemMigrationGeçmiş tablosu
FlywayJava, her dil (CLI)V2__add_phone.sqlflyway_schema_history
LiquibaseJava, her dil (CLI)changelog: XML/YAML/SQL changeSet'leriDATABASECHANGELOG
AlembicPython, SQLAlchemyupgrade() / downgrade() içeren .py dosyasıalembic_version
Prisma MigrateNode.js, TypeScriptmigrations/<time>_name/migration.sql_prisma_migrations
EF Core.NET, C#Up() / Down() içeren C# sınıfı__EFMigrationsHistory
Terminal
alembic revision -m "add phone to customers"   # new migration file
alembic upgrade head                           # apply all pending migrations
alembic downgrade -1                           # undo the last one
flyway migrate                                 # apply V*__*.sql files in order
npx prisma migrate dev --name add_phone        # create + apply (development)
npx prisma migrate deploy                      # apply pending (production)
dotnet ef migrations add AddPhone              # EF Core: create
dotnet ef database update                      # EF Core: apply
Her araçta aynı iki hamle vardır: bir migration oluştur ve bekleyenleri uygula.

Kesintisiz değişiklik: expand–contract

Bir güncelleme sırasında uygulamanın eski ve yeni sürümleri bir süre aynı veritabanıyla birlikte çalışır. Bir sütunun adını tek adımda değiştirirsen eski sürüm hemen bozulur. Expand–contract (genişlet–daralt) değişikliği birkaç güvenli sürüme böler. customers.name sütununu first_name ve last_name olarak ayırıyoruz:

  1. Genişlet (expand)

    Yeni sütunları ekle; eski sütun kalır, eski kod çalışmaya devam eder.

  2. Doldur ve eşitle

    Eski satırları parça parça doldur; yeni yazmalar için uygulama iki yere yazar (ya da geçici bir tetikleyici).

  3. Okumayı geçir

    Yeni sürüm yalnızca yeni sütunları okur.

  4. Daralt (contract)

    Eski kod kalmayınca tetikleyiciyi ve eski sütunu sil.

SQL
ALTER TABLE customers ADD COLUMN first_name TEXT;
ALTER TABLE customers ADD COLUMN last_name TEXT;
UPDATE customers
SET first_name = substr(name, 1, instr(name, ' ') - 1),
    last_name  = substr(name, instr(name, ' ') + 1)
WHERE first_name IS NULL;

-- old code still writes only "name": a temporary trigger fills the new columns
CREATE TRIGGER customers_sync AFTER INSERT ON customers
WHEN NEW.first_name IS NULL
BEGIN
  UPDATE customers
  SET first_name = substr(NEW.name, 1, instr(NEW.name, ' ') - 1),
      last_name  = substr(NEW.name, instr(NEW.name, ' ') + 1)
  WHERE id = NEW.id;
END;

INSERT INTO customers (name, city, country, joined_on)
VALUES ('Aygün Qasımova', 'Quba', 'Azerbaijan', '2025-09-01');

SELECT id, name, first_name, last_name
FROM customers WHERE id IN (1, 3, 8) ORDER BY id;
Beklenen çıktı
id | name | first_name | last_name
1 | Anar Mustafayev | Anar | Mustafayev
3 | Emre Yılmaz | Emre | Yılmaz
8 | Aygün Qasımova | Aygün | Qasımova
Expand: eski satırlar dolduruldu, eski kodun yazdığı yeni müşteri (8) de ayrıldı.
SQL
ALTER TABLE customers ADD COLUMN first_name TEXT;
ALTER TABLE customers ADD COLUMN last_name TEXT;
UPDATE customers
SET first_name = substr(name, 1, instr(name, ' ') - 1),
    last_name  = substr(name, instr(name, ' ') + 1);

-- a later release: nothing reads "name" any more
ALTER TABLE customers DROP COLUMN name;

SELECT group_concat(name, ', ') AS columns FROM pragma_table_info('customers');
Beklenen çıktı
columns
id, city, country, joined_on, first_name, last_name
Contract: eski sütun ancak bütün kod yeni sütunlara geçtikten sonra silinir.

Alıştırma

V2 migration'ını yaz: tek bir işlemde customers tablosuna phone TEXT sütunu ekle, joined_on adını signup_date yap ve schema_migrations tablosuna (2, 'customer_phone_and_signup_date') kaydet. Sonra başlangıç kodundaki denetim sorgusunu çalıştır.

Alıştırma · SQL
CREATE TABLE schema_migrations (version INTEGER PRIMARY KEY, name TEXT NOT NULL);
INSERT INTO schema_migrations VALUES (1, 'create_shop_tables');

-- V2 here (BEGIN ... COMMIT)

SELECT (SELECT MAX(version) FROM schema_migrations) AS schema_version,
       group_concat(name, ', ') AS columns
FROM pragma_table_info('customers');
Beklenen çıktı
schema_version | columns
2 | id, name, city, country, signup_date, phone

Alıştırma

courses.credits sütununu NOT NULL ve CHECK (credits BETWEEN 1 AND 10) yap. SQLite bunu ALTER TABLE ile yapamaz; 12 adımlı yeniden kurulumu uygula (enrollments derslere başvuruyor!). Sonra başlangıç kodundaki denetim sorgusunu çalıştır.

Alıştırma · SQL
-- rebuild courses here (PRAGMA, BEGIN, CREATE new_courses, copy, DROP, RENAME, COMMIT)

SELECT COUNT(*) AS courses,
       (SELECT "notnull" FROM pragma_table_info('courses')
        WHERE name = 'credits') AS credits_not_null
FROM courses;
Beklenen çıktı
courses | credits_not_null
7 | 1

Unutma

  • Migration, Git'te tutulan sürümlü bir şema değişikliğidir; uygulananlar bir sürüm tablosuna kaydedilir.
  • SQLite'ın ALTER TABLE komutu yalnızca ad değiştirir, sütun ekler ve siler (koşullarla); gerisi 12 adımlı yeniden kurulumdur.
  • Yeniden kurulumda yeni bir tablo oluşturulur ve onun adı değiştirilir; eski tablonun adını değiştirmek başvuruları bozar.
  • PostgreSQL ve SQLite'ta DDL işlemseldir; MySQL'de örtük COMMIT vardır.
  • Down her zaman veriyi geri getirmez; birçok ekip forward-only çalışır ve yedek alır.
  • Expand–contract: ekle → doldur ve eşitle → okumayı geçir → eskiyi sil.
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. Migration nedir?