查詢構造器類?

CodeIgniter 提供了查詢構造器類，它允許你用較少的代碼量獲取數(shù)據(jù)庫的信息、新增或更新數(shù)據(jù)。有時只需要一兩行代碼就能完成數(shù)據(jù)庫操作。CodeIgniter 不要求每個數(shù)據(jù)表有一個類文件，它使用了一種更簡單的接口。

除了簡單，使用查詢構造器的主要好處是可以讓你創(chuàng)建跨數(shù)據(jù)庫的應用程序，因為查詢語句是由每種數(shù)據(jù)庫適配器生成的。它也允許用于更安全的查詢，因為系統(tǒng)會自動轉義傳入數(shù)據(jù)。

加載查詢構造器
選擇數(shù)據(jù)
查找具體數(shù)據(jù)
查找相似的數(shù)據(jù)
結果排序
結果分頁與計數(shù)
查詢分組
插入數(shù)據(jù)
更新數(shù)據(jù)
刪除數(shù)據(jù)
鏈式方法
重置查詢構造器
類庫參考

加載查詢構造器 ?

查詢構造器通過數(shù)據(jù)庫連接對象的 table() 方法加載，這會設置查詢語句 FROM 的部分并且返回一個查詢構造器的新實例:

$db      = \Config\Database::connect();
$builder = $db->table('users');

查詢構造器僅在你明確請求類時才加載到內(nèi)存中，因此默認不使用（消耗）任何資源。

選擇數(shù)據(jù)?

下面的方法用來構建 SQL SELECT 語句。

$builder->get()

執(zhí)行選擇查詢并返回結果，可用于獲取一個表的所有記錄:

$builder = $db->table('mytable');
$query   = $builder->get();  // 生成: SELECT * FROM mytable

第一個和第二個參數(shù)用于設置 limit 和 offset 子句:

$query = $builder->get(10, 20);

// 執(zhí)行: SELECT * FROM mytable LIMIT 20, 10
// (在 MySQL 里的情況，其他數(shù)據(jù)庫的語法略有不同）

你應該已經(jīng)注意到了，上面方法的結果賦值給了一個 $query 變量，我們可以用它輸出查詢結果:

$query = $builder->get();

foreach ($query->getResult() as $row)
{
        echo $row->title;
}

請訪問結果方法頁面獲得結果生成的完整論述。

$builder->getCompiledSelect()

和 $builder->get() 方法一樣編譯選擇查詢但是并不執(zhí)行，此方法只是將 SQL 查詢語句作為字符串返回。

例如:

$sql = $builder->getCompiledSelect();
echo $sql;

// 輸出字符串: SELECT * FROM mytable

第一個參數(shù)使你能設置是否重置查詢構造器（默認重置，就像使用 $builder->get() 時一樣):

echo $builder->limit(10,20)->getCompiledSelect(false);

// 輸出字符串: SELECT * FROM mytable LIMIT 20, 10
// (在 MySQL 里的情況，其他數(shù)據(jù)庫的語法略有不同）

echo $builder->select('title, content, date')->getCompiledSelect();

// 輸出字符串: SELECT title, content, date FROM mytable LIMIT 20, 10

最值得注意的是，上例第二個查詢并沒有用到 $builder->from() 方法，也沒有為查詢指定表名參數(shù)。因為這個查詢沒有被可重置值的 $builder->get() 方法執(zhí)行，或是使用 $builder->resetQuery() 方法直接重置。

$builder->getWhere()

與 get() 函數(shù)相同，只是它允許你用第一個參數(shù)中添加 “where” 子句，而不是使用 db->where() 功能:

$query = $builder->getWhere(['id' => $id], $limit, $offset);

請閱讀下面 where 方法獲得更多信息。

$builder->select()

允許你編寫查詢的 SELECT 部分:

$builder->select('title, content, date');
$query = $builder->get();

// 執(zhí)行: SELECT title, content, date FROM mytable

注解

如果要從表中選擇全部字段 (*) ，不需要使用這個函數(shù)。當省略它時，CodeIgniter 假定你希望選擇所有字段并自動添加 ‘SELECT *’ 。

$builder->select() 方法的第二個參數(shù)可選，如果設置為 FALSE， CodeIgniter 將不保護你的表名和字段名。當你編寫復合查詢語句時很有用，它不會因為自動轉義而搞壞你的語句。

$builder->select('(SELECT SUM(payments.amount) FROM payments WHERE payments.invoice_id=4) AS amount_paid', FALSE);
$query = $builder->get();

$builder->selectMax()

該方法用于編寫查詢語句中的 SELECT MAX(field) 部分，你可以使用第二個參數(shù)重命名結果字段（可選）。

$builder->selectMax('age');
$query = $builder->get();  // 生成: SELECT MAX(age) as age FROM mytable

$builder->selectMax('age', 'member_age');
$query = $builder->get(); // 生成: SELECT MAX(age) as member_age FROM mytable

$builder->selectMin()

該方法用于編寫查詢語句中的 “SELECT MIN(field)” 部分，和 selectMax() 一樣，你可以使用第二個參數(shù)重命名結果字段（可選）。

$builder->selectMin('age');
$query = $builder->get(); // 生成: SELECT MIN(age) as age FROM mytable

$builder->selectAvg()

該方法用于編寫查詢語句中的 “SELECT AVG(field)” 部分，和 selectMax() 一樣，你可以使用第二個參數(shù)重命名結果字段（可選）。

$builder->selectAvg('age');
$query = $builder->get(); // 生成: SELECT AVG(age) as age FROM mytable

$builder->selectSum()

該方法用于編寫查詢語句中的 “SELECT SUM(field)” 部分，和 selectMax() 一樣，你可以使用第二個參數(shù)重命名結果字段（可選）。

$builder->selectSum('age');
$query = $builder->get(); // 生成: SELECT SUM(age) as age FROM mytable

$builder->selectCount()

該方法用于編寫查詢語句中的 “SELECT COUNT(field)” 部分，和 selectMax() 一樣，你可以使用第二個參數(shù)重命名結果字段（可選）。

注解

該方法在使用 groupBy() 時特別有用。用于一般的結果計數(shù)詳見 countAll() 或 countAllResults() 。

$builder->selectCount('age');
$query = $builder->get(); // 生成: SELECT COUNT(age) as age FROM mytable

$builder->from()

該方法用于編寫查詢語句中的 FROM 子句:

$builder->select('title, content, date');
$builder->from('mytable');
$query = $builder->get();  // 生成: SELECT title, content, date FROM mytable

注解

正如前面所說，查詢中的 FROM 部分可以在方法 $db->table() 中指定。額外調(diào)用 from() 將向查詢的 FROM 部分添加更多表。

$builder->join()

該方法用于編寫查詢語句中的 JOIN 子句:

$builder->db->table('blog');
$builder->select('*');
$builder->join('comments', 'comments.id = blogs.id');
$query = $builder->get();

// 生成:
// SELECT * FROM blogs JOIN comments ON comments.id = blogs.id

如果你的查詢有多個連接，可以多次調(diào)用這個方法。

你可以傳入第三個參數(shù)指定連接的類型，可選: left，right, outer, inner, left outer 和 right outer 。

$builder->join('comments', 'comments.id = blogs.id', 'left');
// 生成: LEFT JOIN comments ON comments.id = blogs.id

查找具體數(shù)據(jù)?

$builder->where()

該方法提供了4中方式讓你編寫查詢語句中的 WHERE 子句:

注解

所有傳入數(shù)據(jù)將會自動轉義，生成安全的查詢語句。

簡單的 key/value 方式:

$builder->where('name', $name); // 生成: WHERE name = 'Joe'
注意它自動為你加上了等號。

如果你多次調(diào)用該方法，那么多個 WHERE 條件將會使用 AND 連接:
$builder->where('name', $name);
$builder->where('title', $title);
$builder->where('status', $status);
// WHERE name = 'Joe' AND title = 'boss' AND status = 'active'

自定義 key/value 方式:
你可以在第一個參數(shù)中包含一個比較運算符，用來控制比較條件:
$builder->where('name !=', $name); $builder->where('id <', $id); // 生成: WHERE name != 'Joe' AND id < 45

關聯(lián)數(shù)組方式:

$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);

自定義字符串:

你可以手動編寫子句:

$where = "name='Joe' AND status='boss' OR status='active'";
$builder->where($where);

$builder->where() 的第三個參數(shù)（可選），如果設置為 FALSE，CodeIgniter 將不保護你的表名和字段名。

$builder->where('MATCH (field) AGAINST ("value")', NULL, FALSE);

子查詢:

你可以使用匿名函數(shù)生成一個子查詢。

$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()

該方法用于生成 WHERE IN(‘item’, ‘item’) 子句，多個子句之間使用 AND 連接

$names = ['Frank', 'Todd', 'James'];
$builder->whereIn('username', $names);
// 生成: WHERE username IN ('Frank', 'Todd', 'James')

你可以用子查詢替代數(shù)組值。

$builder->whereIn('id', function(BaseBuilder $builder) {
    return $builder->select('job_id')->from('users_jobs')->where('user_id', 3);
});
// 生成: WHERE "id" IN (SELECT "job_id" FROM "users_jobs" WHERE "user_id" = 3)

$builder->orWhereIn()

該方法用于生成 WHERE IN(‘item’, ‘item’) 子句，多個子句之間使用 OR 連接

$names = ['Frank', 'Todd', 'James'];
$builder->orWhereIn('username', $names);
// 生成: OR username IN ('Frank', 'Todd', 'James')

你可以用子查詢替代數(shù)組值。

$builder->orWhereIn('id', function(BaseBuilder $builder) {
    return $builder->select('job_id')->from('users_jobs')->where('user_id', 3);
});

// 生成: OR "id" IN (SELECT "job_id" FROM "users_jobs" WHERE "user_id" = 3)

$builder->whereNotIn()

該方法用于生成 WHERE NOT IN(‘item’, ‘item’) 子句，多個子句之間使用 AND 連接

$names = ['Frank', 'Todd', 'James'];
$builder->whereNotIn('username', $names);
// 生成: WHERE username NOT IN ('Frank', 'Todd', 'James')

你可以用子查詢替代數(shù)組值。

$builder->whereNotIn('id', function(BaseBuilder $builder) {
    return $builder->select('job_id')->from('users_jobs')->where('user_id', 3);
});

// 生成: WHERE "id" NOT IN (SELECT "job_id" FROM "users_jobs" WHERE "user_id" = 3)

$builder->orWhereNotIn()

該方法用于生成 WHERE NOT IN(‘item’, ‘item’) 子句，多個子句之間使用 OR 連接

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

你可以用子查詢替代數(shù)組值。

$builder->orWhereNotIn('id', function(BaseBuilder $builder) {
    return $builder->select('job_id')->from('users_jobs')->where('user_id', 3);
});

// 生成: OR "id" NOT IN (SELECT "job_id" FROM "users_jobs" WHERE "user_id" = 3)

查找相似的數(shù)據(jù)?

$builder->like()

這個方法使您能夠生成類似 LIKE 子句，做搜索時非常有用。

注解

所有傳入數(shù)據(jù)將被自動轉義。

注解

like* 通過傳第五個參數(shù)傳遞值 true 可以強制在執(zhí)行查詢時不區(qū)分大小寫。這項特性可用性跟平臺相關，否則將強制值轉為小寫，例如 WHERE LOWER(column) LIKE '%search%'，讓其生效可能需要在制作索引時用 LOWER(column) 而不是 column 。

簡單 key/value 方式:

$builder->like('title', 'match');
// 生成: WHERE `title` LIKE '%match%' ESCAPE '!'
如果你多次調(diào)用該方法，那么多個 WHERE 條件將會使用 AND 連接起來:
$builder->like('title', 'match');
$builder->like('body', 'match');
// WHERE `title` LIKE '%match%' ESCAPE '!' AND  `body` LIKE '%match% ESCAPE '!'
如果你想控制通配符通配符（%）的位置，可以指定第三個參數(shù)，可用選項：’before’，’after’ 和 ‘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 '!'

關聯(lián)數(shù)組方式:

$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 '!'

$builder->orLike()

這個方法和上面的方法一樣，只是多個 WHERE 條件之間使用 OR 進行連接:

$builder->like('title', 'match'); $builder->orLike('body', $match);
// WHERE `title` LIKE '%match%' ESCAPE '!' OR  `body` LIKE '%match%' ESCAPE '!'

$builder->notLike()

這個方法和 like() 方法一樣，只是生成 NOT LIKE 子句:

$builder->notLike('title', 'match');    // WHERE `title` NOT LIKE '%match% ESCAPE '!'

$builder->orNotLike()

這個方法和 notLike() 方法一樣，只是多個條件之間使用 OR 連接:

$builder->like('title', 'match');
$builder->orNotLike('body', 'match');
// WHERE `title` LIKE '%match% OR  `body` NOT LIKE '%match%' ESCAPE '!'

$builder->groupBy()

該方法用于生成 GROUP BY 子句:

$builder->groupBy("title"); // 生成: GROUP BY title

你也可以通過一個數(shù)組傳入多個值:

$builder->groupBy(["title", "date"]);  // 生成: GROUP BY title, date

$builder->distinct()

該方法用于向查詢中添加 “DISTINCT” 關鍵字

$builder->distinct();
$builder->get(); // 生成: SELECT DISTINCT * FROM mytable

$builder->having()

該方法用于生成 HAVING 子句，有下面兩種不同的語法。有兩種可用語法，單參數(shù)或雙參數(shù):

$builder->having('user_id = 45');  // 生成: HAVING user_id = 45
$builder->having('user_id',  45);  // 生成: HAVING user_id = 45

你還可以傳遞一個包含多個值的數(shù)組:

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

如果你正在使用 CodeIgniter 為其轉義查詢的數(shù)據(jù)庫，你可以傳第三個可選參數(shù)來防止轉義內(nèi)容，設為 FALSE 。

