მახსოვს ის დრო, როცა ჯერ კიდევ არ ვიცოდი რა იყო mysqlდა ხშირად ეძებდა ასეთ სტატიებს ინტერნეტში. მაგრამ რატომღაც ისინი იშვიათად იპოვნეს. ახლა მე გადავწყვიტე გამოვაქვეყნო ერთი, რათა იყოს სასარგებლო სტატიები mysqlდა phpარის კიდევ ერთი. ვეცდები ყველაფერი ხელმისაწვდომ ენაზე დავწერო.
დაიწყეთ mysql და php
ასე რომ, პირველ რიგში, ჩვენ გვჭირდება ლოკალური სერვერი, რათა შევძლოთ გაშვება php სკრიპტებიდა დაუკავშირდით მონაცემთა ბაზას (შემდგომში დავარქმევ DB, რაც ნიშნავს „მონაცემთა ბაზას“). თუ ჯერ არ გაქვთ ლოკალური სერვერი, ჯერ უნდა წაიკითხოთ ინსტალაცია და კონფიგურაცია ლოკალჰოსტი, და შემდეგ დაიწყეთ მონაცემთა ბაზის შესწავლა mysqlდა მისი DBMS (მონაცემთა ბაზის მართვის ინსტრუმენტი).
თუ უკვე გაქვთ ეს სერვერი, გააკეთეთ ეს. პირველ რიგში, მინდა გაგაცნოთ DBMS PhpMyAdmin, საშუალებას გაძლევთ მართოთ (დამატება, წაშლა, შეცვალოთ) ჩანაწერები მონაცემთა ბაზაში.
ეს არის მთავარი გვერდი DBMS PhpMyAdmin. აქედან შეგიძლიათ შექმნათ თქვენი საკუთარი მონაცემთა ბაზა და შეინახოთ საჭირო ჩანაწერები მასში. ეს ძალიან მოსახერხებელია ვებსაიტების შექმნისას, რადგან ინფორმაცია სტრუქტურირებულია და შეგიძლიათ ძალიან სწრაფად მიიღოთ ნებისმიერი ჩანაწერი მონაცემთა ბაზიდან.
როგორც უკვე აღვნიშნეთ, სტატიის პირველი ნაწილი, შესავალი mysqlდა phpmyadmin. ვფიქრობ, ახლა გაიგეთ რა არის mysql და შეგვიძლია დავიწყოთ phpmyadmin-ის ფუნქციონირების შესწავლა. დასაწყებად, ჩვენ თავად უნდა შევქმნათ მონაცემთა ბაზა. მას ექნება საკუთარი სახელი, რომლითაც ჩვენ მას შემდეგ მოვიძიებთ.
აქ არის მონაცემთა ბაზის ზოგადი სტრუქტურა: 
მონაცემთა ბაზის შესაქმნელად შეყვანის ველში შეიყვანეთ სტრიქონში „ახალი მონაცემთა ბაზის შექმნა“ (PhpMyAdmin-ის მთავარ გვერდზე) მომავალი მონაცემთა ბაზის ნებისმიერი სახელი (არა კირილიცა!). შევქმნი მონაცემთა ბაზას სახელად „ბაზა“. ახლა, მონაცემთა ბაზის სტრუქტურის დიაგრამის შემდეგ, ჩვენ უნდა შევქმნათ ცხრილი. ამისათვის, მონაცემთა ბაზის შექმნის შემდეგ, გექნებათ შემდეგი ფანჯარა:
აქ მე ვქმნი ცხრილს სახელად users და მასში 3 ველს. შემდეგი, phpmyadmin მოგვთხოვს დავაყენოთ სტრუქტურა თითოეული ველისთვის:
აქ სვეტში "ველი" უნდა მიუთითოთ სახელი, "ტიპი" ჩვენ მივუთითებთ მონაცემთა ტიპს, რომელიც შეინახება იქ (INT არის რიცხვი, VARCHAR არის სტრიქონი ან მცირე(!) ტექსტი). "Advanced"-ში ჩვენ მივუთითებთ ველს სახელად "id" პარამეტრს "auto_increament", რაც იმას ნიშნავს, რომ ის გაიზრდება ყოველ ჯერზე, როცა რაიმე მონაცემს ჩასვამთ და ვაყენებთ პარამეტრს "Primary key" (დასვით წრე), ეს ნიშნავს, რომ პირველი სვეტის მიხედვით ჩვენ შეგვიძლია ცალსახად ამოვიცნოთ ველი.
"ველის ცალსახად იდენტიფიცირება" ნიშნავს, რომ მაშინაც კი, თუ სახელი და გვარი ერთნაირია, "id" სვეტს ექნება განსხვავებული მნიშვნელობები (რადგან ის ყოველ ჯერზე ავტომატურად იზრდება ერთით).
ახლა დააჭირეთ "შენახვა". ამრიგად, ჩვენ შევქმენით მომხმარებლების ცხრილი, რომელშიც შეგვიძლია შევინახოთ სახელი და გვარი (არ არის საჭირო id-ის ჩასმა, mysql ყველაფერს გააკეთებს ჩვენთვის), მომხმარებლების მონაცემთა ბაზაში. ჩვენ შევქმენით ცხრილი ჩანაწერების შესანახად. როგორ ჩავსვათ ისინი იქ? წაიკითხეთ ქვემოთ 😉
აირჩიეთ "ჩასმა" მენიუდან და ჩაწერეთ საჭირო მნიშვნელობები საჭირო ველებში. ახლა როგორ წაშალოთ ან შეცვალოთ მნიშვნელობები mysql მონაცემთა ბაზაში PhpMyAdmin DBMS-ით... წასაშლელად უბრალოდ გადადით მენიუში „Browse“ და დააწკაპუნეთ წითელ ჯვარზე ჩანაწერის გვერდით:
და რედაქტირებისთვის დააწკაპუნეთ ფანქარზე და შეცვალეთ საჭირო ველები. კარგი, ეს გაკვეთილის დასასრულია. ახლა თქვენ შეგიძლიათ მართოთ mysql მონაცემთა ბაზა PhpMyAdmin-ის გამოყენებით. შემდეგ გაკვეთილზე გასწავლით მონაცემთა ბაზაში შენახვას, მოძიებას, წაშლას და განახლებას php-ის გამოყენებით. ეს არის ძალიან მოსახერხებელი და პრაქტიკული.
php-დან mysql მონაცემთა ბაზასთან მუშაობა
ასე რომ, ჯერ უნდა ისწავლოთ როგორ დაუკავშირდეთ უკვე შექმნილ მონაცემთა ბაზას. ამისათვის გამოიყენეთ შემდეგი კოდი:
ზემოაღნიშნულ კოდში, მე დავუკავშირდი ლოკალჰოსტის სერვერს შესვლის გამოყენებით ფესვირომელიც არ საჭიროებს პაროლს (ასე რომ ჩვენ არ ვაკონკრეტებთ მას). მონაცემთა ბაზასთან დაკავშირების შემდეგ, ჩვენ შეგვიძლია განვახორციელოთ ყველა ის ოპერაცია, რომელიც შევასრულეთ phpmyadmin DBMS-ში. ანუ სხვადასხვა ინფორმაციის ჩასმა, წაშლა, შეცვლა და მოძიება. ახლა წერტილი-პუნქტი:
ჩანაწერების ჩასმა SQL მონაცემთა ბაზაში php-ში
$query="INSERT INTO `table` (`მიუთითეთ ველი`,` მიუთითეთ ველი`) VALUES ("ნებისმიერი მნიშვნელობა", "ნებისმიერი მნიშვნელობა""); $result=mysql_query ($query); if($result==true) (ექო "წარმატება!"; ) else (echo "შეცდომა!".mysql_error();)
ანუ ჩასმა ხდება INSERT ფუნქციით. თუ ყველაფერი კარგად წავიდა, მაშინ mysql დააბრუნებს შედეგს true, ან სხვაგვარად - false.
შეგიძლიათ მიუთითოთ იმდენი ველი, რამდენიც გსურთ, მთავარია, რომ ისინი ყველა არსებობდეს მონაცემთა ბაზაში. ანუ, მაგალითად, არის ცხრილი, რომელშიც არის ველები "სახელი", "გვარი" და "ქალაქი". მასში მნიშვნელობების ჩასასმელად ჩვენ გამოვიყენებთ შემდეგ კოდს:
$query="INSERT INTO `users` (`name`,`surname`,`city`) VALUES ("Ruslan", "Huzin", "Kokshetau""); $result=mysql_query ($query); if($result==true) (ექო "წარმატება!"; ) else (echo "შეცდომა!
".mysql_error();)
ჩანაწერების წაშლა SQL მონაცემთა ბაზიდან php-ში
წაშლა ხორციელდება DELETE ფუნქციის გამოყენებით. ამის კოდი დაახლოებით ასეთი იქნება:
$query="წაშლა `მომხმარებლებიდან` WHERE `name`="Ruslan" "; $result=mysql_query ($query); if($result==true) (ექო "წარმატება!"; ) else (echo "შეცდომა!
".mysql_error();)
ანუ მომხმარებლების ცხრილიდან წავშლით ყველა რიგს (ან ერთს), სადაც სახელის სვეტი უდრის Ruslan მნიშვნელობას.
მნიშვნელობების შეცვლა MySQL მონაცემთა ბაზაში php-ში
ჩვენ ასევე შეგვიძლია ცვლილებები შევიტანოთ ცხრილში არსებულ ჩანაწერებში. მაგალითად, ჩვენ უნდა შევცვალოთ სახელის სვეტის მნიშვნელობა რიგში, სადაც გვარის სვეტს აქვს მნიშვნელობა Huzin. ამისათვის ჩვენ ვაწარმოებთ შემდეგ კოდს:
$query="განახლება `მომხმარებლების` SET `name`="myname" WHERE `surname`="Huzin" "; $result=mysql_query ($query); if($result==true) (ექო "წარმატება!"; ) else (echo "შეცდომა!
".mysql_error();)
მნიშვნელობების მიღება მონაცემთა ბაზიდან
ახლა მოდის სახალისო ნაწილი. რადგან რაღაც დავწერეთ, უკან უნდა დავიბრუნოთ, არა? მაგალითად, მომხმარებლების ცხრილიდან უნდა მივიღოთ მთელი რიგი, სადაც სახელის სვეტი უდრის რუსლანს. ამისათვის ჩვენ გვჭირდება ოდნავ განსხვავებული კოდი, ვიდრე პირველ მაგალითებში. Აქ არის:
$query="SELECT * FROM WHERE `name`="Ruslan" "; $result=mysql_query ($query); if($result==true) (ექო "წარმატება!"; ) else (echo "შეცდომა!
".mysql_error(); ) $data=mysql_fetch_array($result); /* ახლა ცვლადი ინახავს მონაცემებს ცხრილიდან */
აქ დაგვჭირდა კიდევ ერთი ფუნქცია არჩეული მონაცემების ჩასაწერად ცვლადში (მასივში) php-ში. არჩეულ ხაზზე წვდომისთვის ჩვენ ვწერთ ასე:
$data["სვეტის სახელი"]
ანუ არჩეული სტრიქონიდან გვარის მისაღებად (სადაც სახელი იყო რუსლან), გამომავალი უნდა ჩავწეროთ:
echo $data["გვარი"];
და ცხრილიდან არჩევისას, მათ დაწერეს SELECT *, ეს ვარსკვლავი ნიშნავს, რომ თქვენ უნდა აირჩიოთ ყველა სვეტი მწკრივიდან. თუ გვჭირდება, მაგალითად, მხოლოდ გვარის არჩევა, ვწერთ SELECT `გვარი`. და ცხრილიდან ერთდროულად რამდენიმე მწკრივის შესარჩევად, თქვენ ასევე დაგჭირდებათ მარყუჟი მათ გამოსატანად. ეს იმ შემთხვევაში, თუ, მაგალითად, არის რამდენიმე სტრიქონი რუსლან სვეტით. აი კოდი:
$query="SELECT * FROM WHERE `name`="Ruslan" "; $result=mysql_query ($query); while($data=mysql_fetch_array($result)) (echo $data["name"]."
".$data["გვარი"]."
"; }
ახლა ეკრანზე გამოჩნდება ყველა სტრიქონი, რომელთა სახელების სვეტი უდრის Ruslan მნიშვნელობას.
ახლა თქვენ გაეცანით საკონტროლო ძირითად ფუნქციებს mysql მონაცემთა ბაზაპირდაპირ დან php სკრიპტი.
PHP-ით MySQL-თან დაკავშირების 3 მეთოდი კოდის მაგალითებით
MySQL მონაცემთა ბაზის გამოყენების დასაწყებად, ჯერ უნდა გესმოდეთ, როგორ დააკავშიროთ თქვენი მორგებული PHP პროგრამიდან (სკრიპტი) სწორედ ამ MySQL მონაცემთა ბაზასთან.
ეს სტატია აღწერს შემდეგ სამ მეთოდს, შესაბამის PHP კოდის მაგალითებთან ერთად, რომლებიც განმარტავს, თუ როგორ დაუკავშირდეთ თქვენს მონაცემთა ბაზას PHP-დან.
ყველა ქვემოთ მოყვანილი მაგალითისთვის, ჩვენ დავუკავშირდებით არსებულ MySQL მონაცემთა ბაზას. შენიშვნა: ყველაფერი, რაც აქ არის ახსნილი, ასევე იმუშავებს MariaDB-თან, ისევე როგორც MySQL.
1. PHP-თან დაკავშირება mysqli გაფართოების გამოყენებით
*mysqli ნიშნავს MySQL გაუმჯობესებულს
შექმენით შემდეგი mysqli.php ფაილი
connect_error) ( die("შეცდომა: დაკავშირება შეუძლებელია: " . $conn->connect_error); ) echo "დაკავშირებულია მონაცემთა ბაზასთან.
"; $result = $conn->query("SELECT id FROM goroda"); echo "სტრიქონების რაოდენობა: $result->num_rows"; $result->close(); $conn->close(); ?> ზემოთ მოცემულ კოდში:
- mysqli - ეს ფუნქცია იწყებს ახალ კავშირს mysqli გაფართოების გამოყენებით. ფუნქცია იღებს ოთხ არგუმენტს:
- localhost არის ჰოსტის სახელი, რომელზეც მუშაობს MySQL მონაცემთა ბაზა
- სახელი - MySQL მომხმარებლის სახელი დასაკავშირებლად
- pass - პაროლი mysql მომხმარებლისთვის
- db - MySQL მონაცემთა დაკავშირება.
- qvery არის MySQL შეკითხვის ფუნქცია. ამ მაგალითში ჩვენ ვირჩევთ id სვეტს ქალაქის მონაცემთა ბაზიდან.
- და ბოლოს, ჩვენ ვაჩვენებთ შერჩეულ მწკრივების რაოდენობას შედეგში num_rows ცვლადის გამოყენებით. ჩვენ ასევე ვხურავთ როგორც შედეგს, ასევე კავშირის ცვლადს, როგორც ეს ზემოთ არის ნაჩვენები.
დაკავშირებულია მონაცემთა ბაზასთან. ხაზების რაოდენობა: 6 2. კავშირი PHP MySQL PDO გაფართოებიდან
*PDO ნიშნავს PHP მონაცემთა ობიექტებს
PDO_MYSQL დრაივერი ახორციელებს PHP-ის მიერ მოწოდებულ PDO ინტერფეისს თქვენი PHP სკრიპტიდან MySQL მონაცემთა ბაზასთან დასაკავშირებლად.
შექმენით შემდეგი mysql-pdo.php ფაილი:
setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); echo "დაკავშირებულია მონაცემთა ბაზასთან.
"; $sql = "SELECT id FROM goroda"; დაბეჭდეთ "ID-ების სია:
"; foreach ($conn->query($sql) როგორც $row) (დაბეჭდვა $row["id"] . "
"; ) $conn = null; ) catch(PDOException $err) (echo "შეცდომა: დაკავშირება შეუძლებელია: " . $err->getMessage(); ) ?> ზემოთ:
- ახალი PDO - შექმნის ახალ PDO ობიექტს, რომელიც მიიღებს შემდეგ სამ არგუმენტს:
- mysql დაკავშირების სტრიქონი: ის იქნება ფორმატში "mysql:host=localhost;dbname=db". ზემოთ მოყვანილ მაგალითში db მუშაობს localhost-ზე და ჩვენ ვუკავშირდებით db მონაცემთა ბაზას.
- MySQL მომხმარებლის სახელი დასაკავშირებლად
- Mysql მომხმარებლის პაროლი
- $sql ცვლადი - შექმენით sql მოთხოვნა, რომლის შესრულებაც გსურთ. ამ მაგალითში ჩვენ ვირჩევთ id სვეტს ქალაქების ცხრილიდან.
- შეკითხვა ($sql). აქ ჩვენ ვასრულებთ sql მოთხოვნას, რომელიც ახლახან შევქმენით.
- foreach. აქ ჩვენ ვუვლით შედეგს ზემოაღნიშნული შეკითხვის ბრძანებიდან და ვინახავთ მას $row ცვლადში და შემდეგ გამოვიტანთ მას echo-ს გამოყენებით.
- MySQL PDO-ში, კავშირის დასახურად, უბრალოდ დააყენეთ $conn ცვლადი null-ზე.
დაკავშირებულია მონაცემთა ბაზასთან. სიის ID: 1 2 3 4 5 6 3. კავშირი PHP-დან მოძველებული mysql ფუნქციების გამოყენებით
გამოიყენეთ ეს მეთოდი მხოლოდ იმ შემთხვევაში, თუ იყენებთ PHP-ის უფრო ძველ ვერსიას და რაიმე მიზეზით ვერ განაახლებთ ახალ ვერსიას. ამ მეთოდის ნაცვლად რეკომენდებულია ზემოთ ნაჩვენები მეთოდი #2 და მეთოდი #3. მე შევიტანე ეს მეთოდი მხოლოდ მითითებისთვის და არა გამოყენების რეკომენდაციად.
ეს კონკრეტული გაფართოება მოძველებულია PHP 5.5-ის შემდეგ. მაგრამ როგორც PHP 7.0, ეს არც კი იმუშავებს, რადგან ის წაშლილია. PHP 5.5-დან, როდესაც იყენებთ ამ ფუნქციებს, ის წარმოქმნის E_DEPRECATED შეცდომას.
შექმენით mysql.php ფაილი:
"; $result = mysql_query("SELECT id FROM goroda"); $row = mysql_fetch_row($result); echo "id 1: ", $row, "
\n"; mysql_close($conn); ?> ზემოთ მოცემულში:
- mysql_connect ფუნქცია იღებს სამ არგუმენტს:
- ჰოსტის სახელი, სადაც მუშაობს MySQL მონაცემთა ბაზა;
- MySQL მომხმარებლის სახელი დასაკავშირებლად;
- პაროლი mysql მომხმარებლისთვის. აქ ის უკავშირდება MySQL მონაცემთა ბაზას, რომელიც მუშაობს ადგილობრივ სერვერზე მომხმარებლის სახელისა და პაროლის გამოყენებით.
- mysql_select_db ფუნქცია. როგორც სახელი გვთავაზობს, ის ირჩევს მონაცემთა ბაზას, რომელთანაც გსურთ დაკავშირება. "გამოყენების" ბრძანების ექვივალენტურია. ამ მაგალითში ჩვენ ვუკავშირდებით db მონაცემთა ბაზას.
- mysql_query ფუნქცია - გამოიყენება თქვენი MySQL მოთხოვნის დასაზუსტებლად. ამ მაგალითში ჩვენ ვირჩევთ id სვეტს ქალაქის მონაცემთა ბაზიდან. mysql_fetch_row. გამოიყენეთ ეს ფუნქცია ჩვენ მიერ ახლახან შექმნილი SQL მოთხოვნიდან რიგების ამოსაღებად.
- და ბოლოს, დახურეთ კავშირი mysql_close ბრძანების გამოყენებით, როგორც ეს ნაჩვენებია ზემოთ.
დაკავშირებულია მონაცემთა ბაზასთან. id 1: 1 ასე შეგიძლიათ დაუკავშირდეთ MySQL-ს. ვიმეორებ, უმჯობესია გამოიყენოთ პირველი ორი მეთოდი; ო
ტექსტი იყენებს ოფიციალური დოკუმენტაციის თარგმანს, რომელიც დამზადებულია ვებმასტერების სრულიად რუსული კლუბის მიერ.
მონაცემთა ბაზებთან ყველა სამუშაო დამოკიდებულია სერვერთან დაკავშირებაზე, მონაცემთა ბაზის არჩევაზე, მოთხოვნის გაგზავნაზე, მოთხოვნის დამუშავებაზე და მონაცემთა ბაზებიდან გათიშვაზე. ასე რომ, მოდით შევხედოთ ამ ყველაფერს წერტილი-პუნქტით. მთელი ტექსტის სიცხადისთვის, წარმოვიდგინოთ, რომ MySQL სერვერი დაინსტალირებულია ადგილობრივ მანქანაზე. მასთან მუშაობის პორტი სტანდარტულია. დასაკავშირებლად გამოვიყენებთ მომხმარებლის სახელს „root“ და პაროლს „no_one“.
კავშირი
მონაცემთა ბაზასთან დაკავშირება ხდება "mysql_connect()" ფუნქციის გამოყენებით. მას გადაეცემა სამი პარამეტრი: სერვერის სახელი (ან სერვერის სახელი: კავშირის პორტი), მომხმარებლის სახელი და პაროლი. თუ "mysql_connect()"-ზე მეორე ზარი განხორციელდება იგივე არგუმენტებით, ახალი კავშირი არ დამყარდება - ამის ნაცვლად, დაბრუნდება უკვე გახსნილი კავშირის კავშირის ID (ანუ მუშაობა გაგრძელდება იმავე მონაცემთა ბაზაში). თუ თქვენ მუშაობთ მხოლოდ ერთ მონაცემთა ბაზასთან, მაშინ არ გჭირდებათ კავშირის იდენტიფიკატორის შექმნა. სკრიპტის შესრულების დასრულების შემდეგ, სერვერთან კავშირი დაიხურება, გარდა იმ შემთხვევისა, როდესაც ის აშკარად არ დაიხურა ადრე გამოძახებით "mysql_close()-ზე".
მაგალითი: $connect = mysql_connect('localhost', 'root', 'no_one'); ამ შემთხვევაში, $connect ცვლადი არის კავშირის იდენტიფიკატორი. თუ თქვენ მუშაობთ მხოლოდ ერთ მონაცემთა ბაზასთან, მაშინ კოდი იწერება იდენტიფიკატორის გარეშე: mysql_connect('localhost', 'root', 'no_one');
მონაცემთა ბაზის შერჩევა
"mysql_select_db" - ირჩევს MySQL მონაცემთა ბაზას. ეს ნიშნავს, რომ სერვერი შეიძლება შეიცავდეს არა ერთ მონაცემთა ბაზას, არამედ რამდენიმე. ამ ბრძანებით ჩვენ ვირჩევთ ჩვენთვის საჭიროს (რომელზეც გვაქვს უფლება). ამ ფუნქციის პარამეტრი არის მონაცემთა ბაზის სახელი. ამ გზით შერჩეული მონაცემთა ბაზა აქტიურდება და დაკავშირებულია კონკრეტულ იდენტიფიკატორთან. თუ კავშირის ID არ არის განსაზღვრული, მაშინ გამოიყენება ბოლო კავშირი მონაცემთა ბაზასთან.
მაგალითი: mysql_select_bd('ტესტი', $connect); - სადაც ტესტი არის მონაცემთა ბაზის სახელი და $connect არის კავშირის იდენტიფიკატორი. თუ თქვენ მუშაობთ მხოლოდ ერთ მონაცემთა ბაზასთან, მაშინ კოდი იწერება იდენტიფიკატორის გარეშე: mysql_select_bd('test');
მოთხოვნის გაგზავნა
mysql_query() აგზავნის მოთხოვნას სერვერზე ამჟამად მოქმედ მონაცემთა ბაზაში, რომელიც დაკავშირებულია კონკრეტულ ბმულის ID-თან. თუ ID არ არის მითითებული, გამოიყენება ბოლო ღია კავშირი. ამ ფუნქციის პარამეტრი არის სტრიქონი sql მოთხოვნით.
მაგალითი: $tmp=mysql_query("slect * ცხრილიდან", $connect); - ეს ბრძანება დააბრუნებს ცხრილის ცხრილის მთელ შიგთავსს აქტიური მონაცემთა ბაზიდან, რომელზეც მითითებულია $connect იდენტიფიკატორი. თუ თქვენ მუშაობთ მხოლოდ ერთ მონაცემთა ბაზასთან, მაშინ კოდი იწერება იდენტიფიკატორის გარეშე: $tmp=mysql_query(“slect * ცხრილიდან”);
მოთხოვნის დამუშავება
არსებობს რამდენიმე ფუნქცია მოთხოვნის დამუშავებისთვის. მოთხოვნის დამუშავების ამა თუ იმ მეთოდის არჩევანი დამოკიდებულია პროგრამირების სტილზე და სამუშაოზე. გასათვალისწინებელია ისიც, რომ სხვადასხვა ვარიანტები სერვერს სხვადასხვა გზით „იტვირთება“ (ზოგი ძალიან, ზოგი არა იმდენად). მოდით შევხედოთ რამდენიმე მათგანს.
mysql_fetch_object - აბრუნებს php ობიექტს დამუშავების შედეგად. ეს მეთოდი კარგია მათთვის, ვინც მიჩვეულია პროგრამირების ობიექტზე
მაგალითი: while($result= mysql_fetch_object($tmp)) echo($result->name);
mysql_fetch_array - მიიღეთ შედეგი ასოციაციური მასივის სახით. ეს მეთოდი კარგია დამწყებთათვის (თუმცა ეს დამოკიდებულია იმაზე, თუ ვის უფრო მოეწონება).
კავშირის დახურვა
კავშირი დახურულია mysql_close() ფუნქციის გამოყენებით. მისი პარამეტრი არის მონაცემთა ბაზის კავშირის იდენტიფიკატორი. თუ ეს პარამეტრი არ არის მითითებული, ბოლო გამოძახებული კავშირი იხურება.
შეცდომები ნებისმიერი პროგრამის უბედურებაა. რაც უფრო დიდია პროექტი, მით უფრო რთულია შეცდომების გამოსწორება და პოვნა. მაგრამ პროგრამასთან მუშაობის პროცესში ყველაზე მნიშვნელოვანი არის პროგრამისტის კვალიფიკაცია და მისი სურვილი დაწეროს სწორი და ზუსტი კოდი, რომელიც შეიცავს მინიმალურ რაოდენობას...
მუშაობა MySQL მონაცემთა ბაზასთან PHP ინსტრუმენტებით
ლექცია. მოამზადა პროხოროვმა ვ.ს.
1. PHP სცენარების დაკავშირება MySQL ცხრილებთან
მოდით გადავხედოთ ყველაზე ხშირად გამოყენებულ ფუნქციებს, რომლებიც საშუალებას გაძლევთ იმუშაოთ MySQL მონაცემთა ბაზასთან PHP-ის გამოყენებით.
როდესაც PHP და MySQL ურთიერთობენ, პროგრამა ურთიერთქმედებს DBMS-თან ფუნქციების ნაკრების მეშვეობით.
1.1 სერვერთან დაკავშირება. ფუნქციაmysql_connect
მონაცემთა ბაზასთან მუშაობამდე თქვენ უნდა დაამყაროთ ქსელური კავშირი მასთან, ასევე ავტორიზაცია მისცეთ მომხმარებელს. ამისთვის გამოიყენება mysql_connect() ფუნქცია.
რესურსი mysql_connect(]])
ეს ფუნქცია ამყარებს ქსელურ კავშირს MySQL მონაცემთა ბაზასთან, რომელიც მდებარეობს ჰოსტ $სერვერზე (ნაგულისხმევად ეს არის localhost, ანუ მიმდინარე კომპიუტერი) და აბრუნებს ღია კავშირის ID-ს. ყველა შემდგომი სამუშაო ხორციელდება ამ იდენტიფიკატორით. ყველა სხვა ფუნქცია, რომელიც ამ იდენტიფიკატორს (სახელურს) არგუმენტად იღებს, ცალსახად ამოიცნობს შერჩეულ მონაცემთა ბაზას. რეგისტრაციისას მიუთითეთ მომხმარებლის სახელი $username და პაროლი $password (ნაგულისხმევად, მომხმარებლის სახელი, საიდანაც მიმდინარეობს მიმდინარე პროცესი - სკრიპტების გამართვისას: root და ცარიელი პაროლი):
$dbpasswd = ""; //პაროლი
//გაფრთხილების ჩვენება
ექო ("
");
$dblocation, $dbuser და $dbpasswd ცვლადები ინახავს სერვერის სახელს, მომხმარებლის სახელს და პაროლს.
1.2 სერვერიდან გათიშვა. ფუნქციაmysql_close
MySQL სერვერთან კავშირი ავტომატურად დაიხურება სკრიპტის დასრულებისას, ან როდესაც გამოიძახება mysql_close ფუნქცია
bool mysql_close()
ეს ფუნქცია ხურავს კავშირს MySQL სერვერთან და აბრუნებს true-ს, თუ ოპერაცია წარმატებულია და ცრუ. ფუნქცია არგუმენტად იღებს მონაცემთა ბაზის კავშირის სახელურს, რომელიც დაბრუნებულია mysql_connect ფუნქციით.
$dblocation = "localhost"; //Სერვერის სახელი
$dbuser = "root"; //მომხმარებლის სახელი
$dbpasswd = ""; //პაროლი
//დაკავშირება მონაცემთა ბაზის სერვერთან
//ფუნქციის გამოძახებამდე შეცდომის გამოშვების ჩახშობა @ სიმბოლოთი
$dbcnx = @ mysql_connect ($dblocation, $dbuser, $dbpasswd);
თუ (!$dbcnx) //თუ დესკრიპტორი არის 0, კავშირი არ დამყარდება
//გაფრთხილების ჩვენება
ექო ("
მონაცემთა ბაზის სერვერი ამჟამად მიუწვდომელია, ამიტომ გვერდის სწორად ჩვენება შეუძლებელია.");
if (mysql_close($dbcnx)) //დახურეთ კავშირი
echo ("მონაცემთა ბაზის კავშირი შეწყვეტილია");
echo ("ჩვენ ვერ შევძელით კავშირის დასრულება");
1.3 მონაცემთა ბაზის შექმნა. CREATE DATABASE ფუნქცია
ბრძანება - მონაცემთა ბაზის შექმნა ხელმისაწვდომია მხოლოდ სერვერის ადმინისტრატორისთვის და უმეტეს ჰოსტინგ საიტებზე მისი შესრულება შეუძლებელია:
შექმენით მონაცემთა ბაზა მონაცემთა ბაზის სახელი
ქმნის ახალ მონაცემთა ბაზას სახელად DatabaseName.
ამ ფუნქციით მუშაობის მაგალითი:
@mysql_query ("შექმენით მონაცემთა ბაზა $dbname");
მიზანშეწონილია გამოიყენოთ აპოსტროფები ("SQL - ბრძანება") ყველგან, როგორც SQL - ბრძანებების შემცველი ხაზების დელიმიტერები. ეს უზრუნველყოფს, რომ არცერთი $ ცვლადი არ არის შემთხვევით ინტერპოლირებული (ანუ მისი მნიშვნელობით ჩანაცვლება) და ზრდის სკრიპტის უსაფრთხოებას.
CREATE DATABASE მონაცემთა ბაზის შექმნის ბრძანება ხელმისაწვდომია მხოლოდ სუპერმომხმარებლისთვის და უმეტეს ჰოსტინგ საიტებზე მარტივი მომხმარებლისთვის შეუძლებელია მისი შესრულება. ის ხელმისაწვდომია მხოლოდ სერვერის ადმინისტრატორისთვის.
ექსპერიმენტებისთვის, მოდით შევქმნათ სატესტო ბაზის მონაცემთა ბაზა ბრძანების ხაზიდან SQL შეკითხვის შესრულებით. ამისათვის თქვენ უნდა შეხვიდეთ MySQL-ში და შეიყვანოთ MySQL ბრძანების სტრიქონში:
mysql> შექმნა მონაცემთა ბაზა testbase;
ამის შემდეგ თქვენ უნდა აკრიფოთ:
mysql>გამოიყენე testbase;
შეიქმნა მონაცემთა ბაზა:
1.4 მონაცემთა ბაზის შერჩევა. ფუნქციაmysql_select_db
პირველი მოთხოვნის MySQL სერვერზე გაგზავნამდე უნდა მივუთითოთ რომელ მონაცემთა ბაზასთან ვაპირებთ მუშაობას. mysql_select_db ფუნქცია შექმნილია ამისათვის:
bool mysql_select_db (სტრიქონი $database_name [,რესურსი $link_identifier])
ის აცნობებს PHP-ს, რომ მომავალი ოპერაციები $link_identifier კავშირზე გამოიყენებს $database_name მონაცემთა ბაზას.
ამ ფუნქციის გამოყენება უდრის SQL მოთხოვნაში use ბრძანების გამოძახებას, ანუ mysql_select_db ფუნქცია ირჩევს მონაცემთა ბაზას შემდგომი მუშაობისთვის და ყველა შემდგომი SQL მოთხოვნა გამოიყენება არჩეულ მონაცემთა ბაზაზე. ფუნქცია არგუმენტად იღებს არჩეული მონაცემთა ბაზის_სახელის სახელს და კავშირის აღწერის რესურსს. ფუნქცია აბრუნებს true-ს, თუ ოპერაცია წარმატებული იყო და false, წინააღმდეგ შემთხვევაში:
//მონაცემთა ბაზის კავშირის კოდი
if (! @mysql_select_db ($dbname, $dbcnx))
//გაფრთხილების ჩვენება
ექო ("
მონაცემთა ბაზა ამჟამად მიუწვდომელია, ამიტომ გვერდის სწორად ჩვენება შეუძლებელია.");
1.5 შეცდომის დამუშავება
თუ შეცდომები MySQL-თან მუშაობისას მოხდა (მაგალითად, მოთხოვნის ფრჩხილები არ არის დაბალანსებული ან არ არის საკმარისი პარამეტრები), მაშინ შეცდომის შეტყობინება და მისი ნომერი შეიძლება მიიღოთ ქვემოთ აღწერილი ორი ფუნქციის გამოყენებით.
მნიშვნელოვანია ამ ფუნქციების ფრთხილად და დროულად გამოყენება, რადგან წინააღმდეგ შემთხვევაში სკრიპტების გამართვა შეიძლება გართულდეს.
● ფუნქცია:
int mysql_errno ()
აბრუნებს ბოლო მოხსენებული შეცდომის ნომერს. კავშირის იდენტიფიკატორი $link_identifier შეიძლება გამოტოვდეს, თუ სკრიპტის შესრულებისას დამყარდა მხოლოდ ერთი კავშირი.
● ფუნქცია:
string mysql_error()
აბრუნებს არა რიცხვს, არამედ სტრიქონს, რომელიც შეიცავს შეცდომის შეტყობინების ტექსტს. მოსახერხებელია გამოსაყენებლად გამართვის მიზნით. ჩვეულებრივ mysql_error გამოიყენება ან die() კონსტრუქტთან ერთად, მაგალითად:
@mysql_connect ("localhost", "მომხმარებელი", "პაროლი")
ან die("ბაზთან დაკავშირების შეცდომა: ".mysql_error());
@ ოპერატორი, როგორც ყოველთვის, ემსახურება სტანდარტული გაფრთხილების ჩახშობას, რომელიც შეიძლება მოხდეს შეცდომის შემთხვევაში.
PHP-ის ბოლო ვერსიებში MySQL ფუნქციებში გაფრთხილებები ნაგულისხმევად არ არის ჩაწერილი.
1.6 MySQL-თან დაკავშირების ავტომატიზაცია. ფაილი (config.php)
როგორც წესი, საიტზე არის რამდენიმე სკრიპტი, რომელსაც სჭირდება წვდომა იმავე მონაცემთა ბაზაში.
მიზანშეწონილია MySQL-თან დაკავშირებაზე პასუხისმგებელი კოდის გამოყოფა ცალკე ფაილად და შემდეგ დააკავშირეთ იგი საჭირო სკრიპტებთან, ჩათვლით ფუნქციის გამოყენებით.
აზრი აქვს მონაცემთა ბაზის შეერთების, შერჩევისა და შექმნის ფუნქციების განთავსებას იმავე ფაილში (config.php), სადაც გამოცხადებულია ცვლადები სერვერის სახელით $dblocation, მომხმარებლის სახელი $dbuser, პაროლი $dbpasswd და მონაცემთა ბაზის სახელი $dbname:
config.php ჩამონათვალი:
//config.php ფაილის კოდი, რომელიც შეიცავს პარამეტრებს სერვერთან დასაკავშირებლად და მონაცემთა ბაზის არჩევისთვის
// გამოაქვს კავშირის შეცდომის შეტყობინებები ბრაუზერში
$dblocation = "localhost"; //Სერვერის სახელი
$dbname = "დასვით მონაცემთა ბაზის სახელი" //მონაცემთა ბაზის სახელი: იქმნება ან არსებობს
$dbuser = "root"; //მონაცემთა ბაზის მომხმარებლის სახელი
$dbpasswd = ""; //პაროლი
//დაკავშირება მონაცემთა ბაზის სერვერთან
//ფუნქციის გამოძახებამდე შეცდომის გამოშვების ჩახშობა @ სიმბოლოთი
$dbcnx=@mysql_connect($dblocation,$dbuser,$dbpasswd);
თუ (!$dbcnx) //თუ დესკრიპტორი არის 0, კავშირი მონაცემთა ბაზის სერვერთან არ არის დამყარებული
//გაფრთხილების ჩვენება
ექო ("
მონაცემთა ბაზის სერვერი ამჟამად მიუწვდომელია, ამიტომ გვერდის სწორად ჩვენება შეუძლებელია.
");//შექმენით მონაცემთა ბაზა $dbname - ამის გაკეთება მხოლოდ სუპერმომხმარებელს შეუძლია
//თუ მონაცემთა ბაზა უკვე არსებობს, იქნება არაფატალური შეცდომა
@mysql_query ("შექმენით მონაცემთა ბაზა, თუ არ არსებობს $dbname");
//დაკავშირების კოდი მონაცემთა ბაზასთან: ვაკეთებთ ახლად შექმნილი მონაცემთა ბაზის ან უკვე არსებული მონაცემთა ერთმნიშვნელოვნად შერჩევას.
//ფუნქციის გამოძახებამდე შეცდომის გამოშვების ჩახშობა @ სიმბოლოთი
if(!@mysql_select_db($dbname, $dbcnx)) //თუ დესკრიპტორი არის 0, მონაცემთა ბაზასთან კავშირი არ არის დამყარებული
//გაფრთხილების ჩვენება
ექო ("
მონაცემთა ბაზა ამჟამად მიუწვდომელია, ამიტომ გვერდის სწორად ჩვენება შეუძლებელია.
");//მცირე დამხმარე ფუნქცია, რომელიც ბეჭდავს შეტყობინებას
//შეცდომის შეტყობინება მონაცემთა ბაზის შეკითხვის შეცდომის შემთხვევაში
ფუნქცია puterror ($message)
ექო ("");
2. მონაცემთა ბაზის მოთხოვნების შესრულება
2.1 ცხრილის შექმნა. ფუნქციამაგიდის შექმნა:
TABLE TableName-ის შექმნა (FieldName ტიპი, FieldName ტიპი,)
ეს ბრძანება ქმნის ახალ ცხრილს მონაცემთა ბაზაში სვეტებით (ველებით), რომლებიც განისაზღვრება მათი სახელებით (FieldName) და მითითებული ტიპებით. ცხრილის შექმნის შემდეგ შეგიძლიათ დაამატოთ ჩანაწერები, რომლებიც შედგება ამ ბრძანებაში ჩამოთვლილი ველებისგან.
ჩამონათვალი test_11.php. პროგრამა, რომელიც ქმნის ახალ ცხრილს მონაცემთა ბაზაში:
მოიცავს "config.php";//დაკავშირება სერვერზე და აირჩიეთ მონაცემთა ბაზა
mysql_query("შექმენი ცხრილი, თუ არ არსებობს ხალხი
ID INT AUTO_INCREMENT ძირითადი გასაღები,
ან die("MySQL შეცდომა: ".mysql_error());
ეს სკრიპტი ქმნის ახალ ცხრილს ორი ველით. პირველ ველს აქვს ტიპი INT (მთელი რიცხვი) და სახელი id. მეორე არის TEXT ტიპი (ტექსტის სტრიქონი) და სახელის სახელი.
თუ ცხრილი არსებობს, იმუშავებს ან die() კონსტრუქცია.
სურვილისამებრ, თუ არ არსებობს პუნქტი, როდესაც მითითებულია, ეუბნება MySQL სერვერს, რომ მან არ უნდა შექმნას შეცდომის შეტყობინება, თუ მონაცემთა ბაზაში უკვე არსებობს ცხრილი მითითებული სახელით.
MySQL არის რელაციური მონაცემთა ბაზის ტიპი. MySQL არის სერვერი, რომელსაც სხვადასხვა მომხმარებლებს შეუძლიათ დაკავშირება.
ინტერნეტთან დაკავშირებისას შეიყვანთ თქვენს მომხმარებლის სახელს და პაროლს, ასევე სერვერის სახელს, რომელსაც უკავშირდებით? MySQL-თან მუშაობისას იგივე სისტემა გამოიყენება.
კიდევ ერთი რამ: რა არის რელაციური მონაცემთა ბაზა? ცხრილებზე დაფუძნებული ურთიერთობითი საშუალებები. Microsoft-ის ცნობილი ცხრილების რედაქტორი, Excel, რეალურად არის რელატიური მონაცემთა ბაზის რედაქტორი.
MySQL სერვერთან დაკავშირება
PHP-ში MySQL სერვერთან დასაკავშირებლად გამოიყენეთ mysqli_connect() ფუნქცია. ეს ფუნქცია იღებს სამ არგუმენტს: სერვერის სახელი, მომხმარებლის სახელი და პაროლი.
mysqli_connect() ფუნქცია აბრუნებს კავშირის იდენტიფიკატორს, ის ინახება ცვლადში და მოგვიანებით გამოიყენება მონაცემთა ბაზებთან მუშაობისთვის.
MySQL სერვერის კავშირის კოდი:
$link = mysqli_connect ("localhost", "root", "");
ამ შემთხვევაში, მე ვმუშაობ ლოკალურ მანქანაზე Denwere-ზე, ამიტომ ჰოსტის სახელი არის localhost, მომხმარებლის სახელი არის root და პაროლი არ არის.
კავშირი ასევე უნდა დაიხუროს MySQL-თან მუშაობის დასრულების შემდეგ. mysqli_close() ფუნქცია გამოიყენება კავშირის დასახურად. გავაფართოვოთ მაგალითი:
$link = mysqli_connect ("localhost", "root", ""); if (!$link) die ("შეცდომა"); mysqli_close($link);
აქ ჩვენ შევამოწმეთ კავშირის იდენტიფიკატორი სიმართლისთვის; თუ რამე არასწორია ჩვენს კავშირში, მაშინ პროგრამა არ შესრულდება, die() ფუნქცია შეაჩერებს მის შესრულებას და გამოჩნდება შეცდომის შეტყობინება ბრაუზერში.
კავშირის შეცდომები
კავშირის შესამოწმებლად გამოიყენება შემდეგი ფუნქციები:
- mysqli_connect_errno() - აბრუნებს ბოლო კავშირის მცდელობის შეცდომის კოდს. თუ შეცდომები არ არის, აბრუნებს ნულს.
- mysqli_connect_error() - აბრუნებს ბოლო კავშირის შეცდომის აღწერას MySQL სერვერზე.
mysqli_get_host_info() ფუნქცია აბრუნებს სტრიქონს, რომელიც შეიცავს გამოყენებული კავშირის ტიპს.
ასევე გაითვალისწინეთ, რომ define ბრძანების გამოყენებით, მე შევინახე კავშირის ყველა პარამეტრი მუდმივებად. როდესაც წერთ დიდ პროექტებს და ბევრი ფაილია დაკავშირებული MySQL სერვერთან, მოსახერხებელია კავშირის პარამეტრების შენახვა ცალკე ფაილში და ჩასმა ფუნქციის ჩათვლით ან მოთხოვნის გამოყენებით.
მონაცემთა ბაზის შერჩევა
MySQL სერვერს შეიძლება ჰქონდეს მრავალი მონაცემთა ბაზა. უპირველეს ყოვლისა, ჩვენ უნდა შევარჩიოთ ბაზა, რომლითაც უნდა ვიმუშაოთ. PHP-ში ამისთვის არის კიდევ ერთი პარამეტრი mysqli_connect() ფუნქციაში - მონაცემთა ბაზის სახელი.
მე შევქმენი ის ჩემს კომპიუტერზე phpMyAdmin-ის საშუალებით, სახელწოდების ტესტერით. მოდით დავუკავშირდეთ მას:
$link = mysqli_connect("localhost", "root", "", "tester"); if (!$link) die ("შეცდომა"); mysql_close ($link);
ასე რომ, ჩვენ ავირჩიეთ მონაცემთა ბაზა სამუშაოდ. მაგრამ, როგორც ვიცით, რელაციური მონაცემთა ბაზა შედგება ცხრილებისგან და ჩვენს მონაცემთა ბაზაში ჯერ არ არის ცხრილები. მონაცემთა ბაზა იქმნება ცარიელი, ცხრილების გარეშე. მას ცალკე უნდა დაემატოს ცხრილები. ახლა მოდით დავუმატოთ მას ცხრილი PHP-ის გამოყენებით.
შექმენით ცხრილი
MySQL მონაცემთა ბაზების სახელით, SQL ნაწილი ნიშნავს Structured Query Language, რომელიც ითარგმნება როგორც სტრუქტურირებული შეკითხვის ენა. ჩვენ დავწერთ შეკითხვებს SQL-ში და გავაგზავნით მათ MySQL სერვერზე PHP პროგრამიდან.
ცხრილის შესაქმნელად უბრალოდ უნდა გამოვცეთ CREATE TABLE ბრძანება. შევქმნათ ცხრილი სახელწოდებით users, რომლის სვეტებში შეინახება მომხმარებლების შესვლა (ლოგინის სვეტი) და პაროლები (პაროლის სვეტი).
$query = "შექმენით TABLE მომხმარებლები (შესვლა VARCHAR(20), პაროლი VARCHAR(20))";
ამ კოდში $query ცვლადს მივანიჭეთ ტექსტის სტრიქონი, რომელიც წარმოადგენს SQL მოთხოვნას. ჩვენ ვქმნით ცხრილს სახელწოდებით მომხმარებლები, რომელიც შეიცავს ორ სვეტს შესვლას და პაროლს, ორივე VARCHAR(20) მონაცემთა ტიპის. მონაცემთა ტიპებზე მოგვიანებით ვისაუბრებთ, ახლა მხოლოდ აღვნიშნავ, რომ VARCHAR(20) არის სტრიქონი, რომლის მაქსიმალური სიგრძეა 20 სიმბოლო.
ჩვენი მოთხოვნის MySQL სერვერზე გასაგზავნად ვიყენებთ PHP ფუნქციას mysqli_query(). ეს ფუნქცია აბრუნებს დადებით რიცხვს, თუ ოპერაცია წარმატებული იყო და მცდარი, თუ შეცდომა მოხდა (მოთხოვნის სინტაქსი არასწორია ან პროგრამას არ აქვს მოთხოვნის შესრულების უფლება).
$link = mysqli_connect("localhost", "root", "", "tester"); if (!$link) die ("შეცდომა"); $query = "შექმენით TABLE მომხმარებლები (შესვლა VARCHAR(20), პაროლი VARCHAR(20))"; mysqli_query ($query); mysqli_close($link);
SQL შეკითხვას არ სჭირდება ცვლადში ჩაწერა; ის შეიძლება ჩაიწეროს უშუალოდ mysql_query() ფუნქციის არგუმენტად. ეს უბრალოდ ხდის კოდს უფრო წასაკითხად.
ამ სკრიპტს აქვს ერთი ნაკლი - ბრაუზერში არაფერი გამოდის. მოდით დავამატოთ შეტყობინება:
$link = mysqli_connect("localhost", "root", "", "tester"); if (!$link) die ("შეცდომა"); $query = "შექმენით TABLE მომხმარებლები (შესვლა VARCHAR(20), პაროლი VARCHAR(20))"; if (mysqli_query($query)) echo "ცხრილი შეიქმნა."; else echo "ცხრილი არ შეიქმნა."; mysqli_close($link);
თუ ამ სკრიპტს ხელახლა გავუშვით, ბრაუზერში ვნახავთ შეტყობინებას: „ცხრილი არ შეიქმნა“. ფაქტია, რომ ცხრილი შეიქმნა პირველი გაშვების დროს და შეუძლებელია იმავე სახელწოდების ცხრილის ხელახლა შექმნა. ჩვენ შეცდომის სიტუაციის წინაშე ვდგავართ, ამიტომ დროა ვისაუბროთ შეცდომებზე MySQL-თან მუშაობისას.
შეცდომის დამუშავება
პროგრამის გამართვისას შეიძლება დაგვჭირდეს ზუსტი ინფორმაცია შეცდომის შესახებ. როდესაც შეცდომა ხდება MySQL-ში, მონაცემთა ბაზის სერვერი ადგენს შეცდომის ნომერს და ხაზს მისი აღწერილობით. PHP-ს აქვს სპეციალური ფუნქციები ამ მონაცემებზე წვდომისთვის.
- mysqli_errno() - აბრუნებს შეცდომის ნომერს.
- mysqli_error() - აბრუნებს შეცდომის აღწერის სტრიქონს.
ახლა მოდით დავამატოთ mysql_error() ფუნქცია ჩვენს სკრიპტს:
$link = mysql_connect ("localhost", "root", "", "tester"); if (!$link) die ("შეცდომა"); $query = "შექმენით TABLE მომხმარებლები (შესვლა VARCHAR(20), პაროლი VARCHAR(20))"; if (mysqli_query($query)) echo "ცხრილი შეიქმნა."; else echo "ცხრილი არ შეიქმნა: ".mysqli_error(); mysqli_close($link);
ახლა ჩვენი სკრიპტი ბრაუზერში დააბრუნებს ხაზს: „ცხრილი არ შეიქმნა: ცხრილი „მომხმარებლები“ უკვე არსებობს“.
ცხრილის წაშლა
ასე რომ, ახლა ჩვენ გვაქვს მაგიდა, რომელიც არ გვჭირდება. დროა ვისწავლოთ როგორ ამოიღოთ ცხრილები მონაცემთა ბაზიდან.
ცხრილის ჩამოსაშლელად გამოიყენეთ DROP TABLE ბრძანება, რასაც მოჰყვება ცხრილის სახელი.
$link = mysqli_connect("localhost", "root", "", "tester"); if (!$link) die ("შეცდომა"); $query = "DROP TABLE მომხმარებლები"; if (!mysqli_query($query)) echo "შეცდომა ცხრილის წაშლისას: ".mysqli_error(); else echo "ცხრილი წაშლილია."; mysqli_close($link);
შედეგები
ასე რომ, ჩვენ ავითვისეთ MySQL-ის საფუძვლები. რისი გაკეთებაც ვისწავლეთ:
- დაუკავშირდით MySQL მონაცემთა ბაზას mysqli_connect() ფუნქციის გამოყენებით.
- დახურეთ კავშირი MySQL სერვერთან mysqli_close() ფუნქციის გამოყენებით.
- გაგზავნეთ SQL მოთხოვნები MySQL სერვერზე mysqli_query() ფუნქციის გამოყენებით.
- ვისწავლეთ SQL მოთხოვნა ცხრილის შესაქმნელად: შექმნა ცხრილი.
- ჩვენ ვისწავლეთ SQL მოთხოვნა ცხრილის წაშლისთვის: drop table.
- ჩვენ ვისწავლეთ შეცდომების დამუშავება mysqli_errno() და mysqli_error() ფუნქციების გამოყენებით.
შემდეგ ჩვენ უფრო ახლოს მივხედავთ MySQL მონაცემთა ტიპებს.
წაიკითხეთ შემდეგი გაკვეთილი:
