Dlaczego powinieneś używać PHPs PDO w celu uzyskania dostępu do bazy danych

Wielu programistów PHP nauczyło się, jak uzyskać dostęp do baz danych za pomocą rozszerzeń MySQL lub MySQLi. Od PHP 5.1 jest lepszy sposób. Obiekty danych PHP (PDO) zapewniają metody dla przygotowanych instrukcji i pracy z obiektami, które znacznie poprawią Twoją produktywność!

Generatory i frameworki CRUD

Kod bazy danych jest powtarzalny, ale bardzo ważny jest jego prawidłowy przebieg. I tu właśnie pojawiają się generatory i frameworki PHP CRUD — oszczędzają czas, automatycznie generując cały ten powtarzalny kod, dzięki czemu możesz skupić się na innych częściach aplikacji.

W CodeCanyon znajdziesz generatory i frameworki CRUD, które pomogą Ci dostarczać produkty o wyjątkowej jakości na czas. (CRUD to akronim oznaczający tworzenie, odczytywanie, aktualizowanie i usuwanie — podstawowe operacje na bazie danych).

• PHP9 Przydatne generatory i frameworki PHP CRUD dostępne w CodeCanyonFranc Lucas
• PHPSzybko zbuduj interfejs PHP CRUD za pomocą zaawansowanego narzędzia generatora CRUD PDOSajal Soni

Wprowadzenie do PDO

PDO — PHP Data Objects — to warstwa dostępu do bazy danych zapewniająca jednolitą metodę dostępu do wielu baz danych.

Nie uwzględnia składni specyficznej dla bazy danych, ale może sprawić, że proces przełączania baz danych i platform będzie dość bezbolesny, po prostu przez zmianę parametrów połączenia w wielu przypadkach.

Ten samouczek nie jest kompletnym poradnikiem dotyczącym SQL. Jest napisany głównie dla osób obecnie korzystających z mysql lub mysqli rozszerzenie, aby pomóc im przejść do bardziej przenośnego i potężnego PDO.

Jeśli chodzi o operacje na bazach danych w PHP, PDO ma wiele zalet w stosunku do surowej składni. Wymieńmy szybko kilka:

• warstwa abstrakcji
• składnia zorientowana obiektowo
• obsługa przygotowanych oświadczeń
• lepsza obsługa wyjątków
• bezpieczne i wielokrotnego użytku interfejsy API
• obsługa wszystkich popularnych baz danych

Obsługa bazy danych

Rozszerzenie może obsługiwać dowolną bazę danych, dla której został napisany sterownik PDO. W chwili pisania tego tekstu dostępne są następujące sterowniki baz danych:

• PDO_DBLIB (FreeTDS/Microsoft SQL Server/Sybase)
• PDO_FIREBIRD (Firebird/Interbase 6)
• PDO_IBM (IBM DB2)
• PDO_INFORMIX (IBM Informix Dynamic Server)
• PDO_MYSQL (MySQL 3.x/4.x/5.x)
• PDO_OCI (Interfejs połączeń Oracle)
• PDO_ODBC (ODBC v3 (IBM DB2, unixODBC i win32 ODBC))
• PDO_PGSQL (PostgreSQL)
• PDO_SQLITE (SQLite 3 i SQLite 2)
• PDO_4D (D)

Wszystkie te sterowniki niekoniecznie są dostępne w twoim systemie; Oto szybki sposób sprawdzenia, jakie masz sterowniki:

print_r(PDO::getAvailableDrivers());

Łączenie

Różne bazy danych mogą mieć nieco inne metody połączenia. Poniżej możesz zobaczyć sposób łączenia się z niektórymi z najpopularniejszych baz danych. Zauważysz, że pierwsze trzy są identyczne, poza typem bazy danych — a SQLite ma swoją własną składnię.

try {
  # MS SQL Server and Sybase with PDO_DBLIB
  $DBH = new PDO("mssql:host=$host;dbname=$dbname", $user, $pass);
  $DBH = new PDO("sybase:host=$host;dbname=$dbname", $user, $pass);
 
  # MySQL with PDO_MYSQL
  $DBH = new PDO("mysql:host=$host;dbname=$dbname", $user, $pass);
 
  # SQLite Database
  $DBH = new PDO("sqlite:my/database/path/database.db");
}
catch(PDOException $e) {
    echo $e->getMessage();
}