$builder->having('user_id',  45);  // 生成: HAVING `user_id` = 45 in some databases such as MySQL
$builder->having('user_id',  45, FALSE);  // 生成: HAVING user_id = 45

$builder->orHaving()

該方法和 having() 方法一樣，只是多個條件之間使用 “OR” 進行連接。

$builder->havingIn()

生成一個 HAVING 字段的 IN (‘item’, ‘item’) SQL 查詢子句，多個條件之間使用 AND 連接

$groups = [1, 2, 3];
$builder->havingIn('group_id', $groups);
// 生成: HAVING group_id IN (1, 2, 3)

你可以用子查詢代替數(shù)組。

$builder->havingIn('id', function(BaseBuilder $builder) {
    return $builder->select('user_id')->from('users_jobs')->where('group_id', 3);
});
// 生成: HAVING "id" IN (SELECT "user_id" FROM "users_jobs" WHERE "group_id" = 3)

$builder->orHavingIn()

生成一個 HAVING 字段的 IN (‘item’, ‘item’) SQL 查詢子句，多個條件之間使用 OR 連接

$groups = [1, 2, 3];
$builder->orHavingIn('group_id', $groups);
// 生成: OR group_id IN (1, 2, 3)

你可以用子查詢代替數(shù)組。

$builder->orHavingIn('id', function(BaseBuilder $builder) {
    return $builder->select('user_id')->from('users_jobs')->where('group_id', 3);
});

// 生成: OR "id" IN (SELECT "user_id" FROM "users_jobs" WHERE "group_id" = 3)

$builder->havingNotIn()

生成一個 HAVING 字段的 NOT IN (‘item’, ‘item’) SQL 查詢子句，多個條件之間使用 AND 連接

$groups = [1, 2, 3];
$builder->havingNotIn('group_id', $groups);
// 生成: HAVING group_id NOT IN (1, 2, 3)

你可以用子查詢代替數(shù)組。

$builder->havingNotIn('id', function(BaseBuilder $builder) {
    return $builder->select('user_id')->from('users_jobs')->where('group_id', 3);
});

// 生成: HAVING "id" NOT IN (SELECT "user_id" FROM "users_jobs" WHERE "group_id" = 3)

$builder->orHavingNotIn()

生成一個 HAVING 字段的 NOT IN (‘item’, ‘item’) SQL 查詢子句，多個條件之間使用 OR 連接

$groups = [1, 2, 3];
$builder->havingNotIn('group_id', $groups);
// 生成: OR group_id NOT IN (1, 2, 3)

你可以用子查詢代替數(shù)組。

$builder->orHavingNotIn('id', function(BaseBuilder $builder) {
    return $builder->select('user_id')->from('users_jobs')->where('group_id', 3);
});

// 生成: OR "id" NOT IN (SELECT "user_id" FROM "users_jobs" WHERE "group_id" = 3)

$builder->havingLike()

該方法讓你能夠在 HAVING 查詢部分生成 LIKE 子句，常用于搜索。

注解

該方法所有傳入?yún)?shù)會被自動轉義。

注解

havingLike* 通過傳第五個參數(shù)傳遞值 true 可以強制在執(zhí)行查詢時不區(qū)分大小寫。這項特性可用性跟平臺相關，否則將強制值轉為小寫，例如 HAVING LOWER(column) LIKE '%search%'，讓其生效可能需要在制作索引時用 LOWER(column) 而不是 column 。

簡單 key/value 方式:

$builder->havingLike('title', 'match');
// 生成: HAVING `title` LIKE '%match%' ESCAPE '!'

如果你多次調(diào)用該方法，那么多個 WHERE 條件將會使用 AND 連接起來:

$builder->havingLike('title', 'match');
$builder->havingLike('body', 'match');
// HAVING `title` LIKE '%match%' ESCAPE '!' AND  `body` LIKE '%match% ESCAPE '!'

如果你想控制通配符通配符（%）的位置，可以指定第三個參數(shù)，可用選項：’before’，’after’ 和 ‘both’ (默認) 。

$builder->havingLike('title', 'match', 'before');       // 生成: HAVING `title` LIKE '%match' ESCAPE '!'
$builder->havingLike('title', 'match', 'after');        // 生成: HAVING `title` LIKE 'match%' ESCAPE '!'
$builder->havingLike('title', 'match', 'both'); // 生成: HAVING `title` LIKE '%match%' ESCAPE '!'

關聯(lián)數(shù)組方式:

$array = ['title' => $match, 'page1' => $match, 'page2' => $match];
$builder->havingLike($array);
// HAVING `title` LIKE '%match%' ESCAPE '!' AND  `page1` LIKE '%match%' ESCAPE '!' AND  `page2` LIKE '%match%' ESCAPE '!'

$builder->orHavingLike()

這個方法和上面的方法一樣，只是多個條件之間使用 OR 進行連接:

$builder->havingLike('title', 'match'); $builder->orHavingLike('body', $match);
// HAVING `title` LIKE '%match%' ESCAPE '!' OR  `body` LIKE '%match%' ESCAPE '!'

$builder->notHavingLike()

這個方法和 havingLike() 一樣，只是它生成的是 NOT LIKE 子句:

$builder->notHavingLike('title', 'match');      // HAVING `title` NOT LIKE '%match% ESCAPE '!'

$builder->orNotHavingLike()

這個方法和 notHavingLike() 一樣，只是多個條件之間使用 OR 進行連接:

$builder->havingLike('title', 'match');
$builder->orNotHavingLike('body', 'match');
// HAVING `title` LIKE '%match% OR  `body` NOT LIKE '%match%' ESCAPE '!'

結果排序 ?

$builder->orderBy()

該方法用于生成 ORDER BY 子句。

第一個參數(shù)包含你要排序的列名。

第二個參數(shù)用于設置排序的方向，可選項有： ASC ， DESC 和 RANDOM 。

$builder->orderBy('title', 'DESC');
// 生成: ORDER BY `title` DESC

第一個參數(shù)也可以是你自己的排序字符串:

$builder->orderBy('title DESC, name ASC');
// 生成: ORDER BY `title` DESC, `name` ASC

如果需要根據(jù)多個字段進行排序，可以多次調(diào)用該方法。

$builder->orderBy('title', 'DESC');
$builder->orderBy('name', 'ASC');
// 生成: ORDER BY `title` DESC, `name` ASC

如果你選擇了 RANDOM 選項，第一個參數(shù)會被忽略，除非你指定第一個參數(shù)作為隨機數(shù)的種子。

$builder->orderBy('title', 'RANDOM');
// 生成: ORDER BY RAND()

$builder->orderBy(42, 'RANDOM');
// 生成: ORDER BY RAND(42)

注解

Oracle 目前還不支持隨機排序，會默認使用 ASC 替代。

結果分頁與計數(shù)?

$builder->limit()

該方法可以讓你限制查詢結果的返回行數(shù):

$builder->limit(10);  // 生成: LIMIT 10

第二個參數(shù)可以用來設置偏移。

$builder->limit(10, 20);  // 生成: LIMIT 20, 10 (在 MySQL 里的情況，其他數(shù)據(jù)庫的語法略有不同）

$builder->countAllResults()

該方法用于獲取指定構造器查詢返回的結果數(shù)量，接受的構造器方法有

where() , orWhere() , like() , orLike() 等，例如:

echo $builder->countAllResults('my_table');  // 生成一個整數(shù)，比如 25
$builder->like('title', 'match');
$builder->from('my_table');
echo $builder->countAllResults(); // 生成一個整數(shù)，比如 17

然而，這個方法會重置你在 select() 里設置的所有值，如果你要保留它們，可以將第一個參數(shù)設置為 FALSE:

echo $builder->countAllResults(false); // 生成一個整數(shù)，比如 17

$builder->countAll()

該方法用于獲取指定表的總行數(shù)，例如:

echo $builder->countAll();  // 生成一個整數(shù)，比如 25

與 countAllResult 方法一樣，該方法也會重置你在 select() 里設置的所有值，如果你要保留它們，可以將第一個參數(shù)設置為 FALSE。

查詢分組 ?

查詢分組可以讓你生成用括號括起來的一組 WHERE 條件，這能創(chuàng)造出非常復雜的 WHERE 子句，支持嵌套的條件組。例如:

$builder->select('*')->from('my_table')
        ->groupStart()
                ->where('a', 'a')
                ->orGroupStart()
                        ->where('b', 'b')
                        ->where('c', 'c')
                ->groupEnd()
        ->groupEnd()
        ->where('d', 'd')
->get();

// 生成:
// SELECT * FROM (`my_table`) WHERE ( `a` = 'a' OR ( `b` = 'b' AND `c` = 'c' ) ) AND `d` = 'd'

注解

條件組必須要配對，確保每個 groupStart() 方法都有一個 groupEnd() 方法與之配對。

$builder->groupStart()

開始一個新的條件組，為查詢中的 WHERE 條件添加一個左括號。

$builder->orGroupStart()

開始一個新的條件組，為查詢中的 WHERE 條件添加一個左括號，并在前面加上 “OR” 。

$builder->notGroupStart()

開始一個新的條件組，為查詢中的 WHERE 條件添加一個左括號，并在前面加上 “NOT” 。

$builder->orNotGroupStart()

開始一個新的條件組，為查詢中的 WHERE 條件添加一個左括號，并在前面加上 “OR NOT” 。

$builder->groupEnd()

結束當前的條件組，為查詢中的 WHERE 條件添加一個右括號。

$builder->groupHavingStart()

開始一個新的條件組，為查詢中的 HAVING 條件添加一個左括號。

$builder->orGroupHavingStart()

開始一個新的條件組，為查詢中的 HAVING 條件添加一個左括號，并在前面加上 “OR” 。

$builder->notGroupHavingStart()

開始一個新的條件組，為查詢中的 HAVING 條件添加一個左括號，并在前面加上 “NOT” 。

$builder->orNotGroupHavingStart()

開始一個新的條件組，為查詢中的 HAVING 條件添加一個左括號，并在前面加上 “OR NOT” 。

$builder->groupHavingEnd()

結束當前的條件組，為查詢中的 HAVING 條件添加一個右括號。

插入數(shù)據(jù)?

$builder->insert()

該方法根據(jù)你提供的數(shù)據(jù)生成一條 INSERT 語句并執(zhí)行，它的參數(shù)是一個 數(shù)組 或一個對象，下面是使用數(shù)組的例子:

$data = array(
        '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')

第一個參數(shù)為要插入的數(shù)據(jù)，是個關聯(lián)數(shù)組。

下面是使用對象的例子:

/*
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')

第一個參數(shù)為要插入的數(shù)據(jù)，是個對象。

注解

所有數(shù)據(jù)會被自動轉義，生成安全的查詢語句。

$builder->ignore()

該方法根據(jù)你提供的數(shù)據(jù)生成一條 INSERT IGNORE 語句并執(zhí)行，如果已經(jīng)存在相同主鍵，該數(shù)據(jù)不會被插入。你可以給該方法傳入一個可選參數(shù)，類型是 boolean 。下面是使用數(shù)組的例子:

$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')

$builder->getCompiledInsert()

該方法和 $builder->insert() 方法一樣編譯插入查詢，但是 并不執(zhí)行 。此方法只是將 SQL 查詢作為字符串返回。

例如:

$data = array(
        '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')

第二個參數(shù)用于設置是否重置查詢（默認會重置，如 $builder->insert() 方法一樣）:

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->from() 方法，也沒有為查詢指定表名參數(shù)。因為這個查詢沒有被可重置值的 $builder->insert() 方法執(zhí)行，或是使用 $builder->resetQuery() 方法直接重置。

注解

這個方法不支持批量插入。

$builder->insertBatch()

該方法根據(jù)你提供的數(shù)據(jù)生成一條 INSERT 語句并執(zhí)行，它的參數(shù)可以是一個 數(shù)組 或一個對象，下面是使用數(shù)組的例子:

$data = array(
        array(
                'title' => 'My title',
                'name'  => 'My Name',
                'date'  => 'My date'
        ),
        array(
                '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')

第一個參數(shù)為要插入的數(shù)據(jù)，是個二維數(shù)組。

注解

所有數(shù)據(jù)會被自動轉義，生成安全的查詢語句。

更新數(shù)據(jù)?

$builder->replace()

該方法用于執(zhí)行一條 REPLACE 語句，基本上是（可選）DELETE + INSERT 的 SQL 標準，使用 PRIMARY 和 UNIQUE 鍵作為決定因素。在我們的例子中，它可以使你免于實現(xiàn)各種不同邏輯的組合： select() ， update() ， delete() 和 insert() 。

例如:

$data = array(
        'title' => 'My title',
        'name'  => 'My Name',
        'date'  => 'My date'
);

$builder->replace($data);

// Executes: REPLACE INTO mytable (title, name, date) VALUES ('My title', 'My name', 'My date')

上面的例子中，我們假設 title 字段是主鍵，那么如果我們數(shù)據(jù)庫里有一行包含 ‘My title’ 為標題的數(shù)據(jù)，那行將被刪除并被我們的新數(shù)據(jù)取代。

也可以使用 set() 方法，而且所有字段都被自動轉義，正如 insert() 方法一樣。

$builder->set()

該方法可以設置 insert 或 update 用到的數(shù)據(jù)。

它可以用來代替直接將數(shù)據(jù)數(shù)組傳遞給 insert 或 update 方法:

$builder->set('name', $name);
$builder->insert();  // 生成: INSERT INTO mytable (`name`) VALUES ('{$name}')

如果你多次調(diào)用該方法，它會正確組裝出 insert 或 update 語句來:

$builder->set('name', $name);
$builder->set('title', $title);
$builder->set('status', $status);
$builder->insert();

set() 將方法也接受可選的第三個參數(shù)（$escape），如果設置為 FALSE ，數(shù)據(jù)將不會自動轉義。為了說明區(qū)別，這里有一個帶轉義的 set() 方法和不帶轉義的例子。

$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

你也可以傳一個關聯(lián)數(shù)組作為參數(shù):

$array = array(
        'name'   => $name,
        'title'  => $title,
        'status' => $status
);

$builder->set($array);
$builder->insert();

或者一個對象:

/*
class Myclass {
        public $title   = 'My Title';
        public $content = 'My Content';
        public $date    = 'My Date';
}
*/

$object = new Myclass;
$builder->set($object);
$builder->insert();

$builder->update()

該方法根據(jù)你提供的數(shù)據(jù)生成更新字符串并執(zhí)行，它的參數(shù)是一個 數(shù)組 或一個對象，下面是使用數(shù)組的例子:

$data = array(
        '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

或者你可以使用一個對象:

/*
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`

注解

所有數(shù)據(jù)會被自動轉義，生成安全的查詢語句。

你應該注意到用 $builder->where() 方法可以為你設置 WHERE 子句。你可以選擇性的將這些（條件）信息直接以字符串傳入 update 方法:

$builder->update($data, "id = 4");

或者使用一個數(shù)組:

$builder->update($data, array('id' => $id));

當執(zhí)行更新操作時，你還可以使用上面介紹的 $builder->set() 方法。

$builder->updateBatch()

該方法根據(jù)你提供的數(shù)據(jù)生成一條 UPDATE 語句并執(zhí)行，它的參數(shù)是一個 數(shù)組 或一個對象，下面是使用數(shù)組的例子:

$data = array(
   array(
      'title' => 'My title' ,
      'name'  => 'My Name 2' ,
      'date'  => 'My date 2'
   ),
   array(
      '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')

第一個參數(shù)為要更新的數(shù)據(jù)，是個二維數(shù)組，第二個參數(shù)是 where 語句的鍵。

注解

所有數(shù)據(jù)會被自動轉義，生成安全的查詢語句。

注解

由于該方法的內(nèi)部實現(xiàn)，在這之后調(diào)用 affectedRows() 方法的返回值可能不正確，替代辦法是用 updateBatch() 的返回值，表示受影響的行數(shù)。

$builder->getCompiledUpdate()

該方法和 $builder->getCompiledInsert() 方法完全一樣，除了生成的 SQL 語句是 UPDATE 而不是 INSERT。

查看 $builder->getCompiledInsert() 方法的文檔獲取更多信息。

注解

該方法不支持批量更新。

刪除數(shù)據(jù)?

$builder->delete()

該方法生成刪除SQL語句并執(zhí)行。

$builder->delete(array('id' => $id));  // 生成: // DELETE FROM mytable  // WHERE id = $id

第一個參數(shù)為 where 子句。你也可以使用 where() 或 or_where() 方法替代第一個參數(shù):

$builder->where('id', $id);
$builder->delete();

// 生成:
// DELETE FROM mytable
// WHERE id = $id

如果你想刪除一個表中的全部數(shù)據(jù)，可以使用 truncate() 或 emptyTable() 方法。

$builder->emptyTable()

該方法生成刪除 SQl 語句并執(zhí)行:

$builder->emptyTable('mytable'); // 生成: DELETE FROM mytable

$builder->truncate()

該方法生截斷 SQL 語句并執(zhí)行。

$builder->truncate();

// 生成:
// TRUNCATE mytable

注解

如果 TRUNCATE 命令不可用，truncate() 方法將執(zhí)行 “DELETE FROM table”。

$builder->getCompiledDelete()

該方法和 $builder->getCompiledInsert() 方法完全一樣，除了生成的 SQL 語句是 DELETE 而不是 INSERT。

查看 $builder->getCompiledInsert() 方法的文檔獲取更多信息。

鏈式方法 ?

通過將多個方法連接在一起，鏈式方法可以大大簡化你的語法。感受一下這個例子:

$query = $builder->select('title')
                 ->where('id', $id)
                 ->limit(10, 20)
                 ->get();

重置查詢構造器 ?

$builder->resetQuery()

該方法使你可以重置查詢構造器，而無需先執(zhí)行例如 $builder->get() 或 $builder->insert() 這類方法。

當你要用查詢構造器生成 SQL 語句（如： $builder->getCompiledSelect() ），之后再執(zhí)行它，這種情況下，不重置查詢構造器很有用:

    // 注意 get_compiled_select 方法的第二個參數(shù)為 FALSE
$sql = $builder->select(['field1','field2'])
               ->where('field3',5)
               ->getCompiledSelect(false);

// ...
// 用 SQL 代碼做一些瘋狂的事情... 比如將它添加到 cron 腳本中
// 以后執(zhí)行還是什么...
// ...

$data = $builder->get()->getResultArray();

// 會執(zhí)行并返回以下查詢的結果數(shù)組嗎:
// SELECT field1, field1 from mytable where field3 = 5;

類庫參考 ?

class CodeIgniterDatabaseBaseBuilder?

resetQuery()?

返回: BaseBuilder instance (方法鏈)

返回類型: BaseBuilder

重置當前查詢構造器狀態(tài)。當你需要構建一個可在某些情況下取消的查詢時有用。

countAllResults([$reset = TRUE])?

參數(shù):

$reset (bool) – 是否重置 SELECT 的值

返回:
查詢結果中的行數(shù)

返回類型:
int

生成特定于平臺的查詢語句，用于計數(shù)查詢構造器返回的行數(shù)。

countAll([$reset = TRUE])?

參數(shù):

$reset (bool) – 是否重置 SELECT 的值

返回:
查詢結果中的行數(shù)

返回類型:
int

生成特定于平臺的查詢語句，用于計數(shù)查詢構造器返回的行數(shù)。

get([$limit = NULL[, $offset = NULL]])?

參數(shù):

$limit (int) – LIMIT 子句

$offset (int) – OFFSET 子句

返回:
CodeIgniterDatabaseResultInterface instance (方法鏈)

返回類型:
CodeIgniterDatabaseResultInterface

基于已經(jīng)調(diào)用過的查詢構造器方法，編譯執(zhí)行 SELECT 查詢。

getWhere([$where = NULL[, $limit = NULL[, $offset = NULL]]])?

參數(shù):

$where (string) – WHERE 子句

$limit (int) – LIMIT 子句

$offset (int) – OFFSET 子句

返回:
CodeIgniterDatabaseResultInterface instance (方法鏈)

返回類型:
CodeIgniterDatabaseResultInterface

與 get() 相同，但也允許直接添加 WHERE 。

select([$select = '*'[, $escape = NULL]])?

參數(shù):

$select (string) – 查詢的 SELECT 部分

$escape (bool) – 是否轉義值和標識符

返回:
BaseBuilder instance (方法鏈)

返回類型:
BaseBuilder

向查詢添加 SELECT 子句。

selectAvg([$select = ''[, $alias = '']])?

參數(shù):

$select (string) – 用于計算平均值的字段

$alias (string) – 結果值名稱的別名

返回:
BaseBuilder instance (方法鏈)

返回類型:
BaseBuilder

向查詢添加 SELECT AVG(field) 子句。

selectMax([$select = ''[, $alias = '']])?

參數(shù):

$select (string) – 用于計算最大值的字段

$alias (string) – 結果值名稱的別名

返回:
BaseBuilder instance (方法鏈)

返回類型:
BaseBuilder

向查詢添加 SELECT MAX(field) 子句。

selectMin([$select = ''[, $alias = '']])?

參數(shù):

$select (string) – 用于計算最小值的字段

$alias (string) – 結果值名稱的別名

返回:
BaseBuilder instance (方法鏈)

返回類型:
BaseBuilder

向查詢添加 SELECT MIN(field) 子句。

selectSum([$select = ''[, $alias = '']])?

參數(shù):

$select (string) – 字段來計算總和

$alias (string) – 結果值名稱的別名

返回:
BaseBuilder instance (方法鏈)

返回類型:
BaseBuilder

向查詢添加 SELECT SUM(field) 子句。

selectCount([$select = ''[, $alias = '']])?

參數(shù):

$select (string) – 用于計算記錄總和的字段

$alias (string) – 結果值名稱的別名

返回:
BaseBuilder instance (方法鏈)

返回類型:
BaseBuilder

向查詢添加 SELECT COUNT(field) 子句。

distinct([$val = TRUE])?

參數(shù):

$val (bool) – 預期的 “distinct” 標志值

返回:
BaseBuilder instance (方法鏈)

返回類型:
BaseBuilder

設置一個標志，告訴查詢構建器給 SELECT 部分添加 DISTINCT 子句。

from($from[, $overwrite = FALSE])?

參數(shù):

$from (mixed) – Table name(s); 字符串或數(shù)組

$overwrite (bool) – 是否移除第一個設置的表？

返回:
BaseBuilder instance (方法鏈)

返回類型:
BaseBuilder

指定查詢的 FROM 子句。

join($table, $cond[, $type = ''[, $escape = NULL]])?

參數(shù):

$table (string) – 要 join 的表名

$cond (string) – JOIN ON 條件

$type (string) – JOIN 類型

$escape (bool) – 是否轉義值和標識符

返回:
BaseBuilder instance (方法鏈)

返回類型:
BaseBuilder

向查詢添加JOIN子句。

where($key[, $value = NULL[, $escape = NULL]])?

參數(shù):

$key (mixed) – 要比較的字段名稱或關聯(lián)數(shù)組

$value (mixed) – 如果是單個鍵，則與此值相比

$escape (bool) – 是否轉義值和標識符

返回:
BaseBuilder instance

返回類型:
object

生成查詢的 WHERE 部分，用 ‘AND’ 分隔多個調(diào)用。

orWhere($key[, $value = NULL[, $escape = NULL]])?

參數(shù):

$key (mixed) – 要比較的字段名稱或關聯(lián)數(shù)組

$value (mixed) – 如果是單個鍵，則與此值相比

$escape (bool) – 是否轉義值和標識符

返回:
BaseBuilder instance

返回類型:
object

生成查詢的 WHERE 部分，用 ‘OR’ 分隔多個調(diào)用。

orWhereIn([$key = NULL[, $values = NULL[, $escape = NULL]]])?

參數(shù):

$key (string) – 要搜索的字段

$values (array|Closure) – 目標值的數(shù)組，或子查詢的匿名函數(shù)

$escape (bool) – 是否轉義值和標識符

返回:
BaseBuilder instance

返回類型:
object

生成一個 WHERE 字段 IN(‘item’, ‘item’) SQL 查詢，多個用 ‘OR’ 連接。

orWhereNotIn([$key = NULL[, $values = NULL[, $escape = NULL]]])?

參數(shù):

$key (string) – 要搜索的字段

$values (array|Closure) – 目標值的數(shù)組，或子查詢的匿名函數(shù)

$escape (bool) – 是否轉義值和標識符

返回:
BaseBuilder instance

返回類型:
object

生成一個 WHERE 字段 NOT IN(‘item’, ‘item’) SQL 查詢，多個用 ‘OR’ 連接。

whereIn([$key = NULL[, $values = NULL[, $escape = NULL]]])?

參數(shù):

$key (string) – 要檢查的字段的名稱

$values (array|Closure) – 目標值的數(shù)組，或子查詢的匿名函數(shù)

$escape (bool) – 是否轉義值和標識符

返回:
BaseBuilder instance

返回類型:
object

生成一個 WHERE 字段 IN(‘item’, ‘item’) SQL 查詢，多個用 ‘AND’ 連接。

whereNotIn([$key = NULL[, $values = NULL[, $escape = NULL]]])?

參數(shù):

$key (string) – 要檢查的字段的名稱

$values (array|Closure) – 目標值的數(shù)組，或子查詢的匿名函數(shù)

$escape (bool) – 是否轉義值和標識符

返回:
BaseBuilder instance

返回類型:
object

生成一個 WHERE 字段 NOT IN(‘item’, ‘item’) SQL 查詢，多個用 ‘AND’ 連接。

groupStart()?

返回: BaseBuilder instance (方法鏈)

返回類型: BaseBuilder

啟動組表達式，使用 AND 連接其中的條件。

orGroupStart()?

返回: BaseBuilder instance (方法鏈)

返回類型: BaseBuilder

啟動組表達式，使用 OR 連接其中的條件。

notGroupStart()?

返回: BaseBuilder instance (方法鏈)

返回類型: BaseBuilder

啟動組表達式，使用 AND NOT 連接其中的條件。

orNotGroupStart()?

返回: BaseBuilder instance (方法鏈)

返回類型: BaseBuilder

啟動組表達式，使用 OR NOT 連接其中的條件。

groupEnd()?

返回: BaseBuilder instance

返回類型: object

完成一個組表達式。

like($field[, $match = ''[, $side = 'both'[, $escape = NULL[, $insensitiveSearch = FALSE]]]])?

參數(shù):

$field (string) – 字段名

$match (string) – 匹配的文本部分

$side (string) – 將 ‘%’ 通配符放在表達式的哪一側

$escape (bool) – 是否轉義值和標識符

$insensitiveSearch (bool) – 是否強制大小寫不敏感檢索

返回:
BaseBuilder instance (方法鏈)

返回類型:
BaseBuilder

向查詢添加 LIKE 子句，用 AND 分隔多個調(diào)用。

orLike($field[, $match = ''[, $side = 'both'[, $escape = NULL[, $insensitiveSearch = FALSE]]]])?

參數(shù):

$field (string) – 字段名

$match (string) – 匹配的文本部分

$side (string) – 將 ‘%’ 通配符放在表達式的哪一側

$escape (bool) – 是否轉義值和標識符

$insensitiveSearch (bool) – 是否強制大小寫不敏感檢索

返回:
BaseBuilder instance (方法鏈)

返回類型:
BaseBuilder

向查詢添加 LIKE 子句，用 OR 分隔多個調(diào)用。

notLike($field[, $match = ''[, $side = 'both'[, $escape = NULL[, $insensitiveSearch = FALSE]]]])?

參數(shù):

$field (string) – 字段名

$match (string) – 匹配的文本部分

$side (string) – 將 ‘%’ 通配符放在表達式的哪一側

$escape (bool) – 是否轉義值和標識符

$insensitiveSearch (bool) – 是否強制大小寫不敏感檢索

返回:
BaseBuilder instance (方法鏈)

返回類型:
BaseBuilder

向查詢添加 NOT LIKE 子句，用 AND 分隔多個調(diào)用。

orNotLike($field[, $match = ''[, $side = 'both'[, $escape = NULL[, $insensitiveSearch = FALSE]]]])?

參數(shù):

$field (string) – 字段名

$match (string) – 匹配的文本部分

$side (string) – 將 ‘%’ 通配符放在表達式的哪一側

$escape (bool) – 是否轉義值和標識符

$insensitiveSearch (bool) – 是否強制大小寫不敏感檢索

返回:
BaseBuilder instance (方法鏈)

返回類型:
BaseBuilder

向查詢添加 NOT LIKE 子句，用 OR 分隔多個調(diào)用。

having($key[, $value = NULL[, $escape = NULL]])?

參數(shù):

$key (mixed) – 標識符（字符串）或 field/value 對的關聯(lián)數(shù)組

$value (string) – 如果 $key 是標識符，則尋求此值

$escape (string) – 是否轉義值和標識符

返回:
BaseBuilder instance (方法鏈)

返回類型:
BaseBuilder

向查詢添加 HAVING 子句，用 AND 分隔多個調(diào)用。

orHaving($key[, $value = NULL[, $escape = NULL]])?

參數(shù):

$key (mixed) – 標識符（字符串）或 field/value 對的關聯(lián)數(shù)組

$value (string) – 如果 $key 是標識符，則尋求此值

$escape (string) – 是否轉義值和標識符

返回:
BaseBuilder instance (方法鏈)

返回類型:
BaseBuilder

向查詢添加 HAVING 子句，用 OR 分隔多個調(diào)用。

orHavingIn([$key = NULL[, $values = NULL[, $escape = NULL]]])?

參數(shù):

$key (string) – 要檢索的字段名

$values (array|Closure) – 目標值的數(shù)組，或子查詢的匿名函數(shù)

$escape (bool) – 是否轉義值和標識符

返回:
BaseBuilder instance

返回類型:
object

向查詢添加 HAVING 字段 IN(‘item’, ‘item’) 子句，多個用 OR 連接。

orHavingNotIn([$key = NULL[, $values = NULL[, $escape = NULL]]])?

參數(shù):

$key (string) – 要檢索的字段名

$values (array|Closure) – 目標值的數(shù)組，或子查詢的匿名函數(shù)

$escape (bool) – 是否轉義值和標識符

返回:
BaseBuilder instance

返回類型:
object

向查詢添加 HAVING 字段 NOT IN(‘item’, ‘item’) 子句，多個用 OR 連接。

havingIn([$key = NULL[, $values = NULL[, $escape = NULL]]])?

參數(shù):

$key (string) – 要檢索的字段名

$values (array|Closure) – 目標值的數(shù)組，或子查詢的匿名函數(shù)

$escape (bool) – 是否轉義值和標識符

返回:
BaseBuilder instance

返回類型:
object

向查詢添加 HAVING 字段 IN(‘item’, ‘item’) 子句，多個用 AND 連接。

havingNotIn([$key = NULL[, $values = NULL[, $escape = NULL]]])?

參數(shù):

$key (string) – 要檢索的字段名

$values (array|Closure) – 目標值的數(shù)組，或子查詢的匿名函數(shù)

$escape (bool) – 是否轉義值和標識符

返回:
BaseBuilder instance

返回類型:
object

向查詢添加 HAVING 字段 NOT IN(‘item’, ‘item’) 子句，多個用 AND 連接。

havingLike($field[, $match = ''[, $side = 'both'[, $escape = NULL[, $insensitiveSearch = FALSE]]]])?

參數(shù):

$field (string) – 字段名

$match (string) – 匹配的文本部分

$side (string) – 將 ‘%’ 通配符放在表達式的哪一側

$escape (bool) – 是否轉義值和標識符

$insensitiveSearch (bool) – 是否強制大小寫不敏感檢索

返回:
BaseBuilder instance (方法鏈)

返回類型:
BaseBuilder

向查詢的 HAVING 部分添加 LIKE 子句，用 AND 分隔多個調(diào)用。

orHavingLike($field[, $match = ''[, $side = 'both'[, $escape = NULL[, $insensitiveSearch = FALSE]]]])?

參數(shù):

$field (string) – 字段名

$match (string) – 匹配的文本部分

$side (string) – 將 ‘%’ 通配符放在表達式的哪一側

$escape (bool) – 是否轉義值和標識符

$insensitiveSearch (bool) – 是否強制大小寫不敏感檢索

返回:
BaseBuilder instance (方法鏈)

返回類型:
BaseBuilder

向查詢的 HAVING 部分添加 LIKE 子句，用 OR 分隔多個調(diào)用。

notHavingLike($field[, $match = ''[, $side = 'both'[, $escape = NULL[, $insensitiveSearch = FALSE]]]])?

參數(shù):

$field (string) – 字段名

$match (string) – 匹配的文本部分

$side (string) – 將 ‘%’ 通配符放在表達式的哪一側

$escape (bool) – 是否轉義值和標識符

$insensitiveSearch (bool) – 是否強制大小寫不敏感檢索

返回:
BaseBuilder instance (方法鏈)

返回類型:
BaseBuilder

向查詢的 HAVING 部分添加 NOT LIKE 子句，用 AND 分隔多個調(diào)用。

orNotHavingLike($field[, $match = ''[, $side = 'both'[, $escape = NULL[, $insensitiveSearch = FALSE]]]])?

參數(shù):

$field (string) – 字段名

$match (string) – 匹配的文本部分

$side (string) – 將 ‘%’ 通配符放在表達式的哪一側

$escape (bool) – 是否轉義值和標識符

$insensitiveSearch (bool) – 是否強制大小寫不敏感檢索

返回:
BaseBuilder instance (方法鏈)

返回類型:
BaseBuilder

向查詢的 HAVING 部分添加 NOT LIKE 子句，用 OR 分隔多個調(diào)用。

havingGroupStart()?

返回: BaseBuilder instance (方法鏈)

返回類型: BaseBuilder

啟動 HAVING 子句的組表達式，使用 AND 連接其中的條件。

orHavingGroupStart()?

返回: BaseBuilder instance (方法鏈)

返回類型: BaseBuilder

啟動 HAVING 子句的組表達式，使用 OR 連接其中的條件。

notHavingGroupStart()?

返回: BaseBuilder instance (方法鏈)

返回類型: BaseBuilder

啟動 HAVING 子句的組表達式，使用 AND NOT 連接其中的條件。

orNotHavingGroupStart()?

返回: BaseBuilder instance (方法鏈)

返回類型: BaseBuilder

啟動 HAVING 子句的組表達式，使用 OR NOT 連接其中的條件。

havingGroupEnd()?

返回: BaseBuilder instance

返回類型: object

完成一個 HAVING 子句的組表達式。

groupBy($by[, $escape = NULL])?

參數(shù):

$by (mixed) – 根據(jù)字段分組; 字符串或數(shù)組

返回:
BaseBuilder instance (方法鏈)

返回類型:
BaseBuilder

向查詢添加 GROUP BY 子句。

orderBy($orderby[, $direction = ''[, $escape = NULL]])?

參數(shù):

$orderby (string) – 根據(jù)字段排序

$direction (string) – 要求的排序 - ASC ， DESC 或 RANDOM

$escape (bool) – 是否轉義值和標識符

返回:
BaseBuilder instance (方法鏈)

返回類型:
BaseBuilder

向查詢添加 ORDER BY 子句。

limit($value[, $offset = 0])?

參數(shù):

$value (int) – 限制返回行數(shù)

$offset (int) – 偏移行數(shù)

返回:
BaseBuilder instance (方法鏈)

返回類型:
BaseBuilder

向查詢添加 LIMIT 和 OFFSET 子句。

offset($offset)?

參數(shù):

$offset (int) – 偏移行數(shù)

返回:
BaseBuilder instance (方法鏈)

返回類型:
BaseBuilder

向查詢添加 OFFSET 子句。

set($key[, $value = ''[, $escape = NULL]])?

參數(shù):

$key (mixed) – 字段名或 field/value 對的關聯(lián)數(shù)組

$value (string) – 字段值，如果 $key 是單個字段

$escape (bool) – 是否轉義值和標識符

返回:
BaseBuilder instance (方法鏈)

返回類型:
BaseBuilder

添加 field/value 鍵值對，稍后用于傳遞給 insert() ， update() 或 replace() 。

insert([$set = NULL[, $escape = NULL]])?

參數(shù):

$set (array) – field/value 對的關聯(lián)數(shù)組

$escape (bool) – 是否轉義值和標識符

返回:
成功時為 TRUE，失敗時為 FALSE

返回類型:
bool

編譯并執(zhí)行 INSERT 語句。

insertBatch([$set = NULL[, $escape = NULL[, $batch_size = 100]]])?

參數(shù):

$set (array) – 要插入的數(shù)據(jù)

$escape (bool) – 是否轉義值和標識符

$batch_size (int) – 要一次插入的行數(shù)

返回:
插入的行數(shù)或失敗時的 FALSE

返回類型:
mixed

編譯并執(zhí)行批量的 INSERT 語句。

注解

當數(shù)據(jù)超過 $batch_size 行時，將執(zhí)行多個 INSERT 查詢，每次嘗試插入最多為 $batch_size 行。

setInsertBatch($key[, $value = ''[, $escape = NULL]])?

參數(shù):

$key (mixed) – 字段名或 field/value 對應的關聯(lián)數(shù)組

$value (string) – 字段值，如果 $key 是單個字段

$escape (bool) – 是否轉義值和標識符

返回:
BaseBuilder instance (方法鏈)

返回類型:
BaseBuilder

添加 field/value 鍵值對，稍后通過 insertBatch() 向一個表插入。

update([$set = NULL[, $where = NULL[, $limit = NULL]]])?

參數(shù):

$set (array) – field/value 對應的關聯(lián)數(shù)組

$where (string) – WHERE 子句

$limit (int) – LIMIT 子句

返回:
TRUE 為成功, FALSE 為失敗

返回類型:
bool

編譯并執(zhí)行 UPDATE 語句。

updateBatch([$set = NULL[, $value = NULL[, $batch_size = 100]]])?

參數(shù):

$set (array) – 字段名，或 field/value 對的關聯(lián)數(shù)組

$value (string) – 字段值，如果 $set 是單個字段

$batch_size (int) – 在單個查詢中分組的條件計數(shù)

返回:
更新的行數(shù)或失敗時的 FALSE

返回類型:
mixed

編譯并執(zhí)行批量的 UPDATE 語句。

注解

當數(shù)據(jù)超過 $batch_size 行時，將執(zhí)行多個 INSERT 查詢，每次最多處理 $batch_size 行。

setUpdateBatch($key[, $value = ''[, $escape = NULL]])?

參數(shù):

$key (mixed) – 字段名，或 field/value 對的關聯(lián)數(shù)組

$value (string) – 字段值，如果 $key 是單個字段

$escape (bool) – 是否轉義值和標識符

返回:
BaseBuilder instance (方法鏈)

返回類型:
BaseBuilder

添加 field/value 鍵值對，稍后通過 updateBatch() 更新一個表。

replace([$set = NULL])?

參數(shù):

$set (array) – field/value 對應的關聯(lián)數(shù)組

返回:
TRUE 為成功, FALSE 為失敗

返回類型:
bool

編譯并執(zhí)行 REPLACE 語句。

delete([$where = ''[, $limit = NULL[, $reset_data = TRUE]]])?

參數(shù):

$where (string) – WHERE 子句

$limit (int) – LIMIT 子句

$reset_data (bool) – TRUE 會重置查詢 “write” 子句

返回:
BaseBuilder instance (方法鏈) 或者失敗時為 FALSE

返回類型:
mixed

編譯并執(zhí)行 DELETE 查詢。

increment($column[, $value = 1])?

參數(shù):	$column (string) – 要遞增的列的名稱 $value (int) – 要給列增加的數(shù)值給一個字段增加指定量的數(shù)值，如果該字段不是數(shù)字型字段，比如如 VARCHAR ，它可能會被新的 $value 值替換。

decrement($column[, $value = 1])?

參數(shù):	$column (string) – 要減少的列的名稱 $value (int) – 要給列減少的數(shù)值給一個字段減去指定量的數(shù)值，如果該字段不是數(shù)字型字段，比如如 VARCHAR ，它可能會被新的 $value 值替換。

truncate()?

返回:	TRUE 為成功, FALSE 為失敗
返回類型:	bool

在表上執(zhí)行 TRUNCATE 語句。

注解

如果所用的數(shù)據(jù)庫平臺不支持 TRUNCATE ，將使用 DELETE 語句替代。

emptyTable()?

返回:	TRUE 為成功, FALSE 為失敗
返回類型:	bool

通過 DELETE 語句刪除表中所有記錄。

getCompiledSelect([$reset = TRUE])?

參數(shù):	$reset (bool) – 是否重置當前查詢構造器（QB）的值
返回:	已編譯的 SQL 語句為字符串
返回類型:	string

編譯 SELECT 語句并將其作為字符串返回。

getCompiledInsert([$reset = TRUE])?

參數(shù):	$reset (bool) – 是否重置當前查詢構造器（QB）的值
返回:	已編譯的 SQL 語句為字符串
返回類型:	string

編譯 INSERT 語句并將其作為字符串返回。

getCompiledUpdate([$reset = TRUE])?

參數(shù):	$reset (bool) – 是否重置當前查詢構造器（QB）的值
返回:	已編譯的 SQL 語句為字符串
返回類型:	string

編譯 UPDATE 語句并將其作為字符串返回。

getCompiledDelete([$reset = TRUE])?

參數(shù):	$reset (bool) – 是否重置當前查詢構造器（QB）的值
返回:	已編譯的 SQL 語句為字符串
返回類型:	string

編譯 DELETE 語句并將其作為字符串返回。