MySQL'de saklı yordamlar nasıl kullanılır?

giriiş

İlişkisel bir veritabanıyla çalışırken, genellikle uygulama kodunuzdan doğrudan SELECT, INSERT, UPDATE veya DELETE gibi verileri almak veya işlemek için Yapılandırılmış Sorgu Dili (SQL) ifadeleri kullanırsınız. Bu ifadeler, doğrudan temel veritabanı tabloları üzerinde çalışır ve bu tabloları işler. Aynı veritabanına erişen birden fazla uygulamada aynı ifadeler veya ifade grupları kullanıldığında, genellikle farklı uygulamalar arasında tekrarlanırlar.

MySQL, diğer birçok ilişkisel veritabanı yönetim sistemi gibi, saklı yordamların kullanımını destekler. Saklı yordamlar, bir veya daha fazla SQL ifadesinin ortak bir ad altında yeniden kullanılmak üzere gruplanmasına yardımcı olur ve ortak iş mantığını veritabanının kendisinde kapsüller. Böyle bir yordam, verileri tutarlı bir şekilde almak veya işlemek için veritabanına erişen bir uygulamadan çağrılabilir.

Saklı yordamları kullanarak, birden fazla uygulamada kullanılacak ortak görevler için yeniden kullanılabilir rutinler oluşturabilir, verileri doğrulayabilir veya veritabanı kullanıcılarının temel tablolara doğrudan erişmesini ve keyfi sorgular göndermesini kısıtlayarak ek bir veri erişim güvenliği katmanı sağlayabilirsiniz.

Bu eğitimde saklı yordamların ne olduğunu ve veri döndüren, giriş ve çıkış parametrelerini kullanan temel saklı yordamların nasıl oluşturulacağını öğreneceksiniz.

Ö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ı ve saklı yordamların sözdiziminin resmi SQL standardının bir parçası olmadığını lütfen unutmayın. Bu eğitimde belirtilen komutlar diğer RDBMS'lerde çalışabilse de, saklı yordamlar veritabanına özgüdür ve bu nedenle MySQL dışında bir sistemde test ederseniz kesin sözdizimi veya çıktı farklı olabilir.

Ayrıca, saklı yordamları kullanarak tablolar oluşturabileceğiniz boş bir veritabanına da ihtiyacınız olacak. Bu kılavuzdaki örneklerde kullanılan MySQL sunucusuna bağlanma ve 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 örnek bir veritabanı oluşturacaksınız.

Bu rehberde kurgusal bir araba koleksiyonu kullanacaksınız. Şu anda sahip olduğunuz arabaların marka, model, üretim yılı ve değeri gibi bilgilerini saklayacaksı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

Procedures adında bir veritabanı oluşturun:

CREATE DATABASE procedures;

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

Output
Query OK, 1 row affected (0.01 sec)

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

USE procedures;

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

Output
Database changed

Bir veritabanı seçtikten sonra, içinde örnek tablolar oluşturabilirsiniz. "Makineler" tablosu, veritabanındaki makineler hakkında basitleştirilmiş veriler içerecektir. Aşağıdaki sütunları içerir:

• make: Bu sütun, sahip olduğu her arabayı temsil eder ve en fazla 100 karakter uzunluğunda varchar veri türü kullanılarak ifade edilir.
• Model: Bu sütun, en fazla 100 karakter uzunluğunda, varchar veri tipi kullanılarak ifade edilen araç model adını içerir.
• yıl: Bu sütun, sayısal değerleri tutmak için int veri türünde aracın üretim yılını depolar.
• Değer: Bu sütun, aracın değerini, noktadan sonra en fazla 10 hane ve 2 hane olacak şekilde ondalık veri türünü kullanarak depolar.

Aşağıdaki komutla örnek tabloyu oluşturun:

CREATE TABLE cars (
make varchar(100),
model varchar(100),
year int,
value decimal(10, 2)
);

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 Cars tablosunu örnek verilerle yükleyin:

