PDO [Đối tượng dữ liệu PHP] là một lớp trừu tượng cho các truy vấn cơ sở dữ liệu của bạn và là một giải pháp thay thế tuyệt vời cho MySQLi, vì nó hỗ trợ. Đây là một lợi ích to lớn cho những người và công ty cần nó. Tuy nhiên, hãy nhớ rằng MySQL cho đến nay vẫn là. Nó cũng được kết hợp cực kỳ chặt chẽ với PHP, đó là lý do tại sao con số đó cao hơn đáng kể trong thế giới PHP, vì PHP và MYSQL giống như bơ đậu phộng và thạch. NoSQL là một câu chuyện khác, và Firebase và MongoDB là những lựa chọn tuyệt vời, đặc biệt là cái trước, vì nó là cơ sở dữ liệu trực tiếp — rõ ràng là cả hai đều không được hỗ trợ trong PDO
Ghi chú. Đối với hướng dẫn này, tôi sẽ hiển thị các câu lệnh được chuẩn bị PDO không mô phỏng [gốc] hoàn toàn với MySQL, vì vậy có thể có một số khác biệt trên một trình điều khiển khác
Nếu bạn biết chắc chắn rằng cơ sở dữ liệu SQL duy nhất bạn sẽ sử dụng là MySQL hoặc MariaDB, thì bạn có thể chọn giữa PDO hoặc MySQLi. Hãy xem hướng dẫn sau, Nếu bạn muốn học MySQLi. Một trong hai cách này hoàn toàn có thể chấp nhận được để sử dụng, mặc dù PDO là lựa chọn tốt hơn cho hầu hết người dùng, vì nó đơn giản và linh hoạt hơn, trong khi MySQLi đôi khi phù hợp hơn với người dùng nâng cao do một số tính năng dành riêng cho MySQL của nó
Rất nhiều người nhắc lại rằng ưu điểm chính của PDO là nó có thể di động từ cơ sở dữ liệu này sang cơ sở dữ liệu khác. Đây là một lợi ích cực kỳ phóng đại và về cơ bản là vô nghĩa. SQL không được chuyển theo cách này, vì mỗi trình điều khiển cơ sở dữ liệu có sắc thái riêng;
Ưu điểm thực sự của PDO là bạn đang sử dụng một API gần như tương tự cho bất kỳ cơ sở dữ liệu nào trong số vô số cơ sở dữ liệu mà nó hỗ trợ, vì vậy bạn không cần phải tìm hiểu cơ sở dữ liệu mới cho từng cơ sở dữ liệu. Các tham số được đặt tên chắc chắn cũng là một chiến thắng lớn cho PDO, vì bạn có thể sử dụng lại các giá trị giống nhau ở những vị trí khác nhau trong các truy vấn. Thật không may, bạn không thể sử dụng cùng một tham số được đặt tên nhiều lần khi tắt chế độ mô phỏng, do đó, nó trở nên vô dụng vì mục đích của hướng dẫn này
Một lợi thế gây tranh cãi của PDO là bạn không cần sử dụng
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Nếu bạn muốn tìm hiểu cách hoạt động của SQL injection, bạn có thể
Cách thức hoạt động của báo cáo chuẩn bị PDO
Theo thuật ngữ của giáo dân, các câu lệnh chuẩn bị PDO hoạt động như thế này
- Chuẩn bị một truy vấn SQL với các giá trị trống dưới dạng trình giữ chỗ có dấu chấm hỏi hoặc tên biến có dấu hai chấm trước nó cho mỗi giá trị
- Liên kết các giá trị hoặc biến với trình giữ chỗ
- Thực hiện truy vấn đồng thời
Tạo kết nối PDO mới
Tôi khuyên bạn nên tạo một tệp có tên
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
try {
$pdo = new PDO[$dsn, "username", "password", $options];
} catch [Exception $e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}
Vì vậy, những gì đang xảy ra ở đây? . Đây là cách được đề xuất để thực hiện và rõ ràng bạn có thể đặt bộ ký tự của mình thành bất kỳ thứ gì mà ứng dụng của bạn cần [mặc dù utf8mb4 khá chuẩn]. Bây giờ bạn có thể chuyển thông tin DSN, tên người dùng, mật khẩu và các tùy chọn của mình
Ngoài ra, bạn có thể bỏ qua việc sử dụng khối
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
Điều này cực kỳ gây tranh cãi, nhưng một điều tôi thích ở MySQLi là báo cáo lỗi bị tắt theo mặc định. Điều này thật thông minh, vì vậy người mới bắt đầu sẽ không vô tình in ra mật khẩu của mình. Trong PDO, mặc dù bạn có quyền kiểm soát để tắt các lỗi, nhưng bạn không thể làm điều này cho. Vì vậy, rõ ràng trước tiên bạn nên thiết lập php của mình. ini cho sản xuất
Để ngăn rò rỉ mật khẩu của bạn, đây là những gì php của bạn. ini sẽ giống như trong sản xuất. làm cả
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$stmt = $pdo->prepare["UPDATE myTable SET name = ? WHERE id = ?"];
$stmt->execute[[$_POST['name'], $_SESSION['id']]];
echo $stmt->rowCount[];
$stmt = null;
Bây giờ tất cả các lỗi trên trang web của bạn sẽ chỉ tích lũy trong nhật ký lỗi của bạn, thay vì in chúng ra
Tuy nhiên, tôi không thấy có lý do gì để in mật khẩu của bạn trong nhật ký lỗi, vì vậy tôi khuyên bạn nên thực hiện
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$stmt = $pdo->prepare["UPDATE myTable SET name = ? WHERE id = ?"];
$stmt->execute[[$_POST['name'], $_SESSION['id']]];
echo $stmt->rowCount[];
$stmt = null;
$stmt = $pdo->prepare["UPDATE myTable SET name = ? WHERE id = ?"];
$stmt->execute[[$_POST['name'], $_SESSION['id']]];
echo $stmt->rowCount[];
$stmt = null;
$stmt = $pdo->prepare["UPDATE myTable SET name = ? WHERE id = ?"];
$stmt->execute[[$_POST['name'], $_SESSION['id']]];
echo $stmt->rowCount[];
$stmt = null;
Tham số được đặt tên
Tôi thực sự yêu thích tính năng này và đó là một lợi thế rất lớn cho PDO. Bạn chỉ định một biến có tên là
$stmt = $pdo->prepare["UPDATE myTable SET name = ? WHERE id = ?"];
$stmt->execute[[$_POST['name'], $_SESSION['id']]];
echo $stmt->rowCount[];
$stmt = null;
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Về mặt kỹ thuật, bạn không cần dấu hai chấm ở đầu trên
$stmt = $pdo->prepare["UPDATE myTable SET name = ? WHERE id = ?"];
$stmt->execute[[$_POST['name'], $_SESSION['id']]];
echo $stmt->rowCount[];
$stmt = null;
Tôi dành riêng một phần để sử dụng các tham số được đặt tên, vì phần còn lại của bài đăng sẽ sử dụng
$stmt = $pdo->prepare["UPDATE myTable SET name = ? WHERE id = ?"];
$stmt->execute[[$_POST['name'], $_SESSION['id']]];
echo $stmt->rowCount[];
$stmt = null;
Chèn, cập nhật và xóa
Tất cả những thứ này cực kỳ giống nhau, vì vậy chúng sẽ được kết hợp
Chèn
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Cập nhật
Bạn thậm chí có thể xâu chuỗi
$stmt = $pdo->prepare["UPDATE myTable SET name = ? WHERE id = ?"];
$stmt->execute[[$_POST['name'], $_SESSION['id']]];
echo $stmt->rowCount[];
$stmt = null;
$stmt = $pdo->prepare["UPDATE myTable SET name = ? WHERE id = ?"];
$stmt->execute[[$_POST['name'], $_SESSION['id']]];
echo $stmt->rowCount[];
$stmt = null;
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Xóa bỏ
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Nhận số hàng bị ảnh hưởng
Lấy số hàng bị ảnh hưởng cực kỳ đơn giản, vì tất cả những gì bạn cần làm là
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
-1 - Truy vấn trả về lỗi. Dự phòng nếu đã xử lý lỗi cho exec[]
0 - Không có bản ghi nào được cập nhật khi CẬP NHẬT, không có hàng nào khớp với mệnh đề WHERE hoặc không có truy vấn nào được thực thi;
Lớn hơn 0 - Trả về số hàng bị ảnh hưởng; . Có thể được sử dụng để lấy số hàng trong CHỌN nếu trình điều khiển cơ sở dữ liệu hỗ trợ nó, điều mà MySQL làm
Nhận khóa chính mới nhất được chèn
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Kiểm tra xem mục trùng lặp
Đôi khi, bạn có thể cần thực thi một giá trị duy nhất cho một hoặc nhiều cột. Rõ ràng là bạn có thể chỉ cần sử dụng câu lệnh SELECT để kiểm tra xem đã có một hàng có các giá trị được cố gắng chèn vào chưa. Làm điều này không nhất thiết là sai, nhưng sẽ không hợp lý khi thực hiện thêm một truy vấn cơ sở dữ liệu, khi bạn có thể dễ dàng kiểm tra thông báo lỗi
Bạn có thể kiểm tra SQLSTATE hoặc lỗi dành riêng cho nhà cung cấp. Đối với một mục trùng lặp trên một ràng buộc duy nhất, SQLSTATE là 23000, trong khi mã lỗi MySQL là 1062. Đây là một danh sách các lỗi. Để lấy SQLSTATE, bạn có thể sử dụng
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Trong trường hợp bạn đang thắc mắc, bạn có thể tạo một ràng buộc duy nhất bằng cách thực hiện
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Lựa chọn
Để tìm nạp kết quả trong PDO, bạn có tùy chọn
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Các chế độ tìm nạp trong PDO dễ dàng là khía cạnh yêu thích của tôi. Tôi sẽ trộn chúng vào các ví dụ của mình, nhưng đây là một số hằng số mà tôi thấy là hữu ích nhất
Ghi chú. một số chế độ tìm nạp này sử dụng toán tử bitwise, như. Trong trường hợp của PDO, về cơ bản bạn có thể coi nó là sự kết hợp các chế độ tìm nạp. Điều này được gọi là bao hàm hoặc và là toán tử bitwise duy nhất mà bạn cần quan tâm
Chế độ tìm nạp
Cả tìm nạp [] và tìm nạp Tất cả []
47 - Tìm nạp một mảng số$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"]; $stmt->execute[[$_SESSION['id']]]; $stmt = null;
48 - Tìm nạp một mảng kết hợp$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"]; $stmt->execute[[$_SESSION['id']]]; $stmt = null;
49 - Chỉ tìm nạp một cột. Vô hướng nếu sử dụng$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"]; $stmt->execute[[$_SESSION['id']]]; $stmt = null;
45; . Nếu$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"]; $stmt->execute[[$_SESSION['id']]]; $stmt = null;
45, thì bạn có thể sử dụng$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"]; $stmt->execute[[$_SESSION['id']]]; $stmt = null;
63 cho đường cú pháp để thay thế$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"]; $stmt->execute[[$_SESSION['id']]]; $stmt = null;
64 - Tìm nạp một đối tượng có tên lớp theo giá trị cơ sở dữ liệu. Nếu lớp không tồn tại, sẽ mặc định là stdClass$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"]; $stmt->execute[[$_SESSION['id']]]; $stmt = null;
Chỉ cần tìm nạp []
65 - Tìm nạp dưới dạng Đối tượng stdClass chung. Thay vào đó, bạn nên sử dụng đường cú pháp$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"]; $stmt->execute[[$_SESSION['id']]]; $stmt = null;
66 vì nó cho phép bạn tìm nạp một lớp ẩn danh và được chỉ định. Bạn vẫn có thể sử dụng$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"]; $stmt->execute[[$_SESSION['id']]]; $stmt = null;
67, nhưng bạn phải đặt nó bằng$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"]; $stmt->execute[[$_SESSION['id']]]; $stmt = null;
68, sau đó là$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"]; $stmt->execute[[$_SESSION['id']]]; $stmt = null;
45. Có thể được sử dụng với$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"]; $stmt->execute[[$_SESSION['id']]]; $stmt = null;
46, nhưng không được ưu tiên vì nó kém linh hoạt hơn$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"]; $stmt->execute[[$_SESSION['id']]]; $stmt = null;
01 - Tìm nạp một tham chiếu PDORow có khả năng là một đối tượng, mảng kết hợp hoặc số. Hiệu quả về bộ nhớ, vì nó sẽ tìm nạp kết quả một cách nghiêm ngặt khi một đối tượng, chỉ mục kết hợp hoặc số được gọiset_exception_handler[function[$e] { error_log[$e->getMessage[]]; exit['Something weird happened']; //something a user can understand }]; $dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4"; $options = [ PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array ]; $pdo = new PDO[$dsn, "username", "password", $options];
02 - Tìm nạp vào một lớp hiện có. Phải sử dụngset_exception_handler[function[$e] { error_log[$e->getMessage[]]; exit['Something weird happened']; //something a user can understand }]; $dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4"; $options = [ PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array ]; $pdo = new PDO[$dsn, "username", "password", $options];
03, tiếp theo làset_exception_handler[function[$e] { error_log[$e->getMessage[]]; exit['Something weird happened']; //something a user can understand }]; $dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4"; $options = [ PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array ]; $pdo = new PDO[$dsn, "username", "password", $options];
45$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"]; $stmt->execute[[$_SESSION['id']]]; $stmt = null;
Chỉ cần tìm nạp Tất cả []
67 - Tìm nạp dưới dạng Đối tượng stdClass chung hoặc vào một lớp hiện có nếu được chỉ định; . Cũng có thể được sử dụng với$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"]; $stmt->execute[[$_SESSION['id']]]; $stmt = null;
45, nhưng không được ưu tiên$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"]; $stmt->execute[[$_SESSION['id']]]; $stmt = null;
08 - Tìm nạp cặp khóa/giá trị với cột đầu tiên là khóa duy nhất và cột thứ hai là giá trị đơnset_exception_handler[function[$e] { error_log[$e->getMessage[]]; exit['Something weird happened']; //something a user can understand }]; $dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4"; $options = [ PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array ]; $pdo = new PDO[$dsn, "username", "password", $options];
09 - Giống nhưset_exception_handler[function[$e] { error_log[$e->getMessage[]]; exit['Something weird happened']; //something a user can understand }]; $dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4"; $options = [ PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array ]; $pdo = new PDO[$dsn, "username", "password", $options];
08, chỉ có phần giá trị là mảngset_exception_handler[function[$e] { error_log[$e->getMessage[]]; exit['Something weird happened']; //something a user can understand }]; $dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4"; $options = [ PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array ]; $pdo = new PDO[$dsn, "username", "password", $options];
11 - Tìm nạp theo tên cột chung và nhóm tất cả các hàng vào khóa đó dưới dạng một mảng gồm các mảng kết hợpset_exception_handler[function[$e] { error_log[$e->getMessage[]]; exit['Something weird happened']; //something a user can understand }]; $dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4"; $options = [ PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array ]; $pdo = new PDO[$dsn, "username", "password", $options];
12 - Giống nhưset_exception_handler[function[$e] { error_log[$e->getMessage[]]; exit['Something weird happened']; //something a user can understand }]; $dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4"; $options = [ PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array ]; $pdo = new PDO[$dsn, "username", "password", $options];
11, chỉ có phần giá trị là một mảng gồm các mảng số 1dset_exception_handler[function[$e] { error_log[$e->getMessage[]]; exit['Something weird happened']; //something a user can understand }]; $dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4"; $options = [ PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array ]; $pdo = new PDO[$dsn, "username", "password", $options];
14 - Giống nhưset_exception_handler[function[$e] { error_log[$e->getMessage[]]; exit['Something weird happened']; //something a user can understand }]; $dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4"; $options = [ PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array ]; $pdo = new PDO[$dsn, "username", "password", $options];
11, nhưng thay vào đó là một mảng các mảng đối tượngset_exception_handler[function[$e] { error_log[$e->getMessage[]]; exit['Something weird happened']; //something a user can understand }]; $dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4"; $options = [ PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array ]; $pdo = new PDO[$dsn, "username", "password", $options];
Tìm nạp mảng liên kết
Vì chúng tôi đặt loại tìm nạp mặc định là một mảng kết hợp, nên chúng tôi không chỉ định bất cứ điều gì khi tìm nạp kết quả
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
Ngoài ra còn có phiên bản vòng lặp while dài hơn một chút, đôi khi thuận tiện cho các thao tác
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
đầu ra
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
Tìm nạp mảng số
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
đầu ra
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
Tìm nạp mảng đối tượng
Tương tự như tìm nạp một mảng kết hợp, nhưng với các đối tượng, vì vậy bạn có thể truy cập nó như, chẳng hạn như
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
đầu ra
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
Bạn thậm chí có thể nối các giá trị thuộc tính vào một lớp đã tồn tại, như vậy
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
đầu ra
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
Hãy nhớ rằng điều này có hành vi không thể đoán trước khi đưa giá trị thuộc tính trước khi đặt nó vào hàm tạo [nếu bạn có]. Điều này có nghĩa là nếu bạn đã sử dụng một trong các tên biến trong hàm tạo, thì giá trị tìm nạp sẽ bị ghi đè bởi giá trị mặc định. hành vi này. Để đảm bảo các giá trị được chỉ định sau khi hàm tạo được gọi, bạn phải thực hiện ____
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
Một hành vi bất ngờ nhưng có khả năng hữu ích khác là bạn có thể sửa đổi các biến riêng tư. Tôi thực sự không chắc mình cảm thấy thế nào về điều này, vì điều này dường như vi phạm các nguyên tắc đóng gói
Tìm nạp một hàng
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
Bây giờ bạn truy cập từng biến, chẳng hạn như
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
đầu ra
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Tìm nạp một hàng như MySQLi bind_result[]
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Điều này là để bắt chước hành vi [chỉ có lợi] của
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
Tìm nạp vô hướng [Một giá trị]
Một trường hợp sử dụng phổ biến cho điều này là nếu bạn chỉ muốn lấy số lượng hàng và lưu trữ nó trong một biến. Có vấn đề với việc sử dụng
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
Để rõ ràng, hành vi này không xảy ra khi bạn cần tìm nạp một mảng với
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Bây giờ
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
Tìm nạp nhiều cột dưới dạng biến mảng riêng biệt
Điều này có thể hữu ích vì bạn có thể dễ dàng tách nó thành một loạt các mảng 1D riêng biệt, thay vì chỉ một mảng đa chiều. Hãy nhớ rằng tôi đã sử dụng
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
đầu ra
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Tìm nạp một cột dưới dạng biến mảng
Khái niệm tương tự như ví dụ ngay trước đó, nhưng điều này rất hữu ích nếu tất cả những gì bạn cần làm là lấy một mảng chỉ có một cột
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
đầu ra
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Tìm nạp cặp khóa/giá trị
Điều này tạo ra một mảng kết hợp với định dạng của cột đầu tiên là khóa và cột thứ hai là giá trị. Do đó, cột đầu tiên của bạn cần phải là một giá trị duy nhất
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
đầu ra
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Tìm nạp mảng cặp khóa/giá trị
Vì thiếu một thuật ngữ tốt hơn rõ ràng. Điều tôi muốn nói ở đây là khóa sẽ là cột đầu tiên của bạn, cần phải là một giá trị duy nhất, trong khi giá trị sẽ là phần còn lại của các cột dưới dạng một mảng kết hợp
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Tôi không chắc tại sao trên các tài liệu PHP nói rằng bạn phải bitwise nó và thêm
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
đầu ra
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Tìm nạp theo nhóm
Giả sử bạn muốn nhóm theo màu mắt chẳng hạn. Chế độ tìm nạp tiện dụng này cho phép bạn thực hiện điều đó cực kỳ đơn giản
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
đầu ra
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Tìm nạp theo nhóm, một cột
Sự khác biệt giữa ví dụ này và ví dụ trước về cơ bản là tình huống giống như
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
đầu ra
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Tìm nạp theo nhóm, mảng đối tượng
Tương tự như tìm nạp trong một nhóm thông thường, nhưng thay vào đó là các mảng con đối tượng
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
đầu ra
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Bạn cũng có thể chỉ định một tên lớp
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Tìm nạp vào lớp hiện có
Điều này gần giống với
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
đầu ra
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Tìm nạp lớp từ giá trị cơ sở dữ liệu
Đối với người bình thường, điều này có lẽ không quá hữu ích. Nhưng đối với những người dùng sử dụng nhiều ánh xạ đối tượng trong PDO, điều này thực sự khá tuyệt. Mặc dù những loại người dùng này muốn sử dụng ORM hoặc trình tạo truy vấn, tuy nhiên, nó vẫn cho thấy PDO mạnh mẽ như thế nào
Đối với công việc này, bạn cần khai báo tên các lớp của mình, nếu không, nó sẽ chỉ sử dụng stdClass. Vì vậy, bạn cần biết các giá trị của cơ sở dữ liệu của mình, điều này có thể gây bất tiện. Bạn cũng không được phép khai báo đối số tham số, giống như bạn làm với riêng
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
đầu ra
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Tìm nạp đối tượng, mảng liên kết và số một cách lười biếng
Tôi chắc rằng nó nghe có vẻ khó hiểu, nhưng tôi không thể nghĩ ra cách nào tốt hơn để mô tả nó. Nó thực sự khá gọn gàng, vì bạn đang tìm nạp một đối tượng PDORow về cơ bản là một con trỏ tới tập kết quả. Nó hoàn toàn không tìm nạp bất cứ thứ gì, cho đến khi bạn sử dụng một mảng hoặc chỉ mục đối tượng [lười biếng]. Phần tuyệt vời nhất của quá trình triển khai là một khi bạn "tìm nạp" nó, bạn có tùy chọn sử dụng nó như một đối tượng, mảng kết hợp hoặc mảng số theo cách tiết kiệm bộ nhớ nhất có thể. Cần lưu ý rằng nếu chỉ mục nằm ngoài giới hạn, nó sẽ trả về null thay vì đưa ra lỗi
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Thích
Bạn có thể trực giác cố gắng làm điều gì đó như sau
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Tuy nhiên, điều này sẽ không làm việc. Đây là cách bạn sẽ làm đúng cách
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Ở đâu trong mảng
Như bạn có thể thấy, PDO rõ ràng cũng vượt trội về điều này, vì mã ngắn hơn nhiều, do không cần chỉ định loại với
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Với các trình giữ chỗ khác
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Nhiều báo cáo đã chuẩn bị trong giao dịch
Nếu bạn muốn đảm bảo rằng nhiều lệnh gọi SQL đồng thời, thì bạn phải sử dụng các giao dịch. Điều này đảm bảo rằng tất cả các hoạt động của bạn hoặc không có hoạt động nào sẽ thành công. Chẳng hạn, điều này có thể hữu ích để chuyển một hàng sang một bảng khác. Bạn sẽ muốn sao chép hàng sang bảng mới và xóa hàng khác. Nếu một trong các hoạt động không thành công, thì nó cần phải hoàn nguyên về trạng thái trước đó
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Sử dụng lại cùng một mẫu, các giá trị khác nhau
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Xử lý lỗi
Để ngăn rò rỉ mật khẩu của bạn, đây là những gì php của bạn. ini sẽ giống như trong sản xuất. làm cả
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$stmt = $pdo->prepare["UPDATE myTable SET name = ? WHERE id = ?"];
$stmt->execute[[$_POST['name'], $_SESSION['id']]];
echo $stmt->rowCount[];
$stmt = null;
Nếu bạn đã bật lỗi và buộc chúng là ngoại lệ, giống như cách dễ nhất để xử lý lỗi của bạn là đặt chúng vào khối thử/bắt. Bây giờ bạn có quyền truy cập vào lớp PDOException
Người mới bắt đầu có thể cho rằng việc xử lý lỗi thích hợp đòi hỏi phải gói mỗi khối truy vấn trong một khối
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Tất cả các trang của bạn — ngay cả những trang không có PDO — nên được thiết lập như thế này, vì bạn thường chỉ cần đưa ra một thông báo cho toàn bộ trang php. Tuy nhiên, đôi khi bạn có thể cần nắm bắt các trường hợp cụ thể, vì vậy bạn có thể sử dụng bao nhiêu loại ngoại lệ cụ thể tùy thích, cùng với
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Một cách khác để xử lý các ngoại lệ là tạo một trình xử lý ngoại lệ do người dùng định nghĩa,. Bạn sẽ thêm phần sau vào mỗi trang sau khi bao gồm
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Tại sao phải kiểm tra tính trung thực?
Bạn có thể nhận thấy rằng tôi đang đưa ra một ngoại lệ để thực thi nếu nó quá nhanh, điều này có vẻ dư thừa, vì việc xử lý lỗi ở dạng ngoại lệ. Tuy nhiên, tôi nhận thấy một hành vi kỳ lạ, đó là
$stmt = $pdo->prepare["UPDATE myTable SET name = ? WHERE id = ?"];
$stmt->execute[[$_POST['name'], $_SESSION['id']]];
echo $stmt->rowCount[];
$stmt = null;
Tôi có cần $stmt = null không?
Điều này về cơ bản giống như sử dụng
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
Việc đóng các câu lệnh đã chuẩn bị sẽ hữu ích nếu bạn đang sử dụng lại cùng một tên biến. Cả hai đều không thực sự cần thiết, vì dù sao thì chúng cũng sẽ đóng khi kết thúc quá trình thực thi tập lệnh
Chế độ thi đua vs. Tuyên bố chuẩn bị bản địa
Khi sử dụng câu lệnh đã chuẩn bị, bạn có hai tùy chọn. bật hoặc tắt chế độ mô phỏng. Bài viết này đề cập nghiêm ngặt đến các câu lệnh chuẩn bị sẵn, vì tôi tin rằng bạn nên sử dụng các câu lệnh chuẩn bị thực sự nếu phiên bản trình điều khiển của bạn hỗ trợ nó. Chế độ mô phỏng có vẻ giống như một giải pháp dự phòng cho các trình điều khiển/phiên bản không hỗ trợ các câu lệnh chuẩn bị sẵn;
Khi chế độ mô phỏng được bật, về cơ bản nó giống như sử dụng
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
Mặc dù chúng ta đang nói về các mối đe dọa lý thuyết, nhưng các câu lệnh được chuẩn bị sẵn không mô phỏng sẽ loại bỏ hoàn toàn khả năng xảy ra một cuộc tấn công SQL injection. Truy vấn với trình giữ chỗ giả được gửi đến máy chủ trước, sau đó là các giá trị để liên kết — truy vấn và dữ liệu được cách ly hoàn toàn
Dưới đây là một số khác biệt chính giữa hai
Chế độ thi đua
- Có thể sử dụng lại các trình giữ chỗ có tên
- Cho phép hỗ trợ nhiều truy vấn
- Cần sử dụng
5 cho một số trường hợp cạnh nhất định, như với GIỚI HẠN$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"]; $stmt->execute[[$_SESSION['id']]]; $stmt = null; - Nhanh hơn cho một câu lệnh, nhưng không thể chạy chuẩn bị một lần, thực hiện nhiều lần
- Chi phí n chuyến khứ hồi máy khách-máy chủ cho mỗi câu lệnh
- Báo lỗi khi câu lệnh được thực thi
Tuyên bố chuẩn bị bản địa
- Có thể chạy chuẩn bị một lần, thực hiện nhiều lần để đạt hiệu quả
- Chi phí 1+n chuyến khứ hồi máy khách-máy chủ cho mỗi câu lệnh
- Chỉ có thể sử dụng mỗi trình giữ chỗ được đặt tên một lần
- Không thể chạy nhiều truy vấn [mặc dù bạn có thể sử dụng giao dịch]
- Về lý thuyết, an toàn hơn do truy vấn và giá trị bị cô lập
- Báo cáo lỗi khi tuyên bố được chuẩn bị
Đây là một ví dụ về cách bạn sẽ sử dụng GIỚI HẠN khi bật chế độ mô phỏng. Lý do nó xảy ra là vì MySQL cuối cùng đã hiểu nó là GIỚI HẠN '23'. Vì vậy, bạn có thể sử dụng các câu lệnh chuẩn bị sẵn hoặc sử dụng
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
bindValue[] so với. bindParam[]
Hướng dẫn này không thực sự đi quá nhiều, vì bạn không thực sự cần những thứ này, ngoại trừ trong các trường hợp cấp bách khi bạn cần thực thi kiểu dữ liệu. Tuy nhiên, bạn nên hiểu sự khác biệt, vì bạn không bao giờ biết khi nào bạn có thể gặp phải tình huống mà nó có thể hữu ích
Cả hai phương pháp đều được sử dụng để liên kết thủ công với câu lệnh đã chuẩn bị. Sự khác biệt là
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
set_exception_handler[function[$e] {
error_log[$e->getMessage[]];
exit['Something weird happened']; //something a user can understand
}];
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4";
$options = [
PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array
];
$pdo = new PDO[$dsn, "username", "password", $options];
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Với
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
$stmt = $pdo->prepare["DELETE FROM myTable WHERE id = ?"];
$stmt->execute[[$_SESSION['id']]];
$stmt = null;
Vì vậy, sử dụng báo cáo đã chuẩn bị có nghĩa là tôi an toàn trước những kẻ tấn công?
Mặc dù bạn an toàn trước SQL injection, nhưng bạn vẫn cần xác thực và làm sạch dữ liệu do người dùng nhập của mình. Bạn có thể sử dụng một chức năng như filter_var[] để xác thực trước khi chèn nó vào cơ sở dữ liệu và htmlspecialchars[] để khử trùng sau khi truy xuất nó
Làm cách nào để truy xuất dữ liệu từ cơ sở dữ liệu bằng PDO?
Làm theo các bước để lấy dữ liệu từ Cơ sở dữ liệu trong PHP PDO. .
Tạo nên cơ sở dữ liệu. Tạo cơ sở dữ liệu bằng XAMPP, cơ sở dữ liệu được đặt tên là “geeksforgeeks” tại đây. .
Tạo bảng. Tạo bảng có tên “fetch_record” gồm 2 cột để lưu trữ dữ liệu. .
Tạo cấu trúc bảng. Bảng “fetch_record” chứa 2 trường
Truy vấn PDO là gì?
PDO [Đối tượng dữ liệu PHP] là lớp trừu tượng cho các truy vấn cơ sở dữ liệu của bạn và là một giải pháp thay thế tuyệt vời cho MySQLi, vì nó hỗ trợ 12 . Đây là một lợi ích to lớn cho những người và công ty cần nó. Tuy nhiên, hãy nhớ rằng MySQL là cơ sở dữ liệu phổ biến nhất cho đến nay.
Chức năng nào của đối tượng PDO chạy truy vấn?
Mô tả ¶ PDO. query[] chuẩn bị và thực thi một câu lệnh SQL trong một lệnh gọi hàm duy nhất, trả về câu lệnh dưới dạng đối tượng PDOStatement.
Thực thi trong PDO là gì?
PDO. exec[] thực thi một câu lệnh SQL trong một lần gọi hàm duy nhất, trả về số hàng bị ảnh hưởng bởi câu lệnh . PDO. exec[] không trả về kết quả từ câu lệnh SELECT. Đối với câu lệnh CHỌN mà bạn chỉ cần đưa ra một lần trong chương trình của mình, hãy cân nhắc đưa ra PDO. truy vấn[].