SQL'de birincil anahtarlar nasıl kullanılır?

giriiş

İlişkisel veritabanlarının değerli özelliklerinden biri, verilerin iyi tanımlanmış bir yapıda biçimlendirilmesidir. Bu yapı, sabit sütunlu tablolar kullanılarak, iyi tanımlanmış veri türlerine bağlı kalınarak ve her satırın aynı biçime sahip olduğundan emin olunarak elde edilir. Verileri tablolarda satırlar halinde sakladığınızda, bunları açıkça bulup başvurabilmek de aynı derecede önemlidir. Yapılandırılmış Sorgu Dili'nde (SQL), bu, ilişkisel bir veritabanındaki tablolardaki her bir satır için tanımlayıcı görevi gören birincil anahtarlarla sağlanabilir.

Bu eğitimde, birincil anahtarlar hakkında bilgi edinecek ve veritabanı tablolarındaki benzersiz satırları tanımlamak için birkaç farklı tür kullanacaksınız. Bazı örnek veri kümelerini kullanarak, tek sütunlarda, birden çok sütunda ve otomatik artan sıralı anahtarlarda birincil anahtarlar oluşturacaksınız.

Ön koşullar

Bu kılavuzu takip etmek için, SQL tabanlı bir ilişkisel veritabanı yönetim sistemi (RDBMS) çalıştıran bir bilgisayara ihtiyacınız var. Bu kılavuzdaki talimatlar ve örnekler, aşağıdaki ortam kullanılarak doğrulanmıştır:

• Yönetici ayrıcalıklarına sahip kök olmayan bir kullanıcı ve UFW ile yapılandırılmış bir güvenlik duvarı bulunan Ubuntu 20.04 çalıştıran bir sunucu
• Sunucuda MySQL kurulu ve güvenlidir.
• Veritabanından veri almak için SELECT sorgularını çalıştırmaya ilişkin temel giriş

Not: Birçok RDBMS'nin kendi benzersiz SQL uygulamasını kullandığını lütfen unutmayın. Bu eğitimde bahsedilen komutlar çoğu RDBMS'de çalışsa ve birincil anahtarlar SQL standardının bir parçası olsa da, bazı özellikler veritabanına özgüdür ve bu nedenle MySQL dışında bir sistemde test ederseniz kesin sözdizimi veya çıktı farklı olabilir.

Ayrıca, birincil anahtarları kullanarak tabloları oluşturmak için boş bir veritabanına ihtiyacınız olacak. MySQL sunucusuna bağlanma ve bu kılavuzdaki örneklerde kullanılan test veritabanını oluşturma hakkında ayrıntılı bilgi için aşağıdaki MySQL'e Bağlanma ve Örnek Veritabanı Oluşturma bölümünü takip etmenizi öneririz.

MySQL'e bağlanma ve örnek bir veritabanı kurma

Bu bölümde MySQL sunucusuna bağlanacak ve bu kılavuzdaki örnekleri kullanabilmeniz için bir veritabanı örneği oluşturacaksınız.

SQL veritabanı sisteminiz uzak bir sunucuda çalışıyorsa, yerel makinenizden sunucunuza SSH ile bağlanın:

ssh sammy@your_server_ip

Daha sonra MySQL sunucusu istemini açın ve Sami'yi MySQL kullanıcı adınızla değiştirin:

mysql -u sammy -p

primary_keys adında bir veritabanı oluşturun:

CREATE DATABASE primary_keys;

Veritabanı başarıyla oluşturulduysa aşağıdaki çıktıyı alacaksınız:

Output
Query OK, 1 row affected (0.01 sec)

primary_keys veritabanını seçmek için aşağıdaki USE ifadesini çalıştırın:

USE primary_keys;

Aşağıdaki çıktıyı alacaksınız:

Output
Database changed

Bir veritabanı seçtikten sonra, içinde örnek tablolar oluşturabilirsiniz. Artık kılavuzun geri kalanını takip etmeye ve MySQL'de birincil anahtarlarla çalışmaya hazırsınız.

Majör Tuşlara Giriş

İlişkisel bir veritabanındaki veriler, her bir satırdan oluşan belirli ve tekdüze bir yapıya sahip tablolarda saklanır. Tablo tanımı, hangi sütunların bulunduğunu ve her bir sütunda ne tür verilerin saklanabileceğini açıklar. Bu, veritabanında bilgi depolamak ve WHERE ifadesiyle çeşitli filtre ölçütleri kullanarak bulmak için tek başına yeterlidir. Ancak bu yapı, her satırın kesin olarak bulunabileceğini garanti etmez.

