Chapterبەش 9 · Lectureوانە 9.5

Connecting PHP to MySQLپەیوەندیکردنی PHP بە MySQL

The five steps of every database page, MySQLi or PDO, a safe connection file with try/catch (PHP 8.1 throws exceptions), the old mysql_ functions you must not use, and the Lecture 7 example that shows a table's records.

پێنج هەنگاوەکەی هەموو لاپەڕەیەکی ، MySQLi یان PDO، فایلێکی پەیوەندیی سەلامەت بە ⁦try/catch (PHP 8.1⁩ فڕێ دەدات)، کۆنی ⁦mysql_⁩ کە نابێت بەکاریان بهێنیت و نموونەی وانەی 7 کە پیشان دەدات.

24 min read23 خولەک خوێندنەوە · 19 stepsهەنگاو

What you will learnچی فێر دەبیت

List and explain the five steps of PHP–database interaction.
Compare MySQLi and PDO and choose between them.
Write a connection file with mysqli (and with PDO) that sets utf8mb4 and handles failure with try/catch.
Explain why if (!$con) checks do not run in PHP 8.1+, and get error messages correctly.
Recognise the removed mysql_ functions and translate them to mysqli.
Build a page that reads and shows all rows of a table.

پێنج هەنگاوەکەی کارلێکی PHP و ڕیز بکەیت و ڕوونیان بکەیتەوە.
MySQLi و PDO بەراورد بکەیت و یەکێکیان هەڵبژێریت.
فایلێکی پەیوەندی بە mysqli (و بە PDO) بنووسیت کە ⁦utf8mb4⁩ دادەنێت و بە ⁦try/catch⁩ شکست چارەسەر دەکات.
ڕوون بکەیتەوە بۆچی پشکنینەکانی if (!$con) لە ⁦PHP 8.1+⁩دا جێبەجێ نابن و پەیامی هەڵە بە دروستی وەربگریت.
لابراوی ⁦mysql_⁩ بناسیتەوە و بیانگۆڕیت بۆ mysqli.
لاپەڕەیەک دروست بکەیت کە هەموو دەخوێنێتەوە و پیشانیان دەدات.

Opening the door to your dataکردنەوەی دەرگای زانیارییەکانت

Your database now exists in MySQL, and phpMyAdmin can show it. But your PHP pages cannot use it yet. Before a script can read or save anything, it must open a : a link between the PHP script and the MySQL server.

ئێستا لە MySQLدا هەیە و phpMyAdmin دەتوانێت پیشانی بدات. بەڵام هێشتا لاپەڕە PHPـەکانت ناتوانن بەکاری بهێنن. پێش ئەوەی شتێک بخوێنێتەوە یان هەڵبگرێت، دەبێت بکاتەوە: بەستەرێک لە نێوان PHP و MySQLدا.

Definitionپێناسە

The open link between your PHP script and the database server. You open it with the host, user name, password and database name, use it for every , and close it when you finish.

ئەو پەیوەندییە کراوەیەیە لە نێوان کۆدی PHPـەکەت و ڕاژەکاری بنکەدراوەدا. بە ناوی هۆست، ناوی بەکارهێنەر، تێپەڕەوشە و ناوی بنکەدراوە دەیکەیتەوە، بۆ هەموو بەکاری دەهێنیت و کاتێک تەواو بوویت دایدەخەیت.

Host, key and flat numberناونیشان، کلیل و ژمارەی شوقە

Connecting is like visiting a friend in a big apartment building. The host (localhost) is the building's address. The user name and password are your name and the door code. The database name is the flat number. Only when all four are right does the door open.

پەیوەندیکردن وەک سەردانی هاوڕێیەک وایە لە باڵەخانەیەکی گەورەدا. هۆست (localhost) ناونیشانی باڵەخانەکەیە. و ناوی خۆت و کۆدی دەرگاکەن. ناوی ژمارەی شوقەکەیە. تەنها کاتێک هەر چوارەکەیان ڕاست بن دەرگاکە دەکرێتەوە.

Where the analogy stops workingسنووری ئەم نموونەیە

A real door stays open for a while. A PHP connection normally lives only while one script runs; the next page opens a new one.

دەرگای ڕاستەقینە بۆ ماوەیەک کراوە دەمێنێتەوە. پەیوەندیی PHP بە ئاسایی تەنها تا کاتی کارکردنی یەک دەژی؛ لاپەڕەی دواتر یەکێکی نوێ دەکاتەوە.

Two rules for every example on this pageدوو یاسا بۆ هەموو نموونەکانی ئەم لاپەڕەیە

We use mysqli (and show PDO as the alternative). The old mysql_* functions in the course slides were removed in PHP 7 and do not exist in PHP 8. They appear on this page only inside correction boxes.
A value that comes from a visitor is never written into the SQL text. It is sent separately with a . The queries on this page contain no visitor input; the next lecture shows prepared statements in action.

mysqli بەکار دەهێنین (و PDO وەک ڕێگای جێگرەوە پیشان دەدەین). کۆنی mysql_* لە سلایدەکانی وانەکەدا لە ⁦PHP 7⁩دا لابران و لە ⁦PHP 8⁩دا بوونیان نییە. لەم لاپەڕەیەدا تەنها لە ناو چوارچێوەی ڕاستکردنەوەدا دەردەکەون.
نرخێک کە لە سەردانکەرەوە دێت هەرگیز ناخرێتە ناو دەقی SQLـەوە. بە جیا دەنێردرێت بە . ئەم لاپەڕەیە هیچ نێوخستەیەکی سەردانکەر لەخۆ ناگرن؛ وانەی داهاتوو لە کاردا پیشان دەدات.

PHP and a database in five stepsPHP و بنکەدراوە بە پێنج هەنگاو

Every PHP page that uses a database follows the same five steps:

هەموو لاپەڕەیەکی PHP کە بەکار دەهێنێت هەمان پێنج هەنگاو دەگرێتە بەر:

Create a database connection.
Select a database to use.
Perform a database query.
Use the returned data (if any).
Close the connection.

دروست بکە.
ئەو هەڵبژێرە کە بەکاری دەهێنیت.
بنێرە بۆ .
ئەو زانیارییانە بەکار بهێنە کە گەڕاونەتەوە (ئەگەر هەبن).
پەیوەندییەکە دابخە.

The five steps of PHP–database interaction, with the mysqli function for each step.پێنج هەنگاوەکەی کارلێکی PHP و ، لەگەڵ mysqli بۆ هەر هەنگاوێک.CêIT

The PHP script and MySQL are two separate programs. With XAMPP both run on your own computer; on a real host they are often two machines, and the visitor's browser never talks to the database directly. This arrangement is called a : see one, two or three tiers.

PHP و MySQL دوو جیاوازن. لە XAMPPـدا هەردووکیان لەسەر خۆت کار دەکەن؛ لەسەر ڕاستەقینە زۆرجار دوو ئامێری جیاوازن و سەردانکەر هەرگیز ڕاستەوخۆ قسە لەگەڵ ناکات. ئەم ڕێکخستنە پێی دەوترێت : بڕوانە یەک، دوو یان سێ چین.

The five steps in the three modern stylesپێنج هەنگاوەکە بە سێ شێوازە نوێیەکە
Stepهەنگاو	mysqli (procedural)mysqli (پرۆسیجەری)	mysqli (object style)mysqli (شێوازی )	`PDO`
1 Connect1 پەیوەندی	`mysqli_connect($h, $u, $p, $db)`	`new mysqli($h, $u, $p, $db)`	`new PDO("mysql:host=$h;dbname=$db;charset=utf8mb4", $u, $p)`
2 Select database2 هەڵبژاردنی	4th argument, or `mysqli_select_db($con, $db)` چوارەم، یان `mysqli_select_db($con, $db)`	4th argument, or `$con->select_db($db)` چوارەم، یان `$con->select_db($db)`	inside the DSN (`dbname=`)لە ناو DSNـەکەدا (`dbname=`)
3 Query3 ناردنی	`mysqli_query($con, $sql)`; with input: `mysqli_prepare()` + `mysqli_stmt_bind_param()` + `mysqli_stmt_execute()mysqli_query($con, $sql)`؛ لەگەڵ نێوخستە: `mysqli_prepare()` + `mysqli_stmt_bind_param()` + `mysqli_stmt_execute()`	`$con->query($sql)`; with input: `$con->prepare()`, `bind_param()`, `execute()$con->query($sql)`؛ لەگەڵ نێوخستە: `$con->prepare()`، `bind_param()`، `execute()`	`$pdo->query($sql)`; with input: `$pdo->prepare()` + `execute([...])$pdo->query($sql)`؛ لەگەڵ نێوخستە: `$pdo->prepare()` + `execute([...])`
4 Use data4 بەکارهێنانی زانیاری	`mysqli_fetch_assoc($result)`	`$result->fetch_assoc()`	`$stmt->fetch(PDO::FETCH_ASSOC)`
5 Close5 داخستن	`mysqli_close($con)`	`$con->close()`	`$pdo = null;`

Quick checkپشکنینی خێراWhich of the five steps can you usually skip, because PHP does it for you when the script ends?کام لە پێنج هەنگاوەکە زۆرجار دەتوانیت نەیکەیت، چونکە PHP کاتێک تەواو دەبێت خۆی دەیکات؟Step 1: create the connectionهەنگاوی 1: دروستکردنی پەیوەندیStep 5: close the connectionهەنگاوی 5: داخستنی پەیوەندیStep 3: perform the queryهەنگاوی 3: ناردنی پرس

MySQLi or PDO?MySQLi یان PDO؟

PHP 5 and later can work with a MySQL database in two ways:

⁦PHP 5⁩ و دواتر بە دوو ڕێگا دەتوانن کار لەگەڵ MySQL بکەن:

The — the i stands for improved. It has two styles: object-oriented ($con->query()) and procedural (mysqli_query($con, ...)).
(PHP Data Objects): one object-oriented way to talk to many kinds of database.

— پیتی i واتە improved (باشترکراو). دوو شێوازی هەیە: -ئاراستە ($con->query()) و پرۆسیجەری (mysqli_query($con, ...)).
⁦(PHP Data Objects)⁩: یەک ڕێگای -ئاراستە بۆ قسەکردن لەگەڵ زۆر جۆری .

Both are : libraries that carry SQL from PHP to the and back (how a program sends SQL).

هەردووکیان : کە SQL لە PHPـەوە دەگەیەنێتە و دەگەڕێنێتەوە (بەرنامەیەک چۆن SQL دەنێرێت).

MySQLi compared with PDOبەراوردی MySQLi لەگەڵ PDO
	`MySQLi`	`PDO`
Databases	MySQL (and MariaDB) onlyتەنها MySQL (و MariaDB)	about 12 database systems (MySQL, PostgreSQL, SQLite, SQL Server, Oracle, ...)نزیکەی ⁦12⁩ سیستەمی (MySQL، PostgreSQL، SQLite، ⁦SQL Server⁩، Oracle، ...)
Object-oriented-ئاراستە	yesبەڵێ	yesبەڵێ
Procedural APIAPI ـی پرۆسیجەری	yes (`mysqli_...` functions)بەڵێ ( `mysqli_...`)	noنەخێر
Prepared statements	yesبەڵێ	yesبەڵێ
Transactions	yesبەڵێ	yesبەڵێ

Both support , and the course says why that matters: prepared statements protect from SQL injection and are very important for web application security. In a prepared statement the SQL is sent with question marks (?) where the values go, and the values are sent separately, so a value can never change the meaning of the SQL. A groups several statements so that they all succeed or all fail together.

هەردووکیان پشتگیریی دەکەن و وانەکە دەڵێت بۆچی ئەمە گرنگە: لە دەمانپارێزن و بۆ ئاسایشی زۆر گرنگن. لە SQLـەکە لەگەڵ نیشانەی پرسیار (?) لە شوێنی نرخەکان دەنێردرێت و نرخەکان بە جیا دەنێردرێن، بۆیە هیچ نرخێک ناتوانێت واتای SQLـەکە بگۆڕێت. چەند فەرمانێک کۆ دەکاتەوە بۆ ئەوەی هەموویان پێکەوە سەرکەوتوو بن یان هەموویان شکست بهێنن.

Small corrections to the slidesچەند ڕاستکردنەوەیەکی بچووک بۆ سلایدەکان

The summary's table is headed "SQL vs PDO"; it means MySQLi vs PDO. It also says only MySQLi supports transactions — PDO supports them too.
"12 different database systems" is approximate: the number depends on which PDO drivers are installed. Our test PHP, for example, has only the mysql and sqlite drivers.
The slides praise prepared statements but none of the code in Lecture 7, Lecture 8 or the labs uses one. In these lectures every query with visitor input does.

خشتەکەی پوختەکە سەردێڕی «⁦SQL vs PDO⁩»ی هەیە؛ مەبەست MySQLi بەرامبەر PDOـیە. هەروەها دەڵێت تەنها MySQLi پشتگیریی دەکات — PDOش پشتگیرییان دەکات.
«⁦12⁩ سیستەمی جیاوازی » نزیکەییە: ژمارەکە بەندە بەو درایڤەرانەی PDO کە دامەزراون. بۆ نموونە PHPـی تاقیکردنەوەکەمان تەنها درایڤەری mysql و sqliteی هەیە.
سلایدەکان ستایشی دەکەن، بەڵام هیچ کۆدێک لە وانەی 7، وانەی 8 یان تاقیگەکاندا بەکاری ناهێنێت. لەم وانانەدا هەموو کە نێوخستەی سەردانکەری تێدابێت بەکاری دەهێنێت.

PDO Crash Course (PHP)Traversy Media · Englishئینگلیزی · 293K viewsبینین · 6.3K likesلایک · Partبەشی 1:21–5:39 (ofلە 45:35)
See named placeholders, then the four CRUD operations written with PDO prepared statements: fetch one row, insert, update and delete.
سەیری ناودار بکە، پاشان چوار کارەکەی کە بە نووسراون: یەک ، زیادکردن، گۆڕین و سڕینەوە.
Watch 1:21–5:39: what PDO is and why to use it
لە ⁦1:21⁩ تا ⁦5:39⁩ سەیر بکە: چییە و بۆچی بەکاری دەهێنین.

MySQLi or PDO?MySQLi یان PDO؟

The object operator ->کارپێکەری ئۆبجێکت ->

Both extensions are object-oriented, so you will see the arrow -> everywhere. It is the : it reaches inside an to use one of its parts.

هەردوو -ئاراستەن، بۆیە تیری -> لە هەموو شوێنێک دەبینیت. ئەمە : دەچێتە ناو بۆ بەکارهێنانی یەکێک لە بەشەکانی.

A is a value stored in the object. Read it without brackets: $myObject->myProperty, for example $result->num_rows.
A is a function that belongs to the object. Call it with brackets: $myObject->myMethod(), for example $con->query($sql).

نرخێکە کە لە هەڵگیراوە. بەبێ کەوانە دەیخوێنیتەوە: $myObject->myProperty، بۆ نموونە $result->num_rows.
کە سەر بە . بە کەوانەوە بانگی دەکەیت: $myObject->myMethod()، بۆ نموونە $con->query($sql).

object_operator.phpPHPRuns on the serverلەسەر ڕاژەکاری وێب کار دەکات

<?php
$pdo  = new PDO("sqlite::memory:");                    // create an object
$stmt = $pdo->query("SELECT 'Aram' AS name, 85 AS marks"); // call a method with ->

echo $stmt->queryString . "\n";     // read a property: no ( )
echo $stmt->columnCount() . "\n";   // call a method: with ( )

Explain the codeڕوونکردنەوەی کۆدەکە

Lineدێڕی 2

new PDO(...) creates an object; $pdo holds it.

new PDO(...) دروست دەکات؛ $pdo هەڵیدەگرێت.

Lineدێڕی 3

->query(...) calls a method of $pdo; it returns another object, $stmt.

->query(...) $pdo بانگ دەکات؛ تر دەگەڕێنێتەوە، $stmt.

Lineدێڕی 5

queryString is a property: no brackets.

queryString : بێ کەوانە.

Lineدێڕی 6

columnCount() is a method: with brackets. The query has 2 columns.

columnCount() : بە کەوانەوە. 2 هەیە.

Connecting with mysqliپەیوەندیکردن بە mysqli

This is the connection file we use from now on. It does steps 1 and 2 in one call, sets the to utf8mb4 so Kurdish text survives, and handles a failed connection.

ئەمە ئەو فایلی پەیوەندییەیە کە لێرە بەدواوە بەکاری دەهێنین. هەنگاوی 1 و 2 بە یەک بانگکردن دەکات، دادەنێت بە utf8mb4 بۆ ئەوەی دەقی کوردی تێک نەچێت و پەیوەندیی شکستخواردوو چارەسەر دەکات.

connection.phpPHPRuns on the serverلەسەر ڕاژەکاری وێب کار دەکات

<?php
// connection.php: steps 1 and 2 (connect + choose the database)
$host     = "localhost";  // the computer the database server runs on
$user     = "root";       // XAMPP's default user name
$password = "";           // XAMPP's root password is empty by default
$database = "school";     // the database we want to use

try {
    $con = mysqli_connect($host, $user, $password, $database);
    mysqli_set_charset($con, "utf8mb4");   // so Kurdish text is stored correctly
} catch (mysqli_sql_exception $e) {
    error_log("Database connection failed: " . $e->getMessage()); // for the developer
    exit("Sorry, the database is not available right now.");       // for the visitor
}

Explain the codeڕوونکردنەوەی کۆدەکە

Lineدێڕی 3-6

The four values the connection needs. On XAMPP the user is root with an empty password.

ئەو چوار نرخەی پەیوەندییەکە پێویستیانە. لە XAMPPدا بەکارهێنەرەکە rootـە بە بەتاڵ.

Lineدێڕی 9

Steps 1 + 2: mysqli_connect(host, user, password, database). The 4th argument selects the database. It returns a connection object, kept in $con.

هەنگاوی ⁦1 + 2⁩: mysqli_connect(host, user, password, database). چوارەم هەڵدەبژێرێت. پەیوەندی دەگەڕێنێتەوە، کە لە $conدا هەڵدەگیرێت.

Lineدێڕی 10

Use utf8mb4 on the connection too, not only on the database.

utf8mb4 لەسەر پەیوەندییەکەش بەکار بهێنە، نەک تەنها لەسەر .

Lineدێڕی 11-14

If the connection fails, PHP 8.1+ throws mysqli_sql_exception; we log the reason and stop with a friendly message.

ئەگەر پەیوەندییەکە شکستی هێنا، ⁦PHP 8.1+⁩ mysqli_sql_exception فڕێ دەدات؛ هۆکارەکە لە لۆگدا دەنووسین و بە پەیامێکی دۆستانە دەوەستین.

The four connection values (from the course slide)چوار نرخەکەی پەیوەندی (لە سلایدی وانەکەوە)
Valueنرخ	Meaningواتا
`"localhost"`	the computer the database server is on (here: this computer)ئەو کۆمپیوتەرەی لەسەرە (لێرە: هەمان ئەم کۆمپیوتەرە)
`"root"`	the user name XAMPP gives youئەو ناوی بەکارهێنەرەی XAMPP پێت دەدات
`""`	the password — empty in XAMPP (MAMP uses `"root"`) — لە XAMPPدا بەتاڵە (MAMP `"root"` بەکار دەهێنێت)
`"school"`	the name of your databaseناوی

