Laravel’da Eloquent ile Veritabanı Sorgulama (SELECT İşlemleri)

Laravel’da Eloquent ile Veritabanı Sorgulama (SELECT İşlemleri)

Modern web uygulamalarının kalbinde veritabanı etkileşimleri yer alır. Verileri depolamak, almak, güncellemek ve silmek, bir uygulamanın temel işlevselliğini oluşturur. Laravel, bu veritabanı etkileşimlerini kolaylaştırmak ve daha okunabilir hale getirmek için güçlü bir ORM (Object-Relational Mapper) olan Eloquent’i sunar. Eloquent, geliştiricilerin veritabanı tablolarını sınıflar (modeller) olarak ele almasına olanak tanıyarak, SQL sorguları yazma ihtiyacını büyük ölçüde azaltır. Bu makalede, Laravel’da Eloquent kullanarak veritabanından nasıl veri seçileceğini (SELECT işlemleri) derinlemesine inceleyeceğiz. Temel sorgulardan gelişmiş ilişkilere ve performans ipuçlarına kadar geniş bir yelpazeyi kapsayacağız.

Eloquent ORM Nedir ve Neden Kullanılır?

Eloquent, Laravel’ın dahili ORM aracıdır. ORM, nesne yönelimli programlama dillerindeki sınıflar ile ilişkisel veritabanları arasındaki uyumsuzluk sorununu çözmeye yardımcı olan bir programlama tekniğidir. Geleneksel olarak, veritabanı işlemleri için SQL sorguları yazılır. Ancak bu, özellikle karmaşık sorgularda ve farklı veritabanı sistemleri arasında geçiş yapıldığında bazı zorluklar yaratabilir:

• Veritabanı Bağımlılığı: SQL sorguları belirli bir veritabanı sistemine özgü olabilir.
• Okunabilirlik: Karmaşık SQL sorguları okunması ve bakımı zor olabilir.
• Güvenlik: SQL enjeksiyonu gibi güvenlik açıklarına yol açabilir.
• Tekrarlayan Kod: Aynı tablolara yönelik sorgular sürekli tekrar edebilir.

Eloquent, bu sorunları çözmek için bir soyutlama katmanı sunar. Her veritabanı tablosu için bir “Model” sınıfı oluşturulur. Bu model, o tablodaki kayıtları temsil eden nesnelerle etkileşime girmemizi sağlar. Örneğin, bir users tablonuz varsa, bir User modeli oluşturursunuz ve bu model üzerinden kullanıcıları sorgulayabilir, oluşturabilir, güncelleyebilir veya silebilirsiniz. Eloquent’in başlıca avantajları şunlardır:

• Okunabilirlik ve Bakım Kolaylığı: Nesne tabanlı sözdizimi sayesinde sorgular daha anlaşılır olur.
• Veritabanı Bağımsızlığı: Farklı veritabanı sistemleri (MySQL, PostgreSQL, SQLite, SQL Server) arasında kolayca geçiş yapmanızı sağlar.
• Güvenlik: Parametreli sorgular kullanarak SQL enjeksiyonu riskini azaltır.
• Gelişmiş Özellikler: İlişkiler, koleksiyonlar, mutator’lar, erişimciler ve sorgu kapsamları gibi güçlü özellikler sunar.
• Geliştirme Hızı: Tekrarlayan kod miktarını azaltarak geliştirme sürecini hızlandırır.

Model Tanımlama ve Temel Yapı

Eloquent ile çalışmaya başlamadan önce, veritabanı tablolarınızı temsil eden modelleri oluşturmanız gerekir. Laravel, bu işlemi make:model Artisan komutuyla kolaylaştırır.

php artisan make:model Post

Bu komut, app/Models dizini altında Post.php adında bir dosya oluşturur. Oluşturulan modelin temel yapısı şöyledir:

 posts).
    // protected $table = 'my_posts';

    // Birincil anahtarın adı. Varsayılan olarak 'id'dir.
    // protected $primaryKey = 'post_id';

    // Birincil anahtarın otomatik artan olup olmadığı. Varsayılan olarak true'dur.
    // public $incrementing = false;

    // Birincil anahtarın türü. Varsayılan olarak int'dir.
    // protected $keyType = 'string';

    // created_at ve updated_at zaman damgalarının otomatik olarak yönetilip yönetilmeyeceği. Varsayılan olarak true'dur.
    // public $timestamps = false;

    // Zaman damgalarının formatı. Varsayılan olarak 'Y-m-d H:i:s'dir.
    // protected $dateFormat = 'U';

    // Toplu atama (mass assignment) sırasında izin verilen sütunlar.
    // protected $fillable = ['title', 'content', 'user_id'];

    // Toplu atama sırasında korunacak (izin verilmeyen) sütunlar.
    // protected $guarded = ['id'];
}

