MySQL
MySQL
MySQL - მონაცემთა ბაზები
MySQL - მონაცემთა ბაზები
ატრიბუტი
აღწერა
 
MySQL
MySQL წარმოადგენს სერვერულ პროგრამას, რომელიც განკუთვნილია რელაციური მონაცემების ერთდროულად დასამუშავებლად. მასში შესაძლებელია რამდენიმე მონაცემთა ბაზის მართვა.
 
Database
Database - მონაცემთა ბაზა წარმოადგენს მონაცემების, ფუნქციონალის, ხედვების, კავშირების და ერთობლიობას.
 
Table
Table - ცხრილი/ტაბულა წარმოადგენს წინასწარ განსაზღვრული მონაცემების გაერთიანებულ სტრუქტურას.
 
Collumn
Collumn - სვეტი, რომელიც წარმოადგენს ცხრილის შემადგენელ ნაწილს. ის შეიძლება იყოს რამდენიმე, მიზან შეწონილია რომ არ იყო 1000-ზე მეტი. მათ გაანჩნიათ ტიპები, Int, Char, Text და აშ. თვითოეულ სვტეს გააჩნია თავისი სიგრძე, კოდირება, გაჩუმებითი მნიშნველობა, ინდექსი, ტრიგერი, კომენტარი, შეზღუდვები და სხვა საშუალებები. თვითოეულ სვეტს აქვს თავის სახელი.
 
Row
Row - სტრიქონი, წარმოადგენს ცხრილის შემადგენელ ნაწილს, რომლის თვითოეულ ბლოკში არის იმდენივე სვეტი, რამდენიც ცხრილის თავდაპირველი სტრუქტურის განსაზღვრის დროსაც მოვახდინეთ. თვითოეულ სტრიქონს აქვს თავის უნიკალური მისამართი, რის მიხედითაც ხდება ჩაწერა-კითხვის დროს რიგის დაცვა.
 
Index
ინდექსი - ეს არის სვეტის გამოცხადება სწრაფი ძებნის მოწესრიგებულ ბუფერში შესაბამისი სახელით. როდესაც ხდება დაინდექსებული სვეტის გამოყენება, მაშინ შესაბამის ჩანაწერზე წვდომა ხდება დაინდექსებული ბუფერიდან, რომლისთვისაც სერვერს გამოყოფილი აქვს ოპერატიულში მეხსირებეა და კონკრეტული მნისნველობის მოძებნა ხდება გაცილებით სწრაფად, ვიდრე არა დაინდექსებული ველიდან. ინდექსების დადებას ბაზის ოპტიმიზაციისთვის აქვს დიდი მნიშნველობა, მისი დადება ყველა სვეტზე არ არის რეკომენდირებული. ჯობია მოხდეს ანალიზი მონაცემთა ბაზის და შემდეგ გადაინდექსება.
 
View
ხედვა - view, შესაძლებელია ერთი ან რამდენიმე ცხრილიდან სასურველი სახით ინფორმაციის დამუშავება და გამოტანა;
 
Procedure
პროცედურა წარმოადგენს მონაცემთა ბაზის ფუნქციონალის შემადგენელ ნაწილს, რომელსაც აქვს სახელი, რომელიც თავის თავში მოიცავს მონაცემთა ბაზის ბრძანებებით წინასწარ გაწერილ კოდს და სრულდება ცალკე გამოძახებით, კოდიდან CALL პროცედურის_სახელი. ის არ აბრუნებს მონაცემებს.
 
Function
ფუნქცია წარმოადგენს მონაცემთა ბაზის ფუნქციონალის შემადგენელ ნაწილს, რომელსაც აქვს სახელი, რომელიც თავის თავში მოიცავს მონაცემთა ბაზის ბრძანებებით წინასწარ გაწერილ კოდს და სრულდება სხვა მოქმედებებთან ერთად. ის აბრუნებს წინასწარ განსაზღვრულ პარამეტრს. მისი გამოძახება ხდება SELECT ფუნქციის_სახელი; დასაბრუნებელი მნისნველობა გამოვა ეკრანზე.
 
