หน้าแรก>ซอร์สโค้ด PHP>หมวดหมู่อื่นๆ
ดาวน์โหลด

PHP-DbHandler

สถานะการดำเนินการ CI GitHub

PHP-DbHandler เป็นไลบรารี PHP ที่ออกแบบมาเพื่อลดความซับซ้อนของการโต้ตอบกับฐานข้อมูล MySQL มีชุดเครื่องมือที่ครอบคลุมสำหรับการสร้างและดำเนินการสืบค้น การจัดการธุรกรรม และการจัดการสคีมาฐานข้อมูลผ่านการเชื่อมต่อ PDO

สารบัญ

  • คุณสมบัติ
  • การติดตั้ง
  • ตั้งค่า
  • การสร้าง Where และ Having clauses
    • ตัวดำเนินการเปรียบเทียบ
    • ตัวดำเนินการเชิงตรรกะ
    • or และ and ตัวดำเนินการ
  • การสร้างและการดำเนินการค้นหา
    • เลือก
    • แทรก
    • อัปเดต
    • ลบ
    • ขั้นตอนที่เก็บไว้
  • การทำธุรกรรม
    • การจัดการธุรกรรมทั่วโลก
  • มีส่วนร่วม
    • กระบวนการมีส่วนร่วม
    • การใช้คอนเทนเนอร์การพัฒนา
    • ทดสอบกับเพสท์
    • การส่งผลงาน
    • กระบวนการตรวจสอบ
    • คำถามและการสนทนา
  • ใบอนุญาต
  • สนับสนุน

คุณสมบัติ

  • การสร้างแบบสอบถาม : สร้างแบบสอบถาม SQL ได้อย่างง่ายดายโดยใช้ไวยากรณ์ที่คล่องแคล่วและใช้งานง่าย
  • การจัดการธุรกรรม : จัดการธุรกรรมฐานข้อมูลอย่างมีประสิทธิภาพด้วยการสนับสนุนแบบรวม
  • การจัดการสคีมา : จัดการสคีมาฐานข้อมูล รวมถึงตารางและขั้นตอนการจัดเก็บได้อย่างสะดวก
  • การรวมแคช : ใช้ประโยชน์จากแคชสำหรับผลลัพธ์การสืบค้นเพื่อเพิ่มประสิทธิภาพ
  • การบันทึกและการจัดการข้อผิดพลาด : การบันทึกแบบรวมและการจัดการข้อผิดพลาดเพื่อการดีบักและการตรวจสอบที่ดีขึ้น
  • การปฏิบัติตามมาตรฐาน PSR : ปฏิบัติตามมาตรฐาน PSR เพื่อให้มั่นใจว่าโค้ด PHP คุณภาพสูงและทำงานร่วมกันได้

การติดตั้ง

ติดตั้งแพ็คเกจผ่าน Composer: 

composer require tribal2/db-handler

ตั้งค่า

เริ่มต้นด้วยการสร้างอินสแตนซ์ Db : 

 use Tribal2  DbHandler  Core  PDOWrapper ;
use Tribal2  DbHandler  Db ;
use Tribal2  DbHandler  DbConfig ;

$ config = DbConfig:: create ( ' my_database ' )
  -> withUser ( ' username ' )
  -> withPassword ( ' password ' )
  -> withHost ( ' localhost ' )   // Optional. Default: 'localhost'
  -> withPort ( 3306 )          // Optional. Default: 3306
  -> withCharset ( ' utf8mb4 ' ); // Optional. Default: 'utf8mb4'

$ pdoWrapper = new PDOWrapper (
  $ config ,
  // Optional PsrLogLoggerInterface instance.
  // $logger, // Default: PsrLogNullLogger
);

$ db = new Db (
  $ pdoWrapper ,
  // Optional PsrSimpleCacheCacheInterface instance.
  // $cache,  // Default: NULL
);

การสร้าง Where และ Having clauses

คลาส Where มอบวิธีที่ยืดหยุ่นและใช้งานง่ายในการสร้างเงื่อนไขการสืบค้น รองรับการเปรียบเทียบและตัวดำเนินการเชิงตรรกะที่หลากหลาย ช่วยให้คุณสามารถกำหนดเกณฑ์ในการเลือกหรือกรองข้อมูลจากฐานข้อมูลของคุณได้อย่างแม่นยำ

วิธีการส่งคืนอ็อบเจ็กต์ Where ที่ห่อหุ้มเงื่อนไข พร้อมด้วยค่าที่กำหนดพารามิเตอร์เพื่อการสืบค้นที่ปลอดภัยและมีประสิทธิภาพ

