Skip to content

7. Korzystanie z obiektów SGBD i MySql

Napiszemy skrypty PHP, korzystając z bazy danych MySQL:

SGBD MySQL jest zawarty w pakiecie WampServer (patrz punkt 2.1.1). Pokazujemy, jak utworzyć bazę danych oraz użytkownika MySQL.

  • Po uruchomieniu WampServer można nim zarządzać za pomocą ikony [1] umieszczonej w prawym dolnym rogu paska zadań.
  • W [2] uruchamia się narzędzie administracyjne MySQL

Tworzymy bazę danych [dbpersonnes]:

Image

Tworzymy użytkownika o nazwie [admpersonnes] z hasłem [nobody]:

  • w [1], nazwa użytkownika
  • na [2], komputer o nazwie SGBD, na którym przyznano mu uprawnienia
  • w [3] – jego hasło
  • w [4], to samo
  • w [5] – użytkownikowi temu nie przyznano żadnych uprawnień
  • w [6] – tworzy się go
  • w [7], powrót do strony głównej phpMyAdmin
  • w [8] korzystamy z linku [Privileges] na tej stronie, aby przejść do edycji danych użytkownika [admpersonnes] i [9].

1011

Image

  • w [10] należy wskazać, że chcemy przyznać użytkownikowi [admpersonnes] uprawnienia do bazy danych [dbpersonnes]
  • w pliku [11] zatwierdza się ten wybór
  • za pomocą linku [12] W [Tout cocher] przyznaje się użytkownikowi [admpersonnes] wszystkie uprawnienia do bazy danych [dbpersonnes] W [13]
  • zatwierdzamy w [14]

Teraz mamy:

  • bazę danych MySQL [dbpersonnes]
  • użytkownika [admpersonnes / nobody], który ma pełne uprawnienia do tej bazy danych

Napiszemy skrypty PHP w celu wykorzystania bazy danych. PHP udostępnia różne biblioteki do zarządzania bazami danych. Wykorzystamy bibliotekę PDO (PHP Data Objects), która stanowi interfejs między kodem PHP a SGBD:

Biblioteka PDO pozwala skryptowi PHP na abstrakcję od dokładnego charakteru używanego modułu SGBD. W ten sposób, jak pokazano powyżej, bibliotekę SGBD (MySQL) można zastąpić biblioteką SGBD dla Postgres przy minimalnym wpływie na kod skryptu PHP. Biblioteka ta nie jest domyślnie dostępna. Dostępność biblioteki można sprawdzić w następujący sposób:

  • 1: z poziomu ikony administracyjnej WampServer należy wybrać opcję [PHP / PHP extensions]
  • 2: wyświetlą się różne dostępne rozszerzenia PDO oraz te, które są aktywne: [PHP_pdo_mysql] dla SGBD MySQL, [PHP_pdo_sqlite] dla SGBD oraz SQL Lite. Aby aktywować rozszerzenie, wystarczy na nie kliknąć. Interpreter PHP zostanie wówczas ponownie uruchomiony z nowym, aktywnym rozszerzeniem.

7.1. Połączenie z bazą MySQL – 1 (mysql_01)

Połączenie z SGBD odbywa się poprzez utworzenie obiektu PDO. Konstruktor akceptuje różne parametry:

$dbh=new PDO($dsn,$user,$passwd,$driver_options)

Znaczenie parametrów jest następujące:

$dsn
(Data Source Name) to ciąg znaków określający charakter obiektu SGBD oraz jego lokalizację w Internecie. Ciąg znaków
„mysql:host=localhost” oznacza, że mamy do czynienia z SGBD MySQL działającym na serwerze lokalnym. Ciąg ten
może zawierać inne parametry, w szczególności port nasłuchowy SGBD oraz nazwę bazy, z którą
chcemy się połączyć: „mysql:host=localhost:port=3306:dbname=dbpersonnes”.
$user
identyfikator logujący się użytkownika
$passwd
jego hasło
$driver_options
tablica opcji dla sterownika SGBD

Tylko pierwszy parametr jest obowiązkowy. Tak utworzony obiekt będzie następnie służył do obsługi wszystkich operacji wykonywanych na bazie danych, z którą nawiązano połączenie. Jeśli nie udało się utworzyć obiektu PDO, zgłaszany jest wyjątek typu PDOException.

Oto przykład połączenia:


<?php

// połączenie z bazą danych MySql
// tożsamość użytkownika to (admpersonnes,nobody)
$ID = "admpersonnes";
$PWD = "nobody";
$HOTE = "localhost";