INSERT INTO cars
VALUES
('Porsche', '911 GT3', 2020, 169700),
('Porsche', 'Cayman GT4', 2018, 118000),
('Porsche', 'Panamera', 2022, 113200),
('Porsche', 'Macan', 2019, 27400),
('Porsche', '718 Boxster', 2017, 48880),
('Ferrari', '488 GTB', 2015, 254750),
('Ferrari', 'F8 Tributo', 2019, 375000),
('Ferrari', 'SF90 Stradale', 2020, 627000),
('Ferrari', '812 Superfast', 2017, 335300),
('Ferrari', 'GTC4Lusso', 2016, 268000);

INSERT INTO işlemi, tabloya beş Porsche ve beş Ferrari modeli olmak üzere on örnek spor otomobil ekler. Aşağıdaki çıktı, beş satırın da eklendiğini göstermektedir:

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

Artık kılavuzun geri kalanını takip etmeye ve SQL'de saklı yordamları kullanmaya başlamaya hazırsınız.

Saklı Yordamlara Giriş

MySQL ve diğer birçok ilişkisel veritabanı sistemindeki saklı yordamlar, veritabanı tarafından çağrıldığında sırayla yürütülen bir veya daha fazla talimat içeren nesneler olarak adlandırılır. En temel örnekte, bir saklı yordam, sık kullanılan filtreler içeren bir veritabanından veri almak gibi, yeniden kullanılabilir bir rutin altında ortak bir ifadeyi depolayabilir. Örneğin, bir çevrimiçi mağazanın son birkaç ay içinde sipariş veren müşterilerini almak için bir saklı yordam oluşturabilirsiniz. En karmaşık senaryolarda, saklı yordamlar, güçlü uygulamalar için karmaşık iş mantığını tanımlayan kapsamlı programları temsil edebilir.

Saklı yordamdaki talimat kümesi, verileri döndüren veya işleyen SELECT veya INSERT sorguları gibi yaygın SQL ifadelerini içerebilir. Ayrıca, saklı yordamlar şunları kullanabilir:

• Parametreler saklı yordama geçirilir veya saklı yordamdan döndürülür.
• Alınan verileri doğrudan prosedür kodunda işlemek için tanımlanan değişkenler.
• Koşullu ifadeler, saklı yordam kodunun belirli koşullara bağlı olarak yürütülmesine izin verir, örneğin IF veya CASE ifadeleri.
• WHILE, LOOP ve REPEAT gibi döngüler, alınan bir veri kümesindeki her satır için olduğu gibi, kod bölümlerinin birden çok kez yürütülmesine olanak tanır.
• Prosedüre erişimi olan veritabanı kullanıcılarına hata mesajları döndürmek gibi hata işleme talimatları.
• Veritabanındaki diğer saklı yordamları çağırmak.

Not: MySQL tarafından desteklenen kapsamlı sözdizimi, güçlü programlar yazmayı ve saklı yordamlarla karmaşık sorunları çözmeyi mümkün kılar. Bu kılavuz, saklı yordam gövdesinde, giriş ve çıkış parametrelerinde SQL ifadeleri bulunan saklı yordamların yalnızca temel kullanımını ele almaktadır. Koşullu kod yürütme, değişken kullanımı, döngüler ve özel hata yönetimi bu kılavuzun kapsamı dışındadır. Resmi MySQL belgelerinde saklı yordamlar hakkında daha fazla bilgi edinmenizi öneririz.

Prosedür ismiyle çağrıldığında, veritabanı motoru onu tanımlandığı şekilde, talimat talimat yürütür.

Veritabanı kullanıcısı, belirtilen prosedürü yürütmek için uygun izinlere sahip olmalıdır. Bu izin gereksinimi, veritabanına doğrudan erişimi engellerken, kullanıcıların güvenli bir şekilde yürütülebilecek bireysel prosedürlere erişmesine izin veren bir güvenlik katmanı sağlar.