PHP Full Course for free 🐘Bro Code · Englishئینگلیزی · 3M viewsبینین · 65K likesلایک · Partبەشی 3:26:07–3:34:57 (ofلە 4:00:00)
How to create a function, send values in with arguments, and get a result back with return, with a short practice example.
چۆن دروست بکەیت، بە بنێریتە ناوی و بە `return` ئەنجامێک لێی وەربگریتەوە، لەگەڵ ڕاهێنانێکی کورت.
Watch 3:26:07–3:34:57: mysqli_connect, try/catch and a database.php file
لە ⁦3:26:07⁩ تا ⁦3:34:57⁩ سەیر بکە: `mysqli_connect()`، `try`/`catch` و `database.php`.

Connecting with mysqliپەیوەندیکردن بە mysqli

Choosing the database in a separate stepهەڵبژاردنی بنکەدراوە لە هەنگاوێکی جیادا

You can also connect without a database name and choose it afterwards with mysqli_select_db(). The connection comes first, then the name:

دەتوانیت بەبێ ناوی پەیوەندی بکەیت و دواتر بە mysqli_select_db() هەڵیبژێریت. پەیوەندییەکە یەکەمە، پاشان ناوەکە:

PHPRuns on the serverلەسەر ڕاژەکاری وێب کار دەکات

<?php
$con = mysqli_connect("localhost", "root", "");   // no database chosen yet
mysqli_select_db($con, "school");                  // connection first, then the name

Connecting with mysqliپەیوەندیکردن بە mysqli

The same in object styleهەمان شت بە شێوازی ئۆبجێکت

connection.phpPHPRuns on the serverلەسەر ڕاژەکاری وێب کار دەکات

<?php
// The same connection in object-oriented style
try {
    $con = new mysqli("localhost", "root", "", "school");
    $con->set_charset("utf8mb4");
} catch (mysqli_sql_exception $e) {
    error_log("Database connection failed: " . $e->getMessage());
    exit("Sorry, the database is not available right now.");
}

Explain the codeڕوونکردنەوەی کۆدەکە

Lineدێڕی 4

new mysqli(...) creates the connection object. The arguments are the same as for mysqli_connect().

new mysqli(...) پەیوەندییەکە دروست دەکات. هەمان ئەوانەی mysqli_connect()ن.

Lineدێڕی 5

Methods are called with ->.

بە -> بانگ دەکرێن.

mysqli_connect() and new mysqli() return the same kind of object, so you can mix the styles: $con->query($sql) and mysqli_query($con, $sql) do the same thing.

mysqli_connect() و new mysqli() هەمان جۆری دەگەڕێننەوە، بۆیە دەتوانیت شێوازەکان تێکەڵ بکەیت: $con->query($sql) و mysqli_query($con, $sql) هەمان کار دەکەن.

Connecting with mysqliپەیوەندیکردن بە mysqli

What was wrong in the slide's mysqli codeچی هەڵە بوو لە کۆدی mysqliـی سلایدەکەدا

Correctionڕاستکردنەوە

The lecture slide and the summary show this mysqli connection (quotes straightened here):

سلایدی وانەکە و پوختەکە ئەم پەیوەندییە mysqliـیە پیشان دەدەن (کۆتەیشنەکان لێرە ڕاست کراونەتەوە):

Course version — do not useوەشانی وانەکە — بەکاری مەهێنەPHPRuns on the serverلەسەر ڕاژەکاری وێب کار دەکات

$connect=mysqli_connect('servername','user','password');
if(!$connect){
Dei("could not connect".mysqli_error($connect));
}
$database=mysqli_select_db("your database",$connect);
if(!$database)
{
Dei("could not select database".mysqli_error($connect));
}

Dei is a typo for die. PHP 8: Error: Call to undefined function Dei().
Wrong argument order. mysqli_select_db() takes the connection first: mysqli_select_db($connect, "your_database"). PHP 8: TypeError: mysqli_select_db(): Argument #1 ($mysql) must be of type mysqli, string given. (The summary copies the same mistake.)
mysqli_error($connect) cannot report a failed connection: $connect is false then. PHP 8: TypeError: mysqli_error(): Argument #1 ($mysql) must be of type mysqli, false given. Use mysqli_connect_error().
Curly quotes (‘servername', ”your database”) are a parse error.
PHP 8.1+: a failed connection throws before if(!$connect) runs, so the whole check is dead code. Use try/catch.

Dei هەڵەی نووسینە بۆ die. ⁦PHP 8⁩: Error: Call to undefined function Dei().
ڕیزبەندیی هەڵەی . mysqli_select_db() سەرەتا پەیوەندییەکە وەردەگرێت: mysqli_select_db($connect, "your_database"). ⁦PHP 8⁩: TypeError: mysqli_select_db(): Argument #1 ($mysql) must be of type mysqli, string given. (پوختەکەش هەمان هەڵە کۆپی دەکات.)
mysqli_error($connect) ناتوانێت پەیوەندیی شکستخواردوو ڕاپۆرت بکات: ئەو کاتە $connect falseـە. ⁦PHP 8⁩: TypeError: mysqli_error(): Argument #1 ($mysql) must be of type mysqli, false given. mysqli_connect_error() بەکار بهێنە.
کۆتەیشنی چەماوە (‘servername'، ”your database”) .
⁦PHP 8.1+⁩: پەیوەندیی شکستخواردوو پێش جێبەجێبوونی if(!$connect) فڕێ دەدات، بۆیە هەموو پشکنینەکە کۆدی مردووە. try/catch بەکار بهێنە.

The course deck's screenshot of dbcon.php has two more problems: it calls mysqli_connect_error($con) with an argument (PHP 8: ArgumentCountError: mysqli_connect_error() expects exactly 0 arguments, 1 given), and it does echo "successfuly"; inside the connection file, which prints that word on every page that includes it and breaks later header() redirects.

وێنەی dbcon.php لە سلایدەکانی کۆرسەکەدا دوو کێشەی تری هەیە: mysqli_connect_error($con) بە بانگ دەکات (⁦PHP 8⁩: ArgumentCountError: mysqli_connect_error() expects exactly 0 arguments, 1 given) و لە ناو فایلی پەیوەندییەکەدا echo "successfuly"; دەکات، کە ئەو وشەیە لە هەموو لاپەڕەیەکدا چاپ دەکات کە ئەو فایلە دەهێنێت و دواتر header() تێک دەدات.

Connecting with mysqliپەیوەندیکردن بە mysqli

When the connection fails: exceptions (PHP 8.1+)کاتێک پەیوەندییەکە شکست دەهێنێت: هەڵاوێردەکان ⁦(PHP 8.1+)⁩

Old tutorials (and the course slides) check the connection with if (!$con) { die(...); }. Since PHP 8.1, this check never runs when the connection fails. Instead, mysqli throws an of the class mysqli_sql_exception — the script stops at the mysqli_connect() line itself, before the if is reached.

فێرکارییە کۆنەکان (و سلایدەکانی وانەکە) بە if (!$con) { die(...); } پەیوەندییەکە دەپشکنن. لە ⁦PHP 8.1⁩ـەوە، ئەم پشکنینە هەرگیز جێبەجێ نابێت کاتێک پەیوەندییەکە شکست دەهێنێت. لە جیاتی ئەوە، mysqli لە کلاسی mysqli_sql_exception فڕێ دەدات — هەر لە دێڕی mysqli_connect() ڕادەوەستێت، پێش ئەوەی بگاتە ifـەکە.

test.phpPHPRuns on the serverلەسەر ڕاژەکاری وێب کار دەکات

<?php
$con = mysqli_connect("localhost", "root", "", "school");

if (!$con) {                        // never reached in PHP 8.1+ when the connection fails
    die("Connection failed");
}
echo "Connected successfully";

Explain the codeڕوونکردنەوەی کۆدەکە

Lineدێڕی 2

MySQL is stopped, so this line throws mysqli_sql_exception.

MySQL وەستاوە، بۆیە ئەم دێڕە mysqli_sql_exception فڕێ دەدات.

Lineدێڕی 4-6

Dead code in PHP 8.1+: "Connection failed" is never printed.

کۆدی مردوو لە ⁦PHP 8.1+⁩دا: «⁦Connection failed⁩» هەرگیز چاپ ناکرێت.

To handle the failure yourself, put the connection inside try { ... } and the error handling inside catch (mysqli_sql_exception $e) { ... }. If anything in try throws, PHP jumps to catch. $e->getMessage() holds the reason.

بۆ ئەوەی خۆت شکستەکە چارەسەر بکەیت، پەیوەندییەکە بخەرە ناو try { ... } و چارەسەرکردنی هەڵەکە بخەرە ناو catch (mysqli_sql_exception $e) { ... }. ئەگەر هەر شتێک لە tryدا فڕێ درا، PHP بازدەدات بۆ catch. $e->getMessage() هۆکارەکە هەڵدەگرێت.

The try/catch version, run without MySQLوەشانی ⁦try/catch⁩، بەبێ MySQL جێبەجێکراوPHPRuns on the serverلەسەر ڕاژەکاری وێب کار دەکات

<?php
// The same connection.php code, run on a computer where MySQL is NOT running
$host = "localhost"; $user = "root"; $password = ""; $database = "school";
try {
    $con = @mysqli_connect($host, $user, $password, $database);
    mysqli_set_charset($con, "utf8mb4");
    echo "Connected successfully";
} catch (mysqli_sql_exception $e) {
    exit("Sorry, the database is not available right now.");
}

Explain the codeڕوونکردنەوەی کۆدەکە

Lineدێڕی 5

The @ only hides the warning line that our test machine adds; in your own connection.php leave it out.

@ تەنها ئەو دێڕە ئاگادارکردنەوەیە دەشارێتەوە کە ئامێری تاقیکردنەوەکەمان زیادی دەکات؛ لە connection.phpـی خۆتدا مەینووسە.

Lineدێڕی 9

The visitor sees a calm message instead of a fatal error with file paths.

سەردانکەر لە جیاتی لەگەڵ ڕێڕەوی فایلەکان، پەیامێکی هێمن دەبینێت.

Getting the error messageوەرگرتنی پەیامی هەڵە
Function	Use it forبۆ چی بەکاری بهێنیت
`mysqli_connect_error()`	the reason the connection failed. It takes no argument (there is no connection object to give it).هۆکاری شکستی پەیوەندییەکە. هیچ وەرناگرێت ( پەیوەندی نییە تا پێی بدەیت).
`mysqli_error($con)`	the reason the last query failed, on a connection that works. Object style: `$con->error`.هۆکاری شکستی دوایین ، لەسەر پەیوەندییەک کە کار دەکات. شێوازی : `$con->error`.
`$e->getMessage()`	the reason inside a `catch` block — the normal way since PHP 8.1.هۆکارەکە لە ناو بلۆکی `catch`دا — ڕێگای ئاسایی لە ⁦PHP 8.1⁩ـەوە.

Do not show the real error to visitorsهەڵە ڕاستەقینەکە پیشانی سەردانکەر مەدە

The real message can reveal your server name, user name or file paths. On a live site, write it to the server log with error_log() and show the visitor a short, friendly message. While you are learning on XAMPP it is fine to echo $e->getMessage(); to see what went wrong.

پەیامە ڕاستەقینەکە دەتوانێت ناوی ، یان ڕێڕەوی فایلەکانت ئاشکرا بکات. لە زیندوودا، بە error_log() لە لۆگی بینووسە و پەیامێکی کورت و دۆستانە پیشانی سەردانکەر بدە. کاتێک لەسەر XAMPP فێر دەبیت، ئاساییە echo $e->getMessage(); بکەیت بۆ ئەوەی ببینیت چی هەڵە بووە.

Quick checkپشکنینی خێراIn PHP 8.1+, what happens when mysqli_connect() cannot reach the server?لە ⁦PHP 8.1+⁩دا، چی ڕوو دەدات کاتێک mysqli_connect() ناگاتە ؟It waits until MySQL starts.چاوەڕێ دەکات تا MySQL هەڵدەبێت.It throws a mysqli_sql_exception; without try/catch the script stops with a fatal error.mysqli_sql_exception فڕێ دەدات؛ بەبێ try/catch دەسنووسەکە بە هەڵەیەکی کوشندە دەوەستێت.It returns false and the if (!$con) check runs.false دەگەڕێنێتەوە و پشکنینی if (!$con) جێبەجێ دەبێت.

Connecting with PDOپەیوەندیکردن بە PDO

With PDO you create a PDO object. Its first argument is a (Data Source Name), a short text that names the driver (mysql:), the host, the database and the character set. Then come the user name and the password.

لە PDOدا PDO دروست دەکەیت. یەکەم ـە ⁦(Data Source Name)⁩، دەقێکی کورتە کە ناوی درایڤەرەکە (mysql:)، هۆست، و دیاری دەکات. پاشان و دێن.

connection_pdo.phpPHPRuns on the serverلەسەر ڕاژەکاری وێب کار دەکات

<?php
$host     = "localhost";
$database = "school";
$user     = "root";
$password = "";

try {
    $pdo = new PDO("mysql:host=$host;dbname=$database;charset=utf8mb4", $user, $password);
    // Since PHP 8.0 this is already the default; writing it makes the intention clear
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    echo "Connected successfully";
} catch (PDOException $e) {
    error_log($e->getMessage());   // keep server details out of the page
    echo "Connection failed.";
}

Explain the codeڕوونکردنەوەی کۆدەکە

Lineدێڕی 8

The DSN: mysql:host=localhost;dbname=school;charset=utf8mb4.

DSNـەکە: mysql:host=localhost;dbname=school;charset=utf8mb4.

Lineدێڕی 10

Throw PDOException on every error. Since PHP 8.0 this is already the default, so the line is optional but harmless.

لە هەموو هەڵەیەکدا PDOException فڕێ بدە. لە ⁦PHP 8.0⁩ـەوە ئەمە بنەڕەتییە، بۆیە دێڕەکە ناچاری نییە بەڵام زیانی نییە.

Lineدێڕی 12-15

If anything fails, catch receives the exception.

ئەگەر هەر شتێک شکستی هێنا، catch وەردەگرێت.

PDO is not only for MySQL. Here is the same kind of code with SQLite, which needs no server, user or password — so it really runs in our sandbox:

PDO تەنها بۆ MySQL نییە. ئەمە هەمان جۆری کۆدە لەگەڵ SQLite، کە نە ، نە بەکارهێنەر و نە پێویستە — بۆیە بەڕاستی لە ژینگەی تاقیکردنەوەکەماندا کار دەکات:

PHPRuns on the serverلەسەر ڕاژەکاری وێب کار دەکات

<?php
// PDO talking to SQLite: same PDO object, but no server, user or password
try {
    $pdo = new PDO("sqlite::memory:");   // a temporary database in memory
    echo "Connected successfully\n";
    echo "Driver: " . $pdo->getAttribute(PDO::ATTR_DRIVER_NAME) . "\n";
    echo "Exceptions on: ";
    var_dump($pdo->getAttribute(PDO::ATTR_ERRMODE) === PDO::ERRMODE_EXCEPTION);
} catch (PDOException $e) {
    echo "Connection failed.";
}

Explain the codeڕوونکردنەوەی کۆدەکە

Lineدێڕی 4

An SQLite DSN is just sqlite: and a file name (:memory: = a temporary database in memory).

DSNـی SQLite تەنها sqlite: و ناوی فایلێکە (:memory: = کاتی لە بیرگەدا).

Lineدێڕی 8

Proof that PHP 8 already uses exception mode.

بەڵگە کە ⁦PHP 8⁩ پێشتر شێوازی بەکار دەهێنێت.

About the slide's PDO codeدەربارەی کۆدی PDOـی سلایدەکە

On the slide the code is broken across bullet points ($password = on one line, "password"; try { on the next). It is valid PHP, but hard to read; above it is laid out properly.
The summary's copy uses curly quotes (“mysql:host=...), which PHP cannot read.
Add ;charset=utf8mb4 to the DSN, or Kurdish text may be stored as question marks.
echo "Connection failed: " . $e->getMessage(); shows server details to every visitor. Log the message and show a short text instead.

لە سلایدەکەدا کۆدەکە بە خاڵەکان پچڕاوە ($password = لە دێڕێک، "password"; try { لە دێڕی دواتر). PHPـی دروستە، بەڵام خوێندنەوەی قورسە؛ لە سەرەوە بە ڕێکی دانراوە.
کۆپییەکەی پوختەکە کۆتەیشنی چەماوە بەکار دەهێنێت (“mysql:host=...)، کە PHP ناتوانێت بیخوێنێتەوە.
;charset=utf8mb4 زیاد بکە بۆ DSNـەکە، دەنا لەوانەیە دەقی کوردی وەک نیشانەی پرسیار هەڵبگیرێت.
echo "Connection failed: " . $e->getMessage(); وردەکارییەکانی پیشانی هەموو سەردانکەرێک دەدات. پەیامەکە لە لۆگدا بنووسە و لە جیاتی ئەوە دەقێکی کورت پیشان بدە.

PHP PDO Tutorial Part 1 - Prepared Statements - SQL Injection - Full PHP 8 TutorialProgram With Gio · Englishئینگلیزی · 53K viewsبینین · 1.4K likesلایک · Partبەشی 2:45–6:34 (ofلە 25:18)
Connect to MySQL with PDO, set the error mode, and see how a PDO connection is built step by step.
فێر دەبیت چۆن بە پەیوەندی بە دەکەیت و دۆخی دادەنێیت و هەنگاو بە هەنگاو دەبینیت بە چۆن دروست دەکرێت.
Watch 2:45–6:34: creating the PDO connection and its error modes
لە ⁦2:45⁩ تا ⁦6:34⁩ سەیر بکە: دروستکردنی بە و دۆخەکانی .

One connection file, included everywhereیەک فایلی پەیوەندی، لە هەموو شوێنێک هاوردەکراو

Write the connection once, in its own file (connection.php in Lecture 7 and Lab 7, dbcon.php on the deck, config.php in Lecture 8), and include it at the top of every page that needs the data. One line, and $con is ready to use:

پەیوەندییەکە یەک جار بنووسە، لە فایلی تایبەتی خۆیدا (connection.php لە وانەی 7 و تاقیگەی 7، dbcon.php لە سلایدەکان، config.php لە وانەی ⁦8⁩) و بە require بیهێنە ناو سەرەتای هەموو لاپەڕەیەک کە پێویستی بە زانیارییەکانە. یەک دێڕ و $con ئامادەیە بۆ بەکارهێنان:

PHPRuns on the serverلەسەر ڕاژەکاری وێب کار دەکات

<?php
require "connection.php";   // now $con exists on this page

If the database details change (a new password, a real server), you change one file instead of every page.
Prefer require (or require_once) to include: a page that needs the database cannot work without it, and require stops with a clear error if the file is missing. See include and require.
The connection file should print nothing. An echo "connected"; there appears on every page, and any output before header("Location: ...") breaks the redirect.
A file that contains only PHP may leave out the closing ?>. Then no stray space or empty line after it can be sent by accident.

ئەگەر وردەکارییەکانی گۆڕان ( نوێ، ڕاستەقینە)، یەک فایل دەگۆڕیت لە جیاتی هەموو لاپەڕەکان.
require (یان require_once) لە include باشترە: لاپەڕەیەک کە پێویستی بە هەیە بەبێ ئەو کار ناکات و require ئەگەر فایلەکە نەبوو بە هەڵەیەکی ڕوون دەوەستێت. بڕوانە include و require.
فایلی پەیوەندییەکە نابێت هیچ چاپ بکات. echo "connected";ێک لەوێ لە هەموو لاپەڕەیەکدا دەردەکەوێت و هەر پێش header("Location: ...") ئاڕاستەکردنەوەکە تێک دەدات.
فایلێک کە تەنها PHPـی تێدایە دەتوانێت ?>ـی کۆتایی نەنووسێت. ئەو کاتە هیچ بۆشایی یان دێڕێکی بەتاڵی دوای ئەو بە هەڵە نانێردرێت.

Quick checkپشکنینی خێراWhat should connection.php print when the connection works?connection.php کاتێک پەیوەندییەکە کار دەکات دەبێت چی چاپ بکات؟Nothing at allهیچ شتێکThe database password, for checkingتێپەڕەوشەی بنکەدراوەکە، بۆ پشکنین"Connected successfully", so you know it worked«⁦Connected successfully⁩»، بۆ ئەوەی بزانیت کاری کرد

Commonly used mysqli functionsکردارە باوەکانی mysqli

mysqli functions you will use all the timeئەو mysqli کە هەمیشە بەکاریان دەهێنیت
Function	What it doesچی دەکات
`mysqli_query($con, $sql)`	Runs a query. Two parameters: the connection (the value returned in step 1) and the SQL text. Returns a result object for `SELECT`, `true` for `INSERT`/`UPDATE`/`DELETE`; on failure it throws (PHP 8.1+). جێبەجێ دەکات. دوو : پەیوەندییەکە (ئەو نرخەی لە هەنگاوی 1دا گەڕایەوە) و دەقی SQL. بۆ `SELECT` ئەنجام دەگەڕێنێتەوە، بۆ `INSERT`/`UPDATE`/`DELETE` `true`؛ لە کاتی شکستدا فڕێ دەدات ⁦(PHP 8.1+)⁩.
`mysqli_num_rows($result)`	How many rows the `SELECT` returned. Object style: `$result->num_rows`.ژمارەی ئەو `SELECT` گەڕاندوونیەتەوە. شێوازی : `$result->num_rows`.
`mysqli_num_fields($result)`	How many columns (fields) are in the result. It takes one parameter: the result. Object style: `$result->field_count`.ژمارەی ئەنجامەکە. یەک وەردەگرێت: ئەنجامەکە. شێوازی : `$result->field_count`.
`mysqli_fetch_array($result)`	Takes the next row and returns it as an array with both number keys and name keys; `null` when no rows are left. دواتر دەهێنێت و وەک بە کلیلی ژمارەیی و کلیلی ناودار دەیگەڕێنێتەوە؛ کاتێک نەما `null`.
`mysqli_fetch_assoc($result)`	Takes the next row and returns it as an : column name → value. دواتر دەهێنێت و وەک دەیگەڕێنێتەوە: ناوی ← نرخ.
`mysqli_error($con)`	The error message of the last failed query.پەیامی هەڵەی دوایین شکستخواردوو.
`mysqli_connect_error()`	The error message of a failed connection (no argument).پەیامی هەڵەی پەیوەندییەکی شکستخواردوو (بێ ).
`mysqli_close($con)`	Closes the connection (step 5).پەیوەندییەکە دادەخات (هەنگاوی ⁦5⁩).

Each fetch call returns one row, the next one, not "several rows". To read all rows you call it again and again in a while loop until it returns null. The difference between fetch_array and fetch_assoc is the keys: here it is with PDO and SQLite, which have the same two modes (FETCH_BOTH and FETCH_ASSOC):

هەر بانگکردنێکی fetch یەک دەگەڕێنێتەوە، دواتر، نەک «چەند ». بۆ خوێندنەوەی هەموو ، لە دووبارە و دووبارە بانگی دەکەیت تا null دەگەڕێنێتەوە. جیاوازیی نێوان fetch_array و fetch_assoc لە کلیلەکاندایە: ئەمە لەگەڵ PDO و SQLite، کە هەمان دوو شێوازیان هەیە (FETCH_BOTH و FETCH_ASSOC):

PHPRuns on the serverلەسەر ڕاژەکاری وێب کار دەکات

<?php
// fetch_array (BOTH) vs fetch_assoc, shown with PDO + SQLite (same idea as mysqli)
$pdo = new PDO("sqlite::memory:");
$pdo->exec("CREATE TABLE result (sId INT, sName TEXT, Marks INT)");
$pdo->exec("INSERT INTO result VALUES (1, 'Aram', 85), (2, 'Shilan', 92)");

$stmt = $pdo->query("SELECT sId, sName, Marks FROM result");
echo "Columns in the result: " . $stmt->columnCount() . "\n";

$row = $stmt->fetch(PDO::FETCH_BOTH);     // like mysqli_fetch_array($result)
echo "BOTH has " . count($row) . " elements\n";
print_r($row);

$row = $stmt->fetch(PDO::FETCH_ASSOC);    // like mysqli_fetch_assoc($result)
echo "ASSOC has " . count($row) . " elements\n";
print_r($row);

var_dump($stmt->fetch());                 // no rows left

Explain the codeڕوونکردنەوەی کۆدەکە

Lineدێڕی 8

Like mysqli_num_fields(): the result has 3 columns.

وەک mysqli_num_fields(): ئەنجامەکە 3 هەیە.

Lineدێڕی 10-12

Both keys for every value: 3 columns give 6 elements. So "the number of fields" equals the size of a fetch_assoc row, not of a default fetch_array row.

هەردوو کلیل بۆ هەر نرخێک: 3 6 دانە دەدەن. کەواتە «ژمارەی » یەکسانە بە قەبارەی fetch_assoc، نەک ئاسایی fetch_array.

Lineدێڕی 14-16

Only the column names: 3 elements. This call took the second row.

تەنها ناوی : 3 دانە. ئەم بانگکردنە دووەمی هێنا.

Lineدێڕی 18

No rows left. PDO returns false; mysqli_fetch_* returns null. Both stop a while loop.

هیچ نەماوە. PDO false دەگەڕێنێتەوە؛ mysqli_fetch_* null دەگەڕێنێتەوە. هەردووکیان ڕادەگرن.

The three fetch modes are drawn and explained in detail in Reading rows.

سێ شێوازەکەی fetch بە وێنە و بە وردی لە خوێندنەوەی تۆمارەکان ڕوون کراونەتەوە.

file_get_contents() is not a database function⁦file_get_contents()⁩ کرداری بنکەدراوە نییە

The course summary lists file_get_contents() among the MySQL functions. It has nothing to do with databases: it reads a whole file into one string. It can also read a web address, which is useful for web APIs.

پوختەی وانەکان file_get_contents() لە ناو MySQLدا ڕیز دەکات. هیچ پەیوەندییەکی بە نییە: فایلێک بە تەواوی دەخوێنێتەوە و دەیکات بە یەک . دەتوانێت ناونیشانێکی وێبیش بخوێنێتەوە، کە بۆ API ـی وێب بەسوودە.

PHPRuns on the serverلەسەر ڕاژەکاری وێب کار دەکات

<?php
file_put_contents("welcome.txt", "Welcome to CeIT!\nThis text came from a file.");

$text = file_get_contents("welcome.txt");   // the whole file becomes one string
echo strlen($text) . " characters\n";
echo $text;

The old mysql_ functions in the slidesکردارەکانی کۆنی ⁦mysql_⁩ لە سلایدەکاندا

Lecture 7 and the summary teach a third, much older set of functions whose names start with mysql_ (no i). You will still meet them in old books and websites, so you must recognise them — and know that they no longer work.

وانەی 7 و پوختەکە کۆمەڵەیەکی سێیەم و زۆر کۆنتری فێر دەکەن کە ناوەکانیان بە mysql_ دەست پێ دەکات (بێ i). هێشتا لە کتێب و کۆنەکاندا دەیانبینیت، بۆیە دەبێت بیانناسیتەوە — و بزانیت کە ئیتر کار ناکەن.

mysql_* was removed in PHP 7⁦mysql_⁩* لە ⁦PHP 7⁩دا لابرا

The mysql_* extension was deprecated in PHP 5.5 and removed in PHP 7.0 (2015). In PHP 8 the functions simply do not exist:

mysql_* لە ⁦PHP 5.5⁩دا ڕاگەیەنرا و لە ⁦PHP 7.0⁩دا لابرا ⁦(2015)⁩. لە ⁦PHP 8⁩دا ئەم هەر بوونیان نییە:

legacy_check.phpPHPRuns on the serverلەسەر ڕاژەکاری وێب کار دەکات

<?php
// What PHP 8 says about the old mysql_ extension
var_dump(function_exists("mysql_connect"));
$connect = mysql_connect("localhost", "root", "");

Here is the slides' connection code (quotes straightened). It also capitalises Die and Echo (allowed, because PHP function names are not case-sensitive, but unusual):

ئەمە کۆدی پەیوەندیی سلایدەکانە (کۆتەیشنەکان ڕاست کراونەتەوە). هەروەها Die و Echo بە پیتی گەورە دەنووسێت (ڕێگەپێدراوە، چونکە ناوی PHP هەستیار نین بە گەورە و بچووکیی پیت، بەڵام نائاساییە):

Old mysql_ code from the slides — does not run in PHP 7 or 8کۆدی کۆنی ⁦mysql_⁩ لە سلایدەکانەوە — لە ⁦PHP 7⁩ و 8دا کار ناکاتPHPRuns on the serverلەسەر ڕاژەکاری وێب کار دەکات

$connect=mysql_connect('servername','user','password');
if(!$connect){
Die("could not connect". mysql_error());
}
$database=mysql_select_db("your database");
if(!$database)
{
Die("could not select database". mysql_error());
}
Echo "success";

The php.net manual showed the same pattern for mysql_select_db(), with the database name first and the connection second: mysql_select_db('foo', $link). The new mysqli_select_db($link, 'foo') puts the connection first — the summary's mysqli example copied the old order by mistake.

ڕێبەری ⁦php.net⁩ هەمان شێوەی بۆ mysql_select_db() پیشان دەدا، بە ناوی یەکەم و پەیوەندییەکە دووەم: mysql_select_db('foo', $link). mysqli_select_db($link, 'foo')ی نوێ پەیوەندییەکە دەخاتە پێشەوە — نموونە mysqliـیەکەی پوختەکە بە هەڵە ڕیزبەندییە کۆنەکەی کۆپی کردووە.

Old mysql_ functions and their modern replacements کۆنی ⁦mysql_⁩ و جێگرەوە نوێکانیان
Old (removed)کۆن (لابراو)	Course descriptionڕوونکردنەوەی وانەکە	Use insteadلە جیاتی ئەوە بەکاری بهێنە
`mysql_connect("hostname","user","pass")`	connects to the database serverپەیوەندی بە دەکات	`mysqli_connect($host, $user, $pass, $db)`
`mysql_select_db("database name", handle)`	selects the database; handle is the connection variable (not a string) هەڵدەبژێرێت؛ handle پەیوەندییەکەیە (نەک )	`mysqli_select_db($con, "school")`
`mysql_query($sql, $connection)`	runs the query; the connection parameter is the value returned in step 1 (it was optional) جێبەجێ دەکات؛ پەیوەندی ئەو نرخەیە کە لە هەنگاوی 1دا گەڕایەوە (ناچاری نەبوو)	`mysqli_query($con, $sql)` — connection required and first`mysqli_query($con, $sql)` — پەیوەندی پێویستە و یەکەمە
`mysql_num_fields($result)`	number of fields in the row; the slide stops at "takes only one parameter:" — that parameter is the resultژمارەی ؛ سلایدەکە لە «تەنها یەک وەردەگرێت:» دەوەستێت — ئەو ئەنجامەکەیە	`mysqli_num_fields($result)`
`mysql_fetch_array($result)`	"returns several rows" — wrong: it returns one row per call, with number and name keys«چەند دەگەڕێنێتەوە» — هەڵەیە: لە هەر بانگکردنێکدا یەک دەگەڕێنێتەوە، بە کلیلی ژمارەیی و ناودار	`mysqli_fetch_array($result)`
`mysql_fetch_assoc($result)`	"several rows with associate array" — one row per call, as an associative array«چەند بە » — یەک لە هەر بانگکردنێکدا، وەک	`mysqli_fetch_assoc($result)`
`mysql_error()`	shows the error message returned from the MySQL serverئەو پەیامە هەڵەیە پیشان دەدات کە لە MySQLـەوە گەڕاوەتەوە	`mysqli_error($con)`, `mysqli_connect_error()`, or `$e->getMessage()` in `catchmysqli_error($con)`، `mysqli_connect_error()`، یان `$e->getMessage()` لە `catch`دا
`mysql_close($connection)`	closes the connectionپەیوەندییەکە دادەخات	`mysqli_close($con)`

The slides also write the arguments as quoted text — mysql_fetch_array("result variable from query") — but the argument is the variable $result, not a string.

سلایدەکان وەک دەقی ناو کۆتەیشن دەنووسن — mysql_fetch_array("result variable from query") — بەڵام $resultـە، نەک .

Worked example: show the records of a school databaseنموونەی کارپێکراو: پیشاندانی تۆمارەکانی بنکەدراوەی قوتابخانەیەک

Now put everything together: a database, a connection file and a page that shows the rows.

ئێستا هەموو شتێک پێکەوە دابنێ: ، فایلێکی پەیوەندی و لاپەڕەیەک کە پیشان دەدات.

Worked example: show the records of a school databaseنموونەی کارپێکراو: پیشاندانی تۆمارەکانی بنکەدراوەی قوتابخانەیەک

The taskئەرکەکە

The lecture ends with this example. Do it on your own computer:

وانەکە بەم نموونەیە کۆتایی دێت. لەسەر کۆمپیوتەرەکەی خۆت بیکە:

Create a database named school in MySQL.
Create a table named result with the fields sId, sName and Marks.
Create a file named connection.php.
Show the records of the database on a page.

بە ناوی school لە MySQLدا دروست بکە.
بە ناوی result بە sId، sName و Marks دروست بکە.
فایلێک بە ناوی connection.php دروست بکە.
لە لاپەڕەیەکدا پیشان بدە.

The lecture never shows the CREATE TABLE for result. A suitable one (run it in the SQL tab of phpMyAdmin) with three test rows:

وانەکە هەرگیز CREATE TABLEی result پیشان نادات. یەکێکی گونجاو (لە تابی SQLـی phpMyAdmin جێبەجێی بکە) لەگەڵ سێ تاقیکردنەوە:

school.sqlSQLRuns in the databaseلە ناو بنکەدراوە کار دەکات

CREATE DATABASE school CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;
USE school;
CREATE TABLE result (
    sId INT NOT NULL PRIMARY KEY,
    sName VARCHAR(50) NOT NULL,
    Marks INT NOT NULL
);
INSERT INTO result (sId, sName, Marks) VALUES
(1, 'Aram', 85),
(2, 'Shilan', 92),
(3, 'Karwan', 78);

Worked example: show the records of a school databaseنموونەی کارپێکراو: پیشاندانی تۆمارەکانی بنکەدراوەی قوتابخانەیەک

The solution, step by stepچارەسەرەکە، هەنگاو بە هەنگاو

Steps 1 and 2 live in connection.php (shown above in Connecting with mysqli). The page index.php requires it before the HTML, does steps 3 and 4 inside the <body>, and closes the connection (step 5) after </html>:

هەنگاوی 1 و 2 لە connection.phpدان (لە سەرەوە لە پەیوەندیکردن بە mysqli پیشان دراوە). لاپەڕەی index.php پێش HTMLـەکە دەیهێنێت، هەنگاوی 3 و 4 لە ناو <body>دا دەکات و دوای </html> پەیوەندییەکە دادەخات (هەنگاوی ⁦5⁩):

index.phpPHPRuns on the serverلەسەر ڕاژەکاری وێب کار دەکات

<?php
// Steps 1 + 2: connect and choose the database
require "connection.php";
?>
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Results</title>
</head>
<body>
<h1>Student results</h1>
<?php
// Step 3: perform the database query
$result = mysqli_query($con, "SELECT sId, sName, Marks FROM result ORDER BY sId");

if (mysqli_num_rows($result) === 0) {
    echo "<p>No record found</p>";
} else {
    // Step 4: use the returned data, one row at a time
    while ($row = mysqli_fetch_assoc($result)) {
        echo htmlspecialchars($row["sId"]) . " - "
            . htmlspecialchars($row["sName"]) . " - "
            . htmlspecialchars($row["Marks"]) . "<br>\n";
    }
}
?>
</body>
</html>
<?php
// Step 5: close the connection
mysqli_close($con);

What the browser showsئەوەی تۆڕگەڕ پیشانی دەدات

Student results

1 - Aram - 85
2 - Shilan - 92
3 - Karwan - 78

HTML sent to the browserئەو HTMLـەی دەنێردرێت بۆ تۆڕگەڕ

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Results</title>
</head>
<body>
<h1>Student results</h1>
1 - Aram - 85<br>
2 - Shilan - 92<br>
3 - Karwan - 78<br>
</body>
</html>

Output produced by running the same five steps with PDO and SQLite in our sandbox (the table result with the three test rows). With MySQL the page is identical.

ئەم بە جێبەجێکردنی هەمان پێنج هەنگاو بە PDO و SQLite لە ژینگەی تاقیکردنەوەکەماندا دروست بووە ( result بە سێ تاقیکردنەوە). لەگەڵ MySQL لاپەڕەکە هەمان شتە.

Explain the codeڕوونکردنەوەی کۆدەکە

Lineدێڕی 1-4

Steps 1 + 2: require the connection file at the top, before any HTML.

هەنگاوی ⁦1 + 2⁩: فایلی پەیوەندییەکە لە سەرەوە require بکە، پێش هەر HTMLێک.

Lineدێڕی 15

Step 3: run the query. It contains no visitor input, so a plain mysqli_query() is safe here.

هەنگاوی 3: جێبەجێ بکە. هیچ نێوخستەیەکی سەردانکەری تێدا نییە، بۆیە mysqli_query()ـی ئاسایی لێرەدا سەلامەتە.

Lineدێڕی 17-18

No rows? Say so. (The slide used die("No record found"), which also stops the rest of the page.)

نییە؟ بیڵێ. (سلایدەکە die("No record found")ی بەکار هێنا، کە بەشەکانی تری لاپەڕەکەش ڕادەگرێت.)

Lineدێڕی 21

Step 4: mysqli_fetch_assoc() returns the next row each time; at the end it returns null and the while loop stops.

هەنگاوی 4: mysqli_fetch_assoc() هەر جارێک دواتر دەگەڕێنێتەوە؛ لە کۆتاییدا null دەگەڕێنێتەوە و ڕادەوەستێت.

Lineدێڕی 22-24

Use column names, and escape every value with htmlspecialchars() before printing it.

ناوی بەکار بهێنە و پێش چاپکردن هەموو نرخێک بە htmlspecialchars() پاک بکەرەوە.

Lineدێڕی 30-32

Step 5: close the connection after the HTML.

هەنگاوی 5: دوای HTMLـەکە پەیوەندییەکە دابخە.

The bugs in the slides' version of this exampleهەڵەکانی وەشانی سلایدەکان بۆ ئەم نموونەیە

The slides build the same page with the removed mysql_* functions. Besides that, each step has its own bug:

سلایدەکان هەمان لاپەڕە بە لابراوی mysql_* دروست دەکەن. جگە لەوە، هەر هەنگاوێک هەڵەی تایبەتی خۆی هەیە:

Steps 1–5 from the slides (quotes straightened) — do not useهەنگاوەکانی ⁦1–5⁩ لە سلایدەکانەوە (کۆتەیشن ڕاستکراوە) — بەکاری مەهێنەPHPRuns on the serverلەسەر ڕاژەکاری وێب کار دەکات

<?php
// 1. create a connection
$connection = mysql_connect("localhost","root","");
if(!connection) {
    die("database connection failed" . mysql_error());
}
// 2. Select a database to use
$db_select = mysql_select_db("school", $connection);
// 3. Perform database query
$query = "SELECT * FROM result";
$result = mysql_query($query, $connection);
if(mysql_num_rows($result <= 0)){
    die("No record found");
}
// 4. Use returned data
while ($row = mysql_fetch_array($result)) {
    echo $row[0] . "<br />";
    echo $row[1] . "<br />";
    echo $row[2] . "<br />";
}
// 5. Close connection
mysql_close($connection);
?>

Step 1: if(!connection) is missing the $. PHP 8: Error: Undefined constant "connection". Step 1 uses an empty password "" but the Step 2 slide uses "password" — they must match your server.
Step 3: mysql_num_rows($result <= 0) has a bracket in the wrong place: it compares $result with 0 and passes true/false to the function (PHP 8 with mysqli: TypeError ... must be of type mysqli_result). Correct: if (mysqli_num_rows($result) <= 0) or === 0.
Step 4: $row[0], $row[1], $row[2] only work because fetch_array also gives number keys; names ($row["sName"]) are clearer and also work with fetch_assoc. The values are printed without htmlspecialchars().
Everywhere: curly quotes (“localhost”) on the slides make the code a parse error; mysql_* no longer exists. The task asks for a separate connection.php, but the slides write everything in one file.

هەنگاوی 1: if(!connection) نیشانەی $ی تێدا نییە. ⁦PHP 8⁩: Error: Undefined constant "connection". هەنگاوی 1 بەتاڵ "" بەکار دەهێنێت بەڵام سلایدی هەنگاوی 2 "password" — دەبێت لەگەڵ بگونجێن.
هەنگاوی 3: mysql_num_rows($result <= 0) کەوانەیەکی لە شوێنی هەڵەدایە: $result لەگەڵ 0 بەراورد دەکات و true/false دەدات بە (⁦PHP 8⁩ لەگەڵ mysqli: TypeError ... must be of type mysqli_result). دروستەکەی: if (mysqli_num_rows($result) <= 0) یان === 0.
هەنگاوی 4: $row[0]، $row[1]، $row[2] تەنها کار دەکەن چونکە fetch_array کلیلی ژمارەییش دەدات؛ ناوەکان ($row["sName"]) ڕوونترن و لەگەڵ fetch_assocیش کار دەکەن. نرخەکان بەبێ htmlspecialchars() چاپ دەکرێن.
لە هەموو شوێنێک: کۆتەیشنی چەماوە (“localhost”) لە سلایدەکاندا کۆدەکە دەکات بە ؛ mysql_* ئیتر بوونی نییە. ئەرکەکە داوای connection.phpێکی جیا دەکات، بەڵام سلایدەکان هەموو شتێک لە یەک فایلدا دەنووسن.

Common mistakesهەڵە باوەکان

Connection mistakes and their fixesهەڵەکانی پەیوەندی و چارەسەرەکانیان
Mistakeهەڵە	What happensچی ڕوو دەدات	Fixچارەسەر
`mysql_connect(...)`	`Call to undefined function mysql_connect()`	Use `mysqli_connect()` or PDO`mysqli_connect()` یان PDO بەکار بهێنە
`mysqli_connect("localhost:8080", ...)`	8080 is the web server's port from the browser's address bar, not MySQL's: Connection refused, or a long wait and then MySQL server has gone away if Apache answers on that port⁦8080⁩ کە لە دەیبینیت، نەک هی MySQL: ⁦Connection refused⁩، یان چاوەڕوانییەکی درێژ و پاشان ⁦MySQL server has gone away⁩ ئەگەر Apache لەسەر ئەو گوێ بگرێت	Write `'localhost'`: MySQL listens on its own port, 3306 (MAMP: 8889). For another port write `'127.0.0.1'` and give the port as the 5th argument; with `'localhost'` macOS and Linux use a local socket file and ignore the port`'localhost'` بنووسە: MySQL لەسەر خۆی، ⁦3306⁩، گوێ دەگرێت ⁦(MAMP: 8889)⁩. بۆ تر `'127.0.0.1'` بنووسە و وەک پێنجەم بدە؛ لەگەڵ `'localhost'`، macOS و Linux فایلێکی socketـی ناوخۆیی بەکار دەهێنن و پشتگوێ دەخەن
`if (!$con) { die(...); }`	Never runs in PHP 8.1+: an uncaught `mysqli_sql_exception` appears insteadلە ⁦PHP 8.1+⁩دا هەرگیز جێبەجێ نابێت: لە جیاتی ئەوە `mysqli_sql_exception`ێکی نەگیراو دەردەکەوێت	`try { ... } catch (mysqli_sql_exception $e) { ... }`
`mysqli_select_db("school", $con)`	`TypeError: ... must be of type mysqli, string given`	Connection first: `mysqli_select_db($con, "school")`, or use the 4th argument of `mysqli_connect()`سەرەتا پەیوەندی: `mysqli_select_db($con, "school")`، یان چوارەمی `mysqli_connect()` بەکار بهێنە
`mysqli_error($con) after a failed connect`	`TypeError: ... mysqli, false given`	`mysqli_connect_error()`
`mysqli_connect_error($con)`	`ArgumentCountError`	No argument: `mysqli_connect_error()`بێ : `mysqli_connect_error()`
`mysqli_query($sql)`	`ArgumentCountError`	The connection is required and comes first: `mysqli_query($con, $sql)`پەیوەندییەکە پێویستە و یەکەمە: `mysqli_query($con, $sql)`
`$conn->error (but the variable is $con)`	"Undefined variable $conn" and no error text«⁦Undefined variable $conn⁩» و هیچ دەقێکی هەڵە نییە	Use the same variable name everywhereهەمان ناوی لە هەموو شوێنێک بەکار بهێنە
`echo "connected";` in `connection.phpecho "connected";` لە `connection.php`دا	Text on every page; `header()` redirects failدەق لە هەموو لاپەڕەیەکدا؛ ئاڕاستەکردنەوەکانی `header()` شکست دەهێنن	The connection file prints nothingفایلی پەیوەندی هیچ چاپ ناکات
No charset set دانەنراوە	Kurdish text saved or shown as question marksدەقی کوردی وەک نیشانەی پرسیار هەڵدەگیرێت یان پیشان دەدرێت	`mysqli_set_charset($con, "utf8mb4")` / `charset=utf8mb4` in the DSN`mysqli_set_charset($con, "utf8mb4")` / `charset=utf8mb4` لە DSNـدا

Exercisesڕاهێنانەکان

Exerciseڕاهێنان1. Lecture 7 example1. نموونەی وانەی 7

Do the lecture's example on your own computer: create the database school and the table result (sId, sName, Marks), write connection.php, and write index.php that shows all records.

نموونەکەی وانەکە لەسەر کۆمپیوتەرەکەی خۆت بکە: school و result (sId، sName، Marks) دروست بکە، connection.php بنووسە و index.phpێک بنووسە کە هەموو پیشان بدات.

Show answerوەڵامەکە پیشان بدە

Run school.sql in phpMyAdmin's SQL tab. Then save connection.php and index.php in a folder such as htdocs/school/ and open http://localhost/school/. You should see the three students, one per line.

⁦school.sql⁩ لە تابی SQLـی phpMyAdmin جێبەجێ بکە. پاشان ⁦connection.php⁩ و ⁦index.php⁩ لە فۆڵدەرێکی وەک htdocs/school/ هەڵبگرە و http://localhost/school/ بکەرەوە. دەبێت سێ خوێندکارەکە ببینیت، هەر یەکەیان لە دێڕێکدا.

Exerciseڕاهێنان2. Update old code2. کۆدی کۆن نوێ بکەرەوە

Rewrite this old code so it works in PHP 8, with the database name in the connect call and a try/catch:

ئەم کۆدە کۆنە دووبارە بنووسەوە بۆ ئەوەی لە ⁦PHP 8⁩دا کار بکات، بە ناوی لە بانگکردنی پەیوەندیدا و try/catch:

PHPRuns on the serverلەسەر ڕاژەکاری وێب کار دەکات

$connection = mysql_connect("localhost", "root", "");
mysql_select_db("shop", $connection);
$result = mysql_query("SELECT * FROM products", $connection);
echo mysql_num_rows($result) . " products";

Show answerوەڵامەکە پیشان بدە

PHPRuns on the serverلەسەر ڕاژەکاری وێب کار دەکات

<?php
try {
    $connection = mysqli_connect("localhost", "root", "", "shop");
    mysqli_set_charset($connection, "utf8mb4");
    $result = mysqli_query($connection, "SELECT * FROM products");
    echo mysqli_num_rows($result) . " products";
    mysqli_close($connection);
} catch (mysqli_sql_exception $e) {
    error_log($e->getMessage());
    echo "Sorry, the shop is not available right now.";
}

If the table does not exist, mysqli_query() also throws inside the same try (and mysqli_num_rows() is then never reached), so one catch covers every step.

ئەگەر نەبێت، mysqli_query()ـیش لە ناو هەمان tryدا فڕێ دەدات (و ئیتر ناگاتە mysqli_num_rows())، بۆیە یەک catch هەموو هەنگاوەکان دەگرێتەوە.

Exerciseڕاهێنان3. A PDO connection file3. فایلی پەیوەندیی PDO

Write connection_pdo.php that connects to the database school with PDO and the utf8mb4 character set, and prints nothing when it succeeds.

connection_pdo.php بنووسە کە بە PDO و utf8mb4 پەیوەندی بە schoolـەوە بکات و کاتێک سەرکەوتوو بوو هیچ چاپ نەکات.

Show answerوەڵامەکە پیشان بدە

connection_pdo.phpPHPRuns on the serverلەسەر ڕاژەکاری وێب کار دەکات

<?php
try {
    $pdo = new PDO("mysql:host=localhost;dbname=school;charset=utf8mb4", "root", "");
} catch (PDOException $e) {
    error_log($e->getMessage());
    exit("Sorry, the database is not available right now.");
}

Exerciseڕاهێنان4. Debug the connection file4. هەڵەکانی فایلی پەیوەندی بدۆزەرەوە

A classmate's dbcon.php is below. Find four problems.

dbcon.phpـی هاوپۆلێک لە خوارەوەیە. چوار کێشە بدۆزەرەوە.

PHPRuns on the serverلەسەر ڕاژەکاری وێب کار دەکات

<?php
$con = mysqli_connect("localhost", "root", "");
if ($con) {
    echo "successfuly";
} else {
    echo mysqli_connect_error($con);
}
mysqli_select_db("school", $con);
?>

Show answerوەڵامەکە پیشان بدە

echo "successfuly"; prints text on every page that includes the file (and breaks header() redirects).
mysqli_connect_error($con) takes no argument: ArgumentCountError.
In PHP 8.1+ the else branch never runs: a failed connection throws mysqli_sql_exception. Use try/catch.
mysqli_select_db() has its arguments the wrong way round; better, give the database as the 4th argument of mysqli_connect().

echo "successfuly"; لە هەموو ئەو لاپەڕانەی ئەم فایلە دەهێنن دەق چاپ دەکات (و ئاڕاستەکردنەوەکانی header() تێک دەدات).
mysqli_connect_error($con) هیچ وەرناگرێت: ArgumentCountError.
لە ⁦PHP 8.1+⁩دا بەشی else هەرگیز جێبەجێ نابێت: پەیوەندیی شکستخواردوو mysqli_sql_exception فڕێ دەدات. try/catch بەکار بهێنە.
mysqli_select_db() پێچەوانەن؛ باشتر وایە وەک چوارەمی mysqli_connect() بدەیت.

The fixed file is the connection.php above, with your own database name.

فایلە چاککراوەکە هەمان ⁦connection.php⁩ـی سەرەوەیە، بە ناوی خۆت.

Summary and reviewپوختە و پێداچوونەوە

Five steps: connect, select the database, query, use the returned data, close. Steps 1 and 2 are usually one call; step 5 is optional.
Use mysqli (procedural or object style) or PDO. Both support prepared statements; PDO also works with other databases such as SQLite. mysql_* was removed in PHP 7.
mysqli_connect($host, $user, $password, $database) + mysqli_set_charset($con, "utf8mb4"), inside try/catch (mysqli_sql_exception $e).
Since PHP 8.1 a failed connection throws an exception, so if (!$con) checks never run.
Keep the connection in one file and require it at the top of every page; it should print nothing.
Each mysqli_fetch_* call returns one row; loop with while until it returns null.

پێنج هەنگاو: پەیوەندی، هەڵبژاردنی ، ، بەکارهێنانی زانیارییە گەڕاوەکان، داخستن. هەنگاوی 1 و 2 زۆرجار یەک بانگکردنن؛ هەنگاوی 5 ناچاری نییە.
mysqli (پرۆسیجەری یان ) یان PDO بەکار بهێنە. هەردووکیان پشتگیریی دەکەن؛ PDO لەگەڵ تری وەک SQLiteـیش کار دەکات. mysql_* لە ⁦PHP 7⁩دا لابرا.
mysqli_connect($host, $user, $password, $database) + mysqli_set_charset($con, "utf8mb4")، لە ناو try/catch (mysqli_sql_exception $e).
لە ⁦PHP 8.1⁩ـەوە پەیوەندیی شکستخواردوو فڕێ دەدات، بۆیە پشکنینەکانی if (!$con) هەرگیز جێبەجێ نابن.
پەیوەندییەکە لە یەک فایلدا بهێڵەوە و لە سەرەتای هەموو لاپەڕەیەکدا requireی بکە؛ نابێت هیچ چاپ بکات.
هەر بانگکردنێکی mysqli_fetch_* یەک دەگەڕێنێتەوە؛ بە while بخولێوە تا null دەگەڕێنێتەوە.

Review questionsپرسیارەکانی پێداچوونەوە

What are the five steps of PHP–database interaction?پێنج هەنگاوەکەی کارلێکی PHP و بنکەدراوە چین؟

1 create a connection, 2 select a database, 3 perform a query, 4 use the returned data (if any), 5 close the connection.

1 دروستکردنی پەیوەندی، 2 هەڵبژاردنی ، 3 ناردنی ، 4 بەکارهێنانی ئەو زانیارییانەی گەڕاونەتەوە (ئەگەر هەبن)، 5 داخستنی پەیوەندی.

Give three differences or similarities between MySQLi and PDO.سێ جیاوازی یان لێکچوون لە نێوان MySQLi و PDO بهێنەرەوە.

PDO works with about 12 database systems, MySQLi only with MySQL; both are object-oriented and MySQLi also has a procedural API; both support prepared statements (and transactions).

PDO لەگەڵ نزیکەی ⁦12⁩ سیستەمی کار دەکات، MySQLi تەنها لەگەڵ MySQL؛ هەردووکیان -ئاراستەن و ⁦MySQLi API⁩ ـی پرۆسیجەریشی هەیە؛ هەردووکیان پشتگیریی (و ) دەکەن.

Why do prepared statements matter?بۆچی ڕستە ئامادەکراوەکان گرنگن؟

The SQL and the values are sent separately, so a value typed by a visitor can never change the SQL. This protects against SQL injection.

SQL و نرخەکان بە جیا دەنێردرێن، بۆیە نرخێک کە سەردانکەر دەینووسێت هەرگیز ناتوانێت SQLـەکە بگۆڕێت. ئەمە لە دەمانپارێزێت.

Why does if (!$con) die(...) not work in PHP 8.1+?بۆچی if (!$con) die(...) لە ⁦PHP 8.1+⁩دا کار ناکات؟

Because mysqli now reports errors as exceptions by default. The failed mysqli_connect() throws mysqli_sql_exception and the script stops on that line, before the if. Catch it with try/catch.

چونکە ئێستا mysqli بە شێوەی بنەڕەتی هەڵەکان وەک ڕاپۆرت دەکات. mysqli_connect()ـی شکستخواردوو mysqli_sql_exception فڕێ دەدات و لەسەر ئەو دێڕە دەوەستێت، پێش ifـەکە. بە try/catch بیگرە.

What is the difference between mysqli_fetch_array() and mysqli_fetch_assoc()?جیاوازیی نێوان mysqli_fetch_array() و mysqli_fetch_assoc() چییە؟

Both return the next row. fetch_array (default) gives every value twice, under a number and under the column name; fetch_assoc gives only column-name keys.

هەردووکیان دواتر دەگەڕێننەوە. fetch_array (بنەڕەتی) هەر نرخێک دوو جار دەدات، بە ژمارە و بە ناوی ؛ fetch_assoc تەنها کلیلی ناوی دەدات.

What does the object operator -> do?کارپێکەری ئۆبجێکت -> چی دەکات؟

It reaches a property ($result->num_rows) or calls a method ($con->query($sql)) of an object.

دەگاتە ($result->num_rows) یان ($con->query($sql))ی بانگ دەکات.

Lesson complete!وانەکە تەواو بوو!

Well done. Review the key terms, then go on to the next lesson.دەستخۆش. سەیرێکی زاراوە سەرەکییەکان بکەرەوە، پاشان بڕۆ بۆ وانەی داهاتوو.

Key termsزاراوە سەرەکییەکان

Next lessonوانەی داهاتوو

Inserting and selecting data with PHPزیادکردن و هەڵبژاردنی زانیاری بە PHP

Related lecturesوانە پەیوەندیدارەکان

References and further readingسەرچاوەکان و خوێندنەوەی زیاتر

This lecture is a first edition. The Kurdish text and terminology are waiting for review by Kurdish IT teachers.ئەم وانەیە چاپی یەکەمە. دەقە کوردییەکە و زاراوەکانی چاوەڕێی پێداچوونەوەی مامۆستایانی کوردی بواری IT ن.