try {
  // logowanie
  $dbh = new PDO("mysql:host=$HOTE", $ID, $PWD);
  print "Connexion réussie\n";
  // zamknięcie
  $dbh = null;
} catch (PDOException $e) {
  print "Erreur : " . $e->getMessage() . "\n";
  exit();
}

Wyniki:

Connexion réussie

Uwagi

  • wiersz 11: połączenie z obiektem SGBD odbywa się poprzez utworzenie obiektu PDO. Konstruktor jest tutaj używany z następującymi parametrami:
    • ciąg znaków określający charakter obiektu SGBD oraz jego lokalizację w Internecie. Ciąg znaków „mysql:host=localhost” wskazuje, że mamy do czynienia z obiektem SGBD MySQL działającym na serwerze lokalnym. Nie podano numeru portu. W takim przypadku domyślnie używany jest port 3306. Nie podano również nazwy bazy danych. Nastąpi wówczas połączenie z SGBD MySQL, a wybór konkretnej bazy danych nastąpi później.
    • identyfikator użytkownika
    • jego hasło
  • wiersz 14: zamknięcie połączenia następuje poprzez usunięcie obiektu PDO utworzonego na początku.
  • wiersz 15: połączenie z obiektem SGBD może się nie powieść. W takim przypadku generowany jest wyjątek typu PDOException.

7.2. Tworzenie tabeli MySQL (mysql_02)


<?php

// logowanie do bazy danych MySql
// tożsamość użytkownika
$ID = "admpersonnes";
$PWD = "nobody";
// identyfikator bazy
$DSN = "mysql:host=localhost;dbname=dbpersonnes";

// połączenie
list($erreur, $connexion) = connecte($DSN, $ID, $PWD);
if ($erreur) {
  print "Erreur lors de la connexion à la base [$DSN] sous l'identité ($ID,$PWD) : $erreur\n";
  exit;
}

// usunięcie tabeli osób, jeśli istnieje
$requête = "drop table personnes";
$erreur = exécuteRequête($connexion, $requête);
//Czy wystąpił błąd?
if ($erreur)
  print "$requête : Erreur ($erreur)\n";
else
  print "$requête: Exécution réussie\n";
// utworzenie tabeli osób
$requête = "create table personnes (prenom varchar(30) NOT NULL, nom varchar(30) NOT NULL, age integer NOT NULL, primary key(nom,prenom))";
$erreur = exécuteRequête($connexion, $requête);
//Czy wystąpił błąd?
if ($erreur)
  print "$requête : Erreur ($erreur)\n";
else
  print "$requête: Exécution réussie\n";
// rozłączamy się i wychodzimy
déconnecte($connexion);
exit;

// ---------------------------------------------------------------------------------
function connecte($dsn, $login, $pwd) {
  // logowanie ($login,$pwd) do bazy danych $dsn
  // zwraca identyfikator połączenia oraz kod błędu
  try {
    // połączenie
    $dbh = new PDO($dsn, $login, $pwd);
    // powrót bez błędu
    return array("", $dbh);
  } catch (PDOException $e) {
    // odpowiedź z błędem
    return array($e->getMessage(), null);
  }
}

// ---------------------------------------------------------------------------------
function déconnecte($connexion) {
  // zamyka połączenie o identyfikatorze $connexion
  $connexion = null;
}

// ---------------------------------------------------------------------------------
function exécuteRequête($connexion, $sql) {
  // wykonuje zapytanie $sql na połączeniu $connexion
  try {
    $connexion->exec($sql);
    // zwraca wynik bez błędu
    return "";
  } catch (PDOException $e) {
    // zwraca błąd
    return $e->getMessage();
  }
}

Wyniki:

drop table personnes: Exécution réussie
create table personnes (prenom varchar(30) NOT NULL, nom varchar(30) NOT NULL, age integer NOT NULL, primary key(nom,prenom)): Exécution réussie

W tabeli PHPMyAdmin widoczna jest obecność tabeli:

 

Komentarze

  • wiersze 38–50: funkcja connecte tworzy połączenie z SGBD. Zwraca ona tablicę ($erreur, $connexion), gdzie $connexion to utworzone połączenie, a null – w przypadku, gdy nie udało się go utworzyć. W tym ostatnim przypadku $erreur jest komunikatem o błędzie.
  • wiersze 53–56: funkcja déconnecte zamyka połączenie
  • wiersz 59: funkcja exécuteRequête umożliwia wykonanie polecenia SQL na połączeniu. Połączenie jest obiektem PDO. Metodą używaną do wykonania polecenia SQL na obiekcie PDO jest metoda exec (wiersz 63). Wykonanie zapytania może uruchomić PDOException. Dlatego też jest ono obsługiwane. Funkcja zwraca komunikat o błędzie w przypadku wystąpienia błędu, a w przeciwnym razie pusty ciąg znaków.

