<?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
$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
    [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]] /*დასაექსპორტებელი ველების სახელი*/
    ] 

    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;
	

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 [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 [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]

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 მოთხოვნების ავტომატურად დამახსოვრება მოხდეს თუ არა;

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 სინტაქსის შიგნით;

DECLARE var_name[,...] type [DEFAULT value];

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

თუ ცვლად წინ უწერია @ ეს ნიშნავს რომ არის გლობალური ცვლადი და მისი გადაცემა შესაძლელია სხვადასხვა ბრძანებებს შორის;

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 var_name = expr [, var_name = expr] 

მაგალითად:
SET vInt=5; 

SELECT col_name[,...] INTO var_name[,...] table_expr

მაგალითად:
SELECT id into vInt FROM Table1;

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_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

[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;

[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

[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

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