Triger
ტრიგერი გამოიყენება, ცხრილში მონაცემების ცვლილებისას რაიმე მოქმედებების ჩასატარებლად. მაგალითად: არქივირება, ლოგირება და აშ.
 
Event
ხდომილება - event, წარმოადგენს წინასწარ გაწერილი ამოცანის შესრულებას რაიმე მოქმედებებზე დაყრდნობით, მაგალითად: ყოველ საათს, ყოველ კვირა დღეს და აშ.
 
Query
მოთხოვნა - წარმოადგენს MySQL-ისთვის ბრძანებების გადაცემას რაიმე ოპერაციების შესასრულებლად, როგორებიც არის SELECT, INSERT, UPDATE, DELETE, SHOW, CREATE, ALTER, CALL და აშ.
 
SELECT
ჩანაწერების წაკითხვა ცხრილიდან და რაიმე ბუფერული მონაცემებიდან;
 
INSERT
ჩანაწერების ჩაწერა ცხრილში;
 
UPDATE
ჩანაწერების ცვლილება;
 
DELETE
ჩანაწერების წაშლა;
 
SHOW
პარამეტრების ნახვა;
 
CREATE
ცხილის შექმნა;
 
ALTER
ცხრილის კორექტირება;
 
CALL
პროცედურის გამოძახება;
 
 
PHP-MySQLi
PHP-ით MySQL ბაზასთან კავშირი
PHP-ით MySQL ბაზასთან კავშირი და მონაცემების წამოღება SELECT
ატრიბუტი
აღწერა
 
mysqli_connect
ბაზასთან დაკავშირება
 
mysqli_connect_error
ბაზასთან დაკავშირების შეცდომის ტექსტურად დაბრუნება
 
mysqli_connect_errno
ბაზასთან დაკავშირების შეცდომის კოდის დაბრუნება
 
mysqli_close
კავშირის შეწყვეტა
 
mysqli_query
ბაზაზე ბრძანების გაშვება
 
mysqli_error
რაიმე ოპერაციის შემდეგ, ბაზის შეცდომის დასახელების დაბრუნება
 
mysqli_errno
რაიმე ოპერაციის შემდეგ, ბაზის შეცდომის კოდი დაბრუნება
 
mysqli_fetch_assoc
წაკითხული მონაცემების ასოცირებული მასივის დაბრუნება
 
mysqli_fetch_array
წაკითხული მონაცემების ინდექსირებული მასივის დაბრუნება
 
mysqli_free_result
წაკითხული მონაცემების გასუფთავება ბუფერიდან
 
დაკავშირება
<?php
$servername = "localhost";//სერვერის IP-ის ან ჰოსტის მისამართი
$username = "username";//მონაცეთა ბაზაში დასაკავშირებელი მომხმარებლის სახელი
$password = "password";//მონაცემთა ბაზაში დასაკავშირებელი პაროლი-კოდური სიტყვა

// დაკავშირება სერვერთან
$conn = mysqli_connect($servername, $username, $password);

// კონექშენის გადამოწმება
if (!$conn) {
    die("Connection failed: " . mysqli_connect_error());
}
echo "Connected successfully";
?> 
 
PHP_Select
<?php
$servername = "localhost";
$username = "username";
$password = "password";
$dbname = "myDB";

// Create connection
$conn = mysqli_connect($servername, $username, $password, $dbname);
// Check connection
if (!$conn) {
    die("Connection failed: " . mysqli_connect_error());
}

$sql = "SELECT id, firstname, lastname FROM MyGuests";
$result = mysqli_query($conn, $sql);

if (mysqli_num_rows($result) > 0) {
    // output data of each row
    while($row = mysqli_fetch_assoc($result)) {
        echo "id: " . $row["id"]. " - Name: " . $row["firstname"]. " " . $row["lastname"]. "<br>";
    }
} else {
    echo "0 results";
}

mysqli_close($conn);
?> 
 
 
SELECT
მონაცემების წაკითხვა ცხრილიდან
მონაცემების წაკითხვა ცხრილიდან
ატრიბუტი
აღწერა
 