ส่วนคำสั่ง Where ไม่เพียงแต่ทำให้การสร้างไวยากรณ์คิวรีง่ายขึ้น แต่ยังเพิ่มความปลอดภัยด้วยการจัดการความเสี่ยงภายในที่เกี่ยวข้องกับการแทรก SQL ไลบรารีนี้จะแทนที่ค่าด้วยพารามิเตอร์ที่มีชื่อ PDO โดยอัตโนมัติ และดำเนินการเชื่อมโยงโดยใช้ประเภทข้อมูล PDO ที่เหมาะสม ด้วยการจัดการประเด็นสำคัญเหล่านี้ ช่วยให้มั่นใจได้ว่าคำถามของคุณไม่เพียงแต่สะอาดและบำรุงรักษาได้ แต่ยังปลอดภัยอีกด้วย

คุณไม่จำเป็นต้องกังวลเกี่ยวกับการทำความสะอาดอินพุตของคุณสำหรับการสืบค้นฐานข้อมูลด้วยตนเองอีกต่อไป ไลบรารีจะดูแลการเตรียมคำสั่งในลักษณะที่ป้องกันการแทรก SQL ซึ่งเป็นหนึ่งในช่องโหว่ด้านความปลอดภัยที่พบบ่อยที่สุดในแอปพลิเคชันที่ขับเคลื่อนด้วยฐานข้อมูล แนวทางนี้ช่วยให้คุณมุ่งเน้นไปที่ตรรกะทางธุรกิจของแอปพลิเคชันของคุณ โดยวางใจว่าการโต้ตอบของฐานข้อมูลจะได้รับการจัดการอย่างปลอดภัยและมีประสิทธิภาพ

ตัวดำเนินการเปรียบเทียบ 

 $ where = Where:: equals ( ' status ' , ' active ' );
// Output: `status` = :status___1

$ where = Where:: notEquals ( ' category ' , ' archived ' );
// Output: `category` <> :category___1

$ where = Where:: greaterThan ( ' price ' , 100 );
// Output: `price` > :price___1

$ where = Where:: greaterThanOrEquals ( ' price ' , 100 );
// Output: `price` >= :price___1

$ where = Where:: lessThan ( ' price ' , 50 );
// Output: `price` < :price___1

$ where = Where:: lessThanOrEquals ( ' price ' , 50 );
// Output: `price` <= :price___1

$ where = Where:: isNull ( ' description ' );
// Output: `description` IS NULL

$ whereNotNull = Where:: isNotNull ( ' description ' );
// Output: Output: `description` IS NOT NULL

ตัวดำเนินการเชิงตรรกะ 

 $ where = Where:: like ( ' name ' , ' %Apple% ' );
// Output: `name` LIKE :name___1

$ where = Where:: notLike ( ' name ' , ' %Apple% ' );
// Output: `name` NOT LIKE :name___1

$ where = Where:: between ( ' date ' , ' 2021-01-01 ' , ' 2021-12-31 ' );
// Output: `date` BETWEEN :date___1 AND :date___2

$ where = Where:: notBetween ( ' date ' , ' 2021-01-01 ' , ' 2021-12-31 ' );
// Output: `date` NOT BETWEEN :date___1 AND :date___2

$ where = Where:: in ( ' status ' , [ ' active ' , ' pending ' , ' on-hold ' ]);
// Output: `status` IN (:status___1, :status___2, :status___3)

$ where = Where:: notIn ( ' status ' , [ ' active ' , ' pending ' , ' on-hold ' ]);
// Output: `status` NOT IN (:status___1, :status___2, :status___3)

or และ and ตัวดำเนินการ 

 $ where1 = Where:: equals ( ' status ' , ' active ' );
$ where2 = Where:: greaterThan ( ' price ' , 100 );
$ orWhere = Where:: or ( $ where1 , $ where2 );
// Output: (`status` = :status___1 OR `price` > :price___1)

$ andWhere = Where:: and ( $ where1 , $ where2 );
// Output: (`status` = :status___1 AND `price` > :price___1)

คุณยังสามารถซ้อน or และ and ตัวดำเนินการ: 

 $ where3 = Where:: equals ( ' category ' , ' archived ' );
$ combinedWhere = Where:: and ( $ where3 , $ orWhere );
// Output: (`category` = :category___1 AND (`status` = :status___1 OR `price` > :price___1))

การสร้างและการดำเนินการค้นหา

ในส่วนย่อยต่อไปนี้ เราจะสำรวจวิธีสร้างและดำเนินการสืบค้นโดยใช้ไลบรารีนี้ เพื่อความเรียบง่าย เราจะถือว่าตัวแปร $db เป็นอินสแตนซ์ของคลาส Db

