CodeIgniter4 查询构造器类

CodeIgniter 提供了查询构造器类，它允许你用较少的代码量获取数据库的信息、新增或更新数据。有时只需要一两行代码就能完成数据库操作。CodeIgniter 不要求每个数据表有一个类文件，它使用了一种更简单的接口。

除了简单，使用查询构造器的主要好处是可以让你创建跨数据库的应用程序，因为查询语句是由每种数据库适配器生成的。它也允许用于更安全的查询，因为系统会自动转义传入数据。

加载查询构造器

查询构造器通过数据库连接对象的 table() 方法加载，这会设置查询语句 FROM 的部分并且返回一个查询构造器的新实例:

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

查询构造器仅在你明确请求类时才加载到内存中，因此默认不使用（消耗）任何资源。

选择数据

下面的方法用来构建 SQL SELECT 语句。

$builder->get()

执行选择查询并返回结果，可用于获取一个表的所有记录:

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

第一个和第二个参数用于设置 limit 和 offset 子句:

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


// 执行: SELECT * FROM mytable LIMIT 20, 10
// (在 MySQL 里的情况，其他数据库的语法略有不同）

你应该已经注意到了，上面方法的结果赋值给了一个 $query 变量，我们可以用它输出查询结果:

$query = $builder->get();


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

请访问结果方法页面获得结果生成的完整论述。

$builder->getCompiledSelect()

和 $builder->get() 方法一样编译选择查询但是并不执行，此方法只是将 SQL 查询语句作为字符串返回。

例如:

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


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

第一个参数使你能设置是否重置查询构造器（默认重置，就像使用 $builder->get() 时一样):

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


// 输出字符串: SELECT * FROM mytable LIMIT 20, 10
// (在 MySQL 里的情况，其他数据库的语法略有不同）


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


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

最值得注意的是，上例第二个查询并没有用到 $builder->from() 方法，也没有为查询指定表名参数。因为这个查询没有被可重置值的 $builder->get() 方法执行，或是使用 $builder->resetQuery() 方法直接重置。

$builder->getWhere()

与 get() 函数相同，只是它允许你用第一个参数中添加 “where” 子句，而不是使用 db->where() 功能:

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

请阅读下面 where 方法获得更多信息。

$builder->select()

允许你编写查询的 SELECT 部分:

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


// 执行: SELECT title, content, date FROM mytable

注解

如果要从表中选择全部字段 () ，不需要使用这个函数。当省略它时，CodeIgniter 假定你希望选择所有字段并自动添加 ‘SELECT ’ 。

$builder->select() 方法的第二个参数可选，如果设置为 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) 部分，你可以使用第二个参数重命名结果字段（可选）。

$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() 一样，你可以使用第二个参数重命名结果字段（可选）。

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

$builder->selectAvg()

该方法用于编写查询语句中的 “SELECT AVG(field)” 部分，和 selectMax() 一样，你可以使用第二个参数重命名结果字段（可选）。

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

$builder->selectSum()

该方法用于编写查询语句中的 “SELECT SUM(field)” 部分，和 selectMax() 一样，你可以使用第二个参数重命名结果字段（可选）。

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

$builder->selectCount()

该方法用于编写查询语句中的 “SELECT COUNT(field)” 部分，和 selectMax() 一样，你可以使用第二个参数重命名结果字段（可选）。

注解

该方法在使用 groupBy() 时特别有用。用于一般的结果计数详见 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() 中指定。额外调用 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

如果你的查询有多个连接，可以多次调用这个方法。

你可以传入第三个参数指定连接的类型，可选: left，right, outer, inner, left outer 和 right outer 。

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

查找具体数据

$builder->where()

该方法提供了4中方式让你编写查询语句中的 WHERE 子句:

注解

所有传入数据将会自动转义，生成安全的查询语句。

简单的 key/value 方式:

   $builder->where('name', $name); // 生成: WHERE name = 'Joe'

注意它自动为你加上了等号。

如果你多次调用该方法，那么多个 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 方式:

你可以在第一个参数中包含一个比较运算符，用来控制比较条件:

   $builder->where('name !=', $name);
   $builder->where('id <', $id); // 生成: WHERE name != 'Joe' AND id < 45

关联数组方式:

   $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() 的第三个参数（可选），如果设置为 FALSE，CodeIgniter 将不保护你的表名和字段名。

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

子查询:

你可以使用匿名函数生成一个子查询。

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

你可以用子查询替代数组值。

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

你可以用子查询替代数组值。

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

你可以用子查询替代数组值。

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

你可以用子查询替代数组值。

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

查找相似的数据

$builder->like()

这个方法使您能够生成类似 LIKE 子句，做搜索时非常有用。

注解

所有传入数据将被自动转义。

like* 通过传第五个参数传递值 true 可以强制在执行查询时不区分大小写。这项特性可用性跟平台相关，否则将强制值转为小写，例如 WHERE LOWER(column) LIKE '%search%'，让其生效可能需要在制作索引时用 LOWER(column) 而不是 column 。

简单 key/value 方式:

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

如果你多次调用该方法，那么多个 WHERE 条件将会使用 AND 连接起来:

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

如果你想控制通配符通配符（%）的位置，可以指定第三个参数，可用选项：’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 '!'

关联数组方式:

   $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

你也可以通过一个数组传入多个值:

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

$builder->distinct()

该方法用于向查询中添加 “DISTINCT” 关键字

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

$builder->having()

该方法用于生成 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

如果你正在使用 CodeIgniter 为其转义查询的数据库，你可以传第三个可选参数来防止转义内容，设为 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)

你可以用子查询代替数组。

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

你可以用子查询代替数组。

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

你可以用子查询代替数组。

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

你可以用子查询代替数组。

$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 子句，常用于搜索。

注解

该方法所有传入参数会被自动转义。

havingLike* 通过传第五个参数传递值 true 可以强制在执行查询时不区分大小写。这项特性可用性跟平台相关，否则将强制值转为小写，例如 HAVING LOWER(column) LIKE '%search%'，让其生效可能需要在制作索引时用 LOWER(column) 而不是 column 。

简单 key/value 方式:

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

如果你多次调用该方法，那么多个 WHERE 条件将会使用 AND 连接起来:

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

如果你想控制通配符通配符（%）的位置，可以指定第三个参数，可用选项：’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 '!'

关联数组方式:

   $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 子句。

第一个参数包含你要排序的列名。

第二个参数用于设置排序的方向，可选项有： ASC ， DESC 和 RANDOM 。

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

第一个参数也可以是你自己的排序字符串:

$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 选项，第一个参数会被忽略，除非你指定第一个参数作为随机数的种子。

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


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

注解

Oracle 目前还不支持随机排序，会默认使用 ASC 替代。

结果分页与计数

$builder->limit()

该方法可以让你限制查询结果的返回行数:

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

第二个参数可以用来设置偏移。

$builder->limit(10, 20);  // 生成: LIMIT 20, 10 (在 MySQL 里的情况，其他数据库的语法略有不同）

$builder->countAllResults()

该方法用于获取指定构造器查询返回的结果数量，接受的构造器方法有

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

echo $builder->countAllResults('my_table');  // 生成一个整数，比如 25
$builder->like('title', 'match');
$builder->from('my_table');
echo $builder->countAllResults(); // 生成一个整数，比如 17

然而，这个方法会重置你在 select() 里设置的所有值，如果你要保留它们，可以将第一个参数设置为 FALSE:

echo $builder->countAllResults(false); // 生成一个整数，比如 17

$builder->countAll()

该方法用于获取指定表的总行数，例如:

echo $builder->countAll();  // 生成一个整数，比如 25

与 countAllResult 方法一样，该方法也会重置你在 select() 里设置的所有值，如果你要保留它们，可以将第一个参数设置为 FALSE。

查询分组

查询分组可以让你生成用括号括起来的一组 WHERE 条件，这能创造出非常复杂的 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 条件添加一个右括号。

插入数据

$builder->insert()

该方法根据你提供的数据生成一条 INSERT 语句并执行，它的参数是一个数组或一个对象，下面是使用数组的例子:

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

第一个参数为要插入的数据，是个关联数组。

下面是使用对象的例子:

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

第一个参数为要插入的数据，是个对象。

注解

所有数据会被自动转义，生成安全的查询语句。

$builder->ignore()

该方法根据你提供的数据生成一条 INSERT IGNORE 语句并执行，如果已经存在相同主键，该数据不会被插入。你可以给该方法传入一个可选参数，类型是 boolean 。下面是使用数组的例子:

$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() 方法一样编译插入查询，但是 并不执行 。此方法只是将 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')

第二个参数用于设置是否重置查询（默认会重置，如 $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() 方法，也没有为查询指定表名参数。因为这个查询没有被可重置值的 $builder->insert() 方法执行，或是使用 $builder->resetQuery() 方法直接重置。

注解

这个方法不支持批量插入。

$builder->insertBatch()

该方法根据你提供的数据生成一条 INSERT 语句并执行，它的参数可以是一个数组或一个对象，下面是使用数组的例子:

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

第一个参数为要插入的数据，是个二维数组。

注解

所有数据会被自动转义，生成安全的查询语句。

更新数据

$builder->replace()

该方法用于执行一条 REPLACE 语句，基本上是（可选）DELETE + INSERT 的 SQL 标准，使用 PRIMARY 和 UNIQUE 键作为决定因素。在我们的例子中，它可以使你免于实现各种不同逻辑的组合： 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 字段是主键，那么如果我们数据库里有一行包含 ‘My title’ 为标题的数据，那行将被删除并被我们的新数据取代。

也可以使用 set() 方法，而且所有字段都被自动转义，正如 insert() 方法一样。

$builder->set()

该方法可以设置 insert 或 update 用到的数据。

它可以用来代替直接将数据数组传递给 insert 或 update 方法:

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

如果你多次调用该方法，它会正确组装出 insert 或 update 语句来:

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

set() 将方法也接受可选的第三个参数（$escape），如果设置为 FALSE ，数据将不会自动转义。为了说明区别，这里有一个带转义的 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

你也可以传一个关联数组作为参数:

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

该方法根据你提供的数据生成更新字符串并执行，它的参数是一个数组或一个对象，下面是使用数组的例子:

$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`

注解

所有数据会被自动转义，生成安全的查询语句。

你应该注意到用 $builder->where() 方法可以为你设置 WHERE 子句。你可以选择性的将这些（条件）信息直接以字符串传入 update 方法:

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

或者使用一个数组:

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

当执行更新操作时，你还可以使用上面介绍的 $builder->set() 方法。

$builder->updateBatch()

该方法根据你提供的数据生成一条 UPDATE 语句并执行，它的参数是一个数组或一个对象，下面是使用数组的例子:

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

第一个参数为要更新的数据，是个二维数组，第二个参数是 where 语句的键。

注解

所有数据会被自动转义，生成安全的查询语句。

由于该方法的内部实现，在这之后调用 affectedRows() 方法的返回值可能不正确，替代办法是用 updateBatch() 的返回值，表示受影响的行数。

$builder->getCompiledUpdate()

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

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

注解

该方法不支持批量更新。

删除数据

$builder->delete()

该方法生成删除SQL语句并执行。

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

第一个参数为 where 子句。你也可以使用 where() 或 or_where() 方法替代第一个参数:

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


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

如果你想删除一个表中的全部数据，可以使用 truncate() 或 emptyTable() 方法。

$builder->emptyTable()

该方法生成删除 SQl 语句并执行:

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

$builder->truncate()

该方法生截断 SQL 语句并执行。

$builder->truncate();


// 生成:
// TRUNCATE mytable

注解

如果 TRUNCATE 命令不可用，truncate() 方法将执行 “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()

该方法使你可以重置查询构造器，而无需先执行例如 $builder->get() 或 $builder->insert() 这类方法。

当你要用查询构造器生成 SQL 语句（如： $builder->getCompiledSelect() ），之后再执行它，这种情况下，不重置查询构造器很有用:

    // 注意 get_compiled_select 方法的第二个参数为 FALSE
$sql = $builder->select(['field1','field2'])
               ->where('field3',5)
               ->getCompiledSelect(false);


// ...
// 用 SQL 代码做一些疯狂的事情... 比如将它添加到 cron 脚本中
// 以后执行还是什么...
// ...


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


// 会执行并返回以下查询的结果数组吗:
// SELECT field1, field1 from mytable where field3 = 5;

类库参考

*class*`CodeIgniterDatabaseBaseBuilder`

resetQuery()

返回:	BaseBuilder instance (方法链)
返回类型:	BaseBuilder

重置当前查询构造器状态。当你需要构建一个可在某些情况下取消的查询时有用。

countAllResults([$reset = TRUE])

参数:	$reset (bool) – 是否重置 SELECT 的值
返回:	查询结果中的行数
返回类型:	int

生成特定于平台的查询语句，用于计数查询构造器返回的行数。

countAll([$reset = TRUE])

参数:	$reset (bool) – 是否重置 SELECT 的值
返回:	查询结果中的行数
返回类型:	int

生成特定于平台的查询语句，用于计数查询构造器返回的行数。

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

参数:	$limit (int) – LIMIT 子句
	$offset (int) – OFFSET 子句
返回:	CodeIgniterDatabaseResultInterface instance (方法链)
返回类型:	CodeIgniterDatabaseResultInterface

基于已经调用过的查询构造器方法，编译执行 SELECT 查询。

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

参数:	$where (string) – WHERE 子句
	$limit (int) – LIMIT 子句
	$offset (int) – OFFSET 子句
返回:	CodeIgniterDatabaseResultInterface instance (方法链)
返回类型:	CodeIgniterDatabaseResultInterface

与 get() 相同，但也允许直接添加 WHERE 。

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

参数:	$select (string) – 查询的 SELECT 部分
	$escape (bool) – 是否转义值和标识符
返回:	BaseBuilder instance (方法链)
返回类型:	BaseBuilder

向查询添加 SELECT 子句。

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

参数:	$select (string) – 用于计算平均值的字段
	$alias (string) – 结果值名称的别名
返回:	BaseBuilder instance (方法链)
返回类型:	BaseBuilder

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

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

参数:	$select (string) – 用于计算最大值的字段
	$alias (string) – 结果值名称的别名
返回:	BaseBuilder instance (方法链)
返回类型:	BaseBuilder

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

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

参数:	$select (string) – 用于计算最小值的字段
	$alias (string) – 结果值名称的别名
返回:	BaseBuilder instance (方法链)
返回类型:	BaseBuilder

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

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

参数:	$select (string) – 字段来计算总和
	$alias (string) – 结果值名称的别名
返回:	BaseBuilder instance (方法链)
返回类型:	BaseBuilder

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

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

参数:	$select (string) – 用于计算记录总和的字段
	$alias (string) – 结果值名称的别名
返回:	BaseBuilder instance (方法链)
返回类型:	BaseBuilder

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

distinct([$val = TRUE])

参数:	$val (bool) – 预期的 “distinct” 标志值
返回:	BaseBuilder instance (方法链)
返回类型:	BaseBuilder

设置一个标志，告诉查询构建器给 SELECT 部分添加 DISTINCT 子句。

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

参数:	$from (mixed) – Table name(s); 字符串或数组
	$overwrite (bool) – 是否移除第一个设置的表？
返回:	BaseBuilder instance (方法链)
返回类型:	BaseBuilder

指定查询的 FROM 子句。

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

参数:	$table (string) – 要 join 的表名
	$cond (string) – JOIN ON 条件
	$type (string) – JOIN 类型
	$escape (bool) – 是否转义值和标识符
返回:	BaseBuilder instance (方法链)
返回类型:	BaseBuilder

向查询添加JOIN子句。

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

参数:	$key (mixed) – 要比较的字段名称或关联数组
	$value (mixed) – 如果是单个键，则与此值相比
	$escape (bool) – 是否转义值和标识符
返回:	BaseBuilder instance
返回类型:	object

生成查询的 WHERE 部分，用 ‘AND’ 分隔多个调用。

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

参数:	$key (mixed) – 要比较的字段名称或关联数组
	$value (mixed) – 如果是单个键，则与此值相比
	$escape (bool) – 是否转义值和标识符
返回:	BaseBuilder instance
返回类型:	object

生成查询的 WHERE 部分，用 ‘OR’ 分隔多个调用。

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

参数:	$key (string) – 要搜索的字段
	$values (array/Closure) – 目标值的数组，或子查询的匿名函数
	$escape (bool) – 是否转义值和标识符
返回:	BaseBuilder instance
返回类型:	object

生成一个 WHERE 字段 IN(‘item’, ‘item’) SQL 查询，多个用 ‘OR’ 连接。

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

参数:	$key (string) – 要搜索的字段
	$values (array/Closure) – 目标值的数组，或子查询的匿名函数
	$escape (bool) – 是否转义值和标识符
返回:	BaseBuilder instance
返回类型:	object

生成一个 WHERE 字段 NOT IN(‘item’, ‘item’) SQL 查询，多个用 ‘OR’ 连接。

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

参数:	$key (string) – 要检查的字段的名称
	$values (array/Closure) – 目标值的数组，或子查询的匿名函数
	$escape (bool) – 是否转义值和标识符
返回:	BaseBuilder instance
返回类型:	object

生成一个 WHERE 字段 IN(‘item’, ‘item’) SQL 查询，多个用 ‘AND’ 连接。

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

参数:	$key (string) – 要检查的字段的名称
	$values (array/Closure) – 目标值的数组，或子查询的匿名函数
	$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]]]])

参数:	$field (string) – 字段名
	$match (string) – 匹配的文本部分
	$side (string) – 将 ‘%’ 通配符放在表达式的哪一侧
	$escape (bool) – 是否转义值和标识符
	$insensitiveSearch (bool) – 是否强制大小写不敏感检索
返回:	BaseBuilder instance (方法链)
返回类型:	BaseBuilder

向查询添加 LIKE 子句，用 AND 分隔多个调用。

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

参数:	$field (string) – 字段名
	$match (string) – 匹配的文本部分
	$side (string) – 将 ‘%’ 通配符放在表达式的哪一侧
	$escape (bool) – 是否转义值和标识符
	$insensitiveSearch (bool) – 是否强制大小写不敏感检索
返回:	BaseBuilder instance (方法链)
返回类型:	BaseBuilder

向查询添加 LIKE 子句，用 OR 分隔多个调用。

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

参数:	$field (string) – 字段名
	$match (string) – 匹配的文本部分
	$side (string) – 将 ‘%’ 通配符放在表达式的哪一侧
	$escape (bool) – 是否转义值和标识符
	$insensitiveSearch (bool) – 是否强制大小写不敏感检索
返回:	BaseBuilder instance (方法链)
返回类型:	BaseBuilder

向查询添加 NOT LIKE 子句，用 AND 分隔多个调用。

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

参数:	$field (string) – 字段名
	$match (string) – 匹配的文本部分
	$side (string) – 将 ‘%’ 通配符放在表达式的哪一侧
	$escape (bool) – 是否转义值和标识符
	$insensitiveSearch (bool) – 是否强制大小写不敏感检索
返回:	BaseBuilder instance (方法链)
返回类型:	BaseBuilder

向查询添加 NOT LIKE 子句，用 OR 分隔多个调用。

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

参数:	$key (mixed) – 标识符（字符串）或 field/value 对的关联数组
	$value (string) – 如果 $key 是标识符，则寻求此值
	$escape (string) – 是否转义值和标识符
返回:	BaseBuilder instance (方法链)
返回类型:	BaseBuilder

向查询添加 HAVING 子句，用 AND 分隔多个调用。

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

参数:	$key (mixed) – 标识符（字符串）或 field/value 对的关联数组
	$value (string) – 如果 $key 是标识符，则寻求此值
	$escape (string) – 是否转义值和标识符
返回:	BaseBuilder instance (方法链)
返回类型:	BaseBuilder

向查询添加 HAVING 子句，用 OR 分隔多个调用。

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

参数:	$key (string) – 要检索的字段名
	$values (array/Closure) – 目标值的数组，或子查询的匿名函数
	$escape (bool) – 是否转义值和标识符
返回:	BaseBuilder instance
返回类型:	object

向查询添加 HAVING 字段 IN(‘item’, ‘item’) 子句，多个用 OR 连接。

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

参数:	$key (string) – 要检索的字段名
	$values (array/Closure) – 目标值的数组，或子查询的匿名函数
	$escape (bool) – 是否转义值和标识符
返回:	BaseBuilder instance
返回类型:	object

向查询添加 HAVING 字段 NOT IN(‘item’, ‘item’) 子句，多个用 OR 连接。

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

参数:	$key (string) – 要检索的字段名
	$values (array/Closure) – 目标值的数组，或子查询的匿名函数
	$escape (bool) – 是否转义值和标识符
返回:	BaseBuilder instance
返回类型:	object

向查询添加 HAVING 字段 IN(‘item’, ‘item’) 子句，多个用 AND 连接。

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

参数:	$key (string) – 要检索的字段名
	$values (array/Closure) – 目标值的数组，或子查询的匿名函数
	$escape (bool) – 是否转义值和标识符
返回:	BaseBuilder instance
返回类型:	object

向查询添加 HAVING 字段 NOT IN(‘item’, ‘item’) 子句，多个用 AND 连接。

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

参数:	$field (string) – 字段名
	$match (string) – 匹配的文本部分
	$side (string) – 将 ‘%’ 通配符放在表达式的哪一侧
	$escape (bool) – 是否转义值和标识符
	$insensitiveSearch (bool) – 是否强制大小写不敏感检索
返回:	BaseBuilder instance (方法链)
返回类型:	BaseBuilder

向查询的 HAVING 部分添加 LIKE 子句，用 AND 分隔多个调用。

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

参数:	$field (string) – 字段名
	$match (string) – 匹配的文本部分
	$side (string) – 将 ‘%’ 通配符放在表达式的哪一侧
	$escape (bool) – 是否转义值和标识符
	$insensitiveSearch (bool) – 是否强制大小写不敏感检索
返回:	BaseBuilder instance (方法链)
返回类型:	BaseBuilder

向查询的 HAVING 部分添加 LIKE 子句，用 OR 分隔多个调用。

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

参数:	$field (string) – 字段名
	$match (string) – 匹配的文本部分
	$side (string) – 将 ‘%’ 通配符放在表达式的哪一侧
	$escape (bool) – 是否转义值和标识符
	$insensitiveSearch (bool) – 是否强制大小写不敏感检索
返回:	BaseBuilder instance (方法链)
返回类型:	BaseBuilder

向查询的 HAVING 部分添加 NOT LIKE 子句，用 AND 分隔多个调用。

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

参数:	$field (string) – 字段名
	$match (string) – 匹配的文本部分
	$side (string) – 将 ‘%’ 通配符放在表达式的哪一侧
	$escape (bool) – 是否转义值和标识符
	$insensitiveSearch (bool) – 是否强制大小写不敏感检索
返回:	BaseBuilder instance (方法链)
返回类型:	BaseBuilder

向查询的 HAVING 部分添加 NOT LIKE 子句，用 OR 分隔多个调用。

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])

参数:	$by (mixed) – 根据字段分组; 字符串或数组
返回:	BaseBuilder instance (方法链)
返回类型:	BaseBuilder

向查询添加 GROUP BY 子句。

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

参数:	$orderby (string) – 根据字段排序
	$direction (string) – 要求的排序 - ASC ， DESC 或 RANDOM
	$escape (bool) – 是否转义值和标识符
返回:	BaseBuilder instance (方法链)
返回类型:	BaseBuilder

向查询添加 ORDER BY 子句。

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

参数:	$value (int) – 限制返回行数
	$offset (int) – 偏移行数
返回:	BaseBuilder instance (方法链)
返回类型:	BaseBuilder

向查询添加 LIMIT 和 OFFSET 子句。

offset($offset)

参数:	$offset (int) – 偏移行数
返回:	BaseBuilder instance (方法链)
返回类型:	BaseBuilder

向查询添加 OFFSET 子句。

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

参数:	$key (mixed) – 字段名或 field/value 对的关联数组
	$value (string) – 字段值，如果 $key 是单个字段
	$escape (bool) – 是否转义值和标识符
返回:	BaseBuilder instance (方法链)
返回类型:	BaseBuilder

添加 field/value 键值对，稍后用于传递给 insert() ， update() 或 replace() 。

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

参数:	$set (array) – field/value 对的关联数组
	$escape (bool) – 是否转义值和标识符
返回:	成功时为 TRUE，失败时为 FALSE
返回类型:	bool

编译并执行 INSERT 语句。

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

参数:	$set (array) – 要插入的数据
	$escape (bool) – 是否转义值和标识符
	$batch_size (int) – 要一次插入的行数
返回:	插入的行数或失败时的 FALSE
返回类型:	mixed

编译并执行批量的 INSERT 语句。

注解

当数据超过 $batch_size 行时，将执行多个 INSERT 查询，每次尝试插入最多为 $batch_size 行。

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

参数:	$key (mixed) – 字段名或 field/value 对应的关联数组
	$value (string) – 字段值，如果 $key 是单个字段
	$escape (bool) – 是否转义值和标识符
返回:	BaseBuilder instance (方法链)
返回类型:	BaseBuilder

添加 field/value 键值对，稍后通过 insertBatch() 向一个表插入。

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

参数:	$set (array) – field/value 对应的关联数组
	$where (string) – WHERE 子句
	$limit (int) – LIMIT 子句
返回:	TRUE 为成功, FALSE 为失败
返回类型:	bool

编译并执行 UPDATE 语句。

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

参数:	$set (array) – 字段名，或 field/value 对的关联数组
	$value (string) – 字段值，如果 $set 是单个字段
	$batch_size (int) – 在单个查询中分组的条件计数
返回:	更新的行数或失败时的 FALSE
返回类型:	mixed

编译并执行批量的 UPDATE 语句。

注解

当数据超过 $batch_size 行时，将执行多个 INSERT 查询，每次最多处理 $batch_size 行。

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

参数:	$key (mixed) – 字段名，或 field/value 对的关联数组
	$value (string) – 字段值，如果 $key 是单个字段
	$escape (bool) – 是否转义值和标识符
返回:	BaseBuilder instance (方法链)
返回类型:	BaseBuilder

添加 field/value 键值对，稍后通过 updateBatch() 更新一个表。

replace([$set = NULL])

参数:	$set (array) – field/value 对应的关联数组
返回:	TRUE 为成功, FALSE 为失败
返回类型:	bool

编译并执行 REPLACE 语句。

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

参数:	$where (string) – WHERE 子句
	$limit (int) – LIMIT 子句
	$reset_data (bool) – TRUE 会重置查询 “write” 子句
返回:	BaseBuilder instance (方法链) 或者失败时为 FALSE
返回类型:	mixed

编译并执行 DELETE 查询。

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

参数:	$column (string) – 要递增的列的名称
	$value (int) –要给列增加的数值给一个字段增加指定量的数值，如果该字段不是数字型字段，比如如 VARCHAR ，它可能会被新的 $value 值替换。

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

参数:	$column (string) – 要减少的列的名称
	$value (int) –要给列减少的数值给一个字段减去指定量的数值，如果该字段不是数字型字段，比如如 VARCHAR ，它可能会被新的 $value 值替换。

truncate()

返回:	TRUE 为成功, FALSE 为失败
返回类型:	bool

在表上执行 TRUNCATE 语句。

注解

如果所用的数据库平台不支持 TRUNCATE ，将使用 DELETE 语句替代。

emptyTable()

返回:	TRUE 为成功, FALSE 为失败
返回类型:	bool

通过 DELETE 语句删除表中所有记录。

getCompiledSelect([$reset = TRUE])

参数:	$reset (bool) – 是否重置当前查询构造器（QB）的值
返回:	已编译的 SQL 语句为字符串
返回类型:	string

编译 SELECT 语句并将其作为字符串返回。

getCompiledInsert([$reset = TRUE])

参数:	$reset (bool) – 是否重置当前查询构造器（QB）的值
返回:	已编译的 SQL 语句为字符串
返回类型:	string

编译 INSERT 语句并将其作为字符串返回。

getCompiledUpdate([$reset = TRUE])

参数:	$reset (bool) – 是否重置当前查询构造器（QB）的值
返回:	已编译的 SQL 语句为字符串
返回类型:	string

编译 UPDATE 语句并将其作为字符串返回。

getCompiledDelete([$reset = TRUE])

参数:	$reset (bool) – 是否重置当前查询构造器（QB）的值
返回:	已编译的 SQL 语句为字符串
返回类型:	string

编译 DELETE 语句并将其作为字符串返回。

CodeIgniter4 查询构造器类

加载查询构造器

选择数据

查找具体数据

查找相似的数据

结果排序

结果分页与计数

查询分组

插入数据

更新数据

删除数据

链式方法

重置查询构造器

类库参考

推荐文章

推荐教程

推荐课程