การใช้งาน Query Builder ใน CodeIgniter 4

บทความใหม่ ปีนี้ โดย Ninenik Narkdee
codeigniter query builder codeigniter 4

คำสั่ง การ กำหนด รูปแบบ ตัวอย่าง เทคนิค ลูกเล่น การประยุกต์ การใช้งาน เกี่ยวกับ codeigniter query builder codeigniter 4



ในสองบทความก่อนหน้า เราได้รู้จักวิธีการคิวรี่
ข้อมูลด้วยคำสั่ง SQL แบบกำหนดเอง รวมถึงการนำ
ข้อมูลผลลัพธ์ได้ไปใช้งาน ทบทวนเนื้หาได้ที่บทความ
    การใช้งาน Query Result และข้อมูล Query ใน CodeIgniter 4 http://niik.in/1002 
 
เนื้อหาในบทความนี้ เราจะมาดูเกี่ยวกับการใช้งาน Query Builder ใน CI4
ว่าเราจะสามารถนำมาใช้งานได้อย่างไร และทำให้การทำงานหรือจัดการกับ
ฐานข้อมูลสะดวกขึ้นจริงหรือไม่ติตามกันในบทความ
 
 

รู้จักับ Query Builder คืออะไร

    Query Builder คือรูปแบบชุดคำสั่งที่ CI กำหนดหรือสร้างขึ้นมาให้จากการเรียกใช้งาน
Query Builder class    โดยเป็นรูปแบบชุดคำสั่งในการอ่านข้อมูล เพิ่ม ลบ แก้ไขข้อมูลด้วย
คำสั่งสั้นๆ กระชับ ได้ในไม่กี่บรรทัด
    นอกจากการใช้งานที่ง่ายแล้ว ยังมีคุณสมบัติรองรับการ database platform ต่างๆ โดยมีตัวช่วย
จัดการ ทำให้เราไม่จำเป็นต้องปรับรูปแบบคำสั่ง SQL เหมือนกับการกำหนดเอง  นอกจากนั้นยังช่วย
ในเรื่องของการคิวรี่ข้อมูลที่ปลอดภัยเพิ่มขึ้น ด้วยการ escape ข้อมูลที่รับเข้ามา เพื่อป้องกัน SQL
Injection ให้โดยอัตโนมัติ
 
 

    การเรียกใช้งาน Query Builder

    เนิ้อหานี้เราจะสาธิตและแสดงตัวอย่างการใช้งานใน Controller อย่างไรก็ตามเราสามารถใช้งานใน Model หรือ
ส่วนอื่นๆ ได้ตามต้องการ เราจะใช้ตารางฐานข้อมูล จังหวัดในประเทศไทน มาประกอบ ดูโครงสร้างตารางได้ที่
ลิ้งค์ตามนี้  http://niik.in/que_2398_6277
    การใช้งาน Query Builder เราจะเรียกใช้งานผ่านคำสั่ง table() ดูตัวอย่างการใช้งาน
 
<?php namespace App\Controllers; 

use CodeIgniter\Controller; // เรียกใช้งาน Controller class

class Helloworld extends Controller 
{
    public function index() 
    {	
			$db = db_connect(); 
			$builder = $db->table('tbl_provinces');		
    }
}
 
    การใช้คำสั่ง table('tbl_provinces') จะเป็นการกำหนดในส่วนของ FROM ในคำสั่ง SQL ให้กับตารางที่เรากำหนด
เป็นค่า parameter ตอนนี้เราพร้อมเรียกใช้งาน Builder แล้ว (ขอใช้คำนี้เพื่อจะได้อธิบายง่าย)
 
 

    การ SELECT หรือการอ่านข้อมูล

    รูปแบบคำสั่งที่จะอธิบายในส่วนนี้ จะเป็นส่วนของคำสั่ง SELECT ใน SQL ที่ใช้งานผ่าน Builder
 
 
    คำสั่ง $builder->get()
    เมื่อเรากำหนดตารางในขั้นตอนการเรียกใช้งาน Builder แล้ว คำสังนี้ ก็เหมือนเป็นการใช้งาน SELECT ข้อมูลทั้งหมด
ของตารางนั้นมา โดยคืนค่าเป็น Query Result ตามบทความที่แล้ว รูปแบบการใช้งานจะเป็นดังนี้
 
$builder = $db->table('tbl_provinces');		
$query   = $builder->get();  // SELECT * FROM `tbl_provinces`
// $query   = $builder->get(5);  // SELECT * FROM `tbl_provinces` LIMIT 5
// $query = $builder->get(10, 20); // SELECT * FROM `tbl_provinces` LIMIT 20, 10

// ดูเกี่ยวกับการใช้งาน Query Result หรือผลลัพธ์ได้ที่  http://niik.in/1002
$result = $query->getResultArray();
 
 
    คำสั่ง $builder->getCompiledSelect()
    ใช้สำหรับแสดงคำสัง SQL เป็นข้อความ โดยไม่มีการคิวรี่ข้อมูล เหมือนคำสั่ง $builder->get() ดังนั้นจึงไม่เกิด
Query Result ขึ้น 
 
$builder = $db->table('tbl_provinces');		
$sql = $builder->getCompiledSelect();
echo $sql;	  // SELECT * FROM `tbl_provinces`
 
    ปกติ ถ้าเราใช้คำสั้งนี้แล้ว ตัวรูปแบบคำสั่ง SQL ที่ถูกสร้างขึ้น จะรีเซ็ตค่าอัตโนมัติ นั่นคือจะไม่สามารถกำหนดคำสั่งอื่น
เพื่อเชื่อมกับคำสั่งก่อนหน้าได้ เว้นเสียแต่เรากำหนด parameter เป็น false เข้าไป ดูตัวอย่าง
 
$builder = $db->table('tbl_provinces');		
$sql = $builder->limit(10,20)->getCompiledSelect(false);
echo $sql;	 // SELECT * FROM `tbl_provinces` LIMIT 20, 10
 
    ส่วนของการกำหนด LIMIT และคำสั่ง SQL จะยังไม่ถูกรีเซ็ต เราสามารถเรียกคำสั่งอื่นๆ ต่อและมีผลให้รูปแบบคำสัง SQL
ปรับค่าตามด้วย เช่น
 
$builder = $db->table('tbl_provinces');		
$builder->limit(10,20)->getCompiledSelect(false);
$sql = $builder->select('province_id, province_name')->getCompiledSelect();
echo $sql; // SELECT `province_id`, `province_name` FROM `tbl_provinces` LIMIT 20, 10
 
    สังเกตว่าส่วนของคำสั่ง select() ที่เพิ่มเข้ามา จะไปเพิ่มในคำสั่ง SQL เดิมได้ เพราะค่าไม่ได้ถูกรีเซ็ตโดยมีการเติมค่า false
เข้าไป แต่ในการเรียกใช้ครั้งที่สอง ไม่ได้เติมค่าเข้าไป นั่นคือ คำสั่งที่เพิ่มหลังจากนี้ จะไม่มีผลกับคำสั่ง SQL เดิมแล้ว เพราะ
ค่าถูกรีเซ็ต
 
 
    คำสั่ง $builder->getWhere()
    เป็นรูปแบบคล้ายกับคำสั่ง get() แต่มีการเพิ่มเงื่อนไขสำหรับแสดงข้อมูลด้วย WHERE เข้าไปแทนการแสดงข้อมูลทั้งหมด
 
$query = $builder->getWhere(['province_id' => 1]); 
// SELECT * FROM `tbl_provinces` WHERE `province_id` = 1
//$query = $builder->getWhere(['province_id < ' => 5], 2); 
// SELECT * FROM `tbl_provinces` WHERE `province_id` < 5 LIMIT 2
// $query = $builder->getWhere(['province_id < ' => 5], 2,1); 
// SELECT * FROM `tbl_provinces` WHERE `province_id` < 5 LIMIT 1, 2	
 
    parameter แรกกำหนด array ของฟิลด์เงื่อนไข และค่าที่ตรวจสอบ เกี่ยวกับรูปแบบการกำหนดนี้ จะอธิบายเพิ่มเติม
เกี่ยวกับการใช้คำสั่ง where() อีกที 
    parameter ตัวที่ 2 และ 3 เป็นค่า limit  และ offset ตามลำดับ *offset ก็คือการเริ่มแถวข้อมุลแถ้วที่เท่าไหร่ค่าเริ่มจาก 0
 
 
    คำสั่ง $builder->select()
    ใช้กำหนดคำสั่ง SQL ในส่วนของ SELECT ฟิลด์
 
$builder->select('province_id, province_name as name');
$query   = $builder->get();  
// SELECT `province_id`, `province_name` as `name` FROM `tbl_provinces`
 
    อย่าลืมว่าใน PHP ข้อมูลที่เป็น String เราสามารถขึ้นบรรทัดใหม่ได้ กรณีต้องเลือกหลายไฟล์ ก็อาจจะใช้เป็นแบบนี้
 
$builder->select('
	province_id, 
	province_name as name'
);
 
    คำสั่ง select() เราจะใช้กรณีที่ไม่ได้แสดงรายการทั้งหมดหรือไม่ใช่ (*) ซึ่งหากแสดงทั้งหมด เราใช้แค่ get() พอ
ซึ่งมีความหมายเท่ากับ SELECT *
    ในการใช้งานคำสั่ง select() เรายังสามารถกำหนด parameter ที่สองสำหรับกรณี ไม่ต้องการให้ CI จัดการหรือป้องกัน
ฟิลด์ที่เลือก เพื่อที่เราจะได้ใช้รูปแบบคำสั่งพิเศษในคำสั่ง select() ได้ เช่น การทำ subquery ตัวอย่าง
 
$builder = $db->table('tbl_provinces');		
$builder->select('
	(SELECT province_name FROM tbl_provinces 
	WHERE province_name LIKE "%บุรี" LIMIT 1) as myprovince
', false);
$query   = $builder->get();  
// SELECT 
//		(SELECT province_name FROM tbl_provinces 
// 		WHERE province_name LIKE "%บุรี" LIMIT 1) as myprovince 
// FROM `tbl_provinces`
 
 
    คำสั่ง $builder->selectMax()
    คำสั่ง $builder->selectMin()
    คำสั่ง $builder->selectAvg()
    คำสั่ง $builder->selectSum()
    คำสั่ง $builder->selectCount()
    สำหรับ 5 คำสั่งข้างต้นมีรูปแบบการใช้งานเหมือนกัน เป็นการหาค่าสูงสุด ต่ำสุด ค่าเฉลี่ย ค่าผลรวม และการนับจำนวน
ตามลำดับ parameter แรกเป้นชื่อฟิลด์ที่ต้องการใช้งาน และ parameter ที่สองเป็น option กำหนดหรือไม่ก็ได้ ใช้กำหนด
ชื่อเรียก คล้ายคำสั่ง as xxx ใน SQL ดูตัวอย่างการใช้งาน
 
$builder = $db->table('tbl_provinces');		
$builder->selectMax('province_id');
// SELECT MAX(`province_id`) AS `province_id` FROM `tbl_provinces`
$builder->selectMax('province_id','maxID');
// SELECT MAX(`province_id`) AS `maxID` FROM `tbl_provinces`
 
    สำหรับคำสั่ง selectCount() ปกติจะใช้ร่วมกับคำสั่ง groupBy() ตัวอย่าง นับแต่ละภาคมีกี่จังหวัด
 
$builder->selectCount('province_id','region');
$builder->groupBy('geo_id');
// SELECT COUNT(`province_id`) AS `region` FROM `tbl_provinces` GROUP BY `geo_id`
 
 
    คำสั่ง $builder->from()
    เป็นการกำหนดคำสั่ง SQL ในส่วนของ FROM ซึ่งปกติ ถ้าเราเรียกใช้งานแค่ตารางเดียว ค่าส่วนนี้จะอยู่ในตอนสร้าง Builder
จากคำสั่ง table() เราไม่ต้องใช้คำสั่ง from() ซ้ำอีก  อย่างไรก็ตามคำสั่งนี้ ก็มีไว้เผื่อกรณีที่เราต้องการใช้งานหลายๆ ตาราง
พร้อมกัน หรือต้องการใช้งานตารางเดียว แต่เรียกใช้งานซ้ำโดยแยกผ่านการกำหนด alias หรือชื่อเรียกแทน ตัวอย่างเช่น
 
$builder = $db->table('tbl_provinces a');		
$builder->select('a.province_id,b.province_name');
$builder->from('tbl_provinces b');
// SELECT `a`.`province_id`, `b`.`province_name` FROM `tbl_provinces` `a`, `tbl_provinces` `b`
 
    เราเรียกใช้งานตาราง tbl_provinces ผ่านชื่อเรียกแทนเป็น a และ b ตามลำดับ
    ถ้ากำหนดหลายๆ ตารางก็ใช้ในลักษณะได้
 
$builder = $db->table('tbl_provinces a');		
$builder->select('a.province_id,b.province_name');
$builder->from('tbl_provinces b');
$builder->from('tbl_provinces c');
 
 
    คำสั่ง $builder->join()
    การกำหนดด้วยคำสั่ง from() แล้วกำหนดตารางหลายๆ ตาราง จะเป็นลักษณะของการเชื่อมตารางในรูปแบบ INNER JOIN
ดังนั้น เพื่อให้แยกการเชื่อมตาราง และสามารถกำหนดรูปแบบการเชื่อมตารางแบบอื่นๆ ไม่วาจะเป็น  left, right, outer, inner, 
left outer, และ right outer เราสามารถใช้คำสั่ง join() แทนได้ ตัวอย่าง
 
$builder = $db->table('tbl_provinces a');		
$builder->select('a.province_id,b.province_name');
$builder->join('tbl_provinces b','a.province_id=b.province_id','inner');
// SELECT `a`.`province_id`, `b`.`province_name` 
// FROM `tbl_provinces` `a` 
// INNER JOIN `tbl_provinces` `b` 
// ON `a`.`province_id`=`b`.`province_id`
 
    ตัวอย่างใช้ LEFT JOIN ก็จะเป็น
 
$builder = $db->table('tbl_provinces a');		
$builder->select('a.province_id,b.province_name');
$builder->join('tbl_provinces b','a.province_id=b.province_id','left');
$builder->join('tbl_provinces c','a.province_id=c.province_id','left');
// SELECT `a`.`province_id`, `b`.`province_name` 
// FROM `tbl_provinces` `a` 
// LEFT JOIN `tbl_provinces` `b` ON `a`.`province_id`=`b`.`province_id` 
// LEFT JOIN `tbl_provinces` `c` ON `a`.`province_id`=`c`.`province_id`
 
 
 

    การ SELECT ข้อมูลแบบมีเงื่อนไข

    เป็นรูปแบบหนึ่งของการกรองข้อมูล โดยมักจะใช้กับเงื่อนไข WHERE 
 
    
    คำสั่ง $builder->where()
    เป็นส่วนของการกำหนด WHERE ในคำสัง SQL เพื่อระบุความจำเพราะเจาะจงของข้อมูล 
สามารถกำหนดได้รูปแบบดังต่อไปนี้
 
    1. แบบ parameter เป็น key/value
โดย key คือฟิลด์ที่ต้องการกำหนดเงื่อนไข และ value คือค่าที่ตรวจสอบ
การเปรียบเทียบจะเสมือนแทนด้วยเครื่องหมาย = 
 
$builder->where('name', $name);
$builder->where('title', $title);
$builder->where('status', $status);
// WHERE name = 'Joe' AND title = 'boss' AND status = 'active'
 
    การเรียกใช้งานหลายบรรทัดจะหมายถึงการเชื่อมข้อมูลแบบ AND ในเงื่อนไขที่กำหนด
 
    2. แบบ parameter กำหนดเอง เป็น key/value คล้ายแบบแรก
แต่เรากำหนด เครื่องหมายหรือตัวดำเนินการเอง โดยไม่จำเป็นต้องเป็นเครื่องหมาย = ก็ได้ 
จะกำหนดไว้ต่อจากค่า key หรือ parameter แรก
 
$builder->where('name !=', $name);
$builder->where('id <', $id); // Produces: WHERE name != 'Joe' AND id < 45
 
    3. แบบ array  การใช้งานเหมือนกับแบบที่ 1 และ 2 เพียงแต่กำหนดเป็น array แทน
และสามารถใช้แบบเครื่อง หมาย = อย่างเดียว หรือแบบกำหนดเอง ในค่า key ก็ได้
 
$array = ['name' => $name, 'title' => $title, 'status' => $status];
$builder->where($array);
// WHERE name = 'Joe' AND title = 'boss' AND status = 'active'
 
    แบบกำหนดเครื่องหมายที่ใช้ดำเนินการเอง
 
$array = ['name !=' => $name, 'id <' => $id, 'date >' => $date];
$builder->where($array);
 
    4. แบบ String กำหนดรูปแบบคำสั่งตามต้องการ
$where = "name='Joe' AND status='boss' OR status='active'";
$builder->where($where);
 
    สามารถกำหนด parameter  ตัว 3 ในคำสั่ง $builder->where() เพื่อกรณีไม่ต้องการ escape ชุดคำสั่งนั้น เพื่อ
ให้คำสั่งทำงานเฉพาะบางอย่างได้
 
$builder->where('MATCH (field) AGAINST ("value")', NULL, FALSE);
 
    5. แบบ Subquery
    เราสามารถกำหนด subquery ในฟักง์ชั่น แล้ว return ค่าออกมาใช้ใน parameter ที่สอง ดังนี้ได้
 
$builder->where('advance_amount <', function(BaseBuilder $builder) {
    return $builder->select('MAX(advance_amount)', false)->from('orders')->where('id >', 2);
});
// WHERE "advance_amount" < (SELECT MAX(advance_amount) FROM "orders" WHERE "id" > 2)
 
 
    คำสั่ง $builder->orWhere()
    เป็นการเชื่อมเงื่อนไข โดยใช้ OR 
 
$builder->where('name !=', $name);
$builder->orWhere('id >', $id);  // WHERE name != 'Joe' OR id > 50
 
    $builder->whereIn()
    เป็นการเชื่อมเงื่อนไข ร่วมกับคำสั่ง IN () ใน SQL 
 
$names = ['Frank', 'Todd', 'James'];
$builder->whereIn('username', $names);
// WHERE username IN ('Frank', 'Todd', 'James')
// มีค่าเหมือน WHERE username = 'Frank' OR username = 'Todd' OR username = 'James'
 
    ถ้ามีคำส่ง where() ก่อนหน้า จะเชื่อมด้วย AND ก่อน
 
$builder->where('name !=', $name);
$names = ['Frank', 'Todd', 'James'];
$builder->whereIn('username', $names);
// WHERE name =! 'Joe' AND username IN ('Frank', 'Todd', 'James')
 
 
    คำสั่ง $builder->orWhereIn()
    สำหรับเชื่อมเงื่อนไขก่อนหน้าด้วย OR
 
$builder->where('name !=', $name);
$names = ['Frank', 'Todd', 'James'];
$builder->orWhereIn('username', $names);
// WHERE name =! 'Joe' OR username IN ('Frank', 'Todd', 'James')
 
    
    คำสั่ง $builder->whereNotIn()
    คำสั่ง $builder->orWhereNotIn()
    การใช้งานเหมือนคำสั่งก่อนหน้า โดยมี AND หรือ OR ให้การเชื่อมเงื่อนไข ตามลำดับ
และทำคำสั่ง ที่มี NOT เข้ามาเป็น NOT IN () แทน
 
$names = ['Frank', 'Todd', 'James'];
$builder->whereNotIn('username', $names);
// WHERE username NOT IN ('Frank', 'Todd', 'James')

$names = ['Frank', 'Todd', 'James'];
$builder->orWhereNotIn('username', $names);
// OR username NOT IN ('Frank', 'Todd', 'James')
 
 
 

    การ SELECT ข้อมูลแบบเงื่อนไขข้อมูลคล้ายกัน

    คำว่าข้อมูลคล้ายกัน หมายถึงอาจจะไม่จำเป็นต้องเท่ากันทั้งหมด อาจจะมีบางส่วนที่เหมือนกัน เป็นส่วนหนึ่ง
ของคำสั่ง LIKE ใน SQL
 
 
    คำสั่ง $builder->like()
    สามารถกำหนดใน 2 รูปแบบดังนี้
 
    1. แบบ parameter เป็น key/value รูปแบบนี้ตัว value จะถูกล้อมด้วย % เพื่อเป็นการบอกคำสั่งว่า มีข้อมูลตาม
ค่ากำหนดอยู่ในฟิลด์เงื่อนไขหรือไม่
 
$builder->like('title', 'match');
// WHERE `title` LIKE '%match%' ESCAPE '!'
 
    คำสั่งนี้จะทำการ escape ตัวอักษรพิเศษบางค่าที่มีกำหนดในค่าข้อมูลเช่น % ตัวอย่างเข่น
 
$builder->like('title', '20% match');
// WHERE `title` LIKE '%20!%match%' ESCAPE '!'
 
    อธิบายเกี่ยวกับ escape ไแล้วในบทความก่อนหน้า สามารถกลับไปทบทวนได้ที่ http://niik.in/1001 
    รูปบแบคำสั่ง SQL เมื่อกำหนดใช้งานพร้อมกันมากกว่าคำสั่งเดียว
 
$builder->like('title', 'match');
$builder->like('body', 'match');
// WHERE `title` LIKE '%match%' ESCAPE '!' AND  `body` LIKE '%match%' ESCAPE '!'
 
    ตัว % ในคำสั่ง SQL ที่ล้อมหน้าหลังของค่าที่ตรวจสอบ จะเป็นค่าเริ่มต้นของเงื่อนไข ที่เราสามารถกำหนด หรือปรับ
เองได้ใน parameter ตัวที่ 3 ประกอบด้วยค่า before, after และ both โดย both คือ ค่าเริ่มต้นจะกำหนดหรือไม่ก็ได้
โดยจำนวนและตำแหน่งของ % ในคำสั่ง SQL มีความหมายดังนี้
    % ด้านหน้าอย่างเดียว คือขึ้นต้นด้วยอะไรก็ได้ แต่ต้องลงท้ายด้วยค่าที่กำหนด เช่น '%บุรี'
    % ด้านหลังอย่างเดียว คือขึ้นต้นเดียวค่าที่กำหนด แต่จะลองท้ายด้วยค่าอะไรก็ได้ เช่น 'เชียง%'
    % อยู่ทั้งด้านหน้าและหลัง คือ มีค่าข้อความที่กำหนดอยู่ส่วนใหนก็ได้ แค่ให้มี เช่น '%คร%'
 
    ตัวอย่างการกำหนด % ใน Builder ทำได้ดังนี้ * กรณีค่า both จะกำหนดหรือไม่ก็ได้
 
$builder->like('title', 'match', 'before'); // WHERE `title` LIKE '%match' ESCAPE '!'
$builder->like('title', 'match', 'after');  // WHERE `title` LIKE 'match%' ESCAPE '!'
$builder->like('title', 'match', 'both');   // WHERE `title` LIKE '%match%' ESCAPE '!'
$builder->like('title', 'match');           // WHERE `title` LIKE '%match%' ESCAPE '!'
 
    2. แบบ array การใช้งานเหมือนกัน เพียงใช้รูปแบบเป็น array ค่า key/value แทน
 
$array = ['title' => $match, 'page1' => $match, 'page2' => $match];
$builder->like($array);
// WHERE `title` LIKE '%match%' ESCAPE '!' AND  `page1` LIKE '%match%' ESCAPE '!' 
// AND  `page2` LIKE '%match%' ESCAPE '!'
 
    คำสั่งต่อไปนี้มีการใช้งานแบบเดียวกัน เพียงแต่ทำคำสั่งที่มี OR ด้านหน้า และมี NOT หรือค่าตรงกันข้าม
    $builder->orLike()    
    $builder->notLike()
    $builder->orNotLike()
 
    นอกจากนั้น การจะได้ข้อมูลที่เหมือน โดยการกรองฟิลด์ที่ต้องการแล้ว ยังสามารถจัดกลุ่มข้อมูล ด้วยคำสั่งต่าง
เหล่านี้ได้ 
 
    คำสั่ง $builder->groupBy()
$builder->groupBy("title"); // GROUP BY title

$builder->groupBy(["title", "date"]);  // GROUP BY title, date
 
    คำสั่ง $builder->distinct()
$builder->distinct();
$builder->get(); // SELECT DISTINCT * FROM mytable
 
    คำสั่ง $builder->having()
$builder->having('user_id = 45');  // HAVING user_id = 45
$builder->having('user_id',  45);  // HAVING user_id = 45

$builder->having(['title =' => 'My Title', 'id <' => $id]);
// HAVING title = 'My Title', id < 45

$builder->having('user_id',  45);  // HAVING `user_id` = 45 
$builder->having('user_id',  45, FALSE);  // HAVING user_id = 45
 
    คำสั่ง $builder->orHaving()
    คำสังนี้จะเพิ่มเฉพาะส่วนของคำว่า OR เข้าไปใน HAVING ส่วนอื่นๆ
 
    คำสั่ง $builder->havingIn()
$groups = [1, 2, 3];
$builder->havingIn('group_id', $groups);
// HAVING group_id IN (1, 2, 3)
 
    คำสั่ง $builder->orHavingIn()
$groups = [1, 2, 3];
$builder->orHavingIn('group_id', $groups);
// OR group_id IN (1, 2, 3)
 
    คำสั่ง $builder->havingNotIn()
$groups = [1, 2, 3];
$builder->havingNotIn('group_id', $groups);
// HAVING group_id NOT IN (1, 2, 3)
 
    คำสั่ง $builder->orHavingNotIn()
$groups = [1, 2, 3];
$builder->havingNotIn('group_id', $groups);
// OR group_id NOT IN (1, 2, 3)
 
    คำสั่ง $builder->havingLike()
    วิธีเดียวกันกับ คำสั่ง like()
 
$builder->havingLike('title', 'match');
// HAVING `title` LIKE '%match%' ESCAPE '!'
 
    คำสั่ง $builder->orHavingLike()
$builder->havingLike('title', 'match'); $builder->orHavingLike('body', $match);
// HAVING `title` LIKE '%match%' ESCAPE '!' OR  `body` LIKE '%match%' ESCAPE '!'
 
    คำสั่ง $builder->notHavingLike()
$builder->notHavingLike('title', 'match');      // HAVING `title` NOT LIKE '%match% ESCAPE '!'
 
    คำสั่ง $builder->orNotHavingLike()
$builder->havingLike('title', 'match');
$builder->orNotHavingLike('body', 'match');
// HAVING `title` LIKE '%match% OR  `body` NOT LIKE '%match%' ESCAPE '!'
 
 
 

    การ Ordering หรือการเรียงข้อมูล

    เป็นส่วนของคำสั่ง ORDER BY ใน SQL
 
    
    คำสั่ง $builder->orderBy()
    สามารถกำหนด parameter แรกเป็นฟิลด์ที่ต้องการเรียง และ parameter ที่สองเป็นรูปแบบการเรียง เช่น
    ASC น้อยไปมาก DESC มากไปน้อย  RANDOM ค่าสุ่ม
 
$builder->orderBy('title', 'DESC');
// ORDER BY `title` DESC
 
    หรือจะกำหนดเป็นรูปแบบ String คำสั่ง SQL ไปเลยก็ได้ ดังนี้
 
$builder->orderBy('title DESC, name ASC');
// ORDER BY `title` DESC, `name` ASC
 
    สามารถเรียกใช้พร้อมกันได้ ดังนี้
 
$builder->orderBy('title', 'DESC');
$builder->orderBy('name', 'ASC');
// ORDER BY `title` DESC, `name` ASC
 
    กรณีใช้เป็นแบบ RANDOM parameter ตัวแรกจะเป็นอะไรก็ได้ไม่มีผล นอกเสียจากว่า เรากำหนดเป็นตัวเลข ค่านั้น
จะเป็น seed value หรือค่าสำหรับเงื่อนไขการเปลี่ยนค่า ผลลัพธ์ นั่นคือถ้ายังเป็น seed ค่าเดิม ผลลัพธ์ RANDOM ก็จะยัง
ไม่เปลี่ยนแปลงจากครั้งแรก จนกว่าค่า seed เปลี่ยน ผลลัพธ์ RANDOM จึงจะเปลี่ยนแปลง
 
$builder->orderBy('title', 'RANDOM'); // ไม่สนใจฟิลด์ title
// ORDER BY RAND()

$builder->orderBy(42, 'RANDOM'); // ค่า 42 คือ seed value
// ORDER BY RAND(42)
 
 
 

    การ LIMIT หรือจำกัดการแสดงข้อมูล

    ใช้กำหนดจำนวนแถวรายการที่ต้องการแสดง หรือกำหนดจุดเริ่มต้นของแถวรายการที่ต้องการแสดง นับไป
จนครบจำนวนที่ต้องการแสดง
 
 
    คำสั่ง $builder->limit()
    เป็นส่วนของคำสั่ง LIMIT ใน SQL จำกัดจำนวนการแสดง และกำหนดแถวเริ่มต้นการแสดง
 
$builder->limit(10);  //  LIMIT 10
 
    แสดง 10 แถวแรกข้อมูล มีค่า offset เป็น 0 แต่เราไม่กำหนดก็ได้
 
$builder->limit(10, 20);  // LIMIT 20, 10 
 
    แสดง 10 แถวรายการ โดยเริ่มแสดงจากแถวที่ 20 + 1 หรือก็คือแถวที่ 21
 
 
    คำสั่ง $builder->countAllResults()
    ใช้แสดงจำนวนแถวของรายการที่มีการใช้งานการคิวรี่ด้วย Builder 
 
$builder = $db->table('tbl_provinces');		
echo $builder->countAllResults();    //  แสดง 77 รายการ เพราะยังไม่มีเงื่อนไขการกรอง
$builder->select('province_id,province_name');
$builder->where('province_id > 60');

// เมื่อมีเงื่อนการกรองข้อมูลเข้ามา จำนวนรายการก็ลดลง เหลือเฉพาะจำนวนรายการตามเงื่อนไข
// แต่กรณีนี้คำสั่ง select() และเงื่อนไขต่างในคำสั่ง SQL จะถูกรีเซ็ต
echo $builder->countAllResults();  // แสดง 17 รายการ
$query   = $builder->get();  
echo $db->getLastQuery();
// SELECT * FROM `tbl_provinces`
 
    สังเกตคำสั่ง SQL สุดท้าย จะเห็นว่า คำสั่ง countAllResults() ทำการรีเซ็ตค่าของคำสั่ง select() ที่เดิมเรากำหนด
แค่แสดงฟิลด์ กลายเป็น * แทน และผลลัพธ์ของข้อมูล Result Object ก็จะกลายเป็นข้อมูลทั้ง 77 รายการแทน
    กรณีนี้เราสามารถกำหนด parameter แรกของคำสั่ง countAllResults() เป็น false ในการแสดงข้อมูลแถวรายการ
หลังจากเข้าเงื่อนไขกรองข้อมูล และให้คำสั่งการกรองข้อมูลยังอยู่ จะได้เป็นดังนี้
 
$builder = $db->table('tbl_provinces');		
echo $builder->countAllResults();    //  แสดง 77 รายการ
$builder->select('province_id,province_name');
$builder->where('province_id > 60');

// กรณีนี้คำสั่ง select() จะไม่ถูกรีเซ็ตค่า และคำสั่ง SQL จะยังคงเงื่อนไขตามที่กำหนดเดิม
echo $builder->countAllResults(false);  // แสดง 17 รายการ
$query   = $builder->get();  
echo $db->getLastQuery();
// SELECT `province_id`, `province_name` FROM `tbl_provinces` WHERE `province_id` > 60
 
    การใช้งานในลักษณะนี้ จะเหมาะสำหรับการทำการแบ่งหน้า ที่เราอยากรู้ว่ารายการทั้งหมดเป็นเท่าไหร่ และเมื่อกรอง
ข้อมูลแล้วจะเหลือรายการอีกเท่าไหร่ ประมาณนี้เป็นต้น
 
 
    คำสั่ง $builder->countAll()
    สำหรับแสดงรายการทั้งหมดของตาราง โดยไม่สนใจเงื่อนไขการกรองใดๆ 
แต่ถ้าเวลาเรียกใช้งาน จะมีผลเหมือนกับคำสั่ง countAllResults() คือค่าจากคำสั่ง select() จะถูกร็เซ็ต 
และเงื่อนไขการกรอง จะถูกตัดออกไป เว้นแต่ว่าเรากำหนด parameter แรกเป็น fasle
 
$builder = $db->table('tbl_provinces');		
echo $builder->countAll();    //  แสดง 77 รายการ 
$builder->select('province_id,province_name');
$builder->where('province_id > 60');

// กรณีนี้คำสั่ง select() จะไม่ถูกรีเซ็ตค่า และคำสั่ง SQL จะยังคงเงื่อนไขตามที่กำหนดเดิม
echo $builder->countAll(false);  // แสดง 77 รายการ
$query   = $builder->get();  
echo $db->getLastQuery();
// SELECT `province_id`, `province_name` FROM `tbl_provinces` WHERE `province_id` > 60
// ถ้าไม่กำหนดเป็น false คำสั่ง SQL จะเป็น SELECT * FROM `tbl_provinces`
 
 

    การใช้คำสั่งแบบต่อเนื่่องด้วย Method chaining

    ก่อนจะต่อที่หัวข้อถัดไป เรามาดูคุณสมบัติของการเรียกใช้งานคำสั่ง หรือ method ต่างๆของ Builder นั้น
เราสามารถกำหนดต่อเนื่องกันได้ หากเราต้องการให้คำสั่งนั้นๆ จบในการกำหนดครั้งเดียว ดูตัวอย่าง
 
$query = $builder->select('title')
                 ->where('id', $id)
                 ->limit(10, 20)
                 ->get();
 
    หรือถ้าไม่ยาวมาก ก็สามารถใช้เป้นบรรทัดเดียวได้
 
$query = $builder->select('title')->where('id', $id)->limit(10, 20)->get();
                 
    ในบางเงื่อนไขการใช้งาน แทนที่เราจะมากำหนดแยกเป็นส่วน เราอาจจะกำหนดการเรียกใช้งานแบบต่อเนื่องได้
รูปแบบด้านบน หากกำหนดแบบที่ผ่านๆ มาก็จะเป็นประมาณนี้
 
$builder->select('title');
$builder->where('id', $id);
$builder->limit(10, 20);
$query = $builder->get();
 
 
 

    การแยกคำสั่งคิวรี่เป็นกลุ่ม Query grouping

    ในการกำหนดเงื่อนไขการคิวรี่หลายๆ เงื่อนไข เรามักจะพบกับการใช้วงเล็บเพื่อแยกเงื่อนไขต่างๆ เหล่านั้นเป็นกลุ่ม
แยกกันเป็นสัดส่วน เพราะไม่อย่างงั้น คำสั่ง SQL ก็อาจจะไม่ใช่รูปแบบที่เราต้องการก็ได้ ที่เห็นชัด ก็เช่น หากมี AND 
หรือ OR เชื่อมกันเยอะๆ แล้วไม่ได้จัดกลุ่มโดยการกำหนดวงเล็บ ก็จะหลายเป็นว่า AND หรือ OR นั้น ไปอยู่ผิดกลุ่ม 
ผิดเงื่อนไขไปได้
    หลักๆ จะมีด้วยกันสองส่วนคือ ส่วนสำหรับเงื่อนไข WHERE และอีกส่วนสำหรับ HAVING เงื่อนไขของรายการ
ที่มีการจัดกลุ่มข้อมูลแล้ว
    การใช้ในเงื่อนไข WHERE จะมีส่วนที่กำหนด ( วงเล็บเปิด ด้วยคำสั่งดังนี้
    คำสั่ง $builder->groupStart()
    คำสั่ง $builder->orGroupStart()
    คำสั่ง $builder->notGroupStart()
    คำสั่ง $builder->orNotGroupStart()
 
    และจะปิดวงเล็บ ) ด้วยคำสั่ง 
    คำสั่ง $builder->groupEnd()
 
    การใช้งานในเงื่อนไข HAVING จะมีส่วนที่กำหนด ( วงเล็บเปิด ด้วยคำสั่งดังนี้
    คำสั่ง $builder->groupHavingStart()
    คำสั่ง $builder->orGroupHavingStart()
    คำสั่ง $builder->notGroupHavingStart()
    คำสั่ง $builder->orNotGroupHavingStart()
 
    และจะปิดวงเล็บ ) ด้วยคำสั่ง 
    คำสั่ง $builder->groupHavingEnd()
 
    ตัวอย่างการกำหนด และผลลัพธ์คำสั่ง SQL ที่ได้
 
$builder->select('*')->from('my_table')
        ->groupStart()
                ->where('a', 'a')
                ->orGroupStart()
                        ->where('b', 'b')
                        ->where('c', 'c')
                ->groupEnd()
        ->groupEnd()
        ->where('d', 'd')
->get();

// ผลลัพธ์คำสั่ง SQL 
// SELECT * FROM (`my_table`) WHERE ( `a` = 'a' OR ( `b` = 'b' AND `c` = 'c' ) ) AND `d` = 'd'
 
 
 

    การ INSERT หรือการเพิ่มข้อมูล

    ประกอบด้วยคำสั่งต่างๆ ดังนี้
 
    
    คำสั่ง $builder->insert()
    ในการเพิ่มข้อมูลด้วยคำสั่ง insert() ตัวแปรค่าของข้อมูล สามารถกำหนดได้ทั้งแบบ array และ object 
โดยถ้าเป็นแบบ array ค่า key จะเป็นฟิลด์ข้อมูลในตาราง และ value คือข้อมูลที่จะบันทึก อาจจะกำหนดเป็น
ตัวแปรอีกต่อก็ได้
    ในส่วนถ้าเป็น object ตัว property ของ object จะเป็นฟิลด์ข้อมูลในตาราง และ ค่าของ property นั้นๆ 
จะเป็นข้อมูลที่ถูกบันทึก ดูตัวอย่างทั้งสองแบบ 
 
    แบบ Array
 
$data = [
        'title' => 'My title',
        'name'  => 'My Name',
        'date'  => 'My date'
];

$builder->insert($data);
// INSERT INTO mytable (title, name, date) VALUES ('My title', 'My name', 'My date')
echo $db->insertID();
 
    แบบ Object
 
class Myclass {
        public $title   = 'My Title';
        public $content = 'My Content';
        public $date    = 'My Date';
}

$object = new Myclass;
$builder->insert($object);
// INSERT INTO mytable (title, content, date) VALUES ('My Title', 'My Content', 'My Date')
echo $db->insertID();
 
 
    คำสั่ง $builder->ignore()
    ในกรณีเราใช้งานคำสั่ง insert() และต้องการตรวจสอบค่า primary key ที่กำหนดไปในข้อมูลที่จะเพิ่ม ว่ามีค่านี้
อยู่แล้วหรือไม่ ถ้ามีอยู่แล้วไม่ต้องทำการเพิ่มข้อมูล โดยเราสามารถกำหนด parameter ค่า true / false ตามต้องการ
ได้ เชน ถ้ามีอยู่แล้ว ไม่ต้องเพิ่มข้อมูล ก็จะเป็น ignore(true) ดูตัวอย่างการกำหนด 
 
$data = [
        'title' => 'My title',
        'name'  => 'My Name',
        'date'  => 'My date'
];

$builder->ignore(true)->insert($data);
// INSERT OR IGNORE INTO mytable (title, name, date) VALUES ('My title', 'My name', 'My date')
 
    สมมติว่า ตารางนี้มี primary key เป็นฟิลด์ชื่อ title และเรากำหนดการเพิ่มข้อมูลเริ่มกับคำสั่ง ignore(true) นั่นคือ ถ้า
ตารางนี้มีฟิลด์ title ที่มีค่าเท่ากับ 'My title' อยู่แล้ว ไม่ต้องทำการเพิ่มข้อมูลนั่นเอง
 
 
    คำสั่ง $builder->getCompiledInsert()    
    ใช้สำหรับสร้างชุดคำสั่ง SQL แบบเดียวกันกับคำสั่ง insert() ต่างๆ แค่ไม่มีการคิวรี่เพื่อเพิ่มข้อมูลจริง ดังนั้น ก็จะคืนค่า
เป็น String คำสั่ง SQL ให้เรานำไปใช้งาน
 
$data = [
        'title' => 'My title',
        'name'  => 'My Name',
        'date'  => 'My date'
];

$sql = $builder->set($data)->getCompiledInsert('mytable');
echo $sql;
// INSERT INTO mytable (`title`, `name`, `date`) VALUES ('My title', 'My name', 'My date')
 
    การใช้คำสั่งข้างต้นตัวคำสั่ง SQL จะถูกรีเซ็ตหลังเรียกใช้งาน เว้นแต่เราเพิ่ม parameter ที่สองเป็น false เข้าไป
จะมีผลให้ชุดคำสั่งเดิมจะยังคงอยู่ และเราสามารถเพิ่มการกำหนดค่าเพิ่มเติมต่อจากคำสั่งเดิมได้ 
 
echo $builder->set('title', 'My Title')->getCompiledInsert('mytable', FALSE);
// INSERT INTO mytable (`title`) VALUES ('My Title')

// คำสั่งเดิมยังอยู่ หากเราเพิ่มการกำหนดค่าเพิ่มเติม ก็จะไปต่อจากค่าเดิม
echo $builder->set('content', 'My Content')->getCompiledInsert();
// INSERT INTO mytable (`title`, `content`) VALUES ('My Title', 'My Content')
 
 
    คำสั่ง $builder->insertBatch()
    ใช้สำหรับเพิ่มข้อมูลทีละหลายรายการในครั้งเดียว โดยจะเป็นข้อมูลแบบ array หรือ object ก็ได้ ดูตัวอย่าง
การใช้งานกรณีชุดข้อมูล array 
 
$data = [
        [
                'title' => 'My title',
                'name'  => 'My Name',
                'date'  => 'My date'
        ],
        [
                'title' => 'Another title',
                'name'  => 'Another Name',
                'date'  => 'Another date'
        ]
];

$builder->insertBatch($data);
// INSERT INTO mytable (title, name, date) VALUES 
// ('My title', 'My name', 'My date'),  ('Another title', 'Another name', 'Another date')
 
 

    การ UPDATE หรือแก้ไขข้อมูล

    ประกอบด้วยคำสั่งต่างๆ ดังนี้
 
 
    คำสั่ง $builder->replace()
    เป็นคำสั่งที่ใช้งานในรูปแบบเดียวกับ REPLACE ใน SQL จะมีหน้าที่ในการทำงานอยู่สองลักษณะคือ การลบข้มมูลหากมี
ข้อมูลนั้นๆอยู่ แล้วเพิ่มข้อมูลใหม่เข้าไปแทน โดยจะพิจารณาข้อมูลในฟิลด์ที่เป็น PRIMARY และ UNIQUE key นั่นคือถ้า
ตารางนั้นมีการกำหนดฟิลด์ทั้ง PRIMARY และ UNIQUE key ก็จะตรวจสอบทั้งสองฟิลด์ แต่ถ้ากำหนดเฉพาะ PRIMARY ก็จะ
ตรวจสอบเฉพาะฟิลด์ที่เป็น PRIMARY เท่านั้น  ข้อดีของคำสั่งนี้ก็คือ แทนที่เราจะสร้างคำสั่งต่างๆ เอง ไม่ว่าจะ select() เพือ
ดูว่ามีซ้ำหรือไม่ หรือ insert() ถ้าไม่มีซ้ำ หรือ delete() ถ้ามีซ้ำแล้ว เพิ่มไปใหม่ เหล่านี้เราก็สามารถจัดการด้วยคำสั่ง replace()
แทนได้
 
$data = [
        'title' => 'My title',
        'name'  => 'My Name',
        'date'  => 'My date'
];

$builder->replace($data);
// REPLACE INTO mytable (title, name, date) VALUES ('My title', 'My name', 'My date')
 
    สมมติว่าตัวอย่างด้านบนฟิลด์ title เป็น PRIMARY และมีค่าเป็นคำว่า 'My title' เป็นค่าข้อมูลเดิม ซึ่งตรงกับค่าใหม่จาก
ตัวแปร $data ตัวคำสั่งนี้ก็จะทำการลบแถวของรายการนี้ออก แล้วทำการเพิ่มข้อมูลใหม่ทั้งหมดลงไปแทน เป็นต้น
    เราสามารถใช้คำสั่ง set() สำหรับกำหนดค่าข้อมูลได้ กรณีต้องการแยกกำหนดในบางกรณี
 
$data = [
        'title' => 'My title',
        'name'  => 'My Name',
        'date'  => 'My date'
];
$builder->set($data)->replace();
 
 
    คำสั่ง $builder->set()
    อย่างที่อธิบายไปเล็กน้อยด้านบน คำสั่ง set() ใช้สำหรับกำหนดค่าฟิลด์และข้อมูลเฉพาะแยกเป็นรายการ กรณีเราต้องการ
จัดการกับค่านั้นๆ เป็นพิเศษ โดยคำสั่งนี้ จะสามารถใช้ได้กับทั้ง inset() repace() และ update()
 
$builder->set('name', $name);
$builder->insert();  // INSERT INTO mytable (`name`) VALUES ('{$name}')
 
    หรือกรณีกำหนดพร้อมกันหลายบรรทัด
 
$builder->set('name', $name);
$builder->set('title', $title);
$builder->set('status', $status);
$builder->insert();
 
    อย่างที่บอกไปตอนต้นแล้วว่าการใช้งาน Builder ข้อมูลจะถูก escape ให้อัตโนมัติ แต่ก็มีในบางกรณี ที่เราอาจจะไม่ต้องการ
escape ค่าข้อมูลที่กำหนด เพื่อให้คำสั่ง SQL ทำงานได้ ยกตัวอย่างก็เช่น การอัพเดทเพิ่มค่าข้อมูล อย่างบวกเพิ่มที่ละ 1 จากค่า
เดิม ดูตัวอย่าง
 
$builder->set('field', 'field+1', FALSE);
$builder->where('id', 2);
$builder->update(); // UPDATE mytable SET field = field+1 WHERE `id` = 2

$builder->set('field', 'field+1');
$builder->where('id', 2);
$builder->update(); //  UPDATE `mytable` SET `field` = 'field+1' WHERE `id` = 2
 
    ตัวอย่างแรก เรากำหนด FALSE เป็นการไม่ให้ escape ข้อมูลของฟิลด์นี้ สังเกตว่าคำสั่ง SQL ที่ได้ จะทำให้ข้อมูลมีการบวก
เพิ่มจากค่าเดิมอีก 1 ทุกครั้งที่อัพเดท
    แต่ถ้าเราปล่อยให้ escape ปกติ คำสั่งที่ได้จะเป็นข้อมูล String ที่มีค่าเป็น 'field+1' ถูกอัพเดทไปแทน ไม่ใช่ค่าที่เราต้องการ
นั่นคือเหตุผลในบางกรณีที่เราอาจจะไม่ต้องการ escape ข้อมูลที่กำหนด
 
    นอกจากกำหนดค่าแต่ละรายการแล้ว เรายังสามารถกำหนดแบบ array หรือ object เข้าไปเลยก็ได้ เช่น
 
    แบบ Array
 
$array = [
        'name'   => $name,
        'title'  => $title,
        'status' => $status
];

$builder->set($array);
$builder->insert();
 
    แบบ Object
 
class Myclass {
        public $title   = 'My Title';
        public $content = 'My Content';
        public $date    = 'My Date';
}

$object = new Myclass;
$builder->set($object);
$builder->insert();
 
    คำสั่ง $builder->update()
    เป็นคำสั่งที่ใช้สำหรับอัพเดทข้อมูล ทำงานในส่วนของ UPDATE ใน SQL มักใช้ร่วมกับเงื่อนไข WHERE ในหลายๆ รูปแบบ
ดังต่อไปนี้
 
// แบบที่ 1
$builder->where('id', $id);
$builder->update($data);

// แบบที่ 2
$builder->update($data, "id = 4");
// แบบที่ 3
$builder->update($data, ['id' => $id]);
 
    สำหรับข้อมูลที่จะทำการอัพเดท เราสามารถกำหนดโดยใช้คำสัง set() ตามที่อธิบายไปด้านบน หรือจะกำหนดเป็น array หรือ
Object ก็ได้เหมือนกัน
 
    แบบ Array
 
$data = [
        'title' => $title,
        'name'  => $name,
        'date'  => $date
];

$builder->where('id', $id);
$builder->update($data);
//      UPDATE mytable
//      SET title = '{$title}', name = '{$name}', date = '{$date}'
//      WHERE id = $id
 
    แบบ Object
 
class Myclass {
        public $title   = 'My Title';
        public $content = 'My Content';
        public $date    = 'My Date';
}

$object = new Myclass;
$builder->where('id', $id);
$builder->update($object);
// UPDATE `mytable`
// SET `title` = '{$title}', `name` = '{$name}', `date` = '{$date}'
// WHERE id = `$id`
 
 
    คำสั่ง $builder->updateBatch()
    ใช้สำหรับอัพเดทหรือแก้ไขข้อมูล โดยมีเงื่อนไขได้หลายค่า ดูตัวอย่างด้านล่างประกอบ
 
$data = [
   [
      'title' => 'My title' ,
      'name'  => 'My Name 2' ,
      'date'  => 'My date 2'
   ],
   [
      'title' => 'Another title' ,
      'name'  => 'Another Name 2' ,
      'date'  => 'Another date 2'
   ]
];

$builder->updateBatch($data, 'title');

// UPDATE `mytable` SET `name` = CASE
// WHEN `title` = 'My title' THEN 'My Name 2'
// WHEN `title` = 'Another title' THEN 'Another Name 2'
// ELSE `name` END,
// `date` = CASE
// WHEN `title` = 'My title' THEN 'My date 2'
// WHEN `title` = 'Another title' THEN 'Another date 2'
// ELSE `date` END
// WHERE `title` IN ('My title','Another title')
 
    ในการใช้งานคำสั่ง updateBatch() parameter แรกเป็น array ข้อมูล ตัวที่สองเป็นชื่อ ฟิลด์ที่เราจะใช้เป็นเงื่อนไข
ในค่า WHERE ข้างต้นใช้เป็นฟิลด์ title
    สำหรับตัวแปรข้อมูลข้างต้น มีสอง array คำสั่งจะทำการอัพเดทฟิลด์ที่ไม่ได้เป็นฟิลด์ในเงื่อนไข WHERE หรือก็คือ
ฟิลด์ name และ date อาจกล่าวได้ว่า ถ้า title มีค่าเท่ากับ  'My title'  ให้อัพเดทฟิลด์ name เป็น 'My Name 2' 
และถ้า title มีค่าเท่ากับ 'Another title' ให้อัพเดทฟิลด์ name เป็น 'Another Name 2' 
    เช่นเดียวกันกับฟิลด์ date ทำเหมือนกับวิธีด้านบน
    คำสั่ง updateBatch() จะคืนค่าเป็นจำนวนแถวที่มีการอัพเดทเกิดขึ้น หรือมีค่าเท่ากับ $db->affectedRows() กรณี
ใช้คำสั่ง update() 
 
 
    คำสั่ง $builder->getCompiledUpdate()
    ใช้สำหรับสร้างชุดคำสั่ง SQL มีรูปแบบการใช้งานเหมือนกับ getCompiledInsert() ที่กล่าวไปแล้วด้านบน เพียงแต่คำสั่ง
นี้สร้างชุดคำสั่ง SQL สำหรับ UPDATE ข้อมูลแทน
 
 
 

    การ DELETE หรือการลบข้อมูล

    ประกอบด้วยคำสั่งต่างๆ ดังนี้
 
 
    คำสั่ง $builder->delete()
    ใช้สำหรับลบรายการข้อมูล ในรูปแบบเดียวกับคำสั่ง DELETE ใน SQL  มักใช้ร่วมกับเงื่อนไข WHERE สามารถ
กำหนดรูปแบบต่างๆ ได้ประมาณนี้
 
$builder->delete(['id' => $id]);  // DELETE FROM mytable  // WHERE id = $id
 
    หรือแบบนี้
 
$builder->where('id', $id);
$builder->delete();

// DELETE FROM mytable
// WHERE id = $id
 
    
    คำสั่ง $builder->emptyTable()
    ใช้สำหรับลบรายการในตารางทั้งหมด มีค่าเหมือนการลบโดยไม่มีเงื่อนไข WHERE
 
$builder->emptyTable('mytable'); // DELETE FROM mytable
 
    การลบด้วยคำสั่งนี้ ข้อมูลทั้งหมดของตารางหายไป แต่ค่าเริ่มต้นของ primary key หรือค่า autoincrement จะไม่เริ่ม
นับใหม่ แต่จะนับจากค่าเดิม ถ้าต้องการให้เริ่มข้อมูลโครงสร้างตารางใหม่ทั้งหมด ให้คำสั่งด้านล่างแทน
 
 
    คำสั่ง $builder->truncate()
    ทำงานในรูปแบบเดียวกับคำสั่ง TRUNCATE ใน SQL ใช้สำหรับลบข้อมูล เหมือนรีเซ็ตต่างๆ ของตารางใหม่ รวมถึงค่า
autoincrement การใช้งานก็จะประมาณคำสั่งด้านล่าง
 
$builder->truncate();

// TRUNCATE mytable
 
    ในกรณีที่คำสั่ง TRUNCATE ไม่สามารถใช้งานได้ ก็คำสั่งนี้ ก็จะไปทำคำสั่ง  “DELETE FROM table” แทน
 
 
    คำสั่ง $builder->getCompiledDelete()
    ใช้สำหรับสร้างชุดคำสั่ง SQL มีรูปแบบการใช้งานเหมือนกับ getCompiledInsert() ที่กล่าวไปแล้วด้านบน เพียงแต่คำสั่ง
นี้สร้างชุดคำสั่ง SQL สำหรับ DELETE ข้อมูลแทน
 
 

    การรีเซ็ตค่าคิวรี่ของ Builder

    เวลาที่เราเรียกใช้งาน Builder เพื่อสร้างคำสั่ง SQL สำหรับคิวรี่ การกำหนดแต่ละคำสั่ง ก็เหมือนการเอาแต่ละค่ามา
เชื่อมต่อกัน และโดยปกติ เมื่อเราใช้คำสั่ง $builder->get() หรือ $builder->insert()  ชุดคำสั่ง SQL ที่เคยกำหนด
ก็จะถูกรีเซ็ตค่า หากมีการเรียกใช้คำสั่งใหม่ ก็เหมือนการเริ่มต้นสร้างชุดคำสั่ง SQL ใหม่ขึ้นมา
 
 
    คำสั่ง $builder->resetQuery()
    นอกจากวิธีการรีเซ็ตค่าที่กล่าวไปข้างต้น เรายังสามารถใช้คำสั่งนี้ ในการรีเซ็ตชุดคำสั่ง SQL ที่ถูกสร้างด้วย Builder ได้
ใช้สำหรับกรณีที่เราไม่มั่นใจ หรือไม่แน่ใจว่า ชุดคำสั่ง SQL จาก Builder ได้ถูกรีเซ็ตไปแล้วหรือไม่ เราต้องการสร้างชุด
คำสั่ง SQL ใหม่เลย ถ้ามีชุดคำสั่งเดิมค้างอยู่ให้รีเซ็ต ก็สามารถกำหนดคำสั่งนี้ไปก่อนกำหนดคำสั่งใหม่ได้ ดูตัวอย่างด้านล่าง
 
// ปกติคำสั่ง getCompiledSelect() จะรีเซ็ตค่าให้แต่พอดีเรากำหนดให้การรีเซ็ตเป็น false 
$sql = $builder->select(['field1','field2'])
               ->where('field3',5)
               ->getCompiledSelect(false);

// ...
// นำคำสั่ง SQL ที่ได้ไปใช้งานบางอย่าง
// ...

$builder->resetQuery();
 
    หรือตัวอย่างเช่น
 
$builder = $db->table('tbl_provinces');		
$builder->select('province_id,province_name');
$builder->where('province_id > 60');
echo $builder->getCompiledSelect(false);
// ถึงตรงนี้คำสั่ง SQL จะประมาณ 
// SELECT `province_id`, `province_name` FROM `tbl_provinces` WHERE `province_id` > 60
$builder->resetQuery();
// แต่เมื่อรีเซ็ตไป ค่าก็จะไปเริ่มที่ SELECT * FROM tbl_provinces
$query   = $builder->get();   
 
 
    สำหรับเนื้อหาเกี่ยวกับการใช้งาน Query Builder ทั้งหมดก็จะประมาณนี้ สามารถใช้เป็นเนื้อหาอ้างอิง ไว้มาดูแล้วไปปรับ
ใช้งานเพิ่มเติมต่อไปได้


กด Like หรือ Share เป็นกำลังใจ ให้มีบทความใหม่ๆ เรื่อยๆ น่ะครับ



อ่านต่อที่บทความ









เนื้อหาที่เกี่ยวข้อง






เนื้อหาพิเศษ เฉพาะสำหรับสมาชิก

กรุณาล็อกอิน เพื่ออ่านเนื้อหาบทความ

ยังไม่เป็นสมาชิก

สมาชิกล็อกอิน



( หรือ เข้าใช้งานผ่าน Social Login )




URL สำหรับอ้างอิง











เว็บไซต์ของเราให้บริการเนื้อหาบทความสำหรับนักพัฒนา โดยพึ่งพารายได้เล็กน้อยจากการแสดงโฆษณา โปรดสนับสนุนเว็บไซต์ของเราด้วยการปิดการใช้งานตัวปิดกั้นโฆษณา (Disable Ads Blocker) ขอบคุณครับ