ในตัวอย่างทั้งหมดด้านล่าง เราได้แยกการสร้างแบบสอบถามออกจากการดำเนินการ วิธีการนี้ช่วยให้คุณสามารถนำวัตถุแบบสอบถามกลับมาใช้ใหม่และดำเนินการได้หลายครั้งด้วยพารามิเตอร์ที่แตกต่างกัน แต่คุณยังสามารถเชื่อมโยงวิธีการสร้างและดำเนินการแบบสอบถามในคำสั่งเดียวดังนี้: 

 $ results = $ db
  -> select ()
  -> columns ([ ' column1 ' , ' column2 ' ])
  -> from ( ' table_name ' )
  -> where (Where:: equals ( ' column2 ' , 1 ))
  -> fethAll ();

เลือก 

 $ select = $ db -> select ()
  -> columns ([ ' column1 ' , ' column2 ' ])
  -> column ( ' column3 ' )
  -> from ( ' table_name ' )
  -> where (Where:: equals ( ' column2 ' , 1 ))  // See "Where Clauses" section above
  -> groupBy ( ' column1 ' )
  -> having (Where:: equals ( ' sum(column2) ' , 5 ))
  -> orderBy ( ' column3 ' , ' ASC ' )
  -> limit ( 10 )
  -> offset ( 5 );

$ sql = $ select -> getSql ();
// $sql:
// SELECT
//     `column1`,
//     `column2`,
//     `column3`
// FROM
//     `table_name`
// WHERE
//     `column2` = :column2___1
// GROUP BY
//     `column1`
// HAVING
//     `sum(column2)` = :sum_column2____1
// ORDER BY
//     `column3` ASC
// LIMIT
//     10
// OFFSET
//     5;

กำลังดึงผลลัพธ์:

ตามค่าเริ่มต้น เมธอด fetchAll() จะส่งคืนอาร์เรย์ของอ็อบเจ็กต์ (โดยใช้ PDO::FETCH_OBJ ตามค่าเริ่มต้น) โดยที่แต่ละอ็อบเจ็กต์แทนแถวของข้อมูล คุณยังสามารถดึงผลลัพธ์เป็นอาร์เรย์ของอาร์เรย์ที่เชื่อมโยงได้โดยส่งค่าคงที่ PDO::FETCH_ASSOC เป็นอาร์กิวเมนต์ไปยังเมธอดตัวสร้าง fetchMethod() ก่อนที่จะดำเนินการสืบค้น 

 $ allResults = $ select -> fetchAll ();
$ firstResult = $ select -> fetchFirst ();
$ column1Values = $ select -> fetchColumn ( ' column1 ' );
$ column3DistinctValues = $ select -> fetchDistincts ( ' column3 ' );

// Output: object(FetchResult) {
//     data => array(n) {
//         [0]...
//         [1]...
//         [n-1]...
//     },
//     count => int(n)
// }

คุณยังดึงจำนวนผลลัพธ์ได้ด้วย: 

 $ countResults = $ select -> fetchCount ();
// Output: 5

การแบ่งหน้า:

การจัดการชุดข้อมูลขนาดใหญ่อย่างมีประสิทธิภาพและการจัดเตรียมอินเทอร์เฟซที่ใช้งานง่ายสำหรับการนำทางข้อมูลถือเป็นสิ่งสำคัญสำหรับแอปพลิเคชันที่มีประสิทธิภาพ คุณลักษณะการแบ่งหน้าใน PHP-DbHandler ตอบสนองความต้องการเหล่านี้อย่างสวยงาม ช่วยให้กระบวนการแบ่งข้อมูลออกเป็นส่วนๆ ที่สามารถจัดการได้หรือ "เพจ" ง่ายขึ้น ทำให้ง่ายต่อการทำงานกับชุดข้อมูลขนาดใหญ่โดยไม่ทำให้ระบบหรือผู้ใช้ล้นหลาม

การตั้งค่าการแบ่งหน้า

มีสองวิธีในการตั้งค่าการแบ่งหน้าสำหรับการสืบค้นของคุณ:

  • การใช้วิธีแบ่งหน้า: วิธีการนี้ช่วยให้คุณสามารถกำหนดจำนวนรายการต่อหน้าในลักษณะที่กระชับ เป็นวิธีที่มีประสิทธิภาพในการเตรียมแบบสอบถามของคุณสำหรับการแบ่งหน้า 

     $ select = $ db -> select ()
  -> from ( ' table_name ' )
  // ...
  -> paginate (itemsPerPage: 10 );

  • การตั้งค่าขีดจำกัดและออฟเซ็ตด้วยตนเอง: เพื่อการควบคุมที่มากขึ้น คุณสามารถระบุขีดจำกัด (จำนวนรายการต่อหน้า) และออฟเซ็ต (จุดเริ่มต้นในชุดข้อมูล) สำหรับการสืบค้นด้วยตนเองได้ 

     $ select = $ db -> select ()
  -> from ( ' table_name ' )
  // ...
  -> limit ( 10 )
  -> offset ( 0 );

ดึงผลลัพธ์ด้วยการแบ่งหน้า