Kamu yollarında trafiğe çıkmasına izin verilen tüm kayıtlı araçların bir veritabanını hayal edin. Veritabanında marka, model, üretim yılı ve boya rengi gibi bilgiler bulunur. Ancak, 2007 yapımı kırmızı bir Chevrolet Camaro arıyorsanız, birden fazla bulabilirsiniz. Sonuçta, otomobil üreticileri aynı arabaları birden fazla müşteriye satar. Bu nedenle, kayıtlı araçların her birini tanımlayan plakaları vardır. OFP857 plakalı bir araç aradıysanız, bu kriterin yalnızca bir araç bulacağından emin olabilirsiniz. Bunun nedeni, yasa gereği plakaların kayıtlı araçları benzersiz şekilde tanımlamasıdır. İlişkisel bir veritabanında, böyle bir veri parçasına birincil anahtar denir.

Birincil anahtarlar, bir veritabanı tablosundaki her satırı açıkça tanımlayabilen bir sütun veya sütun kümesinde bulunan benzersiz tanımlayıcılardır. Birkaç kural, birincil anahtarların teknik özelliklerini yansıtır:

• Birincil anahtar, benzersiz değerler kullanmalıdır. Birincil anahtar birden fazla sütundan oluşuyorsa, bu sütunlardaki değerlerin birleşimi tüm tablo genelinde benzersiz olmalıdır. Anahtar, her satırı benzersiz şekilde tanımlamak için kullanıldığından, birden fazla kez kullanılamaz.
• Birincil anahtar NULL değerleri içermemelidir.
• Her veritabanı tablosu yalnızca bir birincil anahtar kullanabilir.

Veritabanı motoru bu kuralları uygular, dolayısıyla bir tabloda birincil anahtar tanımlanmışsa, bu özniteliklerin doğru olduğundan emin olabilirsiniz.

Bu teknik özelliklere ek olarak, birincil anahtar olarak hangi veri türünün iyi bir seçim olduğuna karar vermek için verilerin içeriğini de göz önünde bulundurmalısınız. Doğal anahtarlar, veri kümesinde zaten mevcut olan tanımlayıcılardır; vekil anahtarlar ise yapay tanımlayıcılardır.

Bazı veri yapıları, veri kümesinde doğal olarak bulunan birincil anahtarlara sahiptir; örneğin, bir araç veritabanındaki plaka numaraları veya bir ABD vatandaşlık kayıt defterindeki Sosyal Güvenlik numaraları gibi. Bazen bu tür tanımlayıcılar tek bir değer değil, birkaç değerin bir çifti veya birleşimi olabilir. Örneğin, yerel bir şehir ev rehberinde, bir sokak adı veya sokak numarası tek başına bir evi benzersiz bir şekilde tanımlayamaz. Bir sokakta birden fazla ev olabilir ve aynı numara birden fazla sokakta görünebilir. Ancak bir sokak adı ve sokak numarası çifti, benzersiz bir ev tanımlayıcısı olarak kabul edilebilir. Bu tür doğal olarak oluşan tanımlayıcılara doğal anahtarlar denir.

Ancak, veriler genellikle tek bir sütunun veya sütunların küçük bir alt kümesinin değerleriyle benzersiz bir şekilde tanımlanamaz. Bu durumda, örneğin bir sayı dizisi veya UUID'ler gibi rastgele oluşturulmuş tanımlayıcılar kullanılarak yapay birincil anahtarlar oluşturulur. Bu tür anahtarlara vekil anahtarlar denir.

Aşağıdaki bölümlerde, bir veya daha fazla sütuna dayalı doğal anahtarlar oluşturacak ve doğal anahtarın bir seçenek olmadığı tablolarda alternatif anahtarlar oluşturacaksınız.

Bir sütunda birincil anahtar oluşturun

Çoğu durumda, bir veri kümesi doğal olarak bir tablodaki satırları benzersiz şekilde tanımlamak için kullanılabilecek bir sütun içerir. Bu durumlarda, verileri tanımlamak için doğal bir anahtar oluşturabilirsiniz. Kayıtlı araç veritabanına ilişkin önceki örnekten devam edersek, aşağıdaki yapıya sahip bir tablo hayal edelim:

Sample table
+---------------+-----------+------------+-------+------+
| license_plate | brand | model | color | year |
+---------------+-----------+------------+-------+------+
| ABC123 | Ford | Mustang | Red | 2018 |
| CES214 | Ford | Mustang | Red | 2018 |
| DEF456 | Chevrolet | Camaro | Blue | 2016 |
| GHI789 | Dodge | Challenger | Black | 2014 |
+---------------+-----------+------------+-------+------+

İlk ve ikinci satırlar, kırmızı renkli 2018 Ford Mustang'i tanımlıyor. Aracın marka ve modelini kullanarak aracı benzersiz bir şekilde tanımlayamazsınız. Plaka her iki durumda da farklıdır ve tablodaki her satır için iyi bir benzersiz tanımlayıcı sağlar. Plaka numarası zaten verinin bir parçası olduğundan, birincil anahtar olarak kullanılması doğal bir anahtar oluşturur. "Plaka" sütununda birincil anahtar kullanmadan tabloyu oluşturduysanız, veri kümesinde bir noktada yinelenen veya boş bir sayfa görünme riskiyle karşı karşıya kalırsınız.

Daha sonra, birincil anahtar olarak License_plate sütununu ve aşağıdaki sütunları kullanarak yukarıdakine benzer bir tablo oluşturun:

• Plaka: Bu sütun, varchar veri türüyle gösterilen plaka numarasını içerir.
• Marka: Bu sütun, en fazla 50 karakter uzunluğunda, varchar veri tipi kullanılarak ifade edilen aracın markasını temsil eder.
• Model: Bu sütun, varchar veri tipi kullanılarak ifade edilen ve en fazla 50 karakterden oluşan araç modelini tutar.
• Renk: Bu sütun, varchar veri türü kullanılarak ifade edilen ve en fazla 20 karakterden oluşan rengi tutar.
• yıl: Bu sütun, sayısal verileri depolamak için int veri türü kullanılarak ifade edilen aracın üretim yılını gösterir.

Makineler tablosunu oluşturmak için aşağıdaki SQL ifadesini çalıştırın:

CREATE TABLE cars (
license_plate varchar(8) PRIMARY KEY,
brand varchar(50),
model varchar(50),
color varchar(20),
year int
);... */

PRIMARY KEY ifadesi, License_plate veri türünün tanımını takip eder. Tek sütunlara dayalı birincil anahtarlarla çalışırken, anahtarı oluşturmak için basitleştirilmiş sözdizimini kullanabilir ve birincil anahtarı sütun tanımına yazabilirsiniz.

Aşağıdaki çıktıyı alırsanız tablo oluşmuş demektir:

Output
Query OK, 0 rows affected (0.00 sec)

Daha sonra yukarıdaki örnekte verilen örnek satırları içeren tabloyu aşağıdaki INSERT INTO işlemini çalıştırarak yükleyin:

INSERT INTO cars VALUES
('ABC123', 'Ford', 'Mustang', 'Red', 2018),
('CES214', 'Ford', 'Mustang', 'Red', 2018),
('DEF456', 'Chevrolet', 'Camaro', 'Blue', 2016),
('GHI789', 'Dodge', 'Challenger', 'Black', 2014);

Veritabanı bir başarı mesajıyla yanıt verecektir:

Output
Query OK, 4 rows affected (0.010 sec)
Records: 4 Duplicates: 0 Warnings: 0

Artık yeni oluşturulan tablonun beklenen verileri ve biçimi içerdiğini SELECT ifadesini kullanarak doğrulayabilirsiniz:

SELECT * FROM cars;

Çıktı, bölümün başındakine benzer bir tabloyu gösterir:

Output
+---------------+-----------+------------+-------+------+
| license_plate | brand | model | color | year |
+---------------+-----------+------------+-------+------+
| ABC123 | Ford | Mustang | Red | 2018 |
| CES214 | Ford | Mustang | Red | 2018 |
| DEF456 | Chevrolet | Camaro | Blue | 2016 |
| GHI789 | Dodge | Challenger | Black | 2014 |
+---------------+-----------+------------+-------+------+

Ardından, birincil anahtar kurallarının veritabanı motoru tarafından garanti edilip edilmediğini kontrol edebilirsiniz. Aşağıdaki komutu çalıştırarak, aynı plaka numarasına sahip bir araç eklemeyi deneyin:

INSERT INTO cars VALUES ('DEF456', 'Jeep', 'Wrangler', 'Yellow', 2019);

MySQL, DEF456 etiketinin birincil anahtar için yinelenen bir girdiyle sonuçlandığını belirten bir hata mesajıyla yanıt verir:

Output
ERROR 1062 (23000): Duplicate entry 'DEF456' for key 'cars.PRIMARY'

Not: Birincil anahtarlar, temelde benzersiz dizinlerle uygulanır ve bir tablodaki diğer sütunlar için manuel olarak oluşturabileceğiniz dizinlerle birçok ortak özelliğe sahiptir. En önemlisi, birincil anahtar dizinleri, dizinin tanımlandığı sütuna göre tablo sorgulama performansını da artırır. Bu amaçla dizin kullanımı hakkında daha fazla bilgi için bu eğitimdeki Dizinlerin Kullanımı kılavuzuna bakın.

Artık çift plakaya izin verilmediğinden emin olabilirsiniz. Ardından, boş plakalı bir aracın ithal edilip edilemeyeceğini kontrol edin:

INSERT INTO cars VALUES (NULL, 'Jeep', 'Wrangler', 'Yellow', 2019);

Bu sefer veritabanı başka bir hata mesajıyla yanıt verecektir:

Output
ERROR 1048 (23000): Column 'license_plate' cannot be null

Veritabanı tarafından uygulanan bu iki kural sayesinde, License_plate'in tablodaki her satırı benzersiz şekilde tanımladığından emin olabilirsiniz. Tabloyu her plaka için sorguladığınızda, her seferinde bir satır döndürmeyi bekleyebilirsiniz.

Bir sonraki bölümde, birden fazla sütuna sahip birincil anahtarların nasıl kullanılacağını öğreneceksiniz.

Birden fazla sütunda birincil anahtar oluşturma

Bir tabloda bir satırı benzersiz şekilde tanımlamak için tek bir sütun yeterli olmadığında, birden fazla sütun kullanan birincil anahtarlar oluşturabilirsiniz.

Örneğin, ne sokak adının ne de sokak numarasının tek başına her evi tanımlamaya yeterli olmadığı bir ev kayıt defterini düşünün:

Sample table
+-------------------+---------------+-------------------+------+
| street_name | street_number | house_owner | year |
+-------------------+---------------+-------------------+------+
| 5th Avenue | 100 | Bob Johnson | 2018 |
| Broadway | 1500 | Jane Smith | 2016 |
| Central Park West | 100 | John Doe | 2014 |
| Central Park West | 200 | Tom Thompson | 2015 |
| Lexington Avenue | 5001 | Samantha Davis | 2010 |
| Park Avenue | 7000 | Michael Rodriguez | 2012 |
+-------------------+---------------+-------------------+------+

Central Park West sokak adı ve 100 numaralı sokak numarası tabloda birden fazla kez geçiyor. Ancak, sokak adı ve sokak numarasının aynı anda tekrarlandığı bir çift görülmüyor. Bu durumda, sütunlardan hiçbiri birincil anahtar olmasa da, bu iki değerin çifti tablodaki her satırı benzersiz şekilde tanımlamak için kullanılabilir.

Daha sonra yukarıda gösterilene benzer bir tabloyu aşağıdaki sütunlarla oluşturun:

• street_name: Bu sütun evin bulunduğu sokağın adını temsil eder, varchar veri tipi 50 karakterle sınırlıdır.
• sokak_numarası: Bu sütun, evin sokak numarasını tutar ve varchar veri türüyle gösterilir. Bu sütun en fazla 5 karakter depolayabilir. Bazı sokak numaraları harf içerebileceğinden (örneğin 200B), sayısal int veri türünü kullanmaz.
• house_owner: Bu sütun, 50 karakterle sınırlı varchar veri türüyle temsil edilen ev sahibinin adını içerir.
• yıl: Bu sütun evin inşa edildiği yılı temsil eder ve sayısal değerleri saklamak için int veri türüyle gösterilir.

Bu sefer birincil anahtar, yalnızca bir sütun yerine hem street_name hem de street_number sütunlarını kullanır. Bunu yapmak için aşağıdaki SQL ifadesini çalıştırın:

CREATE TABLE houses (
street_name varchar(50),
street_number varchar(5),
house_owner varchar(50),
year int,
PRIMARY KEY(street_name, street_number)
);