SELECT სინტაქსი
SELECT
    [ALL /*ყველ ჩანაწეერის წაკითხვა*/ | DISTINCT /*მხოლო უნიკალური ჩანაწერები*/ | DISTINCTROW /*უნიკალური მთელი სტრიქონის მიხედვით*/ ] 
    select_expr [, select_expr ...] /*ველების დასახელება ან SQL ფუნქციები*/
    [FROM table_references /*ცხრილი ან ობიექტი*/
    [WHERE where_condition] /*პირობითი ოპერატორების სეგმენტი*/
    [GROUP BY {col_name | expr | position} /*დაჯგუფების სეგმენტი*/
      [ASC | DESC], ... [WITH ROLLUP]] /*დაჯგუფებისთვის დალაგების მანიშნბელი*/
    [HAVING where_condition] /*გამოთვლილი მონაცემებით ფილტრის სეგმენტი*/
    [ORDER BY {col_name | expr | position} /*დალაგების სეგმენტი, order by id asc, createdate desc*/
      [ASC | DESC], ...] /*ASC ზრდადობა, DESC კლებადობა*/
    [LIMIT {[offset,] row_count | row_count OFFSET offset}] /*მონაცემების ლიმიტირებული კითხვა, limit 0, 10 ან limit 10, ან limit 50,10*/
    [PROCEDURE procedure_name(argument_list)]
    [INTO OUTFILE 'file_name' export_options /*საკითხული მონაცემების დაექსპორტება გარე ფაილში*/
      | INTO DUMPFILE 'file_name' /*საიმპორტო ფაილის სახელი, მომზადებისთვის მონაცემების გენერირებისთვის*/
      | INTO var_name [, var_name]] /*დასაექსპორტებელი ველების სახელი*/
    ] 
 
 
Where
მონაცემების კითხვისთვის პირობითი ოპერატორები
მონაცემების კითხვისთვის პირობითი ოპერატორები
ატრიბუტი
აღწერა
 
=
მონაცემების დადარება. მაგ: Field1="1";
 
>
მეტობა, პირველი მონაცემი მეტია მეორეზე მაგ: Field1>"1";
 
<
აკლებობა, პირველი მონაცემი მეტია მეორეზე მაგ: Field1<"1";
 
>=
მეტია ტოლი;
 
<=
ნაკლებია ტოლი;
 
!= <>
არ უდრის, != ან <>;
 
()
პირობების გაერთიანება;
 
AND
და პირობით დაკავშირება;
 
OR
ან პირობით დაკავშირება;
 
XOR
ლოგიკური დადარება, 1 xor 1 და 0 xor 0 აბრუნებს 0-ს ხოლო, 1 xor 0 და 0 xor 1 აბრუნებს 1-ს;
 
NOT
უარყოფა;
 
ლოგიკური კონსტანტები
true კი, false არა, null.
 
IN
თუ პარამეტრის სიაში გადამოწმება. field in (1,2,3)
 
LIKE x%
თუ პარამეტრი x-ით იწყება მნისნველობა. field like "text%"
 
LIKE %x
თუ პარამეტრი x-ით მთავრდება მნიშნველობა. field like "%text"
 
LIKE %x%
თუ პარამეტრ x-ს შეიცავს მნიშნველობა. field like "%text%"
 
BETWEEN a AND b
მნიშნვნელობა a და b-ს შორის.
 
expr. as name
რაიმე მოქმედებაზე ან მნიშნველობაზე სახელის განსაზღვრა
 
 
Group by
დაჯგუფებები და ძირითადი დამაჯგუფებელი ფუნქციონალი
დაჯგუფებები და ძირითადი დამაჯგუფებელი ფუნქციონალი
ატრიბუტი
აღწერა
 
Group By
დაჯგუფება ველის ან რაიმე მოქმედების მიხედვით
 
Having
დამაჯგუფებელი ფუნქციის შედეგით ფილტრაცია
 
Avg()
საშუალო
 
Count()
რაოდენობა
 
Max()
მაქსიმალური მნიშნველობა
 
Min()
მინიმალური მნიშნველობა
 
Sum()
ჯამი
 
 
Functions
ფუნქციები
ფუნქციები
ატრიბუტი
აღწერა
 
IF
IF(ლოგიკური პირობა,თუ ჭეშმარიტია მაშინ რა ხდება, თუ მცდარია მაშინ რა); განშტოება;
 
Set a=value;
მონაცემების მინიჭება ფუნქციაში ან პროცედურაში
 
@a:=value;
მონაცემების მინიჭება მოთხოვნის-SELECT-ის შიგნით
 
Ucase()
მაღალი რეგისტრის სიმბოლოები. SELECT UCASE("asd"); დაიბეჭდება: ASD;
 
Lcase()
დაბალი რეგისტრის სიმბოლოები. SELECT LCASE("ASD"); დაიბეჭდება: asd;
 
Mid()
სტრიქონიდან მნიშნველობის ამოჭრა SELECT MID("123456789",5,2); დაიბეჭდება: 56
 
SUBSTR()
სტრიქონიდან მნიშნველობის ამოჭრა SELECT SUBSTR("123456789",5,2); დაიბეჭდება: 56
 
Length()
სიგრძე
 
Round()
დამრგვალება
 
Now()
მიმდინარე თარიღი და დრო
 
CURRENT_TIMESTAMP
მიმდინარე თარიღი და დრო
 
CURDATE
მიმდინარე თარიღი
 
CURTIME
მიმდინარე დრო
 
Format()
ფორმატი - FORMAT(Now(),"YYYY-MM-DD")
 
 
Join
ცხრილების დაკავშირება
ცხრილების დაკავშირება
ატრიბუტი
აღწერა
 
Syntax
    table_reference, table_reference // ცხრილების ჩამონათვალი, რომლიდანაც ყველა მონაცემი წამოვა და რამდენიმე ცხრილის შემთხვევაში ყველა შესაძო ვარიანტით მოხდება შეერთება;
  | table_reference [INNER | CROSS] JOIN table_reference [join_condition]//ცხრილები, რომლის შეერთებაც უნდა მოხდეს სხვა ცხრილებზე. აქ ჩმოთვლილი ცხრილების ურთიერთ მიერთება ხდება ჯვარედინი პრინციპით, cross join-ით;
  | table_reference {LEFT|RIGHT} [OUTER] JOIN table_reference join_condition //LEFT და LEFT OUTER ერთიდაიგივე დანიშნულების არის. ასევე  RIGHT და RIGHT OUTER. ისინი განსაზღვრავენ left მარცხენა მხარეს მდგომი მონაცემების სრულყოფილად წამოღებას ხოლო მეორე მხარეს მდგომი ცხრილიდან მხოლოდ შეეღტებული ნაწილის მიერთებას უზრუნველყოს. RIGHT პირიქით მარჯვენა მხარეს მდგომი ცხრილისთვის იქნება ყველა მონაცემი წამოღებული;
  | table_reference NATURAL [{LEFT|RIGHT} [OUTER]] JOIN table_reference //NATURAL მსგავსია inner left join-ის, სადაც ყველა სვეტი შედარდება ერთმანეთს

table_reference:
    ცხრილის_სახელი [[AS] ცხრილის_ალიასი] [index_hint)]
  | ცხრილი_ქვე_ბრძანება [AS] ალიასი

join_condition:
    ON ლოგიკური_პირობითი_ოპერატორები
  | USING (გამოყენებადი სვეტების სია)//რომელი ველებიც იქნება მოცემული, მათი დადარება მოხდება ორივე ცხრილში

index_hint:
    USE {INDEX|KEY} (ინდექსების_სია)] //გამოსაყენებელი ინდექსების სია
  | IGNORE {INDEX|KEY} (დასაიგნორებელი ინდექსების სია)]//
  | FORCE {INDEX|KEY} (ვეების სია)]//გამოიყენოს ველსი ინდექსი და თუ არ არის დაინდექსებული ჯერ ოპერატიულში გდაიტანს და შემდეგ გამოიყენებს

მაგალითი:
select * from table1 as t1 
	inner join table2 as t2 on t1.id=t2.id;

select * from table1 as t1 
	left outer join table2 as t2 on t1.id=t2.id;
	
 
Cross
ყველა კომბინაციის წამოღება -
ან SELECT * FROM table1, table2;
ან SELECT * FROM table1 CROSS JOIN table2;
ან SELECT * FROM table1 JOIN table2;
ან SELECT * FROM table1 INNER JOIN table2;
 
Inner
გამოიყენება როდესაც ერთი ცხრილი უნდა მოიცავდეს მეორეს, ხოლო თუ არ მოიძებნება მაშინ ის ჩანაწერი ამოვარდება რეზულტატიდან.
 
Outer
როდესაც ერთ ცხრილში დაძებნილი იფნრმაცია უნდა გამოვიდეს აუცილებლად და მეორე ცხრილიდან რომელ მონაცემსაც გადაებმევა იმ მონაცემს წამოიღებს
 
Left
მარცხნივ მდგომი ცხრილიდან წამოვა ყველა მოძებნილი პარამეტრი, ხოლო მარჯვნივ მდგომიდან მიეკვრება მხოლოდ გადაბმული მონაცემები, წინააღმდეგ შემთხვევაში იქნება NULL
 
Right
მარჯვნივ მდგომი ცხრილიდან წამოვა ყველა მოძებნილი პარამეტრი, ხოლო მარცხნივ მდგომიდან მიეკვრება მხოლოდ გადაბმული მონაცემები, წინააღმდეგ შემთხვევაში იქნება NULL
 
 
Insert
მონაცემების ჩაწერა ცხრილში
მონაცემების ჩაწერა ცხრილში
ატრიბუტი
აღწერა
 
Syntax
INSERT [LOW_PRIORITY | DELAYED | HIGH_PRIORITY] [IGNORE] //მონაცემების ჩაყრის ფუნქცია პრიორიტეტებით;
    [INTO] tbl_name // ცხრილის დასახელება, რომელშიც უნდა მოხდეს მონაცემების ჩაყრა;
    [PARTITION (partition_name,...)] //ცხრილის იმ ნაწილის რჩევა სადაც უნდა მოხდეს მონაცემების ჩაყრა;
    
	{
	 [(col_name,...)] //სვეტის სახელების ჩამონათვალი, რომლებიც უნდა შეივსოს
    {VALUES | VALUE} ({expr | DEFAULT},...),(...),...// values (შესავსები ველის მნიშვნელობები)
	| //ან 
	 SET col_name={expr | DEFAULT}, ...//რომელი ველი რა მნიშვნელობით შეავსოს
	| //ან
	 [(col_name,...)]//სვეტის მნიშვნელობები რაც უნდა შეივსოს;
    SELECT ...// Select რის მიხედვითაც უნდა შეივოს ველები;

	}
	
    [ ON DUPLICATE KEY UPDATE   //დუბლიკატი ჩანაწერების ჩაყრისას არსებული დუბლიკატი ჩანაწერი გაანახლოს;
      col_name=expr //დუბლიკაი ჩანაწერის განახლებისას არსებულ სვეტის მნიშვნელობა რით ჩაანაცვლოს
        [, col_name=expr] ... ]

მაგალითი:
insert into table1
(id,t_name,t_value)values
(1,"test1","123");

insert into table1
(id,t_name,t_value)
  select id,t_name,t_value 
       from table2;

insert into table1
set id=1,t_name="test1",t_value="123";
	   
 
 
Update
მონაცემების ცვლილება ცხრილში
მონაცემების ცვლილება ცხრილში
ატრიბუტი
აღწერა
 
Syntax
UPDATE [LOW_PRIORITY] [IGNORE] table_reference 
    SET col_name1={expr1|DEFAULT} [, col_name2={expr2|DEFAULT}] ...
    [WHERE where_condition]
    [ORDER BY ...]
    [LIMIT row_count]

multiple-table
UPDATE [LOW_PRIORITY] [IGNORE] table_references
    SET col_name1={expr1|DEFAULT} [, col_name2={expr2|DEFAULT}] ...
    [WHERE where_condition]
 
 
Delete
მონაცემების წაშლა ცხრილიდან
მონაცემების წაშლა ცხრილიდან
ატრიბუტი
აღწერა
 
Syntax
DELETE [LOW_PRIORITY] [QUICK] [IGNORE] FROM tbl_name
    [WHERE where_condition]
    [ORDER BY ...]
    [LIMIT row_count]

Multiple-table syntax:

DELETE [LOW_PRIORITY] [QUICK] [IGNORE]
    tbl_name[.*] [, tbl_name[.*]] ...
    FROM table_references
    [WHERE where_condition]

Or:

DELETE [LOW_PRIORITY] [QUICK] [IGNORE]
    FROM tbl_name[.*] [, tbl_name[.*]] ...
    USING table_references
    [WHERE where_condition]

 
 
Transactions
ტრანზაქცია და ტრანზაქციული გატარებები
ტრანზაქცი წარმოადგენს რამდენიმე SQL ოპერაციის ერთობლივ ოპერაცას, რომელიც ჯერ ლაგდება მოთხოვნების რიგში და შემდეგ ერთიანად ხდება ტრანზაქციაში შემავალი ოპერაციების შესრულება;
ატრიბუტი
აღწერა
 
Syntax
START TRANSACTION [WITH CONSISTENT SNAPSHOT]//ტრანზაქციის დაწყება
BEGIN [WORK] // ბლოკის გახსნა კოდების გაერთიანებისთვის;
COMMIT [WORK] [AND [NO] CHAIN] [[NO] RELEASE]//ტრანზაქციის დაწყებიდან მიმდინარე მომენტამდე გადაცემული ბრძანებების შესრულება;
ROLLBACK [WORK] [AND [NO] CHAIN] [[NO] RELEASE] //ტრანზაქციის გახსნიდან მიმდინარე მომენტამდე გდაცემული ტრანზაქციების გაბათილება;
SET autocommit = {0 | 1}//შესრულებული SQL მოთხოვნების ავტომატურად დამახსოვრება მოხდეს თუ არა;
 
 
ProcedureAndFunction
პროცედურა და ფუნქცია
პროცედურა და ფუნქცია
ატრიბუტი
აღწერა
 
Syntax
CREATE
    [DEFINER = { user | CURRENT_USER }]   //მომხმარებლის სახელის განსაზღვრა, თუ ვის მიერ განისაზღვრა პროცედურა
    PROCEDURE sp_name ([proc_parameter[,...]]) // პროცედურის სახელის დარქმევა და პარამეტრების გადაცემა
    [characteristic ...] routine_body   // აღწერა და პროცედურის ტანი, სადაც მოთვსებულია პროცედურის ლოგიკა SQL კოდით გაწერილი;

CREATE
    [DEFINER = { user | CURRENT_USER }]   // მომხმარებლის სახელის განსაზღვრა, თუ ვის მიერ განისაზღვრა ფუნქცია
    FUNCTION sp_name ([func_parameter[,...]]) // ფუნქციის სახელის დარქმევა და პარამეტრების გადაცემა
    RETURNS type   // დასაბრუნებელი პარამეტრის განსაზღვრა
    [characteristic ...] routine_body //ფუნქციის ტანი, სადაც მოთვსებულია ფუნქციის ლოგიკა
    
proc_parameter: // პროცედურაზე გადასაცემი პარამეტრები
    [ IN /*პარამეტრი მხოლოდ გადაეცემა, default*/ | OUT /*პარამეტრი მხოლოდ ბრუნდება*/ | INOUT /*პარამეტრი გადაეცემა და ბრუნდება*/] param_name /*პარამეტრის სახელი*/ type /*ტიპი*/
	(IN myDate DATE, OUT Amount FLOAT, ...)
    
func_parameter: // ფუნქციაზე გადასაცემი პარამეტრები
    param_name /*პარამეტრის სახელი*/ type /*პარამეტრის ტიპი*/
	 (myDate DATE, Amount FLOAT, ...)

type:
    მონაცემთა ტიპები განისაზღვრება იმ ტიპებით რომლებსაც ვიყენებტ ცხრილის შექმნისას;

characteristic:
    LANGUAGE SQL // ენის არჩევა
  | [NOT] DETERMINISTIC // იხილეთ ქვემოთ
  | { CONTAINS SQL /*შეიცავს SQL სტრიქონებს*/| NO SQL /*არ შეიცავს SQL სტრიქონებს*/| READS SQL DATA /*შეიცავს select-ს*/ | MODIFIES SQL DATA /*შეიცავს, INSERT-ს UPDATE-ს ან DELETE-ს*/ } // გამოიყენება ფუნქციია ან პროცედურის შესრულებისას რომ სხვა შემსრულებელმა ხელი არ შეუშალოს ჩაწერა კითხვის დროს;
  | SQL SECURITY { DEFINERნ/*ფუნქცია გაუშვას აღწერისას განსაზვრული მომხმარებლის სახელით*/ | INVOKER /*ფუნქცია გაუშვა სესიის მფლობელის სახელით, ვინც ახდენს ფუნქციის გაშვებას*/} // უსაფრთხოება, 
  | COMMENT "string" // კომენტარი
  
Deterministic:
მაგალითი 1.
	SELECT * FROM Table1 WHERE Table1.id=myfunc(11, 34);//რამდენი ჩანაწერის არის Table1-ში იმდენჯერ გაეშვება myFunc. ეს ფუნქცია იქნება გაცილებით ნელი ვიდრე მომდევნო

	SELECT Table1.* FROM Table1, (SELECT myfunc(11,34)) AS ret WHERE Table1.id=ret;  
	//ვინაიდან, მეორე ცხრილში მხოლოდ ერთხელ დამუშავდება myFunc ფუნქცია და მისი დამუშავებული მნიშნველობა გამოიყენება ყველა ჯერზე.
	
//თუ პროცედურას ან ფუნქციას აღვწერთ დეტერმინისტიკულად მაშინ ეს პრობლემა მოიხსნება, რადგან ასეთ ფუნქციის შემთხვევაში ერთიდაიგივე გადაცემულ პარამეტრზე SQL ერთხელ დაამუშავებს ფუნქციას და მეორე ჯერზე უკვე დამუშავებულ ინფორმაციას გადასცემს;

routine_body:
    სწორი SQL პროგრამირების კოდი
	
	
პროცედურის ან ფუნქციის კორექტირებისას CREATE-ის ნაცვლად ვიყენებთ ALTER-ს;	
პროცედურის ან ფუნქციის წაშლისას CREATE-ის ნაცვლად ვიყენებთ DROP-ს;	
პროცედურის გამოძახება ხდება CALL ბრძანებით. CALL PROC();
ფუნქციის გამოძახება ხდებს SQL სინტაქსის შიგნით;
 
BeginEnd
SQL პროგრამული კოდების გაერთიანება. მის ქვეშ შესრულებული კოდი უნდა შესრულდეს ყველა ან არ სრუდლება არცერთი. begin update t1 set id=1; update t2 set id=2; end;
 
DeclareVariable
ცვლადის აღწერა
DECLARE var_name[,...] type [DEFAULT value];

მაგალითად:
declare vInt INT;
declare vDate Date;

თუ ცვლად წინ უწერია @ ეს ნიშნავს რომ არის გლობალური ცვლადი და მისი გადაცემა შესაძლელია სხვადასხვა ბრძანებებს შორის;
 
DeclareHandler
DECLARE handler_type HANDLER FOR condition_value[,...] statement

handler_type:
    CONTINUE //გაგრძელება შესაბამის ხდომილებისას
  | EXIT // გამოსვლა შესაბამის ხდომილებისას
  | UNDO // უკან შესაბამის რაიმე ხდომილებისას

condition_value:
    SQLSTATE [VALUE] sqlstate_value // SQL სტატუსის მნიშნველობა
  | condition_name //პირობითი ოპერატორი
  | SQLWARNING // SQL გაფრთხილებისას ან რაიმე სახის მსუბუქი შეცდომა
  | NOT FOUND // ვერ მოძებნის შემთხვევა
  | SQLEXCEPTION // რაიმე გამონაკლისის ხდომილება
  | mysql_error_code // შეცდომის დაფიქსირება
  
 
Set
ცვლადზე მონაცემის მინიჭება;
SET var_name = expr [, var_name = expr] 

მაგალითად:
SET vInt=5; 
 
select_into
ცვლადზე მონაცემის მინიჭება SELECT იდან;
SELECT col_name[,...] INTO var_name[,...] table_expr

მაგალითად:
SELECT id into vInt FROM Table1;
 
IF
განშტოება;
IF search_condition /*ლოგიკური პირობა*/ THEN statement_list /*SQL კოდი*/
    [ELSEIF search_condition THEN statement_list] ...
    [ELSE statement_list]
END IF

მაგალითად:
IF vInt<10 THEN
set vInt=10;
END IF;
 
Case
განშტოება მრავალმხრივი;
CASE case_value
    WHEN when_value THEN statement_list
    [WHEN when_value THEN statement_list] ...
    [ELSE statement_list]
END CASE

Or:

CASE
    WHEN search_condition THEN statement_list
    [WHEN search_condition THEN statement_list] ...
    [ELSE statement_list]
END CASE

 
Loop
მარტიი ციკლი.
[begin_label:] LOOP
    statement_list  //SQL კოდი, სადაც ციკლის დასასრულისთვის გამოიყენება LEAVE ოპერატორი, ხოლო ITERATE ოპერატორი გამოიყენება ციკლის თავში გადასახტომად
END LOOP [end_label]

მაგალითი:
CREATE PROCEDURE sampleloop(p1 INT)
BEGIN
  label1: LOOP
    SET p1 = p1 + 1;
    IF p1 < 10 THEN
      ITERATE label1; //გადამისამართდეს ციკლის თავში, ციკლის შუა კოდიდან label1
    END IF;
    LEAVE label1;//დატოვოს ციკლი label1
  END LOOP label1; //გადამისამართდეს label1 ციკლის თავში
  SET @x = p1;
END;
 
Repeat
[begin_label:] REPEAT
    statement_list
UNTIL search_condition
END REPEAT [end_label]

მაგალითი:
CREATE PROCEDURE samplerepeat(p1 INT)
   BEGIN
     SET @x = 0;
     REPEAT SET @x = @x + 1; UNTIL @x > p1 END REPEAT;
   END
 
While
[begin_label:] WHILE search_condition DO
    statement_list
END WHILE [end_label]

მაგალითი:
CREATE PROCEDURE dowhile()
BEGIN
  DECLARE v1 INT DEFAULT 5;

  WHILE v1 > 0 DO
    ...
    SET v1 = v1 - 1;
  END WHILE;
END
 
Cursor
SELECT სტრიქონის მოსანიშნად და ეტაპობრივად წასაკითხად;
CREATE PROCEDURE curdemo()
BEGIN
  DECLARE done INT DEFAULT 0;
  DECLARE a CHAR(16);
  DECLARE b,c INT;
  DECLARE cur1 CURSOR FOR SELECT id,data FROM test.t1;//კურსორი 1-ის აღწერა
  DECLARE cur2 CURSOR FOR SELECT i FROM test.t2;//კურსორი 2-ის აღწერა
  DECLARE CONTINUE HANDLER FOR SQLSTATE "02000" SET done = 1;//წაიკითხავს სანამ სტატუსი იქნება დასასრული
  DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = 1;//წაიკითხავს ცხრილის ამოწურვამდე

  OPEN cur1;//კურსორი 1ის გახსნა
  OPEN cur2;//კურსორი 2ის გახსნა

  REPEAT
    FETCH cur1 INTO a, b;//კურსორი 1ის წაკითხვა
    FETCH cur2 INTO c;//კურსორი 2ის გახსნა
    IF NOT done THEN
       IF b < c THEN
          INSERT INTO test.t3 VALUES (a,b);
       ELSE
          INSERT INTO test.t3 VALUES (a,c);
       END IF;
    END IF;
  UNTIL done END REPEAT;

  CLOSE cur1;//კურსორი 1ის დახურვა
  CLOSE cur2;//კურსორი 2ის დახურვა
END