7.3. Wypełnianie tabeli osób (mysql_03)

Poniższy skrypt wykonuje polecenia SQL znajdujące się w poniższym pliku tekstowym [creation.txt]:

drop table personnes
create table personnes (prenom varchar(30) not null, nom varchar(30) not null, age integer not null, primary key (nom,prenom))
insert into personnes values('Paul','Langevin',48)
insert into personnes values ('Sylvie','Lefur',70)
insert into personnes values ('Pierre','Nicazou',35)
insert into personnes values ('Geraldine','Colou',26)
insert into personnes values ('Paulette','Girond',56)


<?php

// połączenie z bazą danych MySql
// identyfikator użytkownika
$ID = "admpersonnes";
$PWD = "nobody";
// identyfikator bazy danych
$DSN = "mysql:host=localhost;dbname=dbpersonnes";
// identyfikator pliku tekstowego z poleceniami SQL do wykonania
$TEXTE = "creation.txt";

// połączenie
list($erreur, $connexion) = connecte($DSN, $ID, $PWD);
if ($erreur) {
  print "Erreur lors de la connexion à la base [$DSN] sous l'identité ($ID,$PWD) : $erreur\n";
  exit;
}

// utworzenie i wypełnienie tabeli
$erreurs = exécuterCommandes($connexion, $TEXTE, 1, 0);
//wyświetlenie liczby błędów
print "il y a eu $erreurs[0] erreurs\n";
for ($i = 1; $i < count($erreurs); $i++)
  print "$erreurs[$i]\n";

// rozłączamy się i kończymy działanie
déconnecte($connexion);
exit;

// ---------------------------------------------------------------------------------
function connecte($dsn, $login, $pwd) {
...
}

// ---------------------------------------------------------------------------------
function déconnecte($connexion) {
 ...
}

// ---------------------------------------------------------------------------------
function exécuteRequête($connexion, $sql) {
  // wykonuje zapytanie $sql na połączeniu $connexion
  // zwraca 1 komunikat o błędzie w przypadku błędu, w przeciwnym razie zwraca pusty ciąg znaków
  ...
}

// ---------------------------------------------------------------------------------
function exécuterCommandes($connexion, $SQL, $suivi=0, $arrêt=1) {
  // korzysta z połączenia $connexion
  // wykonuje polecenia SQL zawarte w pliku tekstowym $SQL
  // ten plik jest plikiem poleceń SQL, które mają być wykonywane po jednym na wiersz
  // jeśli $suivi=1, to po każdym wykonaniu polecenia SQL wyświetlany jest komunikat informujący o powodzeniu lub niepowodzeniu
  // jeśli $arrêt=1, funkcja zatrzymuje się przy pierwszym napotkanym błędzie, w przeciwnym razie wykonuje wszystkie polecenia SQL
  // funkcja zwraca tablicę (liczba błędów, błąd1, błąd2, ...)
  
  // sprawdzana jest obecność pliku $SQL
  if (! file_exists($SQL))
    return array(1, "Le fichier $SQL n'existe pas");

  // wykonanie zapytań SQL zawartych w pliku $SQL
  // umieszcza się je w tablicy
  $requêtes = file($SQL);
  // są one wykonywane – początkowo bez błędów
  $erreurs = array(0);
  for ($i = 0; $i < count($requêtes); $i++) {
    //czy mamy puste zapytanie
    if (preg_match("/^\s*$/", $requêtes[$i]))
      continue;
    // wykonanie zapytania $i
    $erreur = exécuteRequête($connexion, $requêtes[$i]);
    //– czy wystąpił błąd?
    if ($erreur) {
      // kolejny błąd
      $erreurs[0]++;
      // komunikat o błędzie
      $msg = "$requêtes[$i] : Erreur ($erreur)\n";
      $erreurs[] = $msg;
      // czy wyświetlać komunikat na ekranie, czy nie?
      if ($suivi)
        print "$msg\n";
      // zatrzymujemy się?
      if ($arrêt)
        return $erreurs;
    } else
    if ($suivi)
      print "$requêtes[$i] : Exécution réussie\n";
  }//dla
  // powrót
  return $erreurs;
}