Bu sefer, önceki örnekten farklı olarak, PRIMARY KEY ifadesi sütun tanımlarının altında görünür. PRIMARY KEY ifadesi, iki sütun adıyla parantez içinde yer alır: sokak_adı ve sokak_numarası. Bu sözdizimi, iki sütunda bulunan evler tablosunda bir birincil anahtar oluşturur.

Aşağıdaki çıktıyı alırsanız tablo oluşmuş demektir:

Output
Query OK, 0 rows affected (0.00 sec)

Daha sonra, aşağıdaki INSERT INTO işlemini yürüterek önceki örnekte verilen örnek satırları içeren tabloyu yükleyin:

INSERT INTO houses VALUES
('Central Park West', '100', 'John Doe', 2014),
('Broadway', '1500', 'Jane Smith', 2016),
('5th Avenue', '100', 'Bob Johnson', 2018),
('Lexington Avenue', '5001', 'Samantha Davis', 2010),
('Park Avenue', '7000', 'Michael Rodriguez', 2012),
('Central Park West', '200', 'Tom Thompson', 2015);

Veritabanı bir başarı mesajıyla yanıt verecektir:

Output
Query OK, 6 rows affected (0.000 sec)
Records: 6 Duplicates: 0 Warnings: 0

Artık yeni oluşturulan tablonun beklenen verileri ve biçimi içerdiğini SELECT ifadesini kullanarak doğrulayabilirsiniz:

SELECT * FROM houses;

Çıktı, bölümün başındakine benzer bir tabloyu gösterir:

Output
+-------------------+---------------+-------------------+------+
| street_name | street_number | house_owner | year |
+-------------------+---------------+-------------------+------+
| 5th Avenue | 100 | Bob Johnson | 2018 |
| Broadway | 1500 | Jane Smith | 2016 |
| Central Park West | 100 | John Doe | 2014 |
| Central Park West | 200 | Tom Thompson | 2015 |
| Lexington Avenue | 5001 | Samantha Davis | 2010 |
| Park Avenue | 7000 | Michael Rodriguez | 2012 |
+-------------------+---------------+-------------------+------+
6 rows in set (0.000 sec)

Şimdi, veritabanının sokak adlarını ve sokak numaralarını tekrarlayan satırlara izin verip vermediğini, ancak tabloda tam adreslerin yinelenen şekilde görünmesini engelleyip engellemediğini kontrol edelim. Park Caddesi'nde başka bir ev ekleyerek başlayalım:

INSERT INTO houses VALUES ('Park Avenue', '8000', 'Emily Brown', 2011);

MySQL, 8000 Park Avenue adresinin daha önce tabloda görünmemesi nedeniyle bir başarı mesajıyla yanıt verir:

Output
Query OK, 1 row affected (0.010 sec)

Benzer bir sonuç, 8000 Main Street adresindeki bir evi eklediğinizde ve sokak numarasını tekrarladığınızda ortaya çıkar:

INSERT INTO houses VALUES ('Main Street', '8000', 'David Jones', 2009);

Bir kez daha, tüm adres tekrarlanmadığı için bu yeni satırı doğru şekilde ekler:

Output
Query OK, 1 row affected (0.010 sec)

Ancak, aşağıdaki INSERT ifadesini kullanarak 100 5. Cadde'ye başka bir ev ekleyin:

INSERT INTO houses VALUES ('5th Avenue', '100', 'Josh Gordon', 2008);

Veritabanı, 5th Avenue ve 100 değer çifti için birincil anahtar için yinelenen bir giriş olduğunu bildiren bir hata mesajıyla yanıt verir:

Output
ERROR 1062 (23000): Duplicate entry '5th Avenue-100' for key 'houses.PRIMARY'

Veritabanı, bir sütun çiftinde tanımlanan anahtarla birincil anahtar kurallarını doğru bir şekilde uygular. Sokak adı ve sokak numarası da dahil olmak üzere tam adresin tabloda tekrarlanmayacağından emin olabilirsiniz.

Bu bölümde, ana tablodaki her satırı benzersiz şekilde tanımlamak için bir çift sütundan oluşan doğal bir anahtar oluşturdunuz. Ancak birincil anahtarlar her zaman veri kümesinden çıkarılamaz. Bir sonraki bölümde, doğrudan verilerden gelmeyen yapay birincil anahtarlar kullanacaksınız.