Modeliniz, varsayılan olarak model adının çoğul haliyle aynı ada sahip bir veritabanı tablosuyla eşleşir (örn. User modeli users tablosuyla). Bu varsayılanı protected $table özelliği ile değiştirebilirsiniz. Benzer şekilde, birincil anahtar (id) ve zaman damgaları (created_at, updated_at) gibi diğer özellikler de özelleştirilebilir.

Temel Veri Çekme İşlemleri

Eloquent, veritabanından veri çekmek için sezgisel ve güçlü yöntemler sunar.

all(): Tüm Kayıtları Çekme

Bir tablodaki tüm kayıtları almak için all() metodunu kullanabilirsiniz:

use App\Models\Post;

$posts = Post::all(); // SELECT * FROM posts

Bu metod, modelin tüm örneklerini içeren bir Illuminate\Database\Eloquent\Collection nesnesi döndürür.

find($id) ve findOrFail($id): Belirli Bir ID’ye Göre Kayıt Çekme

Belirli bir birincil anahtara (ID) sahip tek bir kaydı almak için find() metodunu kullanın:

use App\Models\Post;

$post = Post::find(1); // SELECT * FROM posts WHERE id = 1 LIMIT 1

if ($post) {
    echo $post->title;
}

Eğer belirtilen ID’ye sahip bir kayıt bulunamazsa, find() metodu null döndürür. Eğer kaydın kesinlikle var olmasını bekliyorsanız ve bulunamadığında bir 404 HTTP hatası fırlatmak istiyorsanız, findOrFail() metodunu kullanabilirsiniz:

use App\Models\Post;

$post = Post::findOrFail(1); // Eğer bulunamazsa bir ModelNotFoundException fırlatır.

Birden fazla ID ile kayıt çekmek için find() metoduna bir dizi ID geçirebilirsiniz:

use App\Models\Post;

$posts = Post::find([1, 2, 3]); // SELECT * FROM posts WHERE id IN (1, 2, 3)

first() ve firstOrFail(): İlk Kaydı Çekme

Bir sorgunun sonucundaki ilk kaydı almak için first() metodunu kullanın:

use App\Models\Post;

$post = Post::where('published', true)->first(); // SELECT * FROM posts WHERE published = 1 LIMIT 1

Yine, findOrFail() gibi, firstOrFail() metodu da eğer sonuç bulunamazsa bir ModelNotFoundException fırlatır:

use App\Models\Post;

$post = Post::where('slug', 'my-first-post')->firstOrFail();

get(): Sorgu Sonucunu Koleksiyon Olarak Alma

where gibi sorgu kısıtlamaları uyguladıktan sonra sonuçları almak için get() metodunu kullanın. Bu metod her zaman bir Collection nesnesi döndürür:

use App\Models\Post;

$publishedPosts = Post::where('published', true)->get(); // SELECT * FROM posts WHERE published = 1

value('column'): Tek Bir Sütun Değeri Alma

Bir kaydın tek bir sütun değerini almak için value() metodunu kullanabilirsiniz:

use App\Models\Post;

$title = Post::where('id', 1)->value('title'); // SELECT title FROM posts WHERE id = 1 LIMIT 1

pluck('column', 'key'): Sütunları Anahtar/Değer Çiftleri Olarak Alma

Belirli bir sütunun değerlerini almak veya bir anahtar/değer çiftleri listesi oluşturmak için pluck() metodunu kullanın:

use App\Models\Post;

$titles = Post::pluck('title'); // Sadece başlıkları içeren bir koleksiyon
// ['Post Başlığı 1', 'Post Başlığı 2', ...]

$titlesWithIds = Post::pluck('title', 'id'); // ID'leri anahtar, başlıkları değer olarak içeren bir koleksiyon
// [1 => 'Post Başlığı 1', 2 => 'Post Başlığı 2', ...]