Proszę zwrócić uwagę na blok try/catch. Zawsze powinieneś owijać swoje operacje PDO w try/catch i używać mechanizmu wyjątków — więcej o tym wkrótce. Zazwyczaj nawiązujesz tylko jedno połączenie — na liście znajduje się kilka, które pokazują składnię. $DBH oznacza „uchwyt bazy danych” i będzie używany w tym samouczku.

Możesz zamknąć dowolne połączenie, ustawiając uchwyt na null.

# close the connection
$DBH = null;

Możesz uzyskać więcej informacji na temat opcji specyficznych dla bazy danych i/lub parametrów połączenia dla innych baz danych z PHP.net.

Wyjątki i PDO

PDO może używać wyjątków do obsługi błędów, co oznacza, że ​​wszystko, co robisz z PDO, powinno być opakowane w blok try/catch. Możesz wymusić przejście PDO w jeden z trzech trybów błędów, ustawiając atrybut trybu błędu w nowo utworzonym uchwycie bazy danych. Oto składnia:

$DBH->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_SILENT );
$DBH->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_WARNING );
$DBH->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );

Bez względu na ustawiony tryb błędu, błąd połączenia zawsze wygeneruje wyjątek, a tworzenie połączenia powinno zawsze być zawarte w bloku try/catch.

PDO::ERRMODE_SILENT

To jest domyślny tryb błędu. Jeśli pozostawisz go w tym trybie, będziesz musiał sprawdzić błędy w sposób, do którego prawdopodobnie jesteś przyzwyczajony, jeśli używałeś mysql lub mysqli rozszerzenia. Pozostałe dwie metody są bardziej odpowiednie do programowania na sucho.

PDO::ERRMODE_WARNING

Ten tryb wygeneruje standardowe ostrzeżenie PHP i umożliwi kontynuowanie działania programu. Przydaje się do debugowania.

PDO::ERRMODE_EXCEPTION

To jest tryb, którego potrzebujesz w większości sytuacji. Odpala wyjątek, co pozwala na delikatną obsługę błędów i ukrywanie danych, które mogą pomóc komuś wykorzystać Twój system. Oto przykład wykorzystania wyjątków:

# connect to the database
try {
  $DBH = new PDO("mysql:host=$host;dbname=$dbname", $user, $pass);
  $DBH->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
 
  # UH-OH! Typed DELECT instead of SELECT!
  $DBH->prepare('DELECT name FROM people');
}
catch(PDOException $e) {
    echo "I'm sorry, Dave. I'm afraid I can't do that.";
    file_put_contents('PDOErrors.txt', $e->getMessage(), FILE_APPEND);
}

W instrukcji select jest zamierzony błąd; spowoduje to wyjątek. Wyjątek wysyła szczegóły błędu do pliku dziennika i wyświetla przyjazny (lub nie tak przyjazny) komunikat dla użytkownika.

Wstaw i zaktualizuj

Wstawianie nowych danych (lub aktualizowanie istniejących danych) to jedna z częstszych operacji na bazie danych. W przypadku PHP PDO jest to zwykle proces dwuetapowy. Wszystko omówione w tej sekcji dotyczy w równym stopniu zarówno UPDATE i INSERT operacje.

Oto przykład najbardziej podstawowego typu insertu:

# STH means "Statement Handle"
$STH = $DBH->prepare("INSERT INTO folks ( first_name ) values ( 'Cathy' )");
$STH->execute();

Możesz również wykonać tę samą operację, używając exec() z jednym wywołaniem mniej. W większości sytuacji będziesz korzystać z dłuższej metody, aby móc skorzystać z przygotowanych wypowiedzi. Nawet jeśli zamierzasz go użyć tylko raz, użycie przygotowanych instrukcji pomoże ochronić Cię przed atakami typu SQL injection.

Przygotowane oświadczenia

Korzystanie z przygotowanych instrukcji pomoże chronić Cię przed wstrzyknięciem SQL.

Przygotowana instrukcja to wstępnie skompilowana instrukcja SQL, którą można wykonać wiele razy, wysyłając tylko dane na serwer. Ma tę dodatkową zaletę, że automatycznie zabezpiecza dane używane w symbolach zastępczych przed atakami typu SQL injection.