Wyniki na ekranie:

drop table personnes : Exécution réussie
create table personnes (prenom varchar(30) not null, nom varchar(30) not null, age integer not null, primary key (nom,prenom)) : Exécution réussie
insert into personnes values('Paul','Langevin',48) : Exécution réussie
insert into personnes values ('Sylvie','Lefur',70) : Exécution réussie
insert into personnes values ('Pierre','Nicazou',35) : Exécution réussie
insert into personnes values ('Geraldine','Colou',26) : Exécution réussie
insert into personnes values ('Paulette','Girond',56) : Exécution réussie
il y a eu 0 erreurs

Wstawione elementy są widoczne przy użyciu PhpMyAdmin:

 

Komentarze

Nowością jest funkcja exécuterCommandes w wierszach 48–90. Funkcja ta wykonuje na połączeniu $connexion polecenia SQL znajdujące się w pliku tekstowym o nazwie $SQL. Zwraca ona tablicę błędów ($nbErreurs, $msg1, $msg2, …) gdzie $nbErreurs to liczba błędów, $msgi to komunikat o błędzie nr i.. Jeśli nie ma błędów, zwracana jest tablica o nazwie array(0).

7.4. Wykonanie dowolnych zapytań SQL (mysql_04)

Poniższy skrypt przedstawia wykonanie poleceń SQL z następującego pliku tekstowego [sql.txt]:

select * from personnes
select nom,prenom from personnes order by nom asc, prenom desc
select * from personnes where age between 20 and 40 order by age desc, nom asc, prenom asc
insert into personnes values('Josette','Bruneau',46)
update personnes set age=47 where nom='Bruneau'
select * from personnes where nom='Bruneau'
delete from personnes where nom='Bruneau'
select * from personnes where nom='Bruneau'
xselect * from personnes where nom='Bruneau'

Wśród tych poleceń SQL znajduje się polecenie select, które zwraca wyniki z bazy danych, polecenia insert, update i delete, które modyfikują bazę bez zwracania wyników, a także błędne polecenia, takie jak ostatnie (xselect).


<?php

// połączenie z bazą danych MySql
// tożsamość użytkownika
$ID = "admpersonnes";
$PWD = "nobody";
// identyfikator bazy danych
$DSN = "mysql:host=localhost;dbname=dbpersonnes";
// identyfikator pliku tekstowego z poleceniami SQL do wykonania
$TEXTE = "sql.txt";

// połączenie
list($erreur, $connexion) = connecte($DSN, $ID, $PWD);
if ($erreur) {
  print "Erreur lors de la connexion à la base [$DSN] sous l'identité ($ID,$PWD) : $erreur\n";
  exit;
}

// wykonanie poleceń SQL
$erreurs = exécuterCommandes($connexion, $TEXTE, 1, 0);
//wyświetlenie liczby błędów
print "il y a eu $erreurs[0] erreur(s)\n";
for ($i = 1; $i < count($erreurs); $i++)
  print "$erreurs[$i]\n";

// rozłączamy się i wychodzimy
déconnecte($connexion);
exit;

// ---------------------------------------------------------------------------------
function connecte($dsn, $login, $pwd) {
  // łączy się ($login,$pwd) z bazą $dsn
  // zwraca identyfikator połączenia oraz komunikat o błędzie
  ...
}

// ---------------------------------------------------------------------------------
function déconnecte($connexion) {
  ...
}

// ---------------------------------------------------------------------------------
function exécuteRequête($connexion, $sql) {
  // wykonuje zapytanie $sql na połączeniu $connexion
  // zwraca tablicę zawierającą 2 elementy ($erreur, $résultat)
  
  // sprawdza, czy jest to element typu select, czy nie
  $commande = "";
  if (preg_match("/^\s*(\S+)/", $sql, $champs)) {
    $commande = $champs[0];
  }
  // wykonanie polecenia
  try {
    if (strtolower($commande) == "select") {
      $res = $connexion->query($sql);
    } else {
      $res = $connexion->exec($sql);
      if($res===FALSE){
        $info=$connexion->errorInfo();
        return array($info[2],null);
      }
    }
    // powrót bez błędu
    return array("", $res);
  } catch (PDOException $e) {
    // powrót z błędem
    return array($e->getMessage(), null);
  }
}

// ---------------------------------------------------------------------------------
function exécuterCommandes($connexion, $SQL, $suivi=0, $arrêt=1) {
  // używa połączenia $connexion
  // wykonuje polecenia SQL zawarte w pliku tekstowym $SQL
  // ten plik jest plikiem poleceń SQL, które mają być wykonywane po jednym na wiersz
  // jeśli $suivi=1, to po każdym wykonaniu polecenia SQL wyświetlany jest komunikat informujący o powodzeniu lub niepowodzeniu
  // jeśli $arrêt=1, funkcja zatrzymuje się przy pierwszym napotkanym błędzie, w przeciwnym razie wykonuje wszystkie polecenia SQL
  // funkcja zwraca tablicę (liczba błędów, błąd1, błąd2, ...)
  // sprawdzana jest obecność pliku $SQL
  if (!file_exists($SQL))
    return array(1, "Le fichier $SQL n'existe pas");

  // wykonanie zapytań SQL zawartych w pliku $TEXTE
  // umieszcza się je w tablicy
  $requêtes = file($SQL);
  // uruchamia się je – początkowo bez błędów
  $erreurs = array(0);
  for ($i = 0; $i < count($requêtes); $i++) {
    //– czy mamy puste zapytanie
    if (preg_match("/^\s*$/", $requêtes[$i]))
      continue;
    // wykonywanie zapytania $i
    list($erreur, $res) = exécuteRequête($connexion, $requêtes[$i]);
    //czy wystąpił błąd?
    if ($erreur) {
      // kolejny błąd
      $erreurs[0]++;
      // komunikat o błędzie
      $msg = "$requêtes[$i] : Erreur ($erreur)\n";
      $erreurs[] = $msg;
      // czy wyświetlać komunikat na ekranie, czy nie?
      if ($suivi)
        print "$msg\n";
      // Czy przerwać?
      if ($arrêt)
        return $erreurs;
    } else
    if ($suivi) {
      print "$requêtes[$i] : Exécution réussie\n";
      // informacje o wyniku wykonanego zapytania
      afficherInfos($res);
    }
  }//for
  // powrót
  return $erreurs;
}

// ---------------------------------------------------------------------------------
function afficherInfos($résultat) {
  // wyświetla wynik $résultat zapytania SQL
  // czy była to instrukcja SELECT?
  if ($résultat instanceof PDOStatement) {
    // wyświetla nazwy pól
    $titre = "";
    $nbColonnes = $résultat->columnCount();
    for ($i = 0; $i < $nbColonnes; $i++) {
      $infos = $résultat->getColumnMeta($i);
      $titre.=$infos['name'] . ",";
    }
    // usuwa się ostatni znak ,
    $titre = substr($titre, 0, strlen($titre) - 1);
    // wyświetla się lista pól
    print "$titre\n";
    // linia oddzielająca
    $séparateurs = "";
    for ($i = 0; $i < strlen($titre); $i++) {
      $séparateurs.="-";
    }
    print "$séparateurs\n";
    // dane
    foreach ($résultat as $ligne) {
      $data = "";
      for ($i = 0; $i < $nbColonnes; $i++) {
        $data.=$ligne[$i] . ",";
      }

      // usuwa się ostatni znak ,
      $data = substr($data, 0, strlen($data) - 1);
      // wyświetla
      print "$data\n";
    }
  } else {
    // nie była to instrukcja select
    print " $résultat lignes(s) a (ont) été modifiée(s)\n";
  }
}

Wyniki na ekranie:

select * from personnes
 : Exécution réussie
prenom,nom,age
--------------
Geraldine,Colou,26
Paulette,Girond,56
Paul,Langevin,48
Sylvie,Lefur,70
Pierre,Nicazou,35
select nom,prenom from personnes order by nom asc, prenom desc : Exécution réussie
nom,prenom
----------
Colou,Geraldine
Girond,Paulette
Langevin,Paul
Lefur,Sylvie
Nicazou,Pierre
select * from personnes where age between 20 and 40 order by age desc, nom asc, prenom asc : Exécution réussie
prenom,nom,age
--------------
Pierre,Nicazou,35
Geraldine,Colou,26
insert into personnes values('Josette','Bruneau',46) : Exécution réussie
 1 lignes(s) a (ont) été modifiée(s)
update personnes set age=47 where nom='Bruneau' : Exécution réussie
 1 lignes(s) a (ont) été modifiée(s)
select * from personnes where nom='Bruneau' : Exécution réussie
prenom,nom,age
--------------
Josette,Bruneau,47
delete from personnes where nom='Bruneau' : Exécution réussie
 1 lignes(s) a (ont) été modifiée(s)
select * from personnes where nom='Bruneau' : Exécution réussie
prenom,nom,age
--------------
xselect * from personnes where nom='Bruneau' : Erreur (You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'xselect * from personnes where nom='Bruneau'' at line 1)

il y a eu 1 erreur(s)
xselect * from personnes where nom='Bruneau' : Erreur (You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'xselect * from personnes where nom='Bruneau'' at line 1)

Komentarze

Każde polecenie zawarte w pliku tekstowym [sql.txt] jest wykonywane przez funkcję exécuteRequête z linii 43.

  • wiersz 43: dwoma parametrami funkcji są połączenie ($connexion), na którym mają zostać wykonane polecenia SQL, oraz polecenie SQL ($sql) do wykonania. Funkcja zwraca tablicę zawierającą dwie wartości ($erreur, $résultat), gdzie
    • $erreur to komunikat o błędzie, który może być pusty, jeśli nie wystąpił żaden błąd
    • $résultat: wynik zwracany po wykonaniu polecenia SQL. Wynik ten różni się w zależności od tego, czy polecenie to jest poleceniem select, czy też poleceniem insert, update, delete.
  • wiersze 48–51: pobieramy pierwszy element zamówienia SQL, aby ustalić, czy mamy do czynienia z zamówieniem select, czy też z zamówieniem insert, update, delete.
  • wiersz 55: w przypadku polecenia select jest ono wykonywane za pomocą metody [PDO]->query("polecenie select"). Zwracanym wynikiem jest obiekt typu PDOStatement.
  • wiersz 57: w przypadku polecenia insert, update, delete jest ono wykonywane za pomocą metody [PDO]->exec("polecenie SQL"). Zwracanym wynikiem jest liczba wierszy zmodyfikowanych przez polecenie SQL. Tak więc, jeśli polecenie SQL delete usuwa dwa wiersze, zwracanym wynikiem jest liczba całkowita 2. Jeśli podczas wykonywania wystąpi błąd, zwracanym wynikiem jest wartość logiczna false. W takim przypadku metoda [PDO]->errorinfo() zwraca informacje o błędzie w postaci tablicy wartości. Element o indeksie 2 tej tablicy to komunikat o błędzie.
  • wiersze 58–60: obsługa ewentualnego błędu operacji [PDO]->exec("polecenie SQL").
  • wiersze 65–68: obsługa ewentualnego wyjątku
  • wiersz 72: funkcja exécuterCommandes wykonuje na połączeniu $connexion polecenia SQL zapisane w pliku tekstowym $SQL. Jest to kod, z którym już się spotkaliśmy, z jednym drobnym wyjątkiem: wiersz 111.
  • wiersz 111: funkcja exécuteRequête zwróciła tablicę ($erreur, $résultat) lub $résultat jest wynikiem wykonania polecenia SQL. Wynik ten różni się w zależności od tego, czy polecenie SQL było poleceniem select, czy też poleceniem insert, update, delete. Funkcja afficherInfos wyświetla informacje dotyczące tego wyniku.
  • wiersz 122: jeśli polecenie SQL było poleceniem select, wynik ma typ PDOStatement. Ten typ reprezentuje tabelę złożoną z wierszy i kolumn.
  • wiersz 125: metoda [PDOStatement]->getColumnCount() zwraca liczbę kolumn tabeli wynikowej z select
  • wiersz 127: metoda [PDOStatement]->getMeta(i) zwraca słownik zawierający informacje o kolumnie o numerze i z tabeli wynikowej funkcji select.. W tym słowniku wartość powiązana z kluczem „name” to nazwa kolumny.
  • wiersze 127–129: nazwy kolumn tabeli wynikowej select są łączone w jeden ciąg znaków.
  • wiersze 141–145: obiekt typu PDOStatement można przeglądać za pomocą pętli foreach. W każdej iteracji uzyskiwanym elementem jest wiersz tabeli wynikowej select w postaci tablicy wartości reprezentujących wartości poszczególnych kolumn tego wiersza. Wszystkie te wartości są wyświetlane za pomocą pętli for.
  • wiersz 154: wynikiem wykonania polecenia insert, update, delete jest liczba wierszy zmodyfikowanych przez to polecenie.
https://stahe.github.io
Ten kurs-samouczek, napisany przez Serge'a Tahé, jest udostępniany publicznie na warunkach Creative Commons Uznanie autorstwa – Bez wykorzystania komercyjnego – Na tych samych warunkach 3.0 bez zmian.