Sorgu Kısıtlamaları (Where Clause)

Veritabanından belirli koşullara uyan kayıtları çekmek için where() metodunu ve çeşitli varyasyonlarını kullanırız.

Temel where() Kullanımı

En temel kullanımda, where() metodu üç argüman alır: sütun adı, operatör ve değer. Operatör varsayılan olarak =‘dir.

use App\Models\Post;

// Eşitlik kontrolü (operatör = ise üçüncü argüman isteğe bağlıdır)
$posts = Post::where('user_id', 1)->get(); // SELECT * FROM posts WHERE user_id = 1

// Operatör ile kullanım
$posts = Post::where('views', '>', 100)->get(); // SELECT * FROM posts WHERE views > 100

$posts = Post::where('status', '!=', 'draft')->get(); // SELECT * FROM posts WHERE status != 'draft'

orWhere(): VEYA Koşulu

Birden fazla koşuldan herhangi birinin doğru olmasını istiyorsanız orWhere() metodunu kullanın:

use App\Models\Post;

$posts = Post::where('user_id', 1)
             ->orWhere('views', '>', 500)
             ->get(); // SELECT * FROM posts WHERE user_id = 1 OR views > 500

Daha karmaşık VEYA koşulları için, bir Closure (kapatma) kullanabilirsiniz:

use App\Models\Post;

$posts = Post::where('user_id', 1)
             ->where(function ($query) {
                 $query->where('views', '>', 500)
                       ->orWhere('comments_count', '>', 10);
             })
             ->get();
// SELECT * FROM posts WHERE user_id = 1 AND (views > 500 OR comments_count > 10)

whereIn(), whereNotIn(): Belirli Bir Dizi İçinde/Dışında Olma

Bir sütunun değerinin belirli bir dizi içinde olup olmadığını kontrol etmek için whereIn() veya whereNotIn() kullanın:

use App\Models\Post;

$posts = Post::whereIn('status', ['published', 'archived'])->get(); // WHERE status IN ('published', 'archived')
$posts = Post::whereNotIn('status', ['draft'])->get(); // WHERE status NOT IN ('draft')

whereBetween(), whereNotBetween(): Aralık Sorguları

Bir sütunun değerinin belirli bir aralıkta olup olmadığını kontrol etmek için:

use App\Models\Post;

$posts = Post::whereBetween('views', [100, 500])->get(); // WHERE views BETWEEN 100 AND 500
$posts = Post::whereNotBetween('views', [100, 500])->get(); // WHERE views NOT BETWEEN 100 AND 500

whereNull(), whereNotNull(): NULL Kontrolü

Bir sütunun değerinin NULL olup olmadığını kontrol etmek için:

use App\Models\Post;

$posts = Post::whereNull('deleted_at')->get(); // WHERE deleted_at IS NULL
$posts = Post::whereNotNull('published_at')->get(); // WHERE published_at IS NOT NULL

whereDate(), whereMonth(), whereDay(), whereYear(), whereTime(): Tarih ve Zaman Sorguları

Tarih ve zaman sütunları üzerinde özel sorgular yapmak için:

use App\Models\Post;

$posts = Post::whereDate('created_at', '2023-10-26')->get();
$posts = Post::whereMonth('created_at', '10')->get();
$posts = Post::whereDay('created_at', '26')->get();
$posts = Post::whereYear('created_at', '2023')->get();
$posts = Post::whereTime('created_at', '>', '12:00:00')->get();

whereColumn(): İki Sütunu Karşılaştırma

İki sütunun değerlerini karşılaştırmak için:

use App\Models\Product;

$products = Product::whereColumn('price', '>', 'cost')->get(); // WHERE price > cost

whereJsonContains(): JSON Sütunlarında Sorgu

Eğer veritabanınızda JSON sütunları kullanıyorsanız, bu sütunlardaki değerleri sorgulamak için whereJsonContains() metodunu kullanabilirsiniz:

use App\Models\Order;

// 'options' JSON sütununda 'color' anahtarının 'red' değerini içerdiği siparişleri bul.
$orders = Order::whereJsonContains('options->color', 'red')->get();

Sıralama, Gruplama ve Limit/Offset

orderBy('column', 'direction'): Sıralama

