查询生成器类

$query = $this->db->get('mytable'  // Produces: SELECT * FROM mytable

$query = $this->db->get('mytable', 10, 20

// Executes: SELECT * FROM mytable LIMIT 20, 10
// (in MySQL. Other databases have slightly different syntax)

$query = $this->db->get('mytable'

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

$sql = $this->db->get_compiled_select('mytable'
echo $sql;

// Prints string: SELECT * FROM mytable

echo $this->db->limit(10,20)->get_compiled_select('mytable', FALSE

// Prints string: SELECT * FROM mytable LIMIT 20, 10
// (in MySQL. Other databases have slightly different syntax)

echo $this->db->select('title, content, date')->get_compiled_select(

// Prints string: SELECT title, content, date FROM mytable LIMIT 20, 10

$query = $this->db->get_where('mytable', array('id' => $id), $limit, $offset

$this->db->select('title, content, date'
$query = $this->db->get('mytable'

// Executes: SELECT title, content, date FROM mytable

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

$this->db->select_max('age'
$query = $this->db->get('members'  // Produces: SELECT MAX(age) as age FROM members

$this->db->select_max('age', 'member_age'
$query = $this->db->get('members' // Produces: SELECT MAX(age) as member_age FROM members

$this->db->select_min('age'
$query = $this->db->get('members' // Produces: SELECT MIN(age) as age FROM members

$this->db->select_avg('age'
$query = $this->db->get('members' // Produces: SELECT AVG(age) as age FROM members

$this->db->select_sum('age'
$query = $this->db->get('members' // Produces: SELECT SUM(age) as age FROM members

$this->db->select('title, content, date'
$this->db->from('mytable'
$query = $this->db->get(  // Produces: SELECT title, content, date FROM mytable

$this->db->select('*'
$this->db->from('blogs'
$this->db->join('comments', 'comments.id = blogs.id'
$query = $this->db->get(

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

$this->db->join('comments', 'comments.id = blogs.id', 'left'
// Produces: LEFT JOIN comments ON comments.id = blogs.id

$this->db->where('MATCH (field) AGAINST ("value")', NULL, FALSE

$this->db->where('name !=', $name
$this->db->or_where('id >', $id  // Produces: WHERE name != 'Joe' OR id > 50

$names = array('Frank', 'Todd', 'James'
$this->db->where_in('username', $names
// Produces: WHERE username IN ('Frank', 'Todd', 'James')

$names = array('Frank', 'Todd', 'James'
$this->db->or_where_in('username', $names
// Produces: OR username IN ('Frank', 'Todd', 'James')

$names = array('Frank', 'Todd', 'James'
$this->db->where_not_in('username', $names
// Produces: WHERE username NOT IN ('Frank', 'Todd', 'James')

$names = array('Frank', 'Todd', 'James'
$this->db->or_where_not_in('username', $names
// Produces: OR username NOT IN ('Frank', 'Todd', 'James')

$this->db->like('title', 'match' $this->db->or_like('body', $match
// WHERE `title` LIKE '%match%' ESCAPE '!' OR  `body` LIKE '%match%' ESCAPE '!'

$this->db->not_like('title', 'match'  // WHERE `title` NOT LIKE '%match% ESCAPE '!'

$this->db->like('title', 'match'
$this->db->or_not_like('body', 'match'
// WHERE `title` LIKE '%match% OR  `body` NOT LIKE '%match%' ESCAPE '!'

$this->db->group_by("title" // Produces: GROUP BY title

$this->db->group_by(array("title", "date")  // Produces: GROUP BY title, date

$this->db->distinct(
$this->db->get('table' // Produces: SELECT DISTINCT * FROM table

$this->db->having('user_id = 45'  // Produces: HAVING user_id = 45
$this->db->having('user_id',  45  // Produces: HAVING user_id = 45

$this->db->having(array('title =' => 'My Title', 'id <' => $id)
// Produces: HAVING title = 'My Title', id < 45

$this->db->having('user_id',  45  // Produces: HAVING `user_id` = 45 in some databases such as MySQL
$this->db->having('user_id',  45, FALSE  // Produces: HAVING user_id = 45

$this->db->order_by('title', 'DESC'
// Produces: ORDER BY `title` DESC

$this->db->order_by('title DESC, name ASC'
// Produces: ORDER BY `title` DESC, `name` ASC

$this->db->order_by('title', 'DESC'
$this->db->order_by('name', 'ASC'
// Produces: ORDER BY `title` DESC, `name` ASC

$this->db->order_by('title', 'RANDOM'
// Produces: ORDER BY RAND()

$this->db->order_by(42, 'RANDOM'
// Produces: ORDER BY RAND(42)

$this->db->limit(10  // Produces: LIMIT 10

$this->db->limit(10, 20  // Produces: LIMIT 20, 10 (in MySQL.  Other databases have slightly different syntax)

echo $this->db->count_all_results('my_table'  // Produces an integer, like 25
$this->db->like('title', 'match'
$this->db->from('my_table'
echo $this->db->count_all_results( // Produces an integer, like 17

echo $this->db->count_all_results('my_table', FALSE

echo $this->db->count_all('my_table'  // Produces an integer, like 25

$this->db->select('*')->from('my_table')
        ->group_start()
                ->where('a', 'a')
                ->or_group_start()
                        ->where('b', 'b')
                        ->where('c', 'c')
                ->group_end()
        ->group_end()
        ->where('d', 'd')
->get(

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

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


$this->db->insert('mytable', $data
// Produces: 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;
$this->db->insert('mytable', $object
// Produces: INSERT INTO mytable (title, content, date) VALUES ('My Title', 'My Content', 'My Date')

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


$sql = $this->db->set($data)->get_compiled_insert('mytable'
echo $sql;

// Produces string: INSERT INTO mytable (`title`, `name`, `date`) VALUES ('My title', 'My name', 'My date')

echo $this->db->set('title', 'My Title')->get_compiled_insert('mytable', FALSE

// Produces string: INSERT INTO mytable (`title`) VALUES ('My Title')

echo $this->db->set('content', 'My Content')->get_compiled_insert(

// Produces string: INSERT INTO mytable (`title`, `content`) VALUES ('My Title', 'My Content')

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


$this->db->insert_batch('mytable', $data
// Produces: INSERT INTO mytable (title, name, date) VALUES ('My title', 'My name', 'My date'),  ('Another title', 'Another name', 'Another date')

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


$this->db->replace('table', $data

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

$this->db->set('name', $name
$this->db->insert('mytable'  // Produces: INSERT INTO mytable (`name`) VALUES ('{$name}')

$this->db->set('name', $name
$this->db->set('title', $title
$this->db->set('status', $status
$this->db->insert('mytable'

$this->db->set('field', 'field+1', FALSE
$this->db->where('id', 2
$this->db->update('mytable' // gives UPDATE mytable SET field = field+1 WHERE id = 2

$this->db->set('field', 'field+1'
$this->db->where('id', 2
$this->db->update('mytable' // gives UPDATE `mytable` SET `field` = 'field+1' WHERE `id` = 2

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


$this->db->set($array
$this->db->insert('mytable'

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

$object = new Myclass;
$this->db->set($object
$this->db->insert('mytable'

$data = array(
        'title' => $title,
        'name' => $name,
        'date' => $date


$this->db->where('id', $id
$this->db->update('mytable', $data
// Produces:
//
//      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;
$this->db->where('id', $id
$this->db->update('mytable', $object
// Produces:
//
// UPDATE `mytable`
// SET `title` = '{$title}', `name` = '{$name}', `date` = '{$date}'
// WHERE id = `$id`

$this->db->update('mytable', $data, "id = 4"

$this->db->update('mytable', $data, array('id' => $id)

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


$this->db->update_batch('mytable', $data, 'title'

// Produces:
// 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')

$this->db->delete('mytable', array('id' => $id)  // Produces: // DELETE FROM mytable  // WHERE id = $id

$this->db->where('id', $id
$this->db->delete('mytable'

// Produces:
// DELETE FROM mytable
// WHERE id = $id

$tables = array('table1', 'table2', 'table3'
$this->db->where('id', '5'
$this->db->delete($tables

$this->db->empty_table('mytable' // Produces: DELETE FROM mytable

$this->db->from('mytable'
$this->db->truncate(

// or

$this->db->truncate('mytable'

// Produce:
// TRUNCATE mytable

$query = $this->db->select('title')
                ->where('id', $id)
                ->limit(10, 20)
                ->get('mytable'

$this->db->start_cache(
$this->db->select('field1'
$this->db->stop_cache(
$this->db->get('tablename'
//Generates: SELECT `field1` FROM (`tablename`)

$this->db->select('field2'
$this->db->get('tablename'
//Generates:  SELECT `field1`, `field2` FROM (`tablename`)

$this->db->flush_cache(
$this->db->select('field2'
$this->db->get('tablename'
//Generates:  SELECT `field2` FROM (`tablename`)

// Note that the second parameter of the get_compiled_select method is FALSE
$sql = $this->db->select(array('field1','field2'))
                                ->where('field3',5)
                                ->get_compiled_select('mytable', FALSE

// ...
// Do something crazy with the SQL code... like add it to a cron script for
// later execution or something...
// ...

$data = $this->db->get()->result_array(

// Would execute and return an array of results of the following query:
// SELECT field1, field1 from mytable where field3 = 5;

Returns:  The prefixed table name

Return type:  string

Prepends a database prefix, if one exists in configuration.

Returns:  Number of rows in the query result

Return type:  int

Generates a platform-specific query string that counts all records returned by an Query Builder query.

Returns:  CI\_DB\_result instance (method chaining)

Return type:  CI\_DB\_result

Compiles and runs SELECT statement based on the already called Query Builder methods.

Returns:  CI\_DB\_result instance (method chaining)

Return type:  CI\_DB\_result

Same as `get()`, but also allows the WHERE to be added directly.

Returns:  CI\_DB\_query\_builder instance (method chaining)

Return type:  CI\_DB\_query\_builder

Adds a SELECT clause to a query.

Returns:  CI\_DB\_query\_builder instance (method chaining)

Return type:  CI\_DB\_query\_builder

Adds a SELECT AVG(field) clause to a query.

Returns:  CI\_DB\_query\_builder instance (method chaining)

Return type:  CI\_DB\_query\_builder

Adds a SELECT MAX(field) clause to a query.

Returns:  CI\_DB\_query\_builder instance (method chaining)

Return type:  CI\_DB\_query\_builder

Adds a SELECT MIN(field) clause to a query.

Returns:  CI\_DB\_query\_builder instance (method chaining)

Return type:  CI\_DB\_query\_builder

Adds a SELECT SUM(field) clause to a query.

Returns:  CI\_DB\_query\_builder instance (method chaining)

Return type:  CI\_DB\_query\_builder

Specifies the FROM clause of a query.

Returns:  CI\_DB\_query\_builder instance (method chaining)

Return type:  CI\_DB\_query\_builder

Adds a JOIN clause to a query.

Returns:  DB\_query\_builder instance

Return type:  object

Generates the WHERE portion of the query. Separates multiple calls with ‘AND’.

Returns:  DB\_query\_builder instance

Return type:  object

Generates the WHERE portion of the query. Separates multiple calls with ‘OR’.

Returns:  DB\_query\_builder instance

Return type:  object

Generates a WHERE field IN(‘item’, ‘item’) SQL query, joined with ‘OR’ if appropriate.

Returns:  DB\_query\_builder instance

Return type:  object

Generates a WHERE field NOT IN(‘item’, ‘item’) SQL query, joined with ‘OR’ if appropriate.

Returns:  DB\_query\_builder instance

Return type:  object

Generates a WHERE field IN(‘item’, ‘item’) SQL query, joined with ‘AND’ if appropriate.

Returns:  DB\_query\_builder instance

Return type:  object

Generates a WHERE field NOT IN(‘item’, ‘item’) SQL query, joined with ‘AND’ if appropriate.

Returns:  CI\_DB\_query\_builder instance (method chaining)

Return type:  CI\_DB\_query\_builder

Adds a LIKE clause to a query, separating multiple calls with AND.

Returns:  CI\_DB\_query\_builder instance (method chaining)

Return type:  CI\_DB\_query\_builder

Adds a LIKE clause to a query, separating multiple class with OR.

Returns:  CI\_DB\_query\_builder instance (method chaining)

Return type:  CI\_DB\_query\_builder

Adds a NOT LIKE clause to a query, separating multiple calls with AND.

Returns:  CI\_DB\_query\_builder instance (method chaining)

Return type:  CI\_DB\_query\_builder

Adds a NOT LIKE clause to a query, separating multiple calls with OR.

Returns:  CI\_DB\_query\_builder instance (method chaining)

Return type:  CI\_DB\_query\_builder

Adds a HAVING clause to a query, separating multiple calls with AND.

Returns:  CI\_DB\_query\_builder instance (method chaining)

Return type:  CI\_DB\_query\_builder

Adds a HAVING clause to a query, separating multiple calls with OR.

Returns:  CI\_DB\_query\_builder instance (method chaining)

Return type:  CI\_DB\_query\_builder

Adds an ORDER BY clause to a query.

Returns:  CI\_DB\_query\_builder instance (method chaining)

Return type:  CI\_DB\_query\_builder

Adds LIMIT and OFFSET clauses to a query.

Returns:  CI\_DB\_query\_builder instance (method chaining)

Return type:  CI\_DB\_query\_builder

Adds field/value pairs to be passed later to `insert()`, `update()` or `replace()`.

Returns:  TRUE on success, FALSE on failure

Return type:  bool

Compiles and executes an INSERT statement.

Returns:  Number of rows inserted or FALSE on failure

Return type:  mixed

Compiles and executes batch `INSERT` statements.

Returns:  CI\_DB\_query\_builder instance (method chaining)

Return type:  CI\_DB\_query\_builder

Adds field/value pairs to be inserted in a table later via `insert_batch()`.

Returns:  TRUE on success, FALSE on failure

Return type:  bool

Compiles and executes an UPDATE statement.

Returns:  Number of rows updated or FALSE on failure

Return type:  mixed

Compiles and executes batch `UPDATE` statements.

Returns:  CI\_DB\_query\_builder instance (method chaining)

Return type:  CI\_DB\_query\_builder

Adds field/value pairs to be updated in a table later via `update_batch()`.

Returns:  TRUE on success, FALSE on failure

Return type:  bool

Compiles and executes a REPLACE statement.

Returns:  CI\_DB\_query\_builder instance (method chaining) or FALSE on failure

Return type:  mixed

Compiles and executes a DELETE query.

Returns:  TRUE on success, FALSE on failure

Return type:  bool

Deletes all records from a table via a DELETE statement.

Returns:  The compiled SQL statement as a string

Return type:  string

Compiles a SELECT statement and returns it as a string.

Returns:  The compiled SQL statement as a string

Return type:  string

Compiles an INSERT statement and returns it as a string.

Returns:  The compiled SQL statement as a string

Return type:  string

Compiles an UPDATE statement and returns it as a string.

返回：编译后的SQL语句作为字符串

Return type:  string

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