Używasz przygotowanej instrukcji, umieszczając symbole zastępcze w swoim SQL. Oto trzy przykłady:jeden bez symboli zastępczych, jeden z nienazwanymi symbolami zastępczymi i jeden z nazwanymi symbolami zastępczymi.

# no placeholders - ripe for SQL Injection!
$STH = $DBH->prepare("INSERT INTO folks (name, addr, city) values ($name, $addr, $city)");
 
# unnamed placeholders
$STH = $DBH->prepare("INSERT INTO folks (name, addr, city) values (?, ?, ?)");
 
# named placeholders
$STH = $DBH->prepare("INSERT INTO folks (name, addr, city) values (:name, :addr, :city)");

Chcesz uniknąć pierwszej metody; jest tutaj dla porównania. Wybór użycia nazwanych lub nienazwanych symboli zastępczych wpłynie na sposób ustawiania danych dla tych instrukcji.

Nienazwane symbole zastępcze

# assign variables to each place holder, indexed 1-3
$STH->bindParam(1, $name);
$STH->bindParam(2, $addr);
$STH->bindParam(3, $city);
 
# insert one row
$name = "Daniel"
$addr = "1 Wicked Way";
$city = "Arlington Heights";
$STH->execute();
 
# insert another row with different values
$name = "Steve"
$addr = "5 Circle Drive";
$city = "Schaumburg";
$STH->execute();

Tutaj są dwa kroki. Najpierw przypisujemy zmienne do różnych symboli zastępczych (wiersze 2–4). Następnie przypisujemy wartości do tych symboli zastępczych i wykonujemy instrukcję. Aby wysłać kolejny zestaw danych, po prostu zmień wartości tych zmiennych i ponownie wykonaj instrukcję.

Czy wydaje się to trochę nieporęczne w przypadku wyciągów z dużą ilością parametrów? To jest. Jeśli jednak dane są przechowywane w tablicy, istnieje prosty skrót:

# the data we want to insert
$data = array('Cathy', '9 Dark and Twisty Road', 'Cardiff');
 
$STH = $DBH->prepare("INSERT INTO folks (name, addr, city) values (?, ?, ?)");
$STH->execute($data);

To proste!

Dane w tablicy dotyczą symboli zastępczych w kolejności. $data[0] przechodzi do pierwszego symbolu zastępczego, $data[1] drugi itd. Jeśli jednak indeksy twojej tablicy nie są w porządku, to nie będzie działać poprawnie i będziesz musiał ponownie zindeksować tablicę.

Nazwane symbole zastępcze

Prawdopodobnie możesz odgadnąć składnię, ale oto przykład:

# the first argument is the named placeholder name - notice named
# placeholders always start with a colon.
$STH->bindParam(':name', $name);

Tutaj również możesz użyć skrótu, ale działa on z tablicami asocjacyjnymi. Oto przykład:

# the data we want to insert
$data = array( 'name' => 'Cathy', 'addr' => '9 Dark and Twisty', 'city' => 'Cardiff' );
 
# the shortcut!
$STH = $DBH->prepare("INSERT INTO folks (name, addr, city) value (:name, :addr, :city)");
$STH->execute($data);

Klucze tablicy nie muszą zaczynać się od dwukropka, ale poza tym muszą być zgodne z nazwanymi symbolami zastępczymi. Jeśli masz tablicę tablic, możesz je iterować i po prostu wywołać execute z każdą tablicą danych.

Kolejną fajną cechą nazwanych symboli zastępczych jest możliwość wstawiania obiektów bezpośrednio do bazy danych, zakładając, że właściwości odpowiadają nazwanym polom. Oto przykładowy obiekt i sposób wykonania wstawiania:

# a simple object
class person {
    public $name;
    public $addr;
    public $city;
 
    function __construct($n,$a,$c) {
        $this->name = $n;
        $this->addr = $a;
        $this->city = $c;
    }
    # etc ...
}
 
$cathy = new person('Cathy','9 Dark and Twisty','Cardiff');
 
# here's the fun part:
$STH = $DBH->prepare("INSERT INTO folks (name, addr, city) value (:name, :addr, :city)");
$STH->execute((array)$cathy);

Rzutowanie obiektu na tablicę w execute oznacza, że ​​właściwości są traktowane jako klucze tablicy.

Wybieranie danych

Dane są uzyskiwane przez ->fetch() , metoda uchwytu instrukcji. Przed wywołaniem pobierania najlepiej powiedzieć PDO, w jaki sposób chcesz pobrać dane. Masz następujące opcje:

• PDO::FETCH_ASSOC : zwraca tablicę indeksowaną według nazwy kolumny.
• PDO::FETCH_BOTH (domyślnie): zwraca tablicę indeksowaną przez nazwę i numer kolumny.
• PDO::FETCH_BOUND : przypisuje wartości Twoich kolumn do zmiennych ustawionych za pomocą ->bindColumn() metoda.
• PDO::FETCH_CLASS : przypisuje wartości twoich kolumn do właściwości nazwanej klasy. Utworzy właściwości, jeśli pasujące właściwości nie istnieją.
• PDO::FETCH_INTO : aktualizuje istniejącą instancję nazwanej klasy.
• PDO::FETCH_LAZY :łączy PDO::FETCH_BOTH /PDO::FETCH_OBJ , tworząc nazwy zmiennych obiektów w miarę ich używania.
• PDO::FETCH_NUM : zwraca tablicę indeksowaną przez numer kolumny.
• PDO::FETCH_OBJ : zwraca anonimowy obiekt z nazwami właściwości, które odpowiadają nazwom kolumn.

W rzeczywistości są trzy, które obejmą większość sytuacji: FETCH_ASSOC , FETCH_CLASS i FETCH_OBJ . Aby ustawić metodę pobierania, używana jest następująca składnia:

$STH->setFetchMode(PDO::FETCH_ASSOC);

Możesz też ustawić typ pobierania bezpośrednio w ->fetch() wywołanie metody.

FETCH_ASSOC

Ten typ pobierania tworzy tablicę asocjacyjną, indeksowaną według nazwy kolumny. Powinno to być dobrze znane każdemu, kto używał rozszerzeń mysql/mysqli. Oto przykład wybierania danych tą metodą:

# using the shortcut ->query() method here since there are no variable
# values in the select statement.
$STH = $DBH->query('SELECT name, addr, city from folks');
 
# setting the fetch mode
$STH->setFetchMode(PDO::FETCH_ASSOC);
 
while($row = $STH->fetch()) {
    echo $row['name'] . "\n";
    echo $row['addr'] . "\n";
    echo $row['city'] . "\n";
}

Pętla while będzie nadal przechodzić przez zestaw wyników po jednym rzędzie, aż do zakończenia.

FETCH_OBJ

Ten typ pobierania tworzy obiekt klasy std dla każdego wiersza pobranych danych. Oto przykład:

# creating the statement
$STH = $DBH->query('SELECT name, addr, city from folks');
 
# setting the fetch mode
$STH->setFetchMode(PDO::FETCH_OBJ);
 
# showing the results
while($row = $STH->fetch()) {
    echo $row->name . "\n";
    echo $row->addr . "\n";
    echo $row->city . "\n";
}

FETCH_CLASS

class secret_person {
    public $name;
    public $addr;
    public $city;
    public $other_data;
 
    function __construct($other = '') {
        $this->address = preg_replace('/[a-z]/', 'x', $this->address);
        $this->other_data = $other;
    }
}

$STH = $DBH->query('SELECT name, addr, city from folks');
$STH->setFetchMode(PDO::FETCH_CLASS, 'secret_person');
 
while($obj = $STH->fetch()) {
    echo $obj->addr;
}

$STH->setFetchMode(PDO::FETCH_CLASS | PDO::FETCH_PROPS_LATE, 'secret_person');

$STH->setFetchMode(PDO::FETCH_CLASS, 'secret_person', array('stuff'));

$i = 0;
while($rowObj =  $STH->fetch(PDO::FETCH_CLASS, 'secret_person', array($i))) {
    // do stuff
    $i++
}

$DBH->lastInsertId();

$DBH->exec('DELETE FROM folks WHERE 1');
$DBH->exec("SET time_zone = '-8:00'");

$safe = $DBH->quote($unsafe);

$rows_affected = $STH->rowCount();

$sql = "SELECT COUNT(*) FROM folks";
if ($STH = $DBH->query($sql)) {
    # check the row count
    if ($STH->fetchColumn() > 0) {
 
    # issue a real select here, because there's data!
    }
    else {
        echo "No rows matched the query.";
    }
}