Saklı yordamlar doğrudan veritabanı sunucusunda çalışır, tüm hesaplamaları yerel olarak gerçekleştirir ve sonuçları yalnızca tamamlandıktan sonra çağıran kullanıcıya döndürür.

Bir prosedürün davranışını değiştirmek isterseniz, prosedürü veritabanında güncelleyebilirsiniz ve onu kullanan uygulamalar yeni sürümü otomatik olarak alır. Tüm kullanıcılar, uygulamalarında herhangi bir değişiklik yapmak zorunda kalmadan yeni prosedür kodunu hemen kullanmaya başlar.

Saklı yordam oluşturmak için kullanılan SQL kodunun genel yapısı şöyledir:

DELIMITER //
CREATE PROCEDURE procedure_name(parameter_1, parameter_2, . . ., parameter_n)
BEGIN
instruction_1;
instruction_2;
. . .
instruction_n;
END //
DELIMITER ;

Bu kod parçacığındaki ilk ve son talimatlar DELIMITER // ve DELIMITER ;'dir. MySQL, ifadeleri ayırmak ve ne zaman başlayıp ne zaman bittiklerini belirtmek için genellikle noktalı virgül (;) karakterini kullanır. MySQL konsolunda noktalı virgülle ayrılmış birden fazla komut çalıştırırsanız, bunlar ayrı komutlar olarak ele alınır ve birbiri ardına bağımsız olarak çalışır. Ancak, bir saklı yordam, çağrıldığında ardışık olarak yürütülen birden fazla komut içerebilir. Bu durum, MySQL'e yeni bir prosedür oluşturmasını söylemeye çalıştığınızda bir soruna neden olur. Veritabanı motoru, saklı yordamın gövdesinde noktalı virgül karakteriyle karşılaşır ve komutu yürütmeyi durdurması gerektiğini düşünür. Bu durumda, söz konusu komut, prosedürün kendisindeki tek bir talimat değil, tüm prosedür oluşturma kodudur ve MySQL amacınızı yanlış yorumlar.

Bu sınırlamayı aşmak için, CREATE PROCEDURE çağrısı süresince ayırıcıyı geçici olarak ; yerine // olarak değiştirmek için DELIMITER ifadesini kullanın. Ardından, saklı yordam gövdesindeki tüm noktalı virgüller sunucuya olduğu gibi gönderilir. Tüm yordam tamamlandıktan sonra, ayırıcı ; olarak değiştirilir ve son DELIMITER ; olur.

Yeni bir prosedür oluşturma kodunun kalbi, CREATE PROCEDURE çağrısıdır ve ardından prosedür adı gelir: örnekte procedure_name. Prosedür adının ardından, prosedürün kabul ettiği isteğe bağlı bir parametre listesi gelir. Son kısım ise BEGIN ve END ifadeleri arasında yer alan prosedür gövdesidir. Prosedür kodunun içinde, SELECT sorgusu gibi bir SQL ifadesi veya daha karmaşık bir kod içerebilen bir şey bulunur.

END komutu, normal noktalı virgül yerine geçici bir ayırıcı olan // ile biter.

Sonraki bölümde, bir sorguyu kapsülleyen temel bir parametresiz saklı yordam oluşturacaksınız.

Parametresiz saklı yordam oluşturma

Bu bölümde, markaya göre sıralanmış arabaların listesini ve değerlerini azalan düzende döndüren bir SQL SELECT ifadesi içeren ilk saklı yordamınızı oluşturacaksınız.

Kullanmak istediğiniz SELECT ifadesini çalıştırarak başlayın:

SELECT * FROM cars ORDER BY make, value DESC;

Veritabanı, Arabalar tablosundan, önce markaya göre, sonra da bir markanın içindeki arabaların değerlerini azalan sırada gösteren bir liste döndürür:

Output
+---------+---------------+------+-----------+
| make | model | year | value |
+---------+---------------+------+-----------+
| Ferrari | SF90 Stradale | 2020 | 627000.00 |
| Ferrari | F8 Tributo | 2019 | 375000.00 |
| Ferrari | 812 Superfast | 2017 | 335300.00 |
| Ferrari | GTC4Lusso | 2016 | 268000.00 |
| Ferrari | 488 GTB | 2015 | 254750.00 |
| Porsche | 911 GT3 | 2020 | 169700.00 |
| Porsche | Cayman GT4 | 2018 | 118000.00 |
| Porsche | Panamera | 2022 | 113200.00 |
| Porsche | 718 Boxster | 2017 | 48880.00 |
| Porsche | Macan | 2019 | 27400.00 |
+---------+---------------+------+-----------+
10 rows in set (0.00 sec)

En değerli Ferrari listenin en üstünde, en değersiz Porsche ise en altta yer alıyor.

Diyelim ki bu sorgu birden fazla uygulamada veya birden fazla kullanıcı tarafından tekrar tekrar kullanılıyor ve herkesin sonuçları sıralamak için aynı yöntemi kullandığından emin olmak istiyorsunuz. Bunu yapmak için, bu ifadeyi yeniden kullanılabilir bir adlandırılmış prosedür altında depolayan bir saklı prosedür oluşturmak istiyorsunuz.

Bu saklı yordamı oluşturmak için aşağıdaki kod parçacığını çalıştırın:

DELIMITER //
CREATE PROCEDURE get_all_cars()
BEGIN
SELECT * FROM cars ORDER BY make, value DESC;
END //
DELIMITER ;

Önceki bölümde açıklandığı gibi, ilk ve son ifadeler (DELIMITER // ve DELIMITER 😉), MySQL'e prosedür oluşturma süresince ifade ayırıcı olarak noktalı virgül karakterini yok saymasını söyler.

CREATE PROCEDURE SQL ifadesinin ardından, işlemin ne yaptığını en iyi şekilde tanımlamak için tanımlayabileceğiniz get_all_cars işlem adı gelir. İşlem adından sonra, parametreler ekleyebileceğiniz bir çift parantez () bulunur. Bu örnekte, işlem parametre kullanmadığı için parantezler boştur. Ardından, işlem kod bloğunun başlangıcını ve sonunu tanımlayan BEGIN ve END ifadeleri arasına, daha önce kullanılan SELECT ifadesi aynen yazılır.

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

Output
Query OK, 0 rows affected (0.02 sec)

get_all_cars prosedürü artık veritabanında saklanıyor ve çağrıldığında saklanan ifadeyi olduğu gibi yürütüyor.

Saklı bir prosedürü çalıştırmak için, CALL SQL komutunu ve ardından prosedür adını kullanabilirsiniz. Yeni oluşturulan prosedürü şu şekilde çalıştırmayı deneyin:

CALL get_all_cars;

Prosedürü kullanmak için ihtiyacınız olan tek şey get_all_cars prosedür adıdır. Artık daha önce kullandığınız SELECT ifadesinin hiçbir bölümünü manuel olarak yazmanıza gerek yok. Veritabanı, sonuçları tıpkı SELECT ifadesinin çıktısı gibi yürütür:

Output
+---------+---------------+------+-----------+
| make | model | year | value |
+---------+---------------+------+-----------+
| Ferrari | SF90 Stradale | 2020 | 627000.00 |
| Ferrari | F8 Tributo | 2019 | 375000.00 |
| Ferrari | 812 Superfast | 2017 | 335300.00 |
| Ferrari | GTC4Lusso | 2016 | 268000.00 |
| Ferrari | 488 GTB | 2015 | 254750.00 |
| Porsche | 911 GT3 | 2020 | 169700.00 |
| Porsche | Cayman GT4 | 2018 | 118000.00 |
| Porsche | Panamera | 2022 | 113200.00 |
| Porsche | 718 Boxster | 2017 | 48880.00 |
| Porsche | Macan | 2019 | 27400.00 |
+---------+---------------+------+-----------+
10 rows in set (0.00 sec)
Query OK, 0 rows affected (0.00 sec)

Artık Cars tablosundaki tüm arabaları belirli bir şekilde sıralanmış şekilde döndüren, parametresiz bir saklı yordam başarıyla oluşturdunuz. Bu yöntemi birden fazla uygulamada kullanabilirsiniz.

Sonraki bölümde, kullanıcı girdisine bağlı olarak prosedürün davranışını değiştirmek için parametreler kabul eden bir prosedür oluşturacaksınız.

Giriş parametreleriyle saklı yordam oluşturma

Bu bölümde, saklı yordam tanımına, yordamı çalıştıran kullanıcıların yordama veri aktarmasına olanak tanıyan giriş parametreleri eklersiniz. Örneğin, kullanıcılar sorgu filtreleri sağlayabilir.

Önceki saklı yordam get_all_cars, cars tablosundaki tüm arabaları her zaman alır. Belirli bir üretim yılına ait arabaları bulmak için başka bir yordam oluşturalım. Bunu sağlamak için, yordam tanımında get_all_cars adlı bir parametre tanımlayın.

Aşağıdaki kodu çalıştırın:

DELIMITER //
CREATE PROCEDURE get_cars_by_year(
IN year_filter int
)
BEGIN
SELECT * FROM cars WHERE year = year_filter ORDER BY make, value DESC;
END //
DELIMITER ;

Önceki bölümden prosedür oluşturma kodunda birkaç değişiklik var.

İlk olarak get_cars_by_year ismi, üretim yılına göre arabaları getiren yöntemi anlatıyor.

Önceki boş parantezler artık bir parametre tanımı içeriyor: IN yıl_filtresi int. IN anahtar sözcüğü, veritabanına parametrenin çağıran kullanıcı tarafından prosedüre iletildiğini bildirir. yıl_filtresi, parametre için rastgele bir addır. Prosedür kodunda parametreye atıfta bulunmak için bunu kullanacaksınız. Son olarak, int veri türüdür. Bu durumda, üretim yılı sayısal bir değer olarak ifade edilir.

Prosedür adından sonra tanımlanan year_filter parametresi WHERE year = year_filter ifadesindeki SELECT ifadesinde görünür ve otomobil tablosunu üretim yıllarına göre filtreler.

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

Output
Query OK, 0 rows affected (0.02 sec)

Prosedürü daha önce yaptığınız gibi herhangi bir parametre vermeden çalıştırmayı deneyin:

CALL get_cars_by_year;

MySQL veritabanı bir hata mesajı döndürüyor:

Error message
ERROR 1318 (42000): Incorrect number of arguments for PROCEDURE procedures.get_cars_by_year; expected 1, got 0

Bu sefer, saklı yordam bir parametre sağlanmasını bekliyor, ancak hiçbir parametre sağlanmadı. Parametreli bir saklı yordamı çağırmak için, parametre değerlerini parantez içinde, yordamın beklediği sırayla sağlayabilirsiniz. 2017 yılında üretilen arabaları almak için aşağıdakileri çalıştırın:

CALL get_cars_by_year(2017);

Artık çağrılan prosedür doğru şekilde yürütülür ve o yıla ait arabaların listesini döndürür:

Output
+---------+---------------+------+-----------+
| make | model | year | value |
+---------+---------------+------+-----------+
| Ferrari | 812 Superfast | 2017 | 335300.00 |
| Porsche | 718 Boxster | 2017 | 48880.00 |
+---------+---------------+------+-----------+
2 rows in set (0.00 sec)
Query OK, 0 rows affected (0.00 sec)

Bu örnekte, saklı yordamlara giriş parametrelerinin nasıl geçirileceğini ve bunları bir yordam içindeki sorgularda kullanarak filtreleme seçenekleri sağlamayı öğrendiniz.

Bir sonraki bölümde, tek bir yürütmede birden fazla farklı değer döndüren prosedürler oluşturmak için çıkış parametrelerini kullanacaksınız.

Giriş ve çıkış parametreleriyle saklı yordam oluşturma

Önceki iki örnekte de, oluşturduğunuz saklı yordamlar bir dizi sonuç döndürmek için SELECT ifadesini çağırıyordu. Ancak bazı durumlarda, bir sorgu için tek bir sonuç kümesi yerine birkaç farklı değeri bir arada döndüren bir saklı yordama ihtiyaç duyabilirsiniz.

Belirli bir yıldaki otomobiller hakkında, koleksiyondaki otomobil sayısı ve piyasa değerleri (minimum, maksimum ve ortalama) dahil olmak üzere özet bilgiler sağlayan bir prosedür oluşturmak istediğinizi varsayalım.

Bunu yapmak için, yeni bir saklı yordam oluştururken OUT parametrelerini kullanabilirsiniz. IN parametrelerine benzer şekilde, OUT parametrelerinin de kendilerine ait bir adı ve veri türü vardır. Ancak, saklı yordama veri aktarmak yerine, çağıran kullanıcıya değer döndürmek için saklı yordamdaki verilerle doldurulabilirler.

Çıkış parametrelerini kullanarak, belirli bir üretim yılına ait otomobiller için özet verileri döndüren get_car_stats_by_year prosedürünü oluşturun:

DELIMITER //
CREATE PROCEDURE get_car_stats_by_year(
IN year_filter int,
OUT cars_number int,
OUT min_value decimal(10, 2),
OUT avg_value decimal(10, 2),
OUT max_value decimal(10, 2)
)
BEGIN
SELECT COUNT(*), MIN(value), AVG(value), MAX(value)
INTO cars_number, min_value, avg_value, max_value
FROM cars
WHERE year = year_filter ORDER BY make, value DESC;
END //
DELIMITER ;

Bu sefer, arabaları üretim yılına göre filtrelemek için kullanılan IN parametresi year_filter ile birlikte, parantez bloğunda tanımlanmış dört OUT parametresi bulunmaktadır. cars_number parametresi, int veri türüyle temsil edilir ve kümedeki araba sayısını döndürmek için kullanılır. min_value, avg_value ve max_value parametreleri piyasa değerini temsil eder ve ondalık tür (10, 2) ile tanımlanır (cars tablosundaki değer sütununa benzer). Bunlar, kümedeki en ucuz ve en pahalı arabalar ile eşleşen tüm arabaların ortalama fiyatı hakkında bilgi döndürmek için kullanılır.

SELECT ifadesi, SQL matematiksel fonksiyonlarını kullanarak arabalar tablosundan dört değeri arar: Toplam araba sayısını elde etmek için COUNT ve değer sütunundan minimum, ortalama ve maksimum değerleri elde etmek için MIN, AVG ve MAX.

Veritabanına, bu sorgunun sonuçlarının saklı yordamın çıktı parametrelerinde saklanması gerektiğini bildirmek için INTO adlı yeni bir anahtar sözcük eklendi. INTO anahtar sözcüğünden sonra, alınan verilerle ilgili dört yordam parametresinin adları listelenir. Bu, MySQL'in cars_number parametresinde COUNT(*) değerini, min_value parametresinde MIN(value) sonucunu vb. saklamasına neden olur.

Veritabanı, prosedürün başarıyla oluşturulduğunu doğruluyor:

Output
Query OK, 0 rows affected (0.02 sec)

Şimdi aşağıdakileri çalıştırarak yeni rutini çalıştırın:

CALL get_car_stats_by_year(2017, @number, @min, @avg, @max);

Dört yeni parametre @ simgesiyle başlar. Bunlar, MySQL konsolunda verileri geçici olarak depolamak için kullanabileceğiniz yerel değişkenlerin adlarıdır. Bunları oluşturduğunuz saklı yordama geçirdiğinizde, yordam bu değişkenlere değerler ekler.

Veritabanı aşağıdaki şekilde yanıt verecektir:

Output
Query OK, 1 row affected (0.00 sec)

Bu, sonuçların anında ekranda görüntülendiği önceki davranıştan farklıdır. Bunun nedeni, saklı yordamın sonuçlarının çıktı parametrelerinde depolanması ve sorgu sonuçları olarak döndürülmemesidir. Sonuçlara erişmek için, bunları MySQL kabuğunda aşağıdaki gibi doğrudan seçebilirsiniz:

SELECT @number, @min, @avg, @max;

Bu sorgu ile, prosedürü tekrar çağırmak yerine yerel değişkenlerden değerler seçersiniz. Saklı prosedür, sonuçlarını bu değişkenlerde depolar ve siz kabuktan çıkana kadar veriler kullanılabilir.

Not: MySQL'de kullanıcı tanımlı değişkenlerin kullanımı hakkında daha fazla bilgi için dokümantasyonun Kullanıcı Tanımlı Değişkenler bölümüne bakın. Uygulama geliştirmede kullanıldığında, saklı yordamlardan döndürülen verilere erişim yolları farklı programlama dilleri ve çerçeveleri arasında farklılık gösterecektir. Şüpheniz varsa, seçtiğiniz dil ve çerçevenin dokümantasyonuna bakın.

Çıktıda sorgu değişkenlerinin değerleri görüntülenir:

Output
+---------+----------+-----------+-----------+
| @number | @min | @avg | @max |
+---------+----------+-----------+-----------+
| 2 | 48880.00 | 192090.00 | 335300.00 |
+---------+----------+-----------+-----------+
1 row in set (0.00 sec)

Değerler, 2017 yılında üretilen otomobil sayısını ve bu üretim yılına ait otomobillerin minimum, ortalama ve maksimum piyasa değerini göstermektedir.

Bu örnekte, daha sonra kullanılmak üzere bir saklı yordam içinden birden fazla farklı değer döndürmek için çıkış parametrelerinin nasıl kullanılacağını öğrendiniz. Bir sonraki bölümde, oluşturulan yordamların nasıl silineceğini öğreneceksiniz.

Saklı prosedürleri sil

Bu bölümde veritabanındaki saklı yordamları sileceksiniz.

Bazen oluşturduğunuz bir prosedüre artık ihtiyaç duyulmayabilir. Bazı durumlarda ise, prosedürün çalışma şeklini değiştirmek isteyebilirsiniz. MySQL, bir prosedürün tanımını oluşturulduktan sonra değiştirmenize izin vermez, bu nedenle tek yol önce prosedürü silmek ve ardından istenen değişikliklerle yeniden oluşturmaktır.

Son prosedür olan get_car_stats_by_year'ı bırakalım. Bunu yapmak için DROP PROCEDURE ifadesini kullanabilirsiniz:

DROP PROCEDURE get_car_stats_by_year;

Veritabanı, prosedürün başarıyla silindiğini bir başarı mesajıyla doğrular:

Output
Query OK, 0 rows affected (0.02 sec)

Prosedürün silindiğini, onu çağırarak doğrulayabilirsiniz. Çalıştırın:

CALL get_car_stats_by_year(2017, @number, @min, @avg, @max);

Bu sefer prosedürün veritabanında bulunmadığına dair bir hata mesajı göreceksiniz:

Error message
ERROR 1305 (42000): PROCEDURE procedures.get_car_stats_by_year does not exist

Bu bölümde, bir veritabanından saklı yordamların nasıl silineceğini öğrendiniz.

Sonuç

Bu kılavuzu izleyerek, saklı yordamların ne olduğunu ve MySQL'de yeniden kullanılabilir ifadeleri adlandırılmış yordamlarda depolamak ve daha sonra çalıştırmak için nasıl kullanılacağını öğrendiniz. Parametresiz saklı yordamlar ve giriş ve çıkış parametreleri kullanarak daha esnek hale getiren yordamlar oluşturdunuz.