เมื่อตั้งค่าการแบ่งหน้าแล้ว คุณสามารถดึงผลลัพธ์ได้หลายวิธี โดยสำรวจชุดข้อมูลของคุณได้อย่างง่ายดาย:

  • fetchPage(?int $page) : ดึงข้อมูลหน้าปัจจุบันหรือหน้าเฉพาะ
  • fetchNextPage() : ดึงผลลัพธ์สำหรับหน้าถัดไป
  • fetchPreviousPage() : ดึงผลลัพธ์สำหรับหน้าก่อนหน้า
  • fetchFirstPage() : ดึงผลลัพธ์สำหรับหน้าแรก
  • fetchLastPage() : ดึงผลลัพธ์สำหรับหน้าสุดท้าย

แต่ละวิธีเหล่านี้ส่งคืนออบเจ็กต์ FetchPaginatedResult ซึ่งมีคุณสมบัติต่อไปนี้:

  • data : อาร์เรย์ของเรคคอร์ดในหน้าปัจจุบัน
  • count : จำนวนบันทึกทั้งหมดในชุดข้อมูล
  • page : หมายเลขหน้าปัจจุบัน
  • perPage : จำนวนบันทึกต่อหน้า
  • totalPages : จำนวนหน้าทั้งหมด 
 // Example output structure of FetchPaginatedResult
object (FetchPaginatedResult) {
    data => array (n) {
        [ 0 ]. . .
        [ 1 ]. . .
        [n- 1 ]. . .
    },
    count => int(n),
    page => int( 10 ),
    perPage => int( 10 ),
    totalPages => int( 23 )
}

ระบบแบ่งหน้าใน PHP-DbHandler นี้ช่วยให้แน่ใจว่าคุณสามารถจัดการและนำทางผ่านชุดข้อมูลขนาดใหญ่ได้อย่างมีประสิทธิภาพ ซึ่งช่วยเพิ่มประสิทธิภาพโดยรวมและประสบการณ์ผู้ใช้ของแอปพลิเคชันของคุณ

การแคช:

ในการใช้งานที่ขับเคลื่อนด้วยข้อมูลในปัจจุบัน ประสิทธิภาพและประสิทธิภาพเป็นสิ่งสำคัญ เพื่อปรับปรุงลักษณะเหล่านี้ในการโต้ตอบฐานข้อมูล ไลบรารีมีคุณลักษณะการแคชภายในแบบสอบถาม Select คุณลักษณะนี้เพิ่มประสิทธิภาพโดยการแคชผลลัพธ์การสืบค้น ซึ่งช่วยลดภาระของฐานข้อมูลและเพิ่มเวลาตอบสนองสำหรับการสืบค้นที่ดำเนินการบ่อยครั้ง ที่สำคัญได้รับการออกแบบให้สอดคล้องกับมาตรฐาน PSR-16 (Simple Cache) โดยสมบูรณ์ ทำให้มั่นใจได้ถึงความเข้ากันได้และความยืดหยุ่นในวงกว้าง

การแคชตามมาตรฐาน PSR-16

ฟังก์ชันแคชภายในแบบสอบถาม Select ยอมรับอินสแตนซ์แคชใด ๆ ที่ใช้ PsrSimpleCacheCacheInterface การปฏิบัติตามมาตรฐาน PSR-16 นี้หมายความว่าคุณสามารถรวมไลบรารีแคชที่หลากหลายที่ยึดติดกับอินเทอร์เฟซนี้ได้อย่างราบรื่น ทำให้คุณมีความยืดหยุ่นในการเลือกโซลูชันแคชที่เหมาะกับความต้องการของแอปพลิเคชันของคุณมากที่สุด

  1. การตั้งค่าแคช : หากระบุอินสแตนซ์ของ PsrSimpleCacheCacheInterface เมื่อเริ่มต้นคลาส Db คุณสามารถข้ามขั้นตอนนี้ได้ ฉันไม่มี คุณสามารถใช้วิธี setCache ได้: 
 $ select = $ db -> select ()-> setCache ( $ simpleCacheInstance );

หมายเหตุ:

  • หากคุณไม่ได้ระบุอินสแตนซ์แคชเมื่อเตรียมใช้งานคลาส Db คุณต้องตั้งค่าให้กับแต่ละแบบสอบถาม Select ที่คุณต้องการแคช
  • คุณยังสามารถใช้วิธีนี้ได้ถ้าคุณต้องการตั้งค่าอินสแตนซ์แคชเฉพาะสำหรับแบบสอบถาม Select ซึ่งจะทำให้คุณสามารถใช้โซลูชันการแคชที่แตกต่างกันสำหรับการสืบค้นที่แตกต่างกัน ขึ้นอยู่กับความต้องการของแอปพลิเคชันของคุณ
  1. การกำหนดค่าแคช : เปิดใช้งานและกำหนดค่าแคชสำหรับการสืบค้นของคุณโดยใช้วิธี withCache คุณสามารถระบุค่าเริ่มต้นที่ส่งคืนสำหรับรายการแคชที่หายไปและ TTL (Time To Live) สำหรับข้อมูลที่แคชไว้ 
 $ select -> withCache (defaultValue, ttl);