Sorgu sonuçlarını belirli bir sütuna göre sıralamak için orderBy() kullanın. Yön asc (artan) veya desc (azalan) olabilir:

use App\Models\Post;

$posts = Post::orderBy('created_at', 'desc')->get(); // ORDER BY created_at DESC
$posts = Post::orderBy('title', 'asc')->get(); // ORDER BY title ASC

Kısayol olarak latest() ve oldest() metodları da kullanılabilir. Varsayılan olarak created_at sütununu kullanırlar:

use App\Models\Post;

$latestPosts = Post::latest()->get(); // ORDER BY created_at DESC
$oldestPosts = Post::oldest()->get(); // ORDER BY created_at ASC

groupBy() ve having(): Gruplama

Sorgu sonuçlarını belirli bir sütuna göre gruplamak için groupBy() kullanın. Gruplar üzerinde koşul uygulamak için having() kullanın (SQL’deki HAVING gibi):

use App\Models\Post;

$postsByUser = Post::selectRaw('user_id, count(*) as post_count')
                   ->groupBy('user_id')
                   ->having('post_count', '>', 5)
                   ->get();
// SELECT user_id, count(*) as post_count FROM posts GROUP BY user_id HAVING post_count > 5

limit() / take() ve offset() / skip(): Kayıt Sayısını Sınırlama ve Atlama

Sorgu sonucunda dönecek kayıt sayısını sınırlamak için limit() veya take() kullanın. Belirli bir sayıdan sonraki kayıtları almak için offset() veya skip() kullanın:

use App\Models\Post;

$firstTenPosts = Post::limit(10)->get(); // LIMIT 10
$nextTenPosts = Post::offset(10)->limit(10)->get(); // OFFSET 10 LIMIT 10

paginate(): Sayfalama

Büyük veri kümelerini yönetmek ve kullanıcı arayüzünde sayfalama sağlamak için paginate() metodunu kullanın:

use App\Models\Post;

$posts = Post::paginate(15); // Her sayfada 15 kayıt göster

Bu metod, sayfalama bağlantılarını oluşturmak için gerekli tüm bilgileri içeren bir LengthAwarePaginator örneği döndürür.

İlişkisel Verilerle Çalışma (Relationships)

İlişkisel veritabanlarının en güçlü yanlarından biri, tablolar arasındaki bağlantılardır. Eloquent, bu ilişkileri model seviyesinde tanımlamanıza ve kolayca erişmenize olanak tanır. En yaygın ilişki türleri şunlardır:

İlişki Türleri

• One To One (Bire Bir): Bir modelin diğer bir modelle tek bir kaydının olması (örn. User’ın tek bir Phone’u olabilir).
• One To Many (Bire Çok): Bir modelin diğer bir modelle birden çok kaydının olması (örn. User’ın birden çok Post’u olabilir).
• Many To One (Çoktan Bire): One To Many’nin tersi (örn. Post’un tek bir User’ı olabilir).
• Many To Many (Çoktan Çoğa): Her iki modelin de diğer modelle birden çok kaydının olması (örn. User’ın birden çok Role’ü olabilir ve bir Role’ün birden çok User’ı olabilir). Bu genellikle bir pivot tablo (ara tablo) gerektirir.
• Has Many Through (Aracılığıyla Bire Çok): Uzak bir ilişkiye bir ara model aracılığıyla erişmek (örn. Country’nin Post’ları, User aracılığıyla).
• Polimorfik İlişkiler: Tek bir modelin birden fazla farklı modelle ilişkili olabilmesi (örn. Comment modelinin hem Post hem de Video ile ilişkili olması).

İlişki Tanımlama Örnekleri

Örneğin, bir User modelinin birden çok Post‘u olduğunu varsayalım:

// app/Models/User.php
class User extends Model
{
    public function posts()
    {
        return $this->hasMany(Post::class); // Bir kullanıcının birden çok gönderisi var
    }
}

// app/Models/Post.php
class Post extends Model
{
    public function user()
    {
        return $this->belongsTo(User::class); // Bir gönderinin tek bir kullanıcısı var
    }
}

İlişkileri Yükleme (Eager Loading)

İlişkili verilere erişirken “N+1 Sorgu Problemi” ile karşılaşmamak için Eager Loading kullanmak önemlidir. Bu problem, her ana model için ayrı bir sorgu çalıştırıldığında ortaya çıkar. with() metodu, ilişkili modelleri ana sorguyla birlikte yükleyerek bu problemi çözer:

use App\Models\Post;

// N+1 Problemi: Her post için ayrı bir user sorgusu çalışır
$posts = Post::all();
foreach ($posts as $post) {
    echo $post->user->name; // Her döngüde bir veritabanı sorgusu
}

// Eager Loading ile N+1 Problemini Önleme
$posts = Post::with('user')->get(); // Tek sorguda tüm postları ve ilişkili kullanıcıları çeker
foreach ($posts as $post) {
    echo $post->user->name; // Veritabanı sorgusu yok
}

Birden fazla ilişkiyi veya iç içe ilişkileri de yükleyebilirsiniz:

use App\Models\Post;

$posts = Post::with('user', 'comments.user')->get();

İlişki Kısıtlamaları

İlişkili modelleri yüklerken, bu ilişkiler üzerinde koşullar da belirleyebilirsiniz:

use App\Models\User;

// Sadece aktif gönderileri olan kullanıcıları ve bu aktif gönderilerini yükle
$users = User::with(['posts' => function ($query) {
    $query->where('published', true);
}])->get();

İlişkili Kayıtların Sayısını Çekme

Bir ilişkiyle ilgili kayıtların sayısını çekmek için withCount() metodunu kullanabilirsiniz:

use App\Models\User;

$users = User::withCount('posts')->get();
foreach ($users as $user) {
    echo $user->name . ' has ' . $user->posts_count . ' posts.';
}

Benzer şekilde, withSum(), withMax(), withMin(), withAvg() gibi metodlar da mevcuttur.

İlişkili Modeldeki Koşullara Göre Filtreleme

İlişkili bir modeldeki bir koşula göre ana modeli filtrelemek için whereHas() veya orWhereHas() kullanın:

use App\Models\User;

// En az bir yayınlanmış gönderisi olan kullanıcıları getir
$users = User::whereHas('posts', function ($query) {
    $query->where('published', true);
})->get();

// Hiç gönderisi olmayan kullanıcıları getir
$usersWithoutPosts = User::doesntHave('posts')->get();

Gelişmiş Sorgulama Teknikleri

Sorgu Kapsamları (Query Scopes)

Sorgu kapsamları, uygulamanızda sık kullanılan sorgu kısıtlamalarını yeniden kullanılabilir metodlar halinde paketlemenizi sağlar. Bu, kod tekrarını azaltır ve sorgularınızı daha okunabilir hale getirir.

Local Scopes

Bir modelde scope ile başlayan bir metod tanımlayarak yerel kapsamlar oluşturursunuz:

// app/Models/Post.php
class Post extends Model
{
    public function scopePublished($query)
    {
        return $query->where('published', true);
    }

    public function scopeViewsGreaterThan($query, $views)
    {
        return $query->where('views', '>', $views);
    }
}

Bu kapsamları sorgularınızda zincirleme olarak kullanabilirsiniz:

use App\Models\Post;

$publishedPosts = Post::published()->get(); // SELECT * FROM posts WHERE published = 1
$popularPosts = Post::published()->viewsGreaterThan(1000)->get(); // SELECT * FROM posts WHERE published = 1 AND views > 1000

Global Scopes

Tüm sorgulara otomatik olarak uygulanan kapsamlar için global kapsamlar kullanılır. Örneğin, “soft delete” (yumuşak silme) özelliği global bir kapsamdır.

Ham SQL Sorguları ve DB Facade

Eloquent çoğu durumda yeterli olsa da, bazen çok karmaşık veya performansa duyarlı sorgular için ham SQL yazmanız gerekebilir. Laravel’ın DB Facade’ı, ham SQL sorguları çalıştırmak için bir arayüz sağlar.

use Illuminate\Support\Facades\DB;

// SELECT sorgusu
$users = DB::select('SELECT * FROM users WHERE active = ?', [1]);

// INSERT, UPDATE, DELETE gibi statement'lar
DB::statement('DROP TABLE users');

// Ham ifadeleri sorgu builder ile kullanma
$users = DB::table('users')
           ->select(DB::raw('count(*) as user_count, status'))
           ->whereRaw('age > ?', [25])
           ->groupBy('status')
           ->get();

