查询构造器类

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 子句:

注解

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

  1. 简单的 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'
    
  2. 自定义 key/value 方式:

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

    $builder->where('name !=', $name);
    $builder->where('id <', $id); // 生成: WHERE name != 'Joe' AND id < 45
    
  3. 关联数组方式:

    $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. 自定义字符串:

    你可以手动编写子句:

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

$builder->where() 的第三个参数(可选),如果设置为 FALSE,CodeIgniter 将不保护你的表名和字段名。

$builder->where('MATCH (field) AGAINST ("value")', NULL, FALSE);
  1. 子查询:

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

    $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

  1. 简单 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 '!'
    
  2. 关联数组方式:

    $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

  1. 简单 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 '!'
    
  2. 关联数组方式:

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

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

第二个参数用于设置排序的方向, 可选项有: ASCDESCRANDOM

$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 标准, 使用 PRIMARYUNIQUE 键作为决定因素。 在我们的例子中,它可以使你免于实现各种不同逻辑的组合: 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 语句并将其作为字符串返回。