หมายเหตุ:

  • อาร์กิวเมนต์ defaultValue เป็นทางเลือก หากไม่ได้ระบุไว้ ไลบรารีจะส่งคืนค่า NULL สำหรับรายการแคชที่หายไป
  • อาร์กิวเมนต์ ttl เป็นทางเลือก หากไม่ได้ระบุไว้ ไลบรารีจะใช้ค่า TTL ที่กำหนดโดยอินสแตนซ์ PsrSimpleCache
  1. การจัดการแคชอัตโนมัติ : เมื่อดำเนินการค้นหาโดยเปิดใช้งานการแคช ไลบรารีจะตรวจสอบการมีอยู่ของผลลัพธ์ที่แคชไว้ก่อน หากมี ระบบจะดึงข้อมูลจากแคช โดยข้ามการสืบค้นฐานข้อมูล มิฉะนั้น จะดำเนินการแบบสอบถาม แคชผลลัพธ์ แล้วส่งคืน 
 $ allResults = $ select -> fetchAll ();
$ firstResult = $ select -> fetchFirst ();
$ column1Values = $ select -> fetchColumn ( ' column1 ' );
$ column3DistinctValues = $ select -> fetchDistincts ( ' column3 ' );

ประโยชน์ที่สำคัญ

  • ความยืดหยุ่น : เลือกจากการใช้งานแคชที่หลากหลายที่สอดคล้องกับ PSR-16
  • ประสิทธิภาพ : ลดความถี่ของการสืบค้นฐานข้อมูลโดยใช้ข้อมูลที่แคชไว้สำหรับการสืบค้นซ้ำ
  • ใช้งานง่าย : การใช้แคชนั้นตรงไปตรงมาและผสานรวมกับโครงสร้างการสืบค้นที่มีอยู่ได้อย่างราบรื่น
  • การสร้างคีย์แคชที่เชื่อถือได้ : ไลบรารีสร้างคีย์แคชที่ไม่ซ้ำกันสำหรับการสืบค้นแต่ละครั้ง เพื่อให้มั่นใจในความถูกต้องและความเกี่ยวข้องของข้อมูลที่แคชไว้

แทรก

คลาส Insert ในไลบรารี PHP-DbHandler ช่วยปรับปรุงกระบวนการสร้างและดำเนินการคำสั่งแทรกในฐานข้อมูล คลาสนี้มีคุณสมบัติและอินเทอร์เฟซที่หลากหลาย นำเสนอแนวทางที่ซับซ้อนในการจัดการการทำงานของเม็ดมีดด้วยคุณสมบัติขั้นสูงมากมาย

การสร้างแบบสอบถาม

  1. การกำหนดค่าแบบไดนามิก : คลาส Insert ช่วยให้คุณสามารถกำหนดค่าแบบไดนามิกให้กับคอลัมน์สำหรับการแทรกได้ คุณสามารถเพิ่มค่าเดียวหรือหลายค่าพร้อมกันได้: 
 $ insert = $ db -> insert ()
  -> into ( ' table_name ' )
  -> value ( ' column1 ' , ' value1 ' )
  -> values ([ ' column2 ' => ' value2 ' , ' column3 ' => ' value3 ' ]);

คลาสจะตรวจสอบว่ามีคอลัมน์อยู่ในตารางหรือไม่ก่อนที่จะเพิ่มค่า และจะดูแลการเชื่อมโยง PDO ที่จำเป็นด้วย

  1. การแทรกหลายแถว : แทรกหลายแถวพร้อมกันได้อย่างง่ายดายโดยระบุอาร์เรย์ของค่า: 
 $ rows = [
  [ ' column1 ' => ' value1 ' , ' column2 ' => ' value2 ' ],
  [ ' column1 ' => ' value3 ' , ' column2 ' => ' value4 ' ],
  // ...
];
$ insert -> rows ( $ rows );

การดำเนินการ 

 $ success = $ insert -> execute ();

เช็ค

ก่อนที่จะดำเนินการแทรก คลาสจะตรวจสอบโดยอัตโนมัติ:

  • หากฐานข้อมูลอยู่ใน โหมดอ่านอย่างเดียว ป้องกันการดำเนินการเขียนโดยไม่ได้ตั้งใจ
  • หากมี ความขัดแย้งในคีย์หลักที่ไม่เพิ่มค่าอัตโนมัติ จะทำให้มั่นใจในความสมบูรณ์ของข้อมูล

