პითონის ოპერატორები. ლოგიკური გამონათქვამები და ოპერატორები. პითონი. ტოპები, ლექსიკონები, სიები. ნაჭრები

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

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

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

// ეს MySQL შეკითხვავერ შეძლებს ქეშის $res = mysql_query("SELECT მომხმარებლის სახელი FROM user WHERE signup_date >= CURDATE()"); // შეგიძლიათ სხვაგვარად გააკეთოთ $today = date("Y-m-d"); $res = mysql_query ("SELECT მომხმარებლის სახელი მომხმარებლისგან WHERE signup_date >= "$დღეს"");

ფაქტია, რომ პირველ მოთხოვნაში გამოყენებული იყო CURDATE() ფუნქცია, მისი მოქმედების თავისებურება არ იძლევა მოთხოვნის შედეგების ქეშში მოთავსებას. თარიღის მნიშვნელობა შეიძლება წინასწარ ჩაიწეროს მოთხოვნის სტრიქონში, ეს გამორიცხავს მოთხოვნაში CURDATE() ფუნქციის გამოყენებას.
ანალოგიით, არის სხვა ფუნქციები, რომლებიც თავად არ არის ქეშირებული MySQL სერვერი, მათ შორის RAND(), NOW() ისევე როგორც სხვა ფუნქციები, რომელთა შედეგები არადეტერმინისტულია.

ნახეთ, როგორ მუშაობს თქვენი მოთხოვნა EXPLAIN სინტაქსის გამოყენებით

თქვენ ხედავთ, როგორ ასრულებს MySQL თქვენს შეკითხვას EXPLAIN სინტაქსის გამოყენებით. მისი გამოყენება დაგეხმარებათ ამოიცნოთ სისუსტეები შეკითხვის შესრულებაში, ასევე ცხრილის სტრუქტურაში. შეკითხვის შედეგად, EXPLAIN დააბრუნებს მონაცემებს, რომლებიც აჩვენებს, თუ რა ინდექსებია გამოყენებული, როგორ ხდება მონაცემების შერჩევა ცხრილებიდან, როგორ არის დალაგებული და ა.შ. ამისათვის უბრალოდ დაამატეთ SELECT მოთხოვნის დასაწყისში საკვანძო სიტყვა EXPLAIN, რის შემდეგაც ნაჩვენები იქნება ცხრილი მონაცემებით.

როდესაც გჭირდებათ ერთი ჩანაწერი, დააყენეთ LIMIT 1

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

// მოითხოვეთ ქალაქი Shymkent კოდით მონაცემთა ბაზიდან $res = mysql_query("SELECT * FROM location WHERE city = "Shymkent""); if (mysql_num_rows($res) > 0)( ) // დაამატეთ LIMIT 1 მოთხოვნის ოპტიმიზაციისთვის $res = mysql_query("SELECT * FROM location WHERE city = "Shymkent" LIMIT 1"); თუ (mysql_num_rows($res) > 0)( )

ჩაწერეთ ველები, რომლებსაც ეძებთ

კონკრეტულ შემთხვევაში, ინდექსი ნიშნავს იმ ველების ინდექსს, რომელშიც ეძებთ, ეს გააუმჯობესებს ძიების სიჩქარეს. სხვათა შორის, რეგულარული ინდექსი არ შეიძლება იმუშაოს პირობებთან რეგულარული გამონათქვამების სახით:

// ინდექსის ქალაქი LIKE 'shym%' იმუშავებს აქ // ინდექსი არ იქნება გამოყენებული აქ ქალაქი LIKE '%shymkent%'

პირობების ინდექსის გაკეთება რეგულარული გამონათქვამებითქვენ უნდა გამოიყენოთ ან იფიქროთ თქვენი ინდექსის სისტემაზე.

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

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

იპოვეთ ალტერნატივა ORDER BY RAND()-ის ნაცვლად

შემთხვევითი დახარისხების გამოყენება მართლაც ძალიან მოსახერხებელია და ბევრ ახალბედა პროგრამისტს იგივე აზრი აქვს ამის შესახებ. თუმცა, აქ არის ხარვეზები და ძალიან მნიშვნელოვანი ბოთლიპროდუქტიულობაში. აქ რეკომენდირებულია მიმართო დამატებითი კოდიიმის ნაცვლად, რომ გამოიყენოთ ORDER BY RAND(), როგორც მოშორების ალტერნატივა სუსტი წერტილიშესრულებაში, რომელიც შეახსენებს თავს მონაცემთა მოცულობის გაზრდისას.

გამოიყენეთ კონკრეტული ველების არჩევა SELECT *-ის ნაცვლად

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

დაამატეთ ID ველი ყველა ცხრილისთვის

ყველა მაგიდას, თუ კარგად არის გაკეთებული, უნდა ჰქონდეს id ველი აკრიფეთ INT, რომელიც არის ძირითადი გასაღები (PRIMARY_KEY) და AUTO_INCREMENT. გარდა ამისა, თქვენ უნდა მიუთითოთ ველისთვის UNSIGNED პარამეტრი, რაც ნიშნავს, რომ მნიშვნელობა ყოველთვის დადებითი იქნება.
MySQL აქვს შიდა ოპერაციებირომელსაც შეუძლია გამოიყენოს პირველადი გასაღები, ეს როლს ასრულებს რთული კონფიგურაციებიმონაცემთა ბაზები, როგორიცაა კლასტერები, პარალელიზება და ა.შ.
გარდა ამისა, თუ არსებობს რამდენიმე ცხრილი და თქვენ უნდა შეასრულოთ გაერთიანებული შეკითხვა, მაშინ ცხრილის ID-ები გამოგადგებათ.

ENUM, როგორც VARCHAR-ის ალტერნატივა

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

გამოიყენეთ NOT NULL NULL-ის ნაცვლად

NULL ველები მეტ ადგილს იკავებს ჩანაწერში ამის აღნიშვნის საჭიროების გამო NULL მნიშვნელობა. MyISAM ცხრილები, ველები NULL-ით ინახება ისე, რომ თითოეული ველი იკავებს 1 დამატებითი ცოტა, რომელიც მრგვალდება უახლოეს ბაიტზე. თუ ველში NULL-ის გამოყენება არ არის მნიშვნელოვანი, მაშინ რეკომენდებულია NOT NULL-ის გამოყენება.

გამოიყენეთ მომზადებული განცხადებები

$res = "განახლება ჰოსტების SET ip = INET_ATON("($_SERVER["REMOTE_ADDR"])") WHERE id = $host_id";

გამოიყენეთ სტატიკური ცხრილები

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

გამოიყენეთ ვერტიკალური გამოყოფა

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

გამოყავით დიდი INSERT და DELETE მოთხოვნები

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

while (1)( mysql_query("DELETE FROM logs WHERE log_date<= "2015-07-20" LIMIT 1000"); if (mysql_affected_rows() == 0){ // записи удалены успешно break; } usleep(50000); // делаем небольшую паузу }

შეეცადეთ გამოიყენოთ პატარა ველები

მოგეხსენებათ, მონაცემთა ბაზის მონაცემები ინახება მყარ დისკზე, ეს ხშირად შეიძლება იყოს ერთ-ერთი სუსტი წერტილი ვებ აპლიკაციაში. ფაქტია, რომ მცირე ზომის ჩანაწერები უფრო სასურველია, რადგან... მათი გამოყენება ამცირებს დატვირთვას მყარ დისკზე. თუ დარწმუნებული ხართ, რომ კონკრეტული ცხრილი შეინახავს რამდენიმე რიგს, მაშინ რაციონალური გამოსავალი იქნება ველების ტიპების გამოყენება მინიმალური შესაძლო მნიშვნელობებით. მაგალითად, თუ მთავარი გასაღები არის INT ტიპის და თქვენ შეინახავთ მხოლოდ მცირე რაოდენობის მონაცემებს ცხრილში, მაშინ ჯობია ის გააკეთოთ MEDIUMINT, SMALLINT ან თუნდაც TINYINT ტიპის.

შეარჩიეთ ცხრილების ტიპი, რომელიც შეესაბამება თქვენს ამოცანებს

დღესდღეობით ორი ფართოდ ცნობილი ცხრილის ტიპია MyISAM და InnoDB, თითოეულ მათგანს აქვს თავისი დადებითი და უარყოფითი მხარეები. მაგალითად, MyISAM კარგად კითხულობს მონაცემებს ცხრილებიდან დიდი რაოდენობით, მაგრამ უფრო ნელია წერისას. ის ასევე კარგად მუშაობს შეკითხვებზე, როგორიცაა SELECT COUNT(*).
InnoDB-ის მონაცემთა შენახვის მექანიზმი უფრო რთულია ვიდრე MyISAM, თუმცა მას მხარს უჭერს მწკრივების ჩაკეტვას, რაც სკალირებისას დადებითი მხარეა. ამიტომ, შეუძლებელია იმის თქმა, რომ ერთი ჯობია მეორეს და არ არის სწორი, თქვენ უნდა აირჩიოთ ტიპი თქვენი საჭიროებიდან გამომდინარე.

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

1. მოთხოვნების ოპტიმიზაცია შეკითხვის ქეშისთვის

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

// მოთხოვნა არ შეინახება$r = mysql_query( "აირჩიეთ მომხმარებლის სახელი მომხმარებლისგან WHERE signup_date >= CURDATE()"); // და ასეც იქნება! $დღეს = თარიღი ("Y-m-d" ); $r = mysql_query();

"SELECT მომხმარებლის სახელი მომხმარებლისგან WHERE signup_date >= "$today"" მიზეზი ის არის, რომ პირველი შეკითხვა იყენებს CURDATE() ფუნქციას. ეს ეხება ყველა ფუნქციას, როგორიცაა NOW(), RAND() და სხვა, რომელთა შედეგი არადეტერმინისტულია. თუ ფუნქციის შედეგი შეიძლება შეიცვალოს, მაშინ MySQL არ ქეშირებს ასეთ შეკითხვას. INამ მაგალითში

ამის თავიდან აცილება შესაძლებელია მოთხოვნის შესრულებამდე თარიღის გაანგარიშებით.

2. გამოიყენეთ EXPLAIN თქვენი SELECT მოთხოვნებისთვის// მომზადებული განცხადების შექმნა თუ ($stmt = $mysqli -> მომზადება()) { "არჩევა მომხმარებლის სახელი მომხმარებლისგან WHERE state=?"// დაკავშირების მნიშვნელობები $stmt ->bind_param("s" , $state );// შეასრულეთ $stmt ->შეასრულეთ(); // შედეგის მიბმა$stmt ->bind_result($username );

// მონაცემების მიღება

$stmt ->fetch();
printf("%s არის %s\n-დან", $username, $state);

$stmt ->close(); )

თუმცა, არსებობს გარკვეული შეზღუდვები. თქვენ მოგიწევთ ყველა ჩანაწერის წაკითხვა ან დარეკვა mysql_free_result() სანამ შეძლებთ სხვა შეკითხვის გაშვებას. ასევე, თქვენ არ შეგიძლიათ გამოიყენოთ mysql_num_rows() ან mysql_data_seek() ფუნქციის შედეგზე.

14. შეინახეთ IP ფორმატში Unsigned INT

ბევრი პროგრამისტი ინახავს IP მისამართებს VARCHAR(15) ტიპის ველში, არ იცის, რომ მისი შენახვა შესაძლებელია მთელი რიცხვის სახით. INT იკავებს 4 ბაიტს და აქვს ფიქსირებული ველის ზომა.
დარწმუნდით, რომ გამოიყენეთ Unsigned INT, რადგან IP შეიძლება დაიწეროს როგორც 32-ბიტიანი ხელმოუწერელი ნომერი.
გამოიყენეთ INET_ATON() თქვენს მოთხოვნაში IP მისამართის რიცხვად გადაქცევისთვის და INET_NTOA() ინვერსიული კონვერტაცია. იგივე ფუნქციები არსებობს PHP-ში - ip2long() და long2ip() (PHP-ში ამ ფუნქციებს ასევე შეუძლიათ უარყოფითი მნიშვნელობების დაბრუნება. შენიშვნა The_Lion-დან).

$r = "განაახლეთ მომხმარებლების SET ip = INET_ATON("($_SERVER["REMOTE_ADDR"])") WHERE user_id = $user_id";

15. ფიქსირებული ზომის ცხრილები (სტატიკური) უფრო სწრაფია

თუ ცხრილის თითოეულ სვეტს აქვს ფიქსირებული ზომა, მაშინ ცხრილს ეწოდება "სტატიკური" ან "ფიქსირებული ზომა". არაფიქსირებული სიგრძის სვეტების მაგალითი: VARCHAR, TEXT, BLOB. თუ ასეთ ველს შეიტანთ ცხრილში, ის აღარ გამოსწორდება და სხვაგვარად დამუშავდება MySQL-ის მიერ.
ასეთი ცხრილების გამოყენება გაზრდის ეფექტურობას, რადგან... MySQL-ს შეუძლია მათში ჩანაწერების უფრო სწრაფად მოძიება. როდესაც თქვენ გჭირდებათ ცხრილის სასურველი მწკრივის არჩევა, MySQL-ს შეუძლია ძალიან სწრაფად გამოთვალოს თავისი პოზიცია. თუ ჩანაწერის ზომა არ არის დაფიქსირებული, ის იძებნება ინდექსით.
ეს ცხრილები ასევე უფრო ადვილია ქეშირება და აღდგენა მონაცემთა ბაზის ავარიის შემდეგ. მაგალითად, თუ VARCHAR(20)-ს გადააქცევთ CHAR(20-ად), ჩანაწერი დაიკავებს 20 ბაიტს, მიუხედავად მისი რეალური შინაარსისა.
„ვერტიკალური გაყოფის“ მეთოდის გამოყენებით, შეგიძლიათ ცვლადი მწკრივის სიგრძის სვეტები ცალკე ცხრილში გადაიტანოთ.

16. ვერტიკალური გამოყოფა

ვერტიკალური დაყოფა გულისხმობს ცხრილის სვეტებად დაყოფას შესრულების გასაუმჯობესებლად.
მაგალითი 1. თუ მისამართები ინახება მომხმარებლების ცხრილში, მაშინ ფაქტი არ არის, რომ ისინი ძალიან ხშირად დაგჭირდებათ. თქვენ შეგიძლიათ გაყოთ ცხრილი და შეინახოთ მისამართები ცალკე მაგიდა. ამრიგად, მომხმარებლის ცხრილის ზომა შემცირდება. პროდუქტიულობა გაიზრდება.
მაგალითი 2: თქვენ გაქვთ ველი "last_login" ცხრილში. ის განახლდება ყოველ ჯერზე, როდესაც მომხმარებელი შედის საიტზე. მაგრამ ცხრილის ყველა ცვლილება ასუფთავებს მის ქეშს. ამ ველის სხვა ცხრილში შენახვით, თქვენ მინიმუმამდე დაიცავთ ცვლილებებს მომხმარებლების ცხრილში.
მაგრამ თუ თქვენ მუდმივად იყენებთ შეერთებებს ამ ცხრილებზე, ეს გამოიწვევს ცუდ შესრულებას.

17. გამოყავით დიდი DELETE და INSERT მოთხოვნები

თუ მონაცემების წაშლის ან ჩასმის დიდი მოთხოვნის გაკეთება გჭირდებათ, ფრთხილად უნდა იყოთ, რომ არ დაარღვიოთ აპლიკაცია. აღსრულება დიდი თხოვნაშეიძლება ჩაკეტოს მაგიდა და გამოიწვიოს გაუმართაობამთელი აპლიკაცია.
Apache-ს შეუძლია მრავალი პარალელური პროცესებიერთდროულად. ამიტომ, ის უფრო ეფექტურად მუშაობს, თუ სკრიპტები რაც შეიძლება სწრაფად შესრულდება.
თუ მაგიდებს ჩაკეტავთ გრძელვადიანი(მაგალითად, 30 წამის ან მეტი ხნის განმავლობაში), შემდეგ საიტის მაღალი ტრაფიკის შემთხვევაში, შეიძლება წარმოიშვას პროცესებისა და მოთხოვნების დიდი რიგი, რამაც შეიძლება გამოიწვიოს ნელი მუშაობასაიტი ან თუნდაც სერვერის ავარია.
თუ თქვენ გაქვთ მსგავსი მოთხოვნები, გამოიყენეთ LIMIT მათი მცირე ტემპებით გასაშვებად.

ხოლო (1) (mysql_query( "DELETE FROM ჟურნალებიდან WHERE log_date<= "2009-10-01" LIMIT 10000" ); if (mysql_affected_rows() == 0) (// ამოღებულია შესვენება ;)// მოკლე პაუზა

usleep (50000); )

18. პატარა სვეტები უფრო სწრაფია
მონაცემთა ბაზისთვის, მყარ დისკთან მუშაობა ალბათ ყველაზე სუსტი წერტილია. მცირე და კომპაქტური ჩანაწერები, როგორც წესი, უკეთესია შესრულების თვალსაზრისით, რადგან... დისკის მუშაობის შემცირება.
MySQL დოკუმენტაციას აქვს მონაცემთა შენახვის მოთხოვნების სია მონაცემთა ყველა ტიპისთვის.
თუ თქვენი ცხრილი შეინახავს რამდენიმე სტრიქონს, მაშინ აზრი არ აქვს, რომ მთავარი გასაღები იყოს INT ტიპის, შეიძლება იყოს უკეთესი, რომ გახადოთ ის MEDIUMINT, SMALLINT ან თუნდაც TINYINT. თუ არ გჭირდებათ დროის შენახვა, გამოიყენეთ DATE ნაცვლად DATETIME.

თუმცა, ფრთხილად იყავით, რომ ყველაფერი Slashdot-ის მსგავსად არ მოხდეს.

19. აირჩიეთ მაგიდის სწორი ტიპი

20. გამოიყენეთ ORM

21. ფრთხილად იყავით მუდმივ კავშირებთან
მუდმივი კავშირები შექმნილია MySQL-თან კომუნიკაციის დამყარების ხარჯების შესამცირებლად. კავშირის შექმნის შემდეგ, ის ღია რჩება სკრიპტის დასრულების შემდეგ. შემდეგ ჯერზე, ეს სკრიპტი გამოიყენებს იმავე კავშირს.
mysql_pconnect() PHP-ში
მაგრამ ეს მხოლოდ თეორიულად კარგად ჟღერს. ჩემი პირადი გამოცდილებიდან (და სხვების გამოცდილებიდან) ამ ფუნქციის გამოყენება არ არის გამართლებული. თქვენ გექნებათ სერიოზული პრობლემები კავშირის ლიმიტებთან, მეხსიერების ლიმიტებთან და ა.შ.

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

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

   ცხრილის ოპტიმიზაცია `table1`, `table2`…

   არ დაგავიწყდეთ, რომ ოპტიმიზაციის დროს ცხრილზე წვდომა დაბლოკილია.

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

შეცვალეთ ცხრილი `table1` დაალაგეთ `id`-ის მიხედვით

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

NOT NULL და ნაგულისხმევი ველი. უმჯობესია მონიშნოთ ველები, როგორც NOT NULL, რადგან ისინი ზოგავენ სივრცეს და გამორიცხავს არასაჭირო შემოწმებებს. ამ შემთხვევაში, ღირს ველების ნაგულისხმევი მნიშვნელობის დაყენება და ახალი მონაცემების ჩასმა მხოლოდ იმ შემთხვევაში, თუ ისინი განსხვავდება მისგან. ეს დააჩქარებს მონაცემთა დამატებას და შეამცირებს ცხრილების ანალიზზე დახარჯულ დროს. და უნდა გვახსოვდეს, რომ BLOB და TEXT ველების ტიპები არ შეიძლება შეიცავდეს ნაგულისხმევ მნიშვნელობებს.

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

მონაცემთა გამიჯვნა.რეკომენდებულია გრძელი არა გასაღების ველების ცალკე ცხრილად გამოყოფა, თუ წყაროს ცხრილი გამოიყენება მონაცემების მუდმივი მოსაძიებლად და ხშირად იცვლება. ეს მეთოდი შეამცირებს ცხრილის ცვლადი ნაწილის ზომას, რაც გამოიწვევს ინფორმაციის ძიების შემცირებას.
ეს განსაკუთრებით ეხება იმ შემთხვევებს, როდესაც ცხრილის ინფორმაციის ნაწილი განკუთვნილია მხოლოდ წასაკითხად, ხოლო მეორე ნაწილი განკუთვნილია არა მხოლოდ წასაკითხად, არამედ მოდიფიკაციისთვის (არ დაგავიწყდეთ, რომ ინფორმაციის წერისას მთელი ცხრილი იკეტება ). თვალსაჩინო მაგალითია ვიზიტების მრიცხველი.
არის ცხრილი (პირველი სახელი) ველებით id, content, show. პირველი არის გასაღები auto_increment-ით, მეორე არის ტექსტი და მესამე არის რიცხვითი - ის ითვლის შთაბეჭდილებების რაოდენობას. ყოველ ჯერზე, როდესაც ატვირთავთ გვერდს, +1 ემატება ბოლო ველს. ბოლო ველი გამოვყოთ მეორე ცხრილში. ასე რომ, პირველ ცხრილს (პირველს) ექნება id და შინაარსის ველები, ხოლო მეორე (მეორე) იქნება შოუები და first_id ველები. პირველი ველი გასაგებია, მგონი მეორეც - პირველი ცხრილიდან გასაღების id ველზე მითითება.
ახლა მუდმივი განახლებები მოხდება მეორე ცხრილში. ამავდროულად, უმჯობესია შეცვალოთ ვიზიტების რაოდენობა არა პროგრამულად, არამედ მოთხოვნის საშუალებით:

და შერჩევა მოხდება რთული შეკითხვის გამოყენებით, მაგრამ ერთი ან ორი არ არის საჭირო:

SELECT first.id, first.content, second.first_id, second.shows FROM second INNER JOIN first ON (first.id = second.first_id)

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

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

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

აირჩიეთ * "table1"-დან

მოთხოვნა არ არის ეფექტური, რადგან ის სავარაუდოდ აბრუნებს იმაზე მეტ მონაცემს, ვიდრე საჭიროა ფუნქციონირებისთვის. უკეთესი ვარიანტი იქნება დიზაინი:

აირჩიეთ id, დასახელება ცხრილიდან1 ORDER BY id LIMIT 25

მე დაუყოვნებლივ გავაკეთებ დამატებას LIMIT-ის გამოყენების მიზანშეწონილობის შესახებ. ეს ბრძანება ზღუდავს მოთხოვნის მიერ დაბრუნებული მწკრივების რაოდენობას. ანუ, შეკითხვა ხდება "მარტივი" და უფრო პროდუქტიული.
თუ LIMIT დაყენებულია 10-ზე, მაშინ ათი მწკრივის მიღების შემდეგ მოთხოვნა შეწყვეტილია.
თუ შეკითხვა იყენებს ORDER BY დახარისხებას, ის არ ხდება მთელ ცხრილში, არამედ მხოლოდ შერჩევისას.
თუ LIMIT გამოიყენება DISTINCT-თან ერთად, მოთხოვნა შეწყდება მას შემდეგ, რაც მითითებული იქნება უნიკალური სტრიქონები.
თუ იყენებთ LIMIT 0-ს, ცარიელი მნიშვნელობა დაბრუნდება (ზოგჯერ საჭიროა ველის ტიპის დასადგენად ან უბრალოდ მოთხოვნის მოქმედების შესამოწმებლად).

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

შეზღუდეთ SELECT-ის გამოყენება მუდმივად ცვალებადი ცხრილებისთვის.

2. არ დაივიწყოთ HEAP-ის დროებითი ცხრილები. მიუხედავად იმისა, რომ ცხრილს აქვს შეზღუდვები, მოსახერხებელია მასში შუალედური მონაცემების შენახვა, განსაკუთრებით მაშინ, როდესაც თქვენ გჭირდებათ სხვა არჩევანის გაკეთება ცხრილიდან ხელახალი წვდომის გარეშე. ფაქტია, რომ ეს ცხრილი ინახება მეხსიერებაში და ამიტომ მასზე წვდომა ძალიან სწრაფია.
3. ძიება ნიმუშით. დამოკიდებულია ველის ზომაზე და თუ ზომას 400 ბაიტიდან 300-მდე შეამცირებთ, ძიების დრო 25%-ით შემცირდება.