Mengapa Anda harus menggunakan PDO untuk bekerja dengan database. PHP PDO - bekerja dengan database dengan benar, kueri PHP, hapus contoh pdo
Suatu hari saya memutuskan untuk berurusan dengan php PDO. Ini menarik dan perlu mempelajari teknologi baru. Saya tidak menemukan dokumentasi Rusia di mana pun, jadi saya memutuskan untuk mempostingnya. Saya harap artikel ini menarik bagi Anda.
Perkenalan
Mari kita mulai dulu PHP Data Objects (PDO) adalah antarmuka yang ringan untuk mengakses database dalam bahasa PHP. Itu dapat bekerja dengan sebagian besar basis data seperti MS SQL, Firebird, MySQL, Oracle, PostgreSQL, SQLite dan banyak lagi. Tetapi di sini perlu diperhatikan bahwa PDO menyediakan fungsionalitas yang diperlukan untuk bekerja dengan database, tetapi untuk setiap jenis database, driver akses databasenya sendiri harus diinstal dalam bentuk ekstensi PHP.
Menggunakan PDO, Anda dapat membuat aplikasi yang benar-benar independen dari jenis database, sementara dimungkinkan untuk menggunakan sebagian besar fungsionalitas database, seperti membuat pernyataan atau transaksi yang telah disiapkan. Jika fungsionalitas ini tidak didukung oleh database, PDO mengemulasi fungsi ini dengan caranya sendiri, sehingga tidak melanggar logika program dengan cara apa pun.
Menghubungkan cukup sederhana, hanya saja sekarang dalam satu baris Anda harus segera menentukan jenis database yang Anda sambungkan, nama host, dan juga nama database.
Formatnya seperti ini:
database_type:host=namahost;db=nama
Mari kita lihat sebuah contoh, sederhanakan saja contoh tersebut sedikit dengan menggunakan pengecualian dari pustaka PDO (PDOException). Sehingga jika terjadi koneksi yang gagal ke database, kami akan menerima pesan yang jelas tentang ini, dan bukan kumpulan kode yang datang entah dari mana.
coba ($db = PDO baru( "mysql:host=localhost;dbname=tes", "akar" , "" ) ; $baris = $db -> exec( "BUAT TABEL `testing`(id INT PRIMARY KEY AUTO_INCREMENT, fname VARCHAR(20) NOT NULL DEFAULT "", email VARCHAR(50) NOT NULL DEFAULT "")") ; ) catch(PDOException $e ) ( die ("Error: " . $e -> getMessage () ) ; )
Jika Anda membuat kesalahan dalam pernyataan SQL, PDO memiliki fungsi khusus:
errorCode() - mengembalikan nomor kesalahan, dan
errorInfo() - mengembalikan larik yang berisi nomor kesalahan dan teks deskripsi
Query dapat dibuat langsung dengan dua fungsi:
exec() dan kueri()
Perbedaannya terletak pada jenis hasil yang dikembalikan, exec mengembalikan jumlah baris yang dipengaruhi oleh kueri, dan yang kedua mengembalikan hasil kueri di objek PDOStatement, kita akan membicarakannya sedikit lebih rendah.
Sekarang mari tambahkan fungsi-fungsi ini ke kode dan buat contoh sedikit lebih rumit:
// di awal konfigurasi tentukan("DB_DRIVER" , "mysql" ); define("DB_HOST" , "localhost" ); define("DB_NAME" , "test" ); define("DB_USER" , "root" ); tentukan("DB_PASS" , "" ); mencoba( // terhubung ke database$koneksi_str = DB_DRIVER . ": tuan rumah=" . DB_HOST . ";namadb=" . DB_NAME; $db = PDO baru($connect_str , DB_USER, DB_PASS) ; // sisipkan beberapa baris ke dalam tabel dari contoh sebelumnya$baris = $db -> exec( "MASUKKAN KE NILAI `pengujian` (null, "Ivan", " [email dilindungi]"), (nol, "Peter", " [email dilindungi]"), (nol, "Dengan mudah", " [email dilindungi]")
"
) ; $error_array = $db -> errorInfo(); jika ($db ->
"
;
// jika permintaan berhasil,
// lalu tampilkan jumlah baris yang terpengaruh jika ($baris ) gema "Jumlah baris yang terpengaruh:". $baris . "
"
;
// sekarang pilih beberapa baris dari database$hasil = $db -> permintaan( "PILIH * DARI BATAS `pengujian` 2")
;
// jika ada kesalahan dalam ekspresi SQL, cetak pesan kesalahan$error_array = $db -> errorInfo(); if ($db -> errorCode () != 0000) echo "SQL error: " . $error_array [ 2 ] . "
"
;
// sekarang kita mendapatkan data dari kelas PDOStatement while ($baris = $hasil -> ambil()) ( // sebagai hasilnya kita mendapatkan array asosiatif print_r($baris); ) ) catch(PDOException $e ) ( die ("Kesalahan: " . $e -> getMessage () ) ; )
Ekspresi yang disiapkan
Ekspresi yang disiapkan sangat mirip dengan kueri SQL biasa, tetapi memiliki beberapa kelebihan. Pertama, mereka memiliki kecepatan eksekusi yang tinggi, dan kedua, mereka lebih andal dari sudut pandang keamanan, karena semua parameter yang diteruskan ke mereka secara otomatis terlindung dari semua jenis injeksi.
Mereka memiliki keunggulan kecepatan yang signifikan saat menjalankan beberapa kueri identik dibandingkan jika Anda membuat ulang kueri setiap saat. Ini juga menghemat lalu lintas antara aplikasi dan database.
PDO menyediakan fungsi yang nyaman untuk bekerja dengan pernyataan yang disiapkan. Jika tipe database yang dipilih tidak mendukung pernyataan yang disiapkan, PDO hanya akan meniru pekerjaan mereka dengan metodenya sendiri.
Jadi, sebagai permulaan, kita akan membuat ekspresi yang sudah disiapkan, ini dilakukan dengan fungsi Siapkan ().
Dibutuhkan kueri SQL sebagai parameter, tetapi di dalamnya, alih-alih nilai yang perlu diubah, variabel semu ditetapkan, yang bisa dalam bentuk tanda tanya (?), atau nama variabel semu yang dimulai dengan titik dua (:)
$sth1 = $db->prepare("SELECT * FROM `testing` WHERE id=:id");
$sth2 = $db->prepare("SELECT * FROM `testing` WHERE id=?");
Bergantung pada bagaimana Anda mendefinisikan variabel, pekerjaan Anda selanjutnya akan bergantung.
Jika Anda telah menentukan variabel dengan tanda tanya, maka berikan array nilai ke fungsi eksekusi, sesuai urutan variabelnya.
Jika Anda menetapkan variabel dengan nama, Anda perlu menetapkan nilai ke setiap variabel menggunakan fungsi:
bindValue() - memberikan nilai ke variabel semu
bindParam() - mengikat variabel semu ke variabel nyata, dan saat mengubah variabel nyata, Anda tidak perlu lagi memanggil fungsi tambahan apa pun, Anda dapat langsung mengeksekusi()
Berikut adalah contoh menggunakan opsi pertama:
Harap dicatat bahwa setelah objek PDO membuat ekspresi yang disiapkan di kelas PDOStatement, kami hanya menggunakannya, masing-masing, ia memiliki fungsinya sendiri errorCode, errorInfo, serta hasil eksekusi kueri, juga segera disimpan di dalamnya.
Dan sekarang cara kedua.
Untuk menetapkan nilai ke variabel semu, gunakan fungsi bindValue()
Kode ini dapat ditulis lebih sederhana dengan menghubungkan variabel semu dengan yang asli:
Segera perlu ditambahkan bahwa sangat diinginkan (agar tidak menyebabkan kesalahan yang tidak perlu) untuk menunjukkan jenis variabel sebagai parameter ketiga. Saya pribadi, dengan tidak adanya tipe variabel, memiliki kesalahan dalam klausa WHERE, karena menganggap variabel sebagai teks, bukan angka.
$sth3->bindParam(':id',$id, PDO::PARAM_INT);
$sth3->bindParam(':id',$id, PDO::PARAM_STR);
Manfaat lain yang sangat bagus dari menggunakan ekspresi yang disiapkan seperti itu adalah pelolosan variabel. Sebelum substitusi ke dalam prosedur, semua variabel di-escape dan tidak ada injeksi SQL yang buruk.
Transaksi
Transaksi adalah sekumpulan kueri basis data yang harus diselesaikan oleh semua. Jika ada permintaan yang tidak dijalankan atau dieksekusi dengan kesalahan, maka transaksi dibatalkan dan tidak ada perubahan data dalam database yang terjadi.
Ini untuk memastikan bahwa integritas data dipertahankan di beberapa permintaan. Misalnya saat mentransfer dana dari satu akun ke akun lainnya.
Untuk menjalankan transaksi di PDO, Anda perlu beralih ke mode konfirmasi permintaan manual.
Ngomong-ngomong, transaksi digunakan sepanjang waktu, tetapi biasanya PDO bekerja dalam mode autocommit, jadi semua transaksi terdiri dari satu permintaan.
Untuk mematikan mode autocommit, jalankan perintah:
$db->beginTransaction();
Setelah itu, kami menjalankan kueri ke database sebanyak yang diperlukan untuk melakukan transaksi ini.
Dan hanya setelah semua permintaan selesai, Anda dapat mengonfirmasi transaksi dengan fungsi tersebut
$db->komit();
atau membatalkan transaksi
$db->kembalikan();
Berikut adalah contoh kecil transaksi:
coba ( $connect_str = DB_DRIVER . ":host=" .DB_HOST . ";dbname=" .DB_NAME; $db = new PDO($connect_str , DB_USER, DB_PASS) ; $rows = $db -> exec ( "BUAT TABEL `testing`(id INT PRIMARY KEY AUTO_INCREMENT, fname VARCHAR(20) NOT NULL DEFAULT "", email VARCHAR(50) NOT NULL DEFAULT "", money INT NOT NULL DEFAULT 0) ENGINE=InnoDB;") ; $baris = $db -> exec( "MASUKKAN KE NILAI `pengujian` (null, "Ivan", " [email dilindungi]", 15000), (nol, "Petr", " [email dilindungi]", 411000), (nol, "Vasiliy", " [email dilindungi]", 1500000) " ) ; // Ayo coba transfer sejumlah 50000 dari Ivan// Petrus $jumlah = 50000 ; $transaksi = benar ; $db -> beginTransaction(); $sth1 = $db -> permintaan( "PILIH uang DARI pengujian WHERE fname="Ivan"") ; $sth2 = $db -> permintaan( "PILIH uang DARI pengujian WHERE fname="Petr"") ; $baris1 = $sth1 -> ambil() ; $baris2 = $sth2 -> ambil() ; if (! $baris1 || ! $baris2 ) $transaksi = false ; $total2 = $jumlah + $baris2 [ "uang" ] ; $total1 = $baris1 [ "uang" ] - $jumlah ; jika ($total1< 0 || $total2 < 0) $transaction = false ; $num_rows1 = $db ->exec ( . $total1 . "" WHERE fname="Ivan"" ); $num_rows2 = $db -> exec ( "PERBARUI `testing` SET money="". $total2 . "" WHERE fname="Petr"" ); if ($transaction ) ( echo "Transaksi berhasil diselesaikan"; $db -> komit() ; ) lainnya (gema "Transaksi gagal"; $db -> kembalikan() ; ) ) catch(PDOException $e ) ( die ("Kesalahan: " . $e -> getMessage () ) ; )
Perlu juga dicatat di sini bahwa tidak semua jenis tabel mendukung transaksi, jadi dalam contoh ini saya menggunakan tabel InnoDb, bukan MyISAM standar.
Sebagai kesimpulan, saya ingin mengatakan bahwa ini jauh dari manual lengkap tentang PDO. Anda selalu bisa mendapatkan semua informasi terbaru dan lengkap di sini: http://www.php.net/manual/en/book.pdo.php
Pelajari dan ciptakan.
Hari ini saya memulai serangkaian artikel tentang PDO, di mana kami akan menganalisis apa itu PDO mengapa kita membutuhkannya dan bagaimana menggunakannya.
Pasti banyak yang sudah mendengar singkatan tersebut PDO, tetapi hanya sedikit orang yang tahu apa itu. Mari kita bicarakan hari ini.
Apa itu PDO?
PDO (Objek Data PHP)- itu mudah antarmuka, memungkinkan kita untuk mengabstraksi dari database tertentu. Yang terbaik adalah menunjukkan dengan contoh.
mysql_connect($host, $user, $pass); //MySQL
mysql_select_db($db);
sqlite_open($db); // sqlite
pg_connect("host=$host, dbname=$db, pengguna=$pengguna, kata sandi=$pass"); // PostgreSQL
Kode di atas menunjukkan cara untuk terhubung ke tiga database berbeda: MySQL, sqlite Dan PostgreSQL. Seperti yang Anda lihat, fungsi setiap database berbeda.
Hal yang sama berlaku untuk tindakan lainnya. Misalnya, mengambil data dari database.
$sql = "INSERT INTO(name, pass) VALUES($name, $pass)";
mysql_query($sql); //MySQL
sqlite_query($sql); // sqlite
pg_query($sql); // PostgreSQL
Mengapa PDO dibutuhkan?
Bayangkan kita memiliki database yang sangat besar PostgreSQL, dan kami memutuskan untuk mengubahnya menjadi MySQL. Kami harus menulis ulang banyak kode, dan, kemungkinan besar, itu tidak akan berhasil tanpa kesalahan. Untuk mengatasi masalah ini dan ada PDO, yang memungkinkan kita untuk tidak bergantung pada basis tertentu.
Mari kita lihat bagaimana kita sekarang dapat terhubung.
$db = new PDO("mysql:host=$host;dbname=$db", $user, $pass); //MySQL
$db = new PDO("sqlite:host=$host;dbname=$db", $user, $pass); // sqlite
$db = new PDO("pgsql:host=$host;dbname=$db", $user, $pass); // PostgreSQL
Seperti yang Anda lihat dari kode di atas, pada ketiga koneksi ini hanya baris dengan nama database yang berubah, dan sisanya sama.
Untuk memilih sesuatu, kita dapat menulis seperti ini:
$db->exec($sql);
Semua! Permintaan akan dieksekusi terlepas dari database apa yang kita miliki.
Mendukung
PDO tersedia dari PHP 5.1. Agar kita bisa "lupa" database mana yang kita gunakan, mereka melakukan segalanya untuk kita driver. Untuk mengaktifkannya, buka file php.ini dan cari baris yang dimulai dengan ekstensi=php_pdo_ diikuti dengan nama database, dan batalkan komentar.
Itu saja untuk artikel pengantar, dan selanjutnya kita akan mulai memahami, cara menggunakan pdo.
PDO memiliki metode koneksi buatan sendiri yang disebut . Selain itu, selama koneksi, Anda dapat menyetel opsi cloud yang menyebalkan, beberapa di antaranya sangat berguna. Daftar lengkap dapat ditemukan, tetapi hanya sedikit yang penting.
Contoh koneksi yang benar:
$host = "127.0.0.1" ;
$db = "tes" ;
$pengguna = "akar" ;
$lulus = "" ;
$set karakter = "utf8" ;
$dsn = "mysql:host= $host ;dbname= $db ;charset= $charset " ;
$memilih = [
PDO :: ATTR_ERRMODE => PDO :: ERRMODE_EXCEPTION ,
PDO :: ATTR_DEFAULT_FETCH_MODE => PDO :: FETCH_ASSOC ,
PDO::ATTR_EMULATE_PREPARES => salah ,
];
$pdo = PDO baru ($dsn , $user , $pass , $opt );
Apa yang terjadi di sini?
$dsn menentukan jenis database untuk bekerja dengan (mysql), host, nama database, dan charset.
- diikuti dengan nama pengguna dan kata sandi
- setelah itu serangkaian opsi ditentukan, yang tidak disebutkan dalam manual mana pun.
Terlepas dari kenyataan bahwa array ini adalah hal yang sangat berguna, seperti yang disebutkan di atas. Yang paling penting adalah mode kesalahan yang dikeluarkan harus diatur hanya dalam bentuk pengecualian.
- Pertama, karena dalam semua mode lain PDO tidak melaporkan kesalahan apa pun yang dapat dipahami,
- kedua, karena pengecualian selalu berisi jejak tumpukan yang tak tergantikan,
- ketiga - pengecualian sangat nyaman untuk ditangani.
Selain itu, sangat mudah untuk menyetel FETCH_MODE secara default agar tidak menuliskannya di SETIAP permintaan, karena hamster yang rajin sangat suka melakukannya.
Juga di sini Anda dapat mengatur mode pconnect, emulasi ekspresi yang disiapkan, dan banyak kata menakutkan lainnya.
Hasilnya, kami mendapatkan variabel $pdo, yang dengannya kami bekerja lebih jauh di seluruh skrip.
Anda dapat menggunakan dua metode untuk menjalankan kueri.
Jika tidak ada variabel yang diteruskan ke kueri, maka Anda dapat menggunakan fungsi query(). Itu akan mengeksekusi permintaan dan mengembalikan objek khusus - pernyataan PDO. Ini bisa sangat kasar dibandingkan dengan sumber daya mysql yang dikembalikan oleh mysql_query(). Anda bisa mendapatkan data dari objek ini dengan cara tradisional, melalui while, dan melalui foreach (). Anda juga dapat meminta untuk mengembalikan data yang diterima dalam format khusus, seperti yang dijelaskan di bawah ini.
$stmt = $pdo -> query("PILIH nama DARI pengguna" );
while ($baris = $stmt -> ambil())
{
}
Jika setidaknya satu variabel diteruskan ke permintaan, maka permintaan ini harus dijalankan tanpa gagal hanya melalui ekspresi yang telah disiapkan. Apa itu? Ini adalah kueri SQL biasa, di mana penanda khusus ditempatkan alih-alih variabel - placeholder. PDO mendukung placeholder posisi (?), yang urutan variabelnya penting, dan placeholder bernama (:nama), yang urutannya tidak penting. Contoh:
$sql = ;
$sql = ;
Untuk mengeksekusi kueri seperti itu, pertama-tama harus disiapkan menggunakan fungsi persiapan (). Itu juga mengembalikan pernyataan PDO, tetapi belum ada data. Untuk mendapatkannya, Anda perlu menjalankan permintaan ini, setelah meneruskan variabel ke dalamnya. Anda dapat mengirimkannya dengan dua cara:
Paling sering, Anda cukup mengeksekusi metode execution() , meneruskannya ke array dengan variabel:
$stmt = $pdo -> siapkan( "PILIH nama DARI pengguna MANA email =?");
$stmt -> jalankan(array($email ));
$stmt = $pdo -> siapkan( "PILIH nama DARI pengguna MANA email = :email");
$stmt -> jalankan (array("email" => $email ));
Seperti yang Anda lihat, dalam kasus placeholder bernama, array harus diteruskan ke execution(), di mana kunci harus cocok dengan nama placeholder.
Kadang-kadang, sangat jarang, cara kedua mungkin diperlukan, saat pertama kali variabel diikat ke permintaan satu per satu, menggunakan bindValue() / bindParam(), dan kemudian hanya dieksekusi. Dalam hal ini, tidak ada yang diteruskan ke execution(). Contoh dapat ditemukan di manual.
Dengan menggunakan metode ini, haruskah bindValue() selalu lebih disukai? karena perilaku bindParam() tidak jelas bagi pemula dan akan menimbulkan masalah.
Setelah itu, Anda dapat menggunakan pernyataan PDO dengan cara yang sama seperti di atas. Misalnya, melalui foreach:
$stmt = $pdo -> siapkan( "PILIH nama DARI pengguna MANA email =?");
$stmt ->
foreach ($stmt as $row )
{
echo $baris [ "nama" ] . "\N" ;
}
PENTING: Ekspresi yang disiapkan adalah alasan utama untuk menggunakan PDO apa adanya satu-satunya cara yang aman eksekusi kueri SQL yang melibatkan variabel.
Selain itu, prepare() / execution() dapat digunakan untuk berulang kali mengeksekusi kueri yang pernah disiapkan dengan set data yang berbeda. Dalam praktiknya, ini sangat jarang dibutuhkan, dan tidak membawa peningkatan kecepatan yang khusus. Tetapi jika Anda perlu membuat banyak jenis permintaan yang sama, Anda dapat menulis seperti ini:
$data = larik(
1 => 1000,
5 => 300,
9 => 200,
);
$stmt = $pdo -> siapkan( "UPDATE users SET bonus = bonus + ? WHERE id = ?");
foreach ($data as $id => $bonus )
{
$stmt -> jalankan([ $bonus , $id ]);
}
Di sini kami menyiapkan kueri satu kali dan kemudian menjalankannya berkali-kali.
Kita sudah bertemu dengan metode fetch() di atas, yang berfungsi untuk mengambil baris secara berurutan dari database. Metode ini mirip dengan fungsi mysq_fetch_array() dan yang serupa, tetapi cara kerjanya berbeda: alih-alih banyak fungsi, satu digunakan di sini, tetapi perilakunya diatur oleh parameter yang diteruskan. Saya akan menulis lebih banyak tentang opsi ini nanti, tetapi sebagai tip cepat, saya sarankan menggunakan fetch() dalam mode FETCH_LAZY:
$stmt = $pdo -> siapkan( "PILIH nama DARI pengguna MANA email =?");
$stmt -> jalankan([ $_GET [ "email" ]]);
sementara ($baris = $stmt -> ambil (PDO::FETCH_LAZY ))
{
gema $baris [ 0 ] . "\N" ;
echo $baris [ "nama" ] . "\N" ;
gema $baris -> nama . "\N" ;
}
Dalam mode ini, tidak ada memori tambahan yang terbuang, dan selain itu, kolom dapat diakses dengan salah satu dari tiga cara - melalui indeks, nama, atau properti.
Juga, pernyataan PDO memiliki fungsi pembantu untuk mendapatkan nilai dari satu kolom. Sangat nyaman jika kami hanya meminta satu bidang - dalam hal ini, jumlah tulisan berkurang secara signifikan:
$stmt = $pdo -> siapkan( "PILIH nama DARI tabel WHERE id=?");
$stmt -> jalankan(array($id ));
$nama = $stmt -> fetchColumn();
Tetapi fungsi yang paling menarik, dengan fungsionalitas terbanyak, adalah fetchAll(). Dialah yang menjadikan PDO sebagai pustaka tingkat tinggi untuk bekerja dengan database, dan bukan hanya driver tingkat rendah.
FetchAll() mengembalikan larik yang berisi semua baris yang dikembalikan oleh kueri. Dari mana dua kesimpulan dapat ditarik:
1. Fungsi ini tidak boleh digunakan saat kueri mengembalikan banyak data. Dalam hal ini, lebih baik menggunakan loop tradisional dengan fetch()
2. Karena dalam aplikasi PHP modern, data tidak pernah ditampilkan segera setelah diterima, tetapi diteruskan ke templat untuk ini, fetchAll () menjadi sangat diperlukan, memungkinkan Anda untuk tidak menulis siklus secara manual, dan dengan demikian mengurangi jumlah kode.
Mendapatkan array sederhana.
Dipanggil tanpa parameter, fungsi ini mengembalikan larik terindeks reguler yang berisi baris dari database dalam format yang ditentukan dalam FETCH_MODE secara default. Konstanta PDO::FETCH_NUM, PDO::FETCH_ASSOC, PDO::FETCH_OBJ dapat mengubah format dengan cepat.
Dapatkan kolom.
Terkadang Anda perlu mendapatkan larik satu dimensi sederhana dengan meminta satu bidang dari sekumpulan string. Untuk ini, mode PDO::FETCH_COLUMN digunakan.
$data = $pdo -> query("PILIH nama DARI pengguna" )-> fetchAll(PDO::FETCH_COLUMN );
Himpunan(
0 => "Yohanes",
1 => "Mike",
2 => "Maria",
3 => "Kathy" ,
)
Dapatkan pasangan kunci-nilai.
Juga format yang populer ketika diinginkan untuk mendapatkan kolom yang sama, tetapi diindeks bukan dengan angka, tetapi dengan salah satu bidang. Konstanta PDO::FETCH_KEY_PAIR bertanggung jawab untuk ini.
$data = $pdo -> query("PILIH id, nama DARI pengguna" )-> fetchAll(PDO::FETCH_KEY_PAIR );
Himpunan(
104 => "Yohanes",
110
120 => "Maria",
121
)
Dapatkan semua baris diindeks oleh bidang.
Seringkali juga diperlukan untuk mendapatkan semua baris dari database, tetapi juga diindeks bukan dengan angka, tetapi dengan bidang unik. Inilah yang dilakukan konstanta PDO::FETCH_UNIQUE.
$data = $pdo -> query("SELECT * FROM users" )-> fetchAll(PDO::FETCH_UNIQUE );
Himpunan(
104 => larik (
"nama" => "Yohanes",
"mobil" => "Toyota",
),
110 => larik (
"nama" => "Mike",
"mobil" => "Ford",
),
120 => larik (
"nama" => "Maria",
"mobil" => "Mazda",
),
121 => larik (
"nama" => "Kathy",
"mobil" => "Mazda",
),
)
Harus diingat bahwa bidang pertama di kolom harus merupakan bidang yang unik.
Secara total, ada lebih dari selusin mode berbeda untuk memperoleh data di PDO. Plus, Anda dapat menggabungkannya! Tapi ini adalah topik untuk artikel terpisah.
Saat bekerja dengan ekspresi yang telah disiapkan, Anda harus memahami bahwa placeholder hanya dapat mengganti string atau angka. Baik kata kunci, pengidentifikasi, maupun bagian dari string atau kumpulan string tidak dapat diganti melalui placeholder. Oleh karena itu, untuk LIKE, Anda harus menyiapkan seluruh string pencarian terlebih dahulu, lalu menggantinya dengan kueri:
$nama = "% $nama %" ;
$stm = $pdo -> siapkan( "SELECT * FROM table WHERE name LIKE ?");
$stm -> jalankan(array($nama ));
$data = $stm -> fetchAll();
Nah, Anda mengerti. Di sini juga buruk. PDO sama sekali tidak menyediakan alat apa pun untuk bekerja dengan pengidentifikasi, dan mereka harus diformat dengan cara lama, secara manual (atau lihat, setelah semua, SafeMysql , di mana ini, seperti banyak masalah lainnya, diselesaikan dengan sederhana dan elegan).
Harus diingat bahwa aturan untuk memformat pengidentifikasi berbeda untuk basis data yang berbeda.
Di mysql, untuk memformat id secara manual, Anda perlu melakukan dua hal:
- lampirkan di belakang tanda kutip tunggal (backticks, "`").
- skala karakter ini di dalam pengidentifikasi di dalam dengan menggandakan.
$bidang = "`" . str_replace ("`" , "``" , $_GET [ "bidang" ]). "`";
$sql = $bidang" ;
Namun, ada satu peringatan di sini. Memformat saja mungkin tidak cukup. Kode di atas akan melindungi kita dari injeksi klasik, tetapi dalam beberapa kasus musuh masih dapat menulis sesuatu yang tidak diinginkan jika kita mengganti nama bidang dan tabel langsung ke kueri tanpa berpikir panjang. Misalnya, ada bidang admin di tabel pengguna. Jika nama bidang yang masuk tidak difilter, maka di bidang ini, saat permintaan dibuat secara otomatis dari POST, orang bodoh mana pun akan menuliskan kotoran apa pun.
Oleh karena itu, nama tabel dan field yang berasal dari pengguna harus diperiksa validitasnya, seperti pada contoh di bawah ini
Kode embed apa pun yang dapat dilihat di banyak tutorial menginspirasi melankolis dan keinginan untuk membunuh upsten. Konstruksi multi-kilometer dengan pengulangan nama yang sama - dalam indeks $_POST, dalam nama variabel, dalam nama bidang dalam permintaan, dalam nama placeholder dalam permintaan, dalam nama placeholder dan nama variabel saat mengikat.
Melihat kode ini membuat saya ingin membunuh seseorang, atau setidaknya membuatnya sedikit lebih pendek.
Ini dapat dilakukan dengan mengadopsi konvensi bahwa nama bidang dalam formulir akan cocok dengan nama bidang dalam tabel. Kemudian nama-nama ini hanya dapat dicantumkan sekali (untuk melindungi dari substitusi yang disebutkan di atas), dan menggunakan fungsi pembantu kecil untuk membuat kueri, yang, karena kekhasan mysql, cocok untuk kueri INSERT dan UPDATE:
fungsi pdoSet ($diizinkan , & $nilai, $sumber = array()) (
$set = "" ;
$nilai = larik();
jika (! $sumber ) $sumber = & $_POST ;
foreach ($diperbolehkan sebagai $field ) (
jika (isset($sumber [ $bidang ])) (
$set .= "`" . str_replace ("`" , "``" , $field ). "`" . "=: $bidang , " ;
$nilai [ $bidang ] = $sumber [ $bidang ];
}
}
return substr ($set , 0 , - 2 );
}
Dengan demikian, untuk memasukkan kode akan
$diperbolehkan = array("nama", "nama belakang", "email"); // bidang yang diizinkan
$sql = "MASUKKAN KE SET PENGGUNA" . pdoSet($diizinkan , $nilai );
$stm = $dbh -> siapkan($sql );
$stm -> eksekusi($nilai);
Dan untuk pembaruan - ini:
$diperbolehkan = array("nama", "nama belakang", "email", "kata sandi"); // bidang yang diizinkan
$_POST [ "kata sandi" ] = MD5 ( $_POST [ "masuk" ]. $_POST [ "kata sandi" ]);
$sql = "PERBARUI PENGGUNA SET " . pdoSet($diizinkan , $nilai ). "DI MANA id = :id" ;
$stm = $dbh -> siapkan($sql );
$nilai["id"] = $_POST["id"];
$stm -> eksekusi($nilai);
Tidak terlalu efektif, tapi sangat efektif. Izinkan saya mengingatkan Anda, bahwa jika Anda menggunakan Kelas untuk pekerjaan yang aman dan nyaman dengan MySQL, maka ini semua dilakukan dalam dua baris.
PDO dan kata kunci
Di sini, selain memfilter, tidak mungkin memikirkan apa pun. oleh karena itu, bodoh untuk menjalankan semua operator yang tidak ditentukan secara langsung dalam permintaan melalui daftar putih:
$dirs = array("ASC" , "DESC" );
$key = array_search($_GET [ "dir" ], $dirs ));
$dir = $pesanan [ $key ];
$sql = "PILIH * DARI `meja` PESANAN OLEH$bidang $dir" ;
Koneksi basis data ditetapkan saat turunan dari kelas PDO dibuat. Tidak masalah driver mana yang ingin Anda gunakan; Anda akan selalu perlu menggunakan kelas PDO. Konstruktornya mengambil parameter untuk menentukan sumber database (dikenal sebagai DSN) dan parameter opsional untuk nama pengguna dan kata sandi.
koneksi MySQL:
$dbh = new PDO("mysql:host=localhost;dbname=test", $user, $pass);Jika terjadi kesalahan koneksi, pengecualian akan dilemparkan: objek kelas PDOException. Anda dapat menangkapnya jika ingin menangani situasi ini, atau Anda dapat menyerahkannya ke penangan pengecualian global, yang diatur melalui set_exception_handler().
Penanganan kesalahan koneksi:
coba ( $dbh = new PDO("mysql:host=localhost;dbname=test", $user, $pass); foreach($dbh->query('SELECT * from FOO') as $row) ( print_r($ baris); ) $dbh = null; ) catch (PDOException $e) ( die("Kesalahan! Itu dia. Kami telah tiba... ".$e->getMessage()); )Perhatian: Jika Anda tidak menangkap pengecualian yang dilemparkan oleh konstruktor PDO, tindakan default yang diambil oleh mesin zend adalah menghentikan skrip dan menampilkan traceback. Omong kosong ini akan memberikan semua detail komunikasi intim Anda dengan database. Itu adalah akan menampilkan detail koneksi database terperinci termasuk nama pengguna dan kata sandi! Terserah Anda untuk menangkap pengecualian ini, baik secara eksplisit (melalui pernyataan coba tangkap), atau secara implisit melalui set_exception_handler().
Setelah koneksi database berhasil, itu tetap aktif seumur hidup instance objek PDO. Untuk menutup koneksi, Anda harus menghancurkan objek, memastikan bahwa semua referensi yang tersisa dihapus - Anda dapat melakukan ini dengan menetapkan nilai NULL ke variabel yang berisi objek. Jika Anda tidak melakukannya secara eksplisit, maka PHP akan menutup koneksi secara otomatis saat skrip selesai.
Menutup koneksi:
$dbh = new PDO("mysql:host=localhost;dbname=test", $user, $pass); // Di sini kita melakukan sesuatu: ... // Dan sekarang, perhatian: akhir dari koneksi! $dbh = null;Banyak aplikasi web mendapat manfaat dari membuat koneksi persisten ke server basis data. Sambungan tetap tidak ditutup saat skrip keluar, tetapi di-cache dan digunakan kembali saat skrip lain meminta sambungan menggunakan kredensial sambungan yang sama. Cache koneksi persisten menghindari overhead membuat koneksi baru setiap kali skrip perlu berbicara dengan database, menghasilkan aplikasi web yang lebih cepat.
Menyiapkan koneksi permanen:
$dbh = new PDO("mysql:host=localhost;dbname=test", $user, $pass, array(PDO::ATTR_PERSISTENT => true));Mengingat: Jika Anda ingin menggunakan koneksi persisten, Anda harus mengaturnya PDO::ATTR_PERSISTENT dalam larik opsi driver, yang diteruskan ke konstruktor kelas PDO. Dengan menyetel atribut ini melalui PDO::setAttribute() setelah objek dibuat instance-nya, driver tidak akan menggunakan asosiasi persisten. Dan juga, dalam hal ini, Anda tidak akan dapat memperluas kelas PDOStatement untuk beberapa kebutuhan Anda, yaitu. tidak dapat diinstal: PDO::ATTR_STATEMENT_CLASS
- Terjemahan
Banyak pengembang PHP terbiasa menggunakan ekstensi mysql dan mysqli untuk bekerja dengan database. Tapi sejak versi 5.1 di PHP ada cara yang lebih nyaman - Objek Data PHP . Kelas ini, disingkat PDO, menyediakan metode untuk bekerja dengan objek dan pernyataan yang disiapkan yang akan sangat meningkatkan produktivitas Anda!
Pengantar PDO
"PDO - PHP Data Objects adalah lapisan yang menawarkan cara serbaguna untuk bekerja dengan banyak basis data."
Ini meninggalkan perhatian untuk sintaks DBMS yang berbeda kepada pengembang, tetapi membuat proses peralihan antar platform jauh lebih tidak menyakitkan. Seringkali ini hanya membutuhkan perubahan string koneksi database.
Artikel ini ditulis untuk orang yang menggunakan mysql dan mysqli untuk membantu mereka bermigrasi ke PDO yang lebih kuat dan fleksibel.
dukungan DBMS
Ekstensi ini dapat mendukung sistem manajemen basis data apa pun yang memiliki driver PDO. Pada saat penulisan, driver berikut tersedia:- PDO_CUBRID(CUBRID)
- PDO_DBLIB (FreeTDS/Microsoft SQL Server/Sybase)
- PDO_FIREBIRD (Firebird/Interbase 6)
- PDO_IBM (IBM DB2)
- PDO_INFORMIX (Server Dinamis IBM Informix)
- PDO_MYSQL (MySQL 3.x/4.x/5.x)
- PDO_OCI (Antarmuka Panggilan Oracle)
- PDO_ODBC (ODBC v3 (IBM DB2, unixODBC dan win32 ODBC))
- PDO_PGSQL (PostgreSQL)
- PDO_SQLITE (SQLite 3 dan SQLite 2)
- PDO_SQLSRV (Microsoft SQL Server)
- PDO_4D (4D)
print_r(PDO::getAvailableDrivers());
Koneksi
Cara untuk terhubung ke DBMS yang berbeda mungkin sedikit berbeda. Di bawah ini adalah contoh menghubungkan ke yang paling populer. Anda dapat melihat bahwa tiga yang pertama memiliki sintaks yang identik, tidak seperti SQLite.coba ( # MS SQL Server dan Sybase via PDO_DBLIB $DBH = new PDO("mssql:host=$host;dbname=$dbname", $user, $pass); $DBH = new PDO("sybase:host=$host ;dbname=$dbname", $user, $pass); # MySQL melalui PDO_MYSQL $DBH = new PDO("mysql:host=$host;dbname=$dbname", $user, $pass); # SQLite $DBH = PDO baru("sqlite:my/database/path/database.db"); ) catch(PDOException $e) ( echo $e->getMessage(); )
Harap perhatikan blok coba/tangkap - Anda harus selalu membungkus semua operasi PDO Anda di dalamnya dan menggunakan mekanisme pengecualian (lebih lanjut tentang itu nanti).
$DBH adalah singkatan dari "pegangan basis data" dan akan digunakan di seluruh artikel ini.
Anda dapat menutup koneksi apa pun dengan mendefinisikan ulang variabelnya menjadi nol.
# menutup koneksi $DBH = null;
Informasi lebih lanjut tentang topik opsi DBMS yang berbeda dan cara menghubungkannya dapat ditemukan di php.net.
Pengecualian dan PDO
PDO tahu cara melempar pengecualian pada kesalahan, jadi semuanya harus dalam blok coba/tangkap. Setelah koneksi dibuat, PDO dapat dimasukkan ke salah satu dari tiga mode kesalahan:$DBH->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_SILENT); $DBH->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_WARNING); $DBH->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
Tetapi perlu dicatat bahwa kesalahan saat mencoba terhubung akan selalu memunculkan pengecualian.
PDO::ERRMODE_SILENT
Ini adalah mode default. Hal yang sama yang kemungkinan besar Anda gunakan untuk menangkap kesalahan pada ekstensi mysql dan mysqli. Dua mode berikutnya lebih cocok untuk pemrograman KERING.PDO::ERRMODE_WARNING
Mode ini akan memicu Peringatan standar dan memungkinkan skrip untuk terus dijalankan. Berguna untuk debugging.PDO::ERRMODE_EXCEPTION
Dalam kebanyakan situasi, jenis kontrol eksekusi skrip ini lebih disukai. Itu melempar pengecualian, yang memungkinkan Anda menangani kesalahan dengan anggun dan menyembunyikan informasi sensitif. Seperti, misalnya, di sini:# terhubung ke database coba ( $DBH = new PDO("mysql:host=$host;dbname=$dbname", $user, $pass); $DBH->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION) ; # Sialan, mengetik DELECT bukan SELECT! $DBH->prepare("HAPUS nama DARI orang")->execute(); ) catch(PDOException $e) ( echo "Houston, kami dalam masalah."; file_put_contents( "PDOErrors .txt", $e->getMessage(), FILE_APPEND); )
Ada kesalahan sintaksis dalam pernyataan SQL yang akan menimbulkan pengecualian. Kami dapat merekam detail kesalahan dalam file log dan memberi petunjuk kepada pengguna dalam bahasa manusia bahwa sesuatu telah terjadi.
Sisipkan dan Perbarui
Memasukkan data baru dan memperbarui data yang ada adalah salah satu operasi basis data yang paling umum. Dalam kasus PDO, proses ini biasanya terdiri dari dua langkah. (Di bagian selanjutnya, semuanya berlaku untuk UPDATE dan INSERT)
Contoh sepele memasukkan data baru:
# STH berarti "Pegangan Pernyataan" $STH = $DBH->prepare("INSERT INTO people (first_name) values ("Cathy")"); $STH->eksekusi();
Anda sebenarnya dapat melakukan hal yang sama dengan metode exec() tunggal, tetapi metode dua langkah memberi Anda semua manfaat dari pernyataan yang telah disiapkan. Mereka membantu melindungi dari injeksi SQL, jadi masuk akal untuk menggunakannya bahkan dengan satu permintaan.
Pernyataan yang Disiapkan
Penggunaan pernyataan yang disiapkan memperkuat perlindungan terhadap injeksi SQL.
Pernyataan yang disiapkan adalah pernyataan SQL yang telah dikompilasi sebelumnya yang dapat dieksekusi berkali-kali dengan hanya mengirimkan kumpulan data yang berbeda ke server. Keuntungan tambahan adalah ketidakmampuan untuk melakukan injeksi SQL melalui data yang digunakan di placeholder.
Di bawah ini adalah tiga contoh pernyataan yang disiapkan.
# tanpa placeholder - pintu injeksi SQL terbuka! $STH = $DBH->prepare("INSERT INTO people (name, addr, city) values ($name, $addr, $city)"); # tempat penampung yang tidak disebutkan namanya $STH = $DBH->prepare("INSERT INTO people (name, addr, city) values (?, ?, ?)"); # placeholder bernama $STH = $DBH->prepare("INSERT INTO people (name, addr, city) values (:name, :addr, :city)");
Contoh pertama hanya untuk perbandingan dan harus dihindari. Perbedaan antara placeholder tanpa nama dan bernama adalah cara Anda meneruskan data ke pernyataan yang disiapkan.
Placeholder tanpa nama
# tetapkan variabel ke setiap placeholder, diindeks 1 hingga 3 $STH->bindParam(1, $name); $STH->bindParam(2, $addr); $STH->bindParam(3, $kota); # sisipkan satu baris $nama = "Daniel" $addr = "1 Jalan Jahat"; $city = "Arlington Heights"; $STH->eksekusi(); # menyisipkan baris lain dengan data berbeda $nama = "Steve" $addr = "5 Circle Drive"; $kota = "Schaumburg"; $STH->eksekusi();Ada dua langkah di sini. Pada yang pertama, kita menugaskan variabel ke semua placeholder (baris 2-4). Kemudian kami menetapkan nilai ke variabel-variabel ini dan menjalankan kueri. Untuk mengirim kumpulan data baru, cukup ubah nilai variabel dan jalankan permintaan lagi.
Jika ekspresi SQL Anda memiliki banyak parameter, maka menugaskan variabel ke masing-masing parameter sangat merepotkan. Dalam kasus seperti itu, Anda dapat menyimpan data dalam larik dan meneruskannya:
# dataset yang akan kita sisipkan $data = array("Cathy", "9 Dark and Twisty Road", "Cardiff"); $STH = $DBH->prepare("INSERT INTO people (name, addr, city) values (?, ?, ?)"); $STH->eksekusi($data);
$data akan dimasukkan sebagai pengganti placeholder pertama, $data sebagai pengganti placeholder kedua, dan seterusnya. Tapi hati-hati: jika indeks Anda dirobohkan, ini tidak akan berhasil.
Pengganti nominal
# argumen pertama adalah nama placeholder # biasanya dimulai dengan tanda titik dua # meskipun dapat berfungsi tanpa tanda titik dua $STH->bindParam(":name", $name);Di sini Anda juga bisa melewatkan array, tetapi harus asosiatif. Peran kunci seharusnya, seperti yang Anda duga, nama placeholder.
# data yang kita masukkan $data = array("name" => "Cathy", "addr" => "9 Dark and Twisty", "city" => "Cardiff"); $STH = $DBH->prepare("INSERT INTO people (name, addr, city) values (:name, :addr, :city)"); $STH->eksekusi($data);
Salah satu kemudahan menggunakan name placeholder adalah kemampuan untuk menyisipkan objek langsung ke dalam database jika nama properti cocok dengan nama parameter. Memasukkan data, misalnya, Anda dapat melakukan ini:
# kelas untuk orang kelas objek sederhana ( 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"); # dan inilah bagian yang menyenangkan $STH = $DBH->prepare("INSERT INTO people (name, addr, city) values (:name, :addr, :city)"); $STH->execute((array)$cathy);
Mengonversi objek menjadi larik pada eksekusi() menyebabkan properti diperlakukan sebagai kunci larik.
Pengambilan sampel data
Data dapat diambil menggunakan metode ->fetch(). Sebelum memanggilnya, disarankan untuk secara eksplisit menunjukkan dalam bentuk apa Anda membutuhkannya. Ada beberapa opsi:
- PDO::FETCH_ASSOC: mengembalikan array dengan nama kolom sebagai kunci
- PDO::FETCH_BOTH (default): mengembalikan array dengan indeks baik dalam bentuk nama kolom dan nomor urutnya
- PDO::FETCH_BOUND: menetapkan nilai kolom ke set variabel yang sesuai dengan metode ->bindColumn()
- PDO::FETCH_CLASS: memberikan nilai kolom ke properti yang sesuai dari kelas yang ditentukan. Jika tidak ada properti untuk beberapa kolom, itu akan dibuat
- PDO::FETCH_INTO: memperbarui instance yang ada dari kelas yang ditentukan
- PDO::FETCH_LAZY: menggabungkan PDO::FETCH_BOTH dan PDO::FETCH_OBJ
- PDO::FETCH_NUM: mengembalikan array dengan kunci sebagai nomor urut kolom
- PDO::FETCH_OBJ: mengembalikan objek anonim dengan properti yang sesuai dengan nama kolom
$STH->setFetchMode(PDO::FETCH_ASSOC);
Anda juga dapat mengaturnya secara langsung saat memanggil metode ->fetch().
FETCH_ASSOC
Format ini membuat array asosiatif dengan nama kolom sebagai indeks. Itu harus akrab bagi mereka yang menggunakan ekstensi mysql/mysqli.# karena ini adalah query normal tanpa placeholder, # Anda dapat langsung menggunakan metode query() $STH = $DBH->query("SELECT name, addr, city from people"); # atur mode pengambilan $STH->setFetchMode(PDO::FETCH_ASSOC); while($baris = $STH->fetch()) ( echo $baris["nama"] . "\n"; echo $baris["addr"] . "\n"; echo $baris["kota"] . "\N"; )
Loop while() akan mengulangi seluruh hasil kueri.
FETCH_OBJ
Jenis pengambilan ini membuat turunan dari kelas std untuk setiap baris.# buat kueri $STH = $DBH->query("PILIH nama, alamat, kota dari orang"); # pilih mode pengambilan $STH->setFetchMode(PDO::FETCH_OBJ); # cetak hasilnya while($row = $STH->fetch()) ( echo $row->name . "\n"; echo $row->addr . "\n"; echo $row->city . " \ n"; )
FETCH_CLASS
Saat menggunakan fetch_class , data ditulis ke instance dari kelas yang ditentukan. Dalam hal ini, nilai diberikan ke properti objek SEBELUM konstruktor dipanggil. Jika properti dengan nama yang sesuai dengan nama kolom tidak ada, properti tersebut akan dibuat secara otomatis (dengan ruang lingkup publik).Jika data Anda perlu diproses segera setelah diterima dari database, data tersebut dapat diimplementasikan di konstruktor kelas.
Misalnya, mari kita ambil situasi di mana Anda perlu menyembunyikan sebagian dari alamat seseorang.
kelas secret_person ( public $name; public $addr; public $city; public $other_data; function __construct($other = "") ( $this->addr = preg_replace("//", "x", $this-> addr); $ini->data_lain = $lainnya; ) )
Saat membuat objek, semua huruf Latin huruf kecil harus diganti dengan x. Mari kita periksa:
$STH = $DBH->query("PILIH nama, alamat, kota dari orang"); $STH->setFetchMode(PDO::FETCH_CLASS, "secret_person"); while($obj = $STH->fetch()) ( echo $obj->addr; )
Jika alamatnya terlihat seperti '5 Rosebud' di database, maka hasilnya adalah '5 Rxxxxxx'.
Tentu saja, terkadang Anda ingin konstruktor dipanggil SEBELUM nilai ditetapkan. PDO memungkinkan ini juga.
$STH->setFetchMode(PDO::FETCH_CLASS | PDO::FETCH_PROPS_LATE, "secret_person");
Sekarang setelah Anda menyelesaikan contoh sebelumnya dengan opsi tambahan (PDO::FETCH_PROPS_LATE), alamat tidak akan diubah, karena tidak ada yang terjadi setelah nilai ditulis.
Terakhir, jika perlu, Anda dapat meneruskan argumen ke konstruktor secara langsung saat membuat objek:
$STH->setFetchMode(PDO::FETCH_CLASS, "secret_person", array("stuff"));
Anda bahkan dapat memberikan argumen yang berbeda untuk setiap objek:
$i = 0; while($rowObj = $STH->fetch(PDO::FETCH_CLASS, "secret_person", array($i))) ( // melakukan sesuatu $i++; )
Metode bermanfaat lainnya
Meskipun artikel ini tidak dapat (dan tidak mencoba) membahas setiap aspek bekerja dengan PDO (ini adalah modul yang sangat besar!), beberapa fitur berikut tidak dapat diabaikan.$DBH->lastInsertId();
Metode ->lastInsertId() mengembalikan id dari record yang dimasukkan terakhir. Perhatikan bahwa itu selalu dipanggil pada objek database (disebut dalam artikel sebagai $DBH), bukan pada objek ekspresi ($STH).
$DBH->exec("DELETE FROM people WHERE 1"); $DBH->exec("SET time_zone = "-8:00"");
Metode ->exec() digunakan untuk operasi yang tidak mengembalikan data selain jumlah record yang terpengaruh olehnya.
$aman = $DBH->quote($tidak aman);
Metode ->quote() menempatkan kutipan dalam data string sedemikian rupa sehingga aman untuk menggunakannya dalam kueri. Berguna jika Anda tidak menggunakan pernyataan yang disiapkan.
$rows_affected = $STH->rowCount();
Metode ->rowCount() mengembalikan jumlah record yang berpartisipasi dalam operasi. Sayangnya, fungsi ini tidak berfungsi dengan kueri SELECT hingga PHP 5.1.6. Jika tidak memungkinkan untuk memperbarui versi PHP, jumlah catatan dapat diperoleh seperti ini:
$sql = "SELECT COUNT(*) FROM people"; if ($STH = $DBH->query($sql)) ( # periksa jumlah record if ($STH->fetchColumn() > 0) ( # lakukan pengambilan yang benar di sini, karena data ditemukan! ) else ( # tampilkan pesan bahwa tidak ada data yang cocok ditemukan) )