DB::raw() metodu, bir string’in doğrudan SQL sorgusuna eklenmesini sağlar, bu da SQL enjeksiyonu riskini artırabilir, dikkatli kullanılmalıdır. Genellikle selectRaw(), whereRaw(), havingRaw() gibi metodlar daha güvenli bir alternatiftir, çünkü parametre bağlamayı desteklerler.

Sorgu Builder ile Eloquent Farkı

Eloquent, Laravel’ın sorgu oluşturucusunun (Query Builder) üzerine inşa edilmiştir. Temel farklar şunlardır:

• Dönüş Değeri: Eloquent, model örnekleri (nesneleri) döndürürken, Query Builder genellikle stdClass nesneleri veya diziler döndürür.
• İlişkiler ve Model Özellikleri: Eloquent, ilişkileri, erişimcileri, mutator’ları ve diğer model özelliklerini destekler. Query Builder bu özellikleri sağlamaz.
• Kullanım Kolaylığı: Eloquent, model odaklı bir yaklaşım sunduğu için daha yüksek seviyeli ve okunabilirdir.

Genel olarak, bir modeliniz varsa ve modelin özelliklerinden (ilişkiler, mutator’lar vb.) faydalanmak istiyorsanız Eloquent’i kullanmalısınız. Eğer sadece basit veritabanı etkileşimi yapıyorsanız veya çok karmaşık, özel bir sorguya ihtiyacınız varsa Query Builder veya ham SQL daha uygun olabilir.

Aggregates (Toplama Fonksiyonları)

Eloquent, COUNT, MAX, MIN, AVG, SUM gibi toplama fonksiyonlarını kolayca kullanmanızı sağlar:

use App\Models\Post;

$postCount = Post::count(); // SELECT COUNT(*) FROM posts
$maxViews = Post::max('views'); // SELECT MAX(views) FROM posts
$minViews = Post::min('views'); // SELECT MIN(views) FROM posts
$averageViews = Post::avg('views'); // SELECT AVG(views) FROM posts
$totalViews = Post::sum('views'); // SELECT SUM(views) FROM posts

Performans İpuçları ve En İyi Uygulamalar

Veritabanı sorguları, bir uygulamanın performansı üzerinde önemli bir etkiye sahip olabilir. İşte Eloquent ile çalışırken dikkate almanız gereken bazı performans ipuçları:

• N+1 Problemini Önleyin: İlişkili verileri çekerken her zaman with() ile Eager Loading kullanın. Bu, her ilişkili kayıt için ayrı bir sorgu çalıştırmak yerine tek bir sorgu ile tüm verileri çekmenizi sağlar.
• Gereksiz Sütunları Çekmeyin: Sadece ihtiyacınız olan sütunları seçmek için select() metodunu kullanın. SELECT * yerine SELECT id, title, content gibi belirli sütunları çekmek, veritabanı ve ağ yükünü azaltır.

$posts = Post::select('id', 'title', 'content')->get();

// chunk(): Belirli bir sayıda kaydı alıp bir Closure içinde işler
Post::chunk(200, function ($posts) {
    foreach ($posts as $post) {
        // Post'ları işle
    }
});

// cursor(): Her kaydı tek tek bir generator olarak çeker, bellek kullanımı çok düşüktür
foreach (Post::cursor() as $post) {
    // Post'ları işle
}

$posts = Cache::remember('all_posts', 60, function () {
    return Post::all();
});

Sonuç

Laravel’ın Eloquent ORM’i, veritabanı etkileşimlerini basitleştiren ve hızlandıran olağanüstü güçlü bir araçtır. Temel veri çekme işlemlerinden karmaşık ilişki yönetimine, sorgu kapsamlarından performans optimizasyonlarına kadar geniş bir yelpazede yetenekler sunar. Bu makalede ele aldığımız teknikleri kullanarak, uygulamanızın veritabanı katmanını daha okunabilir, bakımı kolay ve performanslı hale getirebilirsiniz. Eloquent’i etkin bir şekilde kullanmak, Laravel geliştiricilerinin üretkenliğini artırmanın ve sağlam, ölçeklenebilir uygulamalar oluşturmanın anahtarlarından biridir.

Unutmayın ki her araçta olduğu gibi, Eloquent’i en verimli şekilde kullanmak için altta yatan veritabanı prensiplerini ve SQL’i anlamak her zaman faydalıdır. İyi kodlama!