คลาส Insert เป็นโซลูชันที่ครอบคลุมทั้งหมดสำหรับการจัดการการดำเนินการแทรกในฐานข้อมูล โดยนำเสนอทั้งความสะดวกในการใช้งานและคุณลักษณะขั้นสูงเพื่อจัดการงานแทรกที่ซับซ้อนได้อย่างมีประสิทธิภาพ

อัปเดต

คลาส Update ในไลบรารี PHP-DbHandler มอบวิธีที่ซับซ้อนและยืดหยุ่นในการสร้างและดำเนินการสืบค้นการอัพเดทในฐานข้อมูล ได้รับการออกแบบมาเพื่อผสานรวมกับโครงสร้างฐานข้อมูลที่มีอยู่ได้อย่างราบรื่น ในขณะเดียวกันก็นำเสนอฟีเจอร์ที่แข็งแกร่งเพื่อจัดการการดำเนินการอัพเดตอย่างมีประสิทธิภาพ

การสร้างแบบสอบถาม

  1. การตั้งค่าการอัปเดต : ระบุคอลัมน์ที่จะอัปเดตและค่าใหม่ได้อย่างง่ายดาย คลาสช่วยให้แน่ใจว่าเฉพาะคอลัมน์ที่มีอยู่เท่านั้นที่ได้รับการอัปเดต ป้องกันข้อผิดพลาดและรักษาความสมบูรณ์ของข้อมูล 
 $ update = $ db -> update ()
  -> table ( ' table_name ' )
  -> set ( ' column1 ' , ' newValue1 ' )
  -> set ( ' column2 ' , ' newValue2 ' );
    ```

2. **Conditional Updates**: Incorporate conditions into your update queries using the `where` method. This allows for precise targeting of records to be updated.

``` php
$ update -> where (Where:: equals ( ' column3 ' , ' conditionValue ' ));

การดำเนินการ 

 $ success = $ update -> execute ();

การตรวจสอบโหมดอ่านอย่างเดียว : ก่อนดำเนินการ คลาสจะตรวจสอบว่าฐานข้อมูลอยู่ในโหมดอ่านอย่างเดียวหรือไม่ จึงป้องกันการดำเนินการเขียนโดยไม่ได้ตั้งใจ

คลาส Update แสดงถึงโซลูชันที่ครอบคลุมสำหรับการสร้างและการดำเนินการอัปเดตในฐานข้อมูล การผสมผสานระหว่างความยืดหยุ่น ความทนทาน และความง่ายในการใช้งานทำให้เป็นตัวเลือกที่เหมาะสำหรับการจัดการการอัปเดตฐานข้อมูลในแอปพลิเคชัน PHP

ลบ

คลาส Delete ในไลบรารี PHP-DbHandler นำเสนอแนวทางที่ซับซ้อนในการสร้างและดำเนินการคำสั่งลบในฐานข้อมูล คลาสนี้ช่วยให้แน่ใจว่าการดำเนินการลบจะดำเนินการด้วยความแม่นยำและปลอดภัย โดยผสานรวมการตรวจสอบและคุณสมบัติที่จำเป็นเพื่อการจัดการแบบสอบถามที่เหมาะสมที่สุด

การสร้างแบบสอบถาม

คลาสช่วยให้สามารถลบการกำหนดเป้าหมายบันทึกได้อย่างแม่นยำโดยใช้นิพจน์แบบมีเงื่อนไข ซึ่งสามารถทำได้โดยใช้เมธอด where ซึ่งช่วยให้สามารถเลือกแถวที่ต้องการเพื่อลบตามเกณฑ์ที่กำหนด 

 $ delete = $ db -> delete ()
  -> from ( ' table_name ' )
  -> where (Where:: equals ( ' column ' , ' value ' ));

Mandatory Where Clause : เพื่อหลีกเลี่ยงการลบบันทึกทั้งหมดในตารางโดยไม่ตั้งใจ คลาสจึงจำเป็นต้องระบุ WHERE clause สิ่งนี้ทำหน้าที่เป็นการป้องกันการลบจำนวนมากโดยไม่ได้ตั้งใจ

การดำเนินการ 

 $ success = $ delete -> execute ();

คลาสดำเนินการตรวจสอบที่จำเป็นก่อนดำเนินการลบ รวมถึงการตรวจสอบการมีอยู่ของตาราง และการทำให้แน่ใจว่าฐานข้อมูลไม่อยู่ในโหมดอ่านอย่างเดียว

คลาส Delete ได้รับการออกแบบมาเพื่อจัดการการดำเนินการลบด้วยการควบคุมและความปลอดภัยในระดับสูง ช่วยให้มั่นใจได้ว่าการลบจะดำเนินการอย่างถูกต้อง โดยคำนึงถึงโครงสร้างและข้อจำกัดของฐานข้อมูล ไม่ว่าคุณจะดำเนินการลบแบบง่ายหรือซับซ้อน คลาสนี้ก็มีเครื่องมือที่จำเป็นในการดำเนินการได้อย่างน่าเชื่อถือและปลอดภัย