Sıralı birincil anahtar oluşturma

Şimdiye kadar, örnek veri kümesindeki sütunları kullanarak benzersiz birincil anahtarlar oluşturdunuz. Ancak bazı durumlarda veriler kaçınılmaz olarak çoğaltılır ve bu da sütunların iyi benzersiz tanımlayıcılar olmasını engeller. Bu gibi durumlarda, oluşturulan tanımlayıcıları kullanarak sıralı birincil anahtarlar oluşturabilirsiniz. Verileriniz satırları tanımlamak için yeni tanımlayıcılar oluşturmanızı gerektirdiğinde, bu yapay tanımlayıcılar üzerinde oluşturulan birincil anahtarlara vekil anahtarlar denir.

Kitap kulübü üyelerinin bir listesini düşünün; herkesin resmi kimlik göstermeden katılabileceği gayriresmi bir toplantı. Benzer isimlere sahip kişilerin bir noktada kulübe katılması muhtemeldir:

Sample table
+------------+-----------+
| first_name | last_name |
+------------+-----------+
| John | Doe |
| Jane | Smith |
| Bob | Johnson |
| Samantha | Davis |
| Michael | Rodriguez |
| Tom | Thompson |
| Sara | Johnson |
| David | Jones |
| Jane | Smith |
| Bob | Johnson |
+------------+-----------+

Bob Johnson ve Jane Smith isimleri tabloda tekrarlanıyor. Kimin kim olduğundan emin olmak için ek bir tanımlayıcı kullanmanız gerekir ve bu tablodaki satırları benzersiz bir şekilde tanımlamanın bir yolu yoktur. Kitap kulübü üyelerinin bir listesini kağıt üzerinde tutuyor olsaydınız, grup içinde benzer isimlere sahip kişileri ayırt etmenize yardımcı olacak yardımcı tanımlayıcılar kullanabilirsiniz.

İlişkisel bir veritabanında da benzer bir şey yapabilirsiniz. Bunun için, tablodaki tüm satırları benzersiz bir şekilde izole etmeyi amaçlayan, üretilmiş, gerçek olmayan kimlikleri tutan ek bir sütun kullanabilirsiniz. Buna Member_id diyelim.

Ancak, veritabanına her kitap kulübü üyesi eklemek istediğinizde böyle bir tanımlayıcı oluşturmak zahmetlidir. Bu sorunu çözmek için MySQL, sayısal sütunların otomatik olarak artırılmasını sağlayan bir özellik sunar; bu özellik sayesinde veritabanı, sütun değerini bir dizi tam sayı kadar otomatik olarak artırır.

Yukarıdakine benzer bir tablo oluşturalım. Her kulüp üyesi için otomatik olarak atanan bir numarayı tutmak üzere ek bir otomatik artan sütun (member_id) ekleyeceksiniz. Otomatik olarak atanan bu numara, tablonun birincil anahtarı olarak kullanılacaktır:

Member_id: Bu sütun, int veri türüyle temsil edilen otomatik artan sayısal bir kimliğe sahiptir.

first_name: Bu sütun, kulüp üyelerinin adlarını içerir ve 50 karakterle sınırlı varchar veri türüyle gösterilir.

soyadı: Bu sütun, kulüp üyelerinin soyadlarını tutar ve 50 karakterle sınırlı varchar veri türüyle görüntülenir.

Tabloyu oluşturmak için aşağıdaki SQL ifadesini çalıştırın:

CREATE TABLE club_members (
member_id int AUTO_INCREMENT PRIMARY KEY,
first_name varchar(50),
last_name varchar(50)
);

PRIMARY KEY ifadesi, tıpkı tek sütunlu birincil anahtarlarda olduğu gibi, sütun türü tanımından sonra görünürken, öncesinde ek bir öznitelik görünür: AUTO_INCREMENT. Bu öznitelik, MySQL'e, açıkça belirtilmediği takdirde, artan sayı dizisi kullanarak o sütun için otomatik olarak değerler üretmesini söyler.

Not: Sütun tanımları için AUTO_INCREMENT özelliği MySQL'e özgüdür. Diğer veritabanları genellikle sıralı anahtarlar oluşturmak için benzer yöntemler sunar, ancak sözdizimi motorlar arasında farklılık gösterir. Şüpheniz varsa, RDBMS'nizin resmi belgelerine başvurmanızı öneririz.

Aşağıdaki çıktıyı alırsanız tablo oluşmuş demektir:

Output
Query OK, 0 rows affected (0.00 sec)

Daha sonra yukarıdaki örnekte verilen örnek satırları içeren tabloyu aşağıdaki INSERT INTO işlemini çalıştırarak yükleyin:

INSERT INTO club_members (first_name, last_name) VALUES
('John', 'Doe'),
('Jane', 'Smith'),
('Bob', 'Johnson'),
('Samantha', 'Davis'),
('Michael', 'Rodriguez'),
('Tom', 'Thompson'),
('Sara', 'Johnson'),
('David', 'Jones'),
('Jane', 'Smith'),
('Bob', 'Johnson');

INSERT ifadesi artık sütun adlarının bir listesini (first_name ve last_name) içerir; bu, veritabanının Member_id sütununun veri kümesinde sağlanmadığını bilmesini sağlar, bu nedenle bunun yerine varsayılan değer alınmalıdır.

Veritabanı bir başarı mesajıyla yanıt verecektir:

Output
Query OK, 10 rows affected (0.002 sec)
Records: 10 Duplicates: 0 Warnings: 0

Yeni oluşturulan tablodaki verileri doğrulamak için SELECT ifadesini kullanın:

SELECT * FROM club_members;

Çıktı, bölümün başındakine benzer bir tabloyu gösterir:

Output
+-----------+------------+-----------+
| member_id | first_name | last_name |
+-----------+------------+-----------+
| 1 | John | Doe |
| 2 | Jane | Smith |
| 3 | Bob | Johnson |
| 4 | Samantha | Davis |
| 5 | Michael | Rodriguez |
| 6 | Tom | Thompson |
| 7 | Sara | Johnson |
| 8 | David | Jones |
| 9 | Jane | Smith |
| 10 | Bob | Johnson |
+-----------+------------+-----------+
10 rows in set (0.000 sec)

Ancak bu sefer sonuçta Member_id sütunu görünür ve 1'den 10'a kadar bir sayı dizisi içerir. Bu sütunla birlikte Jane Smith ve Bob Johnson için yinelenen satırlar artık tanınmaz çünkü her isim benzersiz bir tanımlayıcıyla (Member_id) ilişkilendirilmiştir.

Şimdi veritabanının kulübün üyelik listesine başka bir Tom Thompson eklememize izin verip vermediğini kontrol edelim:

INSERT INTO club_members (first_name, last_name) VALUES ('Tom', 'Thompson');

MySQL bir başarı mesajıyla yanıt verecektir:

Output
Query OK, 1 row affected (0.009 sec)

Veritabanının yeni girdiye hangi sayısal kimliği atadığını kontrol etmek için SELECT sorgusunu tekrar çalıştırın:

SELECT * FROM club_members;

Çıktıda bir satır daha var:

Output
+-----------+------------+-----------+
| member_id | first_name | last_name |
+-----------+------------+-----------+
| 1 | John | Doe |
| 2 | Jane | Smith |
| 3 | Bob | Johnson |
| 4 | Samantha | Davis |
| 5 | Michael | Rodriguez |
| 6 | Tom | Thompson |
| 7 | Sara | Johnson |
| 8 | David | Jones |
| 9 | Jane | Smith |
| 10 | Bob | Johnson |
| 11 | Tom | Thompson |
+-----------+------------+-----------+
11 rows in set (0.000 sec)

Veritabanının AUTO_INCREMENT özniteliği aracılığıyla Member_id sütununda yeni bir satıra otomatik olarak 11 numarası atandı.

Üzerinde çalıştığınız veriler birincil anahtarlar için doğal adaylara sahip değilse ve veritabanına her yeni veri eklediğinizde uydurulmuş tanımlayıcılar üretmek istemiyorsanız, birincil anahtarlar olarak sıralı olarak oluşturulan tanımlayıcılara güvenle güvenebilirsiniz.

Sonuç

Bu kılavuzu izleyerek, birincil anahtarların ne olduğunu ve veritabanı tablolarındaki benzersiz satırları tanımlamak için MySQL'de ortak türlerin nasıl oluşturulacağını öğrendiniz. Doğal birincil anahtarlar oluşturdunuz, birden fazla sütuna yayılan birincil anahtarlar oluşturdunuz ve doğal anahtarların bulunmadığı durumlarda otomatik artan sıralı anahtarlar kullandınız.