Mysql-თან დაკავშირება php-ის საშუალებით. როგორ შევქმნათ მონაცემთა ბაზის კავშირი PHP-ში? როგორ შევქმნათ კავშირი phpmyadmin მონაცემთა ბაზასთან

კითხვა საკმაოდ პოპულარულია დამწყებთათვის და არასწორი იქნებოდა, ცალკე სტატია არ დაეთმოთ ამას. ისევე როგორც ერთად PHP-ის გამოყენებითშევქმნათ კავშირი მონაცემთა ბაზასთან? დაუყოვნებლივ ვიტყვი, რომ PHP ინსტრუმენტები საკმაოდ საკმარისია მონაცემთა ბაზებთან სრულფასოვანი მუშაობისთვის და MySQL-თან ურთიერთობისთვის. ახლა ვცადოთ დაკავშირება!

რა გჭირდებათ PHP-ის MySQL-თან დასაკავშირებლად?

1. დაინსტალირებული DBMS და შეიქმნა სამუშაო მონაცემთა ბაზა. მაგალითად, MySQL-ში (რა არის DBMS და MySQL?).
2. მომხმარებლის ანგარიში MySQL-ისთვის შესაბამისი უფლებებით (რა არის უფლებები და პრივილეგიები MySQL-ში?)
3. შესაბამისად, დაინსტალირებულია სერვერი PHP-ით

თუ ამ ნაბიჯებიდან ერთ-ერთს არ დაასრულებთ, დაკავშირებას ვერ შეძლებთ.

ალგორითმი PHP-სა და MySQL-ს შორის ურთიერთქმედებისთვის

1. მონაცემთა ბაზასთან დაკავშირება
2. მოთხოვნის გაგზავნა და შედეგის მიღება
3. (სასურველია) კავშირის დახურვა

ახლა ჩვენ ვუკავშირდებით მონაცემთა ბაზას PHP-ის გამოყენებით:

PHP კოდი

$db = mysql_connect ("localhost", "Admin", "pass"); // მომხმარებლის მონაცემები
mysql_select_db("baseName",$db); // აირჩიეთ რომელ მონაცემთა ბაზასთან დაკავშირება
?>
როგორც ხედავთ, კავშირისთვის მითითებულია ოთხი პარამეტრი:

1. მასპინძლის სახელი. ხშირ შემთხვევაში, საკმარისია ლოკალჰოსტის მითითება (იგივე ჰოსტინგზე).
2. მომხმარებლის სახელი, რომელიც დარეგისტრირდით MySQL-ის გამოსაყენებლად.
3. იმ მომხმარებლის პაროლი, რომელიც დარეგისტრირდით MySQL-ის გამოსაყენებლად.
4. მონაცემთა ბაზის სახელი, რომელთანაც გვინდა დაკავშირება. შესაბამისად, ჩვენს მიერ მითითებულ მომხმარებელს უნდა ჰქონდეს ამ მონაცემთა ბაზაში მუშაობის უფლება.

შედეგად, თუ რამე არასწორად არის მითითებული, მაშინ არაფერი კრიმინალური არ მოხდება, მაგრამ, სავარაუდოდ, შეცდომას ნახავთ. ოღონდ ოპტიმისტურად ვიყოთ, ვთქვათ ყველაფერი სწორად შეიყვანეთ.

სხვა ტიპის კავშირი:

PHP კოდი

$host="localhost"; /*მასპინძელი*/
$user="admin"; /*მომხმარებლის სახელი*/
$პაროლი = "12345"; /*მომხმარებლის პაროლი*/
$db="baseName"; /*მონაცემთა ბაზის სახელი*/

Mysql_connect ($host, $user, $password); /* სერვერთან დაკავშირება*/
mysql_select_db ($db); /*დაკავშირება სერვერის მონაცემთა ბაზასთან*/
?>
აქ ვიზუალურად ვქმნი ცვლადებს მომხმარებლისა და ჰოსტის მაგალითების მონაცემებით და შემდეგ ვქმნი კავშირს.

როგორ შეწყვიტოთ (დახუროთ) კავშირი მონაცემთა ბაზასთან PHP-ში?

არის შემთხვევები, როდესაც კავშირის ინფორმაცია არასწორად არის მითითებული. ამ შემთხვევაში, სკრიპტი აგრძელებს PHP ფაილის დამუშავებას და აწარმოებს გარკვეული რაოდენობის შეცდომებს და გაფრთხილებებს გვერდზე. ამ შემთხვევებისთვის, მე გირჩევთ გამოიყენოთ შეცდომის დამმუშავებელი მონაცემთა ბაზასთან დაკავშირებისას. თუ კავშირი წარუმატებელია, თქვენ მიიღებთ გაფრთხილებას, რომელიც გეტყვით, რომელ ეტაპზეა პრობლემა:

PHP კოდი

$user="admin";
$პაროლი = "12345";
$db="baseName";

// თუ მოხდა შეცდომა
mysql_connect($host, $user, $password) ან die("MySQL სერვერი მიუწვდომელია!".mysql_error());
mysql_select_db($db) ან die("ბაზებთან კავშირი არ არის."mysql_error());
?>
ასევე ძალიან მნიშვნელოვანია სცენარის შემუშავება შეჩერდეს, რაც გიხსნით უამრავი არასწორი მონაცემებისგან.

გილოცავ! ახლა თქვენ იცით, როგორ დაუკავშირდეთ მონაცემთა ბაზას PHP-ში და დახუროთ კავშირი!

გმადლობთ ყურადღებისთვის!

მას შემდეგ რაც დააინსტალირებთ MySQL სერვერს, შეგიძლიათ დაუკავშირდეთ მას მხოლოდ იმავე აპარატიდან. ეს გაკეთდა სისტემის უსაფრთხოების მიზნით, რადგან უმეტეს შემთხვევაში MySQL გამოიყენება ინტერნეტში და იქ, იშვიათ შემთხვევებში, ვებ სერვერი და მონაცემთა ბაზის სერვერი გამოყოფილია.

კორპორატიულ სეგმენტში უფრო სწორია 1 სერვერის გამოყენება ყველა მსგავსი ამოცანისთვის. სისულელეა შეინარჩუნო MySQL ერთი მონაცემთა ბაზაში ყველა სერვერზე, რომელსაც ეს შეიძლება დასჭირდეს. ამიტომ, უნდა არსებობდეს მონაცემთა ერთი სერვერი, რომელზედაც დაინსტალირებულია მონაცემთა ბაზების საჭირო რაოდენობა სხვადასხვა ამოცანებისთვის.

სხვათა შორის, ინტერნეტში მონაცემთა ბაზის სერვერი და ვებ სერვერი გამოყოფილია მხოლოდ იმ შემთხვევებში, როდესაც ერთი სერვერის სიმძლავრე არ არის საკმარისი. თქვენ იქირავებთ ერთგულ სერვერს და მასზე ათავსებთ მონაცემთა ბაზას. მინდა განვმარტო, რომ მიზანშეწონილია ამის გაკეთება მხოლოდ ერთ DC-ში.

დაუშვით MySQL-თან დისტანციურად დაკავშირება

თავად MySQL-ის კონფიგურაციის ფაილში არის პარამეტრი bind-მისამართირომელიც პასუხისმგებელია ამაზე, ასე რომ:

  1. გახსნა კონფიგურაციის ფაილირედაქტირებისთვის:
    sudo nano /etc/mysql/my.cnf
  2. დააკომენტარეთ ხაზი:
    # bind-address = 127.0.0.1
  3. გადატვირთეთ MySQL:
    sudo სერვისის mysql გადატვირთვა

ამ ხაზის კომენტარის გაკეთება IP მისამართის მინიჭების ტოლფასია 0.0.0.0 , ანუ ყველას მიეცით საშუალება დაკავშირება. თქვენ არ შეგიძლიათ მიუთითოთ 2 IP მისამართი ამ სტრიქონში. თუ თქვენ გჭირდებათ შეზღუდოთ კავშირი MySQL სერვერთან, უნდა გამოიყენოთ iptables-ის შესაძლებლობები.

ახლა თქვენ შეგიძლიათ დაუკავშირდეთ მონაცემთა ბაზის სერვერს telnet კლიენტის საშუალებით, მაგრამ შიგნით შესასვლელად გჭირდებათ ანგარიში, რომელსაც ნებადართულია დაკავშირება არა მხოლოდ ლოკალჰოსტიდან. ამისათვის თქვენ უნდა დაუკავშირდეთ MySQL-ს თავად სერვერიდან და შექმნათ შემდეგი მომხმარებელი:

Mysql -u root -p

და შექმენით მომხმარებელი ბრძანებით:

ყველა პრივილეგიის მინიჭება *.*-ზე "new_user"@"remote_address"-ს, რომელიც იდენტიფიცირებულია "პაროლით" გრანტის ვარიანტით;

ეს ხაზი ქმნის მომხმარებელს შეუზღუდავი უფლებებით, რაც მთლად სწორი არ არის. უფრო სწორია მაქსიმალურად შეზღუდოს დისტანციურად დაკავშირებული მომხმარებლის წვდომა. ასე რომ, ბრძანება შეიძლება ასე გამოიყურებოდეს:

GRANT SELECT,Insert, Delete, Update, Create, Alter ON "database_name".* "new_user"@"remote_address" იდენტიფიცირებული "პაროლით" საგრანტო ვარიანტით;

ამ ბრძანებით ჩვენ შემოვიფარგლეთ მომხმარებლის ნებართვები მხოლოდ ერთი მონაცემთა ბაზაზე და მასთან მოქმედებებით.

ყველა უფლების სრული სია, რომელიც შეიძლება იყოს მითითებული მომხმარებლისთვის:

  • ყველა პრივილეგია- ყველა უფლება მითითებულ ობიექტზე, გარდა ამ ობიექტზე უფლებების მინიჭებისა;
  • შექმნა– მაგიდის შექმნის უფლება;
  • ALTER– ცხრილის შეცვლის უფლება;
  • ვარდნა– მაგიდის განადგურების უფლება;
  • მაგიდების ჩაკეტვა– მაგიდის ჩაკეტვის უფლება;
  • შექმენით დროებითი მაგიდები– დროებითი ცხრილების შექმნის უფლება;
  • რუტინის შექმნა– შენახული პროცედურების და ფუნქციების შექმნის უფლება;
  • რუტინის შეცვლა– შენახული პროცედურების და ფუნქციების შეცვლის ან განადგურების უფლება;
  • ხედის შექმნა– წარმომადგენლობის შექმნის უფლება;
  • ტრიგერი– ტრიგერების შექმნისა და განადგურების უფლება;
  • ინდექსი– ინდექსების შექმნისა და განადგურების უფლება;
  • შეასრულე– შენახული პროცედურების და ფუნქციების შესრულების უფლება;
  • EVENT– მოვლენების შექმნის უფლება;
  • მომხმარებლის შექმნა– მომხმარებლის შექმნის, განადგურების, სახელის გადარქმევის და ყველა უფლება წაშლის უფლება. დანიშნულია მხოლოდ გლობალურ დონეზე;
  • აირჩიეთ– ნიმუშის მიღების უფლება;
  • წაშლა– წაშლის უფლება;
  • INSERT– ჩასმის უფლება;
  • განახლება– განახლების უფლება;
  • FILE– SELECT ... INTO OUTFILE და LOAD DATA INFILE ბრძანებების გამოყენების უფლება;
  • პროცესი– ყველა პროცესის ნახვის უფლება SHOW PROCESSLIST ბრძანების გამოყენებით;
  • მონაცემთა ბაზების ჩვენება– სქემების სიის ნახვის უფლება;
  • ხედის ჩვენება– ნახვების სიის ნახვის უფლება;
  • გამორთვა- დახურვის უფლება.

დღეს ამ სტატიაში ვისაუბრებთ მონაცემთა ბაზასთან კავშირის შექმნაზე და განვიხილავთ რომელი ვარიანტია უკეთესი პროცედურული თუ ობიექტზე ორიენტირებული გამოყენება. ჯერ ვნახოთ, რა დონეზე ვართ, თუ ეს არის სრულიად დამწყების დონე, მაშინ ჩემი რჩევა, გამონაკლისის გარეშე, არის დავიწყოთ მონაცემთა ბაზასთან დაკავშირების პროცედურული სტილის გამოყენება. ადრე დავწერე სტატია ამ თემაზე ჩემს ბლოგზე, მონაცემთა ბაზასთან დაკავშირების პროცედურული სტილის შესახებ მეტი ინფორმაციისთვის წაიკითხეთ სტატია: „როგორ დავუკავშირდეთ MySQL PHP-ის გამოყენებით“. თუ თქვენ უკვე გაქვთ მონაცემთა ბაზასთან დაკავშირების პროცედურულ სტილთან მუშაობის გამოცდილება, მაშინ თქვენ, როგორც მე, უბრალოდ აიღეთ ჩემი პროექტები და აიძულეთ ისინი გამოეყენებინათ ობიექტზე ორიენტირებული მიდგომა.

ასეა თუ ისე, ახლა გავაანალიზებთ კლასის აგების ეტაპებს მონაცემთა ბაზასთან კავშირის შესაქმნელად MySQL მონაცემები on PHP ენა. დაგვჭირდება ორი PHP ფაილი, ერთ ფაილში „დავაყენებთ“ კლასს მონაცემთა ბაზასთან კავშირის შესაქმნელად, მეორეში კი ამ კლასთან ვიმუშავებთ.

მოდით შევქმნათ ორი ფაილი:

  • index.php;
  • database.class.php;

ვფიქრობ, პატარა ბავშვები აღარ ვართ და ვიცით, რა გვჭირდება PHP ფაილებთან მუშაობისთვის. დაინსტალირებული ვებ- Apache სერვერი, PHP, MySQL DBMS და იცის სად განათავსოს ეს ფაილები - (მათთვის, ვინც არ იცის ან დაავიწყდა).

მე დავაყენე ფაილი, რომელშიც კლასი ინახება ცალკე ფაილიდა ვასახელებ ფორმატში: class name.class.php და ვიცი რა ინახება ამ ფაილში. როდესაც პროექტში ბევრი კლასია, შეიძლება დაიკარგოთ, ამიტომ გირჩევთ დაასახელოთ ფაილები კლასებით ზემოთ აღწერილი ფორმატით.

Database.class.php ფაილი:

ახლა ვნახოთ, რაზე შეიქმნა ეს ნაბიჯი. საკვანძო სიტყვის „კლასი“, კლასის სახელი - DataBase და ხვეული ბრეკეტების გამოყენებით შევქმენით კლასის სხეული. შექმნილ კლასში შევქმენით ორი თვისება, $mConnect-ში - სადაც ინახება მონაცემთა ბაზასთან დაკავშირების შედეგი და $mSelectDB - სადაც ინახება მონაცემთა ბაზის შერჩევის შედეგი. თქვენ შეიძლება შენიშნეთ საკვანძო სიტყვები თითოეულ თვისებაში - საჯარო და სტატიკური. რაზე ლაპარაკობენ? საჯარო ნიშნავს, რომ საკუთრება ხელმისაწვდომია კლასის გარედან, ხოლო სტატიკური შესაძლებელს ხდის წვდომას ან გამოძახებას საკუთრებაში კლასის ეგზემპლარის შექმნის გარეშე, რაც ძალიან ხშირად მოსახერხებელია სამუშაოში.

მოდით დავამატოთ Connect() მეთოდი მონაცემთა ბაზასთან კავშირის შესაქმნელად:

".mysql_error()."

"; exit(); return false; ) // დააბრუნეთ შედეგი return self::$mConnect; ) ) ?>

  • $host - სერვერის IP მისამართი, ლოკალურ კომპიუტერზე ეს არის localhost;
  • მომხმარებელი - მონაცემთა ბაზის მომხმარებლის სახელი;
  • $pass - მონაცემთა ბაზის მომხმარებლის პაროლი;
  • $name - მონაცემთა ბაზის სახელი, რომელსაც ვუკავშირდებით;

mysql_connect() ფუნქცია ქმნის კავშირს მონაცემთა ბაზასთან და ინახავს შესრულების შედეგს $mConnect-ში. შემდეგ ხდება შემოწმება IF კონსტრუქტით: თუ კავშირი არ იყო წარმატებული, აჩვენეთ შეცდომის შეტყობინება... წინააღმდეგ შემთხვევაში, PHP უგულებელყოფს IF ბლოკს და გადავა მონაცემთა ბაზის არჩევაზე. mysql_select_db() ფუნქცია ირჩევს მონაცემთა ბაზის სახელს, თუ მოთხოვნილი მონაცემთა ბაზა არ არსებობს მონაცემთა ბაზაში, ამ შემთხვევაში პროგრამა შეცდომის შესახებ შეატყობინებს მომხმარებელს. თუ ყველაფერი წარმატებით დასრულდა, მონაცემთა ბაზის კავშირი დაბრუნდება.

დაამატეთ Close() მეთოდი:

უკაცრავად, ჩვენ ვერ შევძელით MySQL სერვერთან დაკავშირება

"; exit(); return false; ) // სცადეთ აირჩიოთ მონაცემთა ბაზის self::$mSelectDB = mysql_select_db($name, self::$mConnect); // თუ მონაცემთა ბაზა არ არის არჩეული, აჩვენეთ შეცდომის შეტყობინება.. if( !self::$mSelectDB) (echo "

".mysql_error()."

"; exit(); return false; ) // დააბრუნეთ შედეგი დააბრუნეთ self::$mConnect; ) // მეთოდი ხურავს კავშირს მონაცემთა ბაზასთან საჯარო სტატიკური ფუნქცია Close() ( // აბრუნებს შედეგს return mysql_close(self: :$mConnect) ) ) ?>

შემდეგი და ბოლო მეთოდი ამ კლასში, Close(), ხურავს კავშირს მონაცემთა ბაზასთან mysql_close() ფუნქცია ხურავს კავშირს MySQL სერვერთან და აბრუნებს შედეგს.

Index.php ფაილი:

define() ფუნქციის გამოყენებით ჩვენ შევქმენით მუდმივები მონაცემთა ბაზის კავშირის პარამეტრების შესანახად. Require_once მოიცავს ჩვენს DataBase კლასს index.php ფაილში.

გავიხსენოთ საკვანძო სიტყვა static, რომელიც გამოიყენებოდა DataBase კლასში ამ კლასის თვისებებში და მეთოდებში. ეს გვაძლევს შესაძლებლობას მივიღოთ კლასის თვისებებზე და მეთოდებზე "::" (ორი ორწერტილი) გამოყენებით. DataBase::Connect(DB_SERVER, DB_USERNAME, DB_PASSWORD, DB_DATABASE) მეთოდი იღებს 4 პარამეტრს - define() ფუნქციით შექმნილ მუდმივებს, რომლებიც ინახავს ინფორმაციას მონაცემთა ბაზასთან დაკავშირების შესახებ. თუ კავშირი წარმატებულია, Connect() მეთოდი დაგვიბრუნებს მონაცემთა ბაზის კავშირს. შემდეგი, ჩვენ შევძლებთ მუშაობას და შევასრულოთ მოთხოვნები მონაცემთა ბაზაში. mysql_query() ფუნქცია - ასრულებს მოთხოვნას მონაცემთა ბაზაში. mysql_fetch_assoc() ფუნქცია ამუშავებს შეკითხვის შედეგების სერიას და აბრუნებს ასოციაციურ მასივს. ექო კონსტრუქცია აჩვენებს MySQL სერვერის ვერსიას. და ბოლოს, DataBase::Close() მეთოდი დახურავს კავშირს მონაცემთა ბაზასთან.

php-ის გამოყენება...

მონაცემთა ბაზასთან კავშირის შექმნა PHP-ში სხვადასხვა გზით:

1) MySQL-თან დაკავშირების ძველმოდური გზა:

$conn=mysql_connect ($db_hostname, $db_username, $db_password) ან die ("სერვერთან კავშირი არ არის");
mysql_select_db($db_database,$conn) ან die ("არა, მონაცემთა ბაზასთან დაკავშირება ვერ მოხერხდა");

ქვემოთ მოცემული ცვლადების ახსნა.

გამოიყენება შემდეგი ფუნქციები:

  • mysql_connect ()- სერვერთან დასაკავშირებლად;
  • mysql_select_db()- მონაცემთა ბაზასთან დასაკავშირებლად;

ამავდროულად, ჩვენ მუდმივად ვამოწმებთ შეცდომებს ამ გზით: ან იღუპება („შეცდომა არის ასეთი და ასეთი“); - ითარგმნა როგორც ან იღუპება ამა თუ იმ შეცდომით - დაუყოვნებლივ იპოვო სად არის შეცდომა.

config.php

// ცვლადები მონაცემთა ბაზასთან დასაკავშირებლად
$host = "localhost"; / მასპინძელი
$username = "root"; // პაროლი მონაცემთა ბაზასთან დასაკავშირებლად
$პაროლი = ""; // პაროლი მონაცემთა ბაზასთან დასაკავშირებლად - ჩართულია ლოკალური კომპიუტერიმას შეიძლება ჰქონდეს ცარიელი მნიშვნელობა.
$database_name = "my-dolgi"; // მონაცემთა ბაზის სახელი

// მონაცემთა ბაზასთან დაკავშირების ძველი გზა
mysql_connect ($host, $username, $password) ან die ("ვერ დაკავშირება შექმენით კავშირი");

// აირჩიეთ მონაცემთა ბაზა. თუ არის შეცდომა, გამომავალი
mysql_select_db($database_name) ან die(mysql_error());

index.php

require_once "config.php";


$result = mysql_query ("SELECT Name, Money FROM Dolg ORDER BY Money DESC LIMIT 5") ან die(mysql_error());



";


ხოლო ($ row = mysql_fetch_assoc ($ შედეგი)) (
";
}


mysql_free_result($result);

// დახურეთ კავშირი
mysql_close();

2) უფრო პროგრესული პროცედურული სტილი - მონაცემთა ბაზასთან დაკავშირება mysqli-ს გამოყენებით:

ეს მეთოდი:

  1. უფრო მოსახერხებელი;
  2. 40-ჯერ უფრო სწრაფად;
  3. გაზრდილი უსაფრთხოება;
  4. არის ახალი ფუნქციები და ფუნქციები;

PHP-ში მონაცემთა ბაზასთან დაკავშირების მაგალითი ცხრილიდან შერჩევით

config.php

// კავშირები მონაცემთა ბაზასთან
$link = mysqli_connect("localhost", "username", "password", "name-database"); // აქ პირდაპირ შევიყვანთ თქვენს მონაცემებს: მომხმარებლის სახელი, პაროლი და მონაცემთა ბაზის სახელი, პირველი ველი ჩვეულებრივ ლოკალჰოსტია

// გამომავალი კავშირის შეცდომა
თუ (!$link) (
echo "ბაზთან დაკავშირების შეცდომა. შეცდომის კოდი: " . mysqli_connect_error();
გასასვლელი;
}

გთხოვთ გაითვალისწინოთ - mysqli ყველგან გამოიყენება და არა mysql!!!

index.php

require_once "config.php";

// მოთხოვნის შესრულება. თუ არის შეცდომა, ჩვენ ვაჩვენებთ მას
თუ ($ შედეგი = mysqli_query($ლინკი,"აირჩიეთ სახელი, ფული ვალის შეკვეთიდან ფულის მიხედვით DESC LIMIT 5")) (

ექო "ვის ვალში ვარ კლებადობით:

";

// მოთხოვნის შედეგების მიღება
ხოლო ($ row = mysqli_fetch_assoc($ შედეგი)) (
echo $row ["სახელი"] . "ვალებით". $row["ფული"] . "რუბლი.
";
}

// გამოყენებული მეხსიერების გათავისუფლება
mysqli_free_result($ შედეგი);

// დახურეთ კავშირი
mysqli_close($ბმული);
}

როგორც ხედავთ, ზოგიერთი პუნქტი შეიცვალა (დახრილებით).

3) MySQL მონაცემთა ბაზასთან დაკავშირების ობიექტზე ორიენტირებული მეთოდი - მეთოდებისა და კლასების გამოყენებით:

მინუსები: უფრო რთული და ნაკლებად მიდრეკილი შეცდომების მიმართ.

დადებითი: ლაკონურობა და მოხერხებულობა გამოცდილი პროგრამისტებისთვის.

$conn = new mysqli ($db_hostname, $db_username, $db_password, $db_database);
if ($conn->connect_errno)(
die ($conn->connect_error);
) else (echo "დაკავშირება მონაცემთა ბაზასთან წარმატებით დამყარდა";)

აქ, პრინციპში, ყველაფერი ინტუიციურია:

  • $db_hostname არის მასპინძელი(ძირითადად ლოკალური მასპინძელი),
  • $db_database - db სახელი;
  • $db_username და $db_password - მომხმარებლის სახელი და პაროლი, შესაბამისად!

php OOP სტილში მონაცემთა ბაზასთან დაკავშირების მაგალითი ცხრილიდან შერჩევით

config.php

// კავშირები მონაცემთა ბაზასთან
$mysqli = new mysqli("localhost", "username", "password", "name-database"); // აქ პირდაპირ შევიყვანთ თქვენს მონაცემებს: მომხმარებლის სახელი, პაროლი და მონაცემთა ბაზის სახელი, პირველი ველი ჩვეულებრივ ლოკალჰოსტია

// გამომავალი კავშირის შეცდომა
თუ ($mysqli->connect_error) (
die ("DB კავშირის შეცდომა: (" . $mysqli->connect_errno . ") " . mysqli_connect_error) ;
}

გთხოვთ გაითვალისწინოთ - mysqli ყველგან გამოიყენება და არა mysql!!! და წინა მეთოდისგან განსხვავებით, ჩნდება ისრები „->“, რაც მიუთითებს, რომ ეს არის OOP სტილი.

index.php

require_once "config.php";

// მოთხოვნის შესრულება. თუ არის შეცდომა, ჩვენ ვაჩვენებთ მას
თუ ($ შედეგი = $ mysqli->query("აირჩიეთ სახელი, ფული ვალის შეკვეთიდან ფულის მიხედვით DESC LIMIT 5")) (

ექო "ვის ვალში ვარ კლებადობით:

";

// მოთხოვნის შედეგების მიღება
ხოლო ($row = $result-> fetch_assoc()) {
echo $row ["სახელი"] . "ვალებით". $row["ფული"] . "რუბლი.
";
}

// გამოყენებული მეხსიერების გათავისუფლება
$შედეგი->დახურვა();

// დახურეთ კავშირი
$mysqli->დახურვა();
}

თქვენი ამოცანაა იპოვოთ განსხვავებები.

4) მონაცემთა ბაზასთან კომუნიკაცია PDO გამოყენებით:

MySQL მონაცემთა ბაზასთან დაკავშირებისას გამოიყენება მომზადებული გამონათქვამები (მომზადების მეთოდის გამოყენებით) და შედეგად, უფრო მეტი უსაფრთხოება და მნიშვნელოვნად გაზრდის შესრულებას.

კონფიგურაციის ფაილიწინა მეთოდიდან! - იგივე

index.php

// PDO სტილი MySQL-თან კომუნიკაციისთვის
if ($stmt = $mysqli->prepare("SELECT Name, Voney FROM Dolg ORDER BY Money< ? LIMIT 5")) {

$stmt->bind_param("i", $summa);
$summa = 100000;

//აღსრულების დაწყება
$stmt->execute();

// ცვლადების გამოცხადება მომზადებული მნიშვნელობებისთვის
$stmt->bind_result($col1, $col2);

ექო "ვის ვალში ვარ კლებადობით:

";

// მოთხოვნის შედეგების მიღება
ხოლო ($stmt->fetch()) (
ექო $col1. "ვალებით". $ col2. "რუბლი.
";
}

// გამოყენებული მეხსიერების გათავისუფლება
$stmt->close();

// დახურეთ კავშირი
$mysqli->close();

როგორც ხედავთ, ეს ბევრად უფრო რთულია და თქვენ უნდა შეისწავლოთ PDO - ეს ცალკე თემაა.

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 გაფართოების გამოყენებით. ფუნქცია იღებს ოთხ არგუმენტს:
    1. localhost არის ჰოსტის სახელი, რომელზეც მუშაობს MySQL მონაცემთა ბაზა
    2. სახელი - MySQL მომხმარებლის სახელი დასაკავშირებლად
    3. pass - პაროლი mysql მომხმარებლისთვის
    4. db - MySQL მონაცემთა დაკავშირება.
  • qvery - ფუნქცია MySQL შეკითხვა. ამ მაგალითში ჩვენ ვირჩევთ id სვეტს ქალაქის მონაცემთა ბაზიდან.
  • და ბოლოს, ჩვენ ვაჩვენებთ შერჩეულ მწკრივების რაოდენობას შედეგში num_rows ცვლადის გამოყენებით. ჩვენ ასევე ვხურავთ როგორც შედეგს, ასევე კავშირის ცვლადს, როგორც ეს ზემოთ არის ნაჩვენები.
როდესაც თქვენი ბრაუზერიდან გამოიძახებთ ზემოთ mysqli.php-ს, დაინახავთ შემდეგ გამომავალს, რომელიც მიუთითებს, რომ PHP-მ შეძლო დაკავშირება MySQL მონაცემთა ბაზასთან და მონაცემების მოძიება.

დაკავშირებულია მონაცემთა ბაზასთან. ხაზების რაოდენობა: 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(); ) ?> ზემოთ:
    1. ახალი PDO - შექმნის ახალ PDO ობიექტს, რომელიც მიიღებს შემდეგ სამ არგუმენტს:
    2. mysql დაკავშირების სტრიქონი: ის იქნება ფორმატში "mysql:host=localhost;dbname=db". ზემოთ მოყვანილ მაგალითში db მუშაობს localhost-ზე და ჩვენ ვუკავშირდებით db მონაცემთა ბაზას.
    3. 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 ფუნქცია იღებს სამ არგუმენტს:
    1. ჰოსტის სახელი, სადაც მუშაობს MySQL მონაცემთა ბაზა;
    2. MySQL მომხმარებლის სახელი დასაკავშირებლად;
    3. პაროლი mysql მომხმარებლისთვის. აქ ის უკავშირდება MySQL მონაცემთა ბაზას, რომელიც მუშაობს ადგილობრივ სერვერზე მომხმარებლის სახელისა და პაროლის გამოყენებით.
  • mysql_select_db ფუნქცია. როგორც სახელი გვთავაზობს, ის ირჩევს მონაცემთა ბაზას, რომელთანაც გსურთ დაკავშირება. "გამოყენების" ბრძანების ექვივალენტურია. ამ მაგალითში ჩვენ ვუკავშირდებით db მონაცემთა ბაზას.
  • mysql_query ფუნქცია - გამოიყენება თქვენი MySQL მოთხოვნის დასაზუსტებლად. ამ მაგალითში ჩვენ ვირჩევთ id სვეტს ქალაქის მონაცემთა ბაზიდან.
    • mysql_fetch_row. გამოიყენეთ ეს ფუნქცია ჩვენ მიერ ახლახან შექმნილი SQL მოთხოვნიდან რიგების ამოსაღებად.
  • და ბოლოს, დახურეთ კავშირი mysql_close ბრძანების გამოყენებით, როგორც ეს ნაჩვენებია ზემოთ.
როდესაც თქვენი ბრაუზერიდან გამოიძახებთ ზემოხსენებულ mysql-legacy.php-ს, დაინახავთ შემდეგ გამომავალს, რომელიც მიუთითებს, რომ PHP-მ შეძლო MySQL მონაცემთა ბაზასთან დაკავშირება და ინფორმაციის მოპოვება:

დაკავშირებულია მონაცემთა ბაზასთან. id 1: 1 ასე შეგიძლიათ დაუკავშირდეთ MySQL-ს. ვიმეორებ, უმჯობესია გამოიყენოთ პირველი ორი მეთოდი; ო

დაკავშირებული სტატიები