ขั้นตอนที่เก็บไว้

คลาส StoredProcedure ในไลบรารี PHP-DbHandler นำเสนอแนวทางที่มีประสิทธิภาพและมีประสิทธิภาพในการดำเนินการกระบวนงานที่เก็บไว้ในฐานข้อมูล คลาสนี้มีวิธีที่มีประสิทธิภาพในการโต้ตอบกับขั้นตอนการจัดเก็บ การจัดการพารามิเตอร์ การดำเนินการ และการดึงผลลัพธ์ได้อย่างง่ายดาย

การสร้างแบบสอบถาม

การตั้งค่าการเรียกขั้นตอนที่เก็บไว้ : ตั้งค่าการเรียกขั้นตอนที่เก็บไว้ได้อย่างง่ายดายด้วยการจัดการพารามิเตอร์แบบไดนามิก ระบุชื่อขั้นตอนและพารามิเตอร์ที่ต้องการ 

 $ procedure = $ db -> storedProcedure ()
  -> call ( ' procedure_name ' )
  -> with ( ' paramName ' , $ value )
  // ...
  -> with ( ' paramName2 ' , $ value );

การดำเนินการ 

 $ results = $ procedure -> execute ();

การตรวจสอบโหมดอ่านอย่างเดียว : ก่อนที่จะดำเนินการ คลาสจะตรวจสอบว่าฐานข้อมูลอยู่ในโหมดอ่านอย่างเดียวหรือไม่ เพื่อให้มั่นใจว่าการดำเนินการเขียนไม่ได้เกิดขึ้นโดยไม่ได้ตั้งใจ

คลาส StoredProcedure เป็นเครื่องมือที่จำเป็นสำหรับการจัดการการเรียกโพรซีเจอร์ที่เก็บไว้ภายในแอปพลิเคชัน PHP ช่วยให้การโต้ตอบกับขั้นตอนการจัดเก็บง่ายขึ้น ทำให้กระบวนการใช้งานง่ายขึ้นและเกิดข้อผิดพลาดน้อยลง โดยเฉพาะในแอปพลิเคชันที่ต้องอาศัยการดำเนินการฐานข้อมูลที่ซับซ้อนอย่างมาก

การทำธุรกรรม

การจัดการธุรกรรมฐานข้อมูลเป็นส่วนสำคัญในการรับรองความสมบูรณ์ของข้อมูล โดยเฉพาะอย่างยิ่งในแอปพลิเคชันที่เกี่ยวข้องกับการจัดการข้อมูลที่ซับซ้อน PHP-DbHandler ทำให้กระบวนการนี้ง่ายขึ้น โดยเสนอวิธีที่ใช้งานง่ายและตรงไปตรงมาในการจัดการธุรกรรม

ด้วยความสามารถในการจัดการธุรกรรมที่มีให้ คุณสามารถเริ่มต้น ยอมรับ หรือย้อนกลับธุรกรรมได้อย่างง่ายดาย ทำให้คุณควบคุมการดำเนินงานฐานข้อมูลของคุณได้อย่างสมบูรณ์ สิ่งนี้ทำให้แน่ใจได้ว่าชุดของการดำเนินการฐานข้อมูลสามารถถือเป็นหน่วยอะตอมมิกเดียว ไม่ว่าจะเสร็จสมบูรณ์ทั้งหมดหรือไม่ทำงานเลย ดังนั้นจึงรักษาความสอดคล้องและความน่าเชื่อถือของข้อมูลของคุณ 

 $ db -> transaction -> begin ();
$ db -> transaction -> commit ();
$ db -> transaction -> rollback ();

คุณลักษณะนี้มีประโยชน์อย่างยิ่งในสถานการณ์ที่จำเป็นต้องมีการดำเนินการฐานข้อมูลที่เกี่ยวข้องหลายรายการพร้อมกัน หากการดำเนินการใดๆ ภายในธุรกรรมล้มเหลว สามารถใช้วิธีการย้อนกลับเพื่อคืนค่าการเปลี่ยนแปลงทั้งหมดที่ทำตั้งแต่เริ่มต้นธุรกรรม ดังนั้นจึงป้องกันการอัปเดตบางส่วนที่อาจนำไปสู่ความไม่สอดคล้องกันของข้อมูล ในทางกลับกัน หากการดำเนินการทั้งหมดสำเร็จ วิธีการส่งข้อมูลจะบันทึกการเปลี่ยนแปลงทั้งหมดลงในฐานข้อมูล

ด้วยการใช้การควบคุมธุรกรรมเหล่านี้ PHP-DbHandler ช่วยให้มั่นใจได้ว่าการจัดการข้อมูลแอปพลิเคชันของคุณมีประสิทธิภาพ สม่ำเสมอ และทนทานต่อข้อผิดพลาด ไม่ว่าคุณจะจัดการกับการป้อนข้อมูลที่ซับซ้อน การอัปเดต หรือกระบวนการเป็นชุด ความสามารถของธุรกรรมเหล่านี้จะมีเครื่องมือที่จำเป็นในการจัดการการดำเนินงานฐานข้อมูลของคุณอย่างมีประสิทธิภาพ

การจัดการธุรกรรมทั่วโลก

คลาส Transaction ยังแนะนำคุณลักษณะที่มีประสิทธิภาพสำหรับการจัดการสถานการณ์ธุรกรรมที่ซับซ้อน คุณลักษณะนี้ช่วยให้คุณสามารถควบคุมการทำธุรกรรมได้ทั่วโลก ซึ่งมีประโยชน์อย่างยิ่งเมื่อคุณต้องการรวมวิธีการต่างๆ ที่ใช้ธุรกรรมภายใต้บริบทของธุรกรรมที่ครอบคลุมเพียงรายการเดียว

การจัดการธุรกรรมทั่วโลก

คุณสามารถจัดการการดำเนินการธุรกรรมหลายรายการโดยเป็นส่วนหนึ่งของธุรกรรมที่มีขนาดใหญ่กว่าได้โดยการปิดใช้งานการคอมมิตอัตโนมัติ สิ่งนี้มีประโยชน์อย่างยิ่งในสถานการณ์ที่จำเป็นต้องดำเนินการหลายรายการ ซึ่งแต่ละรายการสามารถจัดการธุรกรรมได้อย่างอิสระ โดยเป็นส่วนหนึ่งของธุรกรรมอะตอมมิกเดียว 

 // Begin a transaction
$ db -> transaction -> begin ();

// Disable automatic commits
$ db -> transaction -> setCommitsModeOff ();

// Execute other methods that use transactions
// $db->transaction->begin();
// ...
// $db->transaction->commit();

// Re-enable automatic commits
$ db -> transaction -> setCommitsModeOn ();

// Commit the transaction
$ db -> transaction -> commit ();

คุณสมบัตินี้ช่วยเพิ่มการควบคุมการดำเนินการทางธุรกรรม ทำให้มีสถานการณ์การจัดการข้อมูลที่ซับซ้อนและเชื่อถือได้มากขึ้น ช่วยให้มั่นใจได้ว่าการเปลี่ยนแปลงทั้งหมดที่เกิดขึ้นภายในขอบเขตของธุรกรรมทั่วโลกจะกระทำร่วมกันหรือย้อนกลับ เพื่อรักษาความสมบูรณ์และความสม่ำเสมอของข้อมูล

มีส่วนร่วม

เราให้ความสำคัญและยินดีเป็นอย่างยิ่งที่มีส่วนร่วมในโครงการนี้! หากคุณสนใจที่จะมีส่วนร่วม โปรดอ่านไฟล์ CONTRIBUTING.md ของเราเพื่อดูข้อมูลโดยละเอียดเกี่ยวกับวิธีการเริ่มต้น หลักเกณฑ์ในการส่งการมีส่วนร่วม และเคล็ดลับในการทำให้กระบวนการง่ายและมีประสิทธิภาพมากที่สุดเท่าที่จะเป็นไปได้

ไม่ว่าคุณจะแก้ไขข้อบกพร่อง เพิ่มฟีเจอร์ หรือปรับปรุงเอกสาร การมีส่วนร่วมของคุณได้รับการชื่นชมอย่างมากและสร้างผลกระทบที่สำคัญต่อโครงการ

คำถามและการสนทนา

หากคุณมีคำถามหรือต้องการหารือเกี่ยวกับแนวคิดก่อนการเขียนโค้ด โปรดอย่าลังเลที่จะเปิดประเด็นในหน้าปัญหา GitHub ของเราเพื่อการสนทนา

เราขอขอบคุณที่คุณเต็มใจที่จะมีส่วนร่วมและหวังว่าจะส่งผลงานของคุณ!

ใบอนุญาต

ห้องสมุดนี้ได้รับอนุญาตภายใต้ใบอนุญาต MIT ดูไฟล์ใบอนุญาตสำหรับรายละเอียดเพิ่มเติม

สนับสนุน

สำหรับการสนับสนุน โปรดไปที่หน้าปัญหาบนที่เก็บ GitHub: ปัญหา GitHub

ขยาย
ข้อมูลเพิ่มเติม
แอปที่เกี่ยวข้อง
แนะนำสำหรับคุณ
ข้อมูลที่เกี่ยวข้อง ทั้งหมด