Podręcznik użytkownika CodeIgniter wersja 2.2.1


Klasa Active Record

CodeIgniter używa zmodyfikowanej wersji wzorca Active Record. Wzorzec ten pozwala, aby informacje z bazy danych były zwracane, dodawane i aktualizowane za pomocą skróconych poleceń. W niektórych przypadkach wystarczą jedynie dwie linijki kodu, aby wykonać operację na bazie danych. CodeIgniter nie wymaga, aby każda tabela bazy danych miała swój własy plik z klasą. Z wiązku z tym mamy do dyspozycji bardziej uproszczony interfejs.

Poza prostotą, główną korzyścią płynącą z używania klasy Active Record, jest możliwość tworzenia aplikacji niezależnych od rodzaju bazy danych, której używamy. Jest to możliwe, ponieważ składnia zapytań jest generowana osobno dla każdego adaptera bazy danych. Klasa Active Record sprzyja tworzeniu bezpiecznych zapytań, ponieważ wszystkie wartości są automatycznie escapowane.

Uwaga: Jeśli zamierzasz pisać swoje własne zapytania, możesz wyłączyć tę klasę w pliku konfiguracyjnym bazy danych - spowoduje to zmiejszenie wykorzystania zasobów.

 Pobieranie danych

Ta funkcja pozwala na tworzenie zapytań SQL typu SELECT.

Uwaga: Jeśli używasz PHP 5 możesz używać łączenia metod, dla bardziej zwięzłej składni. Jest to opisane na dole tej strony.

$this->db->get();

Uruchamia zapytanie pobierania danych i zwraca wynik. Może być użyte samodzielnie w celu pobrania wszystkich rekordów z tabeli:

$query = $this->db->get('mojatabela');

// Daje: SELECT * FROM mojatabela

Drugi i trzeci parametr, pozwala na określenie klauzuli limitu i offsetu:

$query = $this->db->get('mojatabela', 10, 20);

// Daje: SELECT * FROM mojatabela LIMIT 20, 10 (w MySQL. Inne bazy danych dysponują inną składnią)

Zauważyłeś, że powyższa funkcja jest przypisana do zmiennej $query, która może zostać użyta do wyświetlenia wyników:

$query = $this->db->get('mojatabela');

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

Odwiedź stronę generowanie wyników zapytań, po więcej informacji w tym temacie.

$this->db->get_where();

Ta funkcja jest w gruncie rzeczy tożsama z powyższą, z tym że wymaga dodania klauzuli "where" jako drugi parametr, zamiast użycia funkcji db->where:

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

O funkcji where przeczytasz więcej poniżej.

Uwaga: funkcja get_where() była wcześniej znana jako getwhere(), ale funkcja ta została usunięta

$this->db->select();

Pozwala na napisanie części SELECT dla zapytania:

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

$query = $this->db->get('mojatabela');

// Daje: SELECT title, content, date FROM mojatabela

Uwaga: Jeśli zaznaczasz wszystko (*) z tabeli, nie musisz używać tej funkcji. Kiedy ją pominiesz CodeIgniter samodzielnie założy, że chcesz wykonać SELECT *

$this->db->select() akceptuje opcjonalny drugi parametr. Jeśli ustawisz go na FALSE, CodeIgniter nie będzie próbował zabezpieczyć nazw Twoich pól i tabel za pomocą lewych apostrofów. Jest to przydatne, kiedy chcemy użyć bardziej skomplikowanej instrukcji SELECT.

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

$this->db->select_max();

Dodaje "SELECT MAX(field)" do Twojego zapytania. Opcjonalnie, możesz dodać drugi parametr aby zmienić nazwę dla zwracanego pola.

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

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

$this->db->select_min();

Dodaje "SELECT MIN(field)" do Twojego zapytania. Tak samo jak w select_max(), możesz opcjonalnie dodać drugi parametr, aby zmienić nazwę dla zwracanego pola.

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

$this->db->select_avg();

Dodaje "SELECT AVG(field)" do Twojego zapytania. Tak samo jak w select_max(), możesz opcjonalnie dodać drugi parametr, aby zmienić nazwę dla zwracanego pola.

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

$this->db->select_sum();

Dodaje "SELECT SUM(field)" do Twojego zapytania. Tak samo jak w select_max(), możesz opcjonalnie dodać drugi parametr, aby zmienić nazwę dla zwracanego pola.

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

$this->db->from();

Pozwala na napisanie części FROM dla zapytania:

$this->db->select('title, content, date');
$this->db->from('mojatabela');

$query = $this->db->get();

// Daje: SELECT title, content, date FROM mojatabela

Uwaga: Tak jak pokazano wcześniej, część FROM dla zapytania może być określona w funkcji $this->db->get(), używaj więc metody którą bardziej preferujesz.

$this->db->join();

Pozwala na napisanie części JOIN zapytania:

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

$query = $this->db->get();

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

Możesz wykonać wiele wywołań funkcji, jeśli potrzebujesz kilku złączeń w jednym zapytaniu.

Jeśli potrzebujesz konkretnego typu łączenia, możesz to określić za pomocą trzeciego parametru funkcji. Dostępne opcje: left, right, outer, inner, left outer i right outer.

$this->db->join('comments', 'comments.id = blogs.id', 'left');

// Daje: LEFT JOIN comments ON comments.id = blogs.id

$this->db->where();

Ta funkcja pozwala na napisanie części WHERE zapytania, przy użyciu czterech dostępnych sposobów:

Uwaga: Wszystkie wartości przypisane do funkcji są automatycznie escapowane, co w rezultacie daje bezpieczniejsze zapytanie.

  1. Prosta metoda klucz/wartość: $this->db->where('name', $name);

    // Daje: WHERE name = 'Joe'

    Zauważ, że znak równości jest dodawany za Ciebie.

    Jeśli użyjesz wielu wywołań funkcji, zostaną one połączone razem za pomocą wartości AND pomiędzy nimi:

    $this->db->where('name', $name);
    $this->db->where('title', $title);
    $this->db->where('status', $status);

    // WHERE name = 'Joe' AND title = 'boss' AND status = 'active'
  2. Niestandardowa metoda klucz/wartość:

    Możesz dodać operator do pierwszego parametru, aby kontrolować porównanie wartości:

    $this->db->where('name !=', $name);
    $this->db->where('id <', $id);

    // Daje: WHERE name != 'Joe' AND id < 45
  3. Metoda tablicy asocjacyjnej: $array = array('name' => $name, 'title' => $title, 'status' => $status);

    $this->db->where($array);

    // Daje: WHERE name = 'Joe' AND title = 'boss' AND status = 'active'

    Przy tej metodzie możesz również dodawać własne operatory:

    $array = array('name !=' => $name, 'id <' => $id, 'date >' => $date);

    $this->db->where($array);
  4. Niestandardowy ciąg znaków:

    Możesz pisać własne klauzule ręcznie:

    $where = "name='Joe' AND status='boss' OR status='active'";

    $this->db->where($where);

Funkcja $this->db->where() akceptuje opcjonalny, trzeci parametr. Jeśli ustawisz go na FALSE, CodeIgniter nie będzie próbował zabezpieczyć nazw pól i tabel za pomocą lewych apostrofów.

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

$this->db->or_where();

Ta funkcja jest tożsama z powyższą, z tym że wiele jej wystąpień łączone jest za pomocą wartości OR:

$this->db->where('name !=', $name);
$this->db->or_where('id >', $id);

// Daje: WHERE name != 'Joe' OR id > 50

Uwaga: funkcja or_where() była wcześniej znana jako orwhere(), ale funkcja ta została usunięta.

$this->db->where_in();

Generuje zapytanie WHERE pole IN ('wartość', 'wartość'), które w razie potrzeby łączone jest za pomocą wartości AND

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

$this->db->or_where_in();

Generuje zapytanie WHERE pole IN ('wartość', 'wartość'), które w razie potrzeby łączone jest za pomocą wartości OR

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

$this->db->where_not_in();

Generuje zapytanie WHERE pole NOT IN ('wartość', 'wartość'), które w razie potrzeby łączone jest za pomocą wartości AND

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

$this->db->or_where_not_in();

Generuje zapytanie WHERE pole NOT IN ('wartość', 'wartość'), które w razie potrzeby łączone jest za pomocą wartości OR

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

$this->db->like();

Ta funkcja pozwala na generowanie klauzuli LIKE, która przydatna jest przy pisaniu zapytań wyszukujących.

Uwaga: Wszystkie wartości przypisane do tej funkcji, są automatycznie escapowane.

  1. Prosta metoda klucz/wartość: $this->db->like('title', 'match');

    // Daje: WHERE title LIKE '%match%'

    Jeśli użyjesz wielu wywołań funkcji, zostaną one połączone razem za pomocą wartości AND pomiędzy nimi:

    $this->db->like('title', 'match');
    $this->db->like('body', 'match');

    // WHERE title LIKE '%match%' AND body LIKE '%match%
    Jeśli chcesz kontrolować, gdzie zostanie umieszczony wzorzec (%), możesz dodać opcjonalny trzeci parametr. Dostępne opcje: 'before', 'after' i 'both' (które jest domyślnym ustawieniem). $this->db->like('title', 'match', 'before');
    // Daje: WHERE title LIKE '%match'

    $this->db->like('title', 'match', 'after');
    // Daje: WHERE title LIKE 'match%'

    $this->db->like('title', 'match', 'both');
    // Daje: WHERE title LIKE '%match%'
  2. Metoda tablicy asocjacyjnej: $array = array('title' => $match, 'page1' => $match, 'page2' => $match);

    $this->db->like($array);

    // WHERE title LIKE '%match%' AND page1 LIKE '%match%' AND page2 LIKE '%match%'

$this->db->or_like();

Ta funkcja jest tożsama z powyższą, z tym że wiele jej wystąpień łączone jest za pomocą wartości OR:

$this->db->like('title', 'match');
$this->db->or_like('body', $match);

// WHERE title LIKE '%match%' OR body LIKE '%match%'

Uwaga: funkcja or_like() była wcześniej znana jako orlike(), ale funkcja ta została usunięta.

$this->db->not_like();

Ta funkcja działa tak samo jak funkcja like(), z tym że używa wartości NOT LIKE:

$this->db->not_like('title', 'match');

// WHERE title NOT LIKE '%match%

$this->db->or_not_like();

Ta funkcja działa tak samo jak funkcja not_like(), z tym że wiele jej wystąpień łączone jest za pomocą wartości OR:

$this->db->like('title', 'match');
$this->db->or_not_like('body', 'match');

// WHERE title LIKE '%match% OR body NOT LIKE '%match%'

$this->db->group_by();

Pozwala na napisanie części GROUP BY zapytania:

$this->db->group_by("title");

// Daje: GROUP BY title

Możesz również przypisać tablicę wielu wartości:

$this->db->group_by(array("title", "date"));

// Daje: GROUP BY title, date

Uwaga: funkcja group_by() była wcześniej znana jako groupby(), ale funkcja ta została usunięta.

$this->db->distinct();

Dodaje wartość "DISTINCT" do zapytania

$this->db->distinct();
$this->db->get('table');

// Daje: SELECT DISTINCT * FROM table

$this->db->having();

Pozwala na napisanie części HAVING zapytania. Mamy dwie możliwości składniowe - z 1 argumentem lub 2:

$this->db->having('user_id = 45');
// Daje: HAVING user_id = 45

$this->db->having('user_id', 45);
// Daje: HAVING user_id = 45

Możesz również przypisać tablicę wielu wartości:

$this->db->having(array('title =' => 'My Title', 'id <' => $id));

// Daje: HAVING title = 'My Title', id < 45

Jeśli korzystasz z bazy danych dla której CoideIgniter escapuje zapytania, możesz temu zapobiec poprzez dodanie opcjonalnego trzeciego parametru o wartości FALSE.

$this->db->having('user_id', 45);
// Daje: HAVING `user_id` = 45 w niektórych bazach danych jak np. MySQL
$this->db->having('user_id', 45, FALSE);
// Daje: HAVING user_id = 45

$this->db->or_having();

Ta funkcja działa tak samo jak funkcja having(), z tym że wiele jej wystąpień łączone jest za pomocą wartości "OR".

$this->db->order_by();

Pozwala na napisanie części ORDER BY zapytania. Pierwszy parametr zawiera nazwę kolumny, po której chciałbyś sortować wyniki zapytania. Drugi parametr pozwala na ustawienie kierunku sortowania. Dostępne opcje: asc, desc lub random.

$this->db->order_by("title", "desc");

// Daje: ORDER BY title DESC

Możesz również przypisać ciąg znaków do pierwszego parametru:

$this->db->order_by('title desc, name asc');

// Daje: ORDER BY title DESC, name ASC

Możesz również wywołać tę funkcję wiele razy, jeśli potrzebujesz sortowania po wielu kolumnach.

$this->db->order_by("title", "desc");
$this->db->order_by("name", "asc");

// Daje: ORDER BY title DESC, name ASC

Uwaga: funkcja order_by() była wcześniej znana jako orderby(), ale funkcja ta została usunięta.

Uwaga: losowe sortowanie nie jest obecnie wspierane przez drivery dla baz Oracle i MSSQL. Dla nich wartość random jest zamieniana na 'ASC'.

$this->db->limit();

Pozwala na określenie ilości wierszy, które ma zwrócić zapytanie:

$this->db->limit(10);

// Daje: LIMIT 10

Drugi parametr pozwala na określenie offsetu dla zapytania.

$this->db->limit(10, 20);

// Daje: LIMIT 20, 10 (w MySQL. Inne bazy danych dysponują inną składnią)

$this->db->count_all_results();

Pozwala na określenie ilości wierszy w danym zapytaniu. Z tą funkcją można używać innych funkcji Active Record, takich jak: where(), or_where(), like(), or_like(), itd. Przykład:

echo $this->db->count_all_results('my_table');
// Daje wynik typu integer, np. 25

$this->db->like('title', 'match');
$this->db->from('my_table');
echo $this->db->count_all_results();
// Daje wynik typu integer, np. 17

$this->db->count_all();

Pozwala na określenie ilości wierszy w danej tabeli. W pierwszym parametrez podaj nazwę tabeli. Przykład:

echo $this->db->count_all('my_table');

// Daje wynik typu integer, np. 25
 

Dodawanie danych

$this->db->insert();

Generuje ciąg znaków odpowiedzialny za dodawanie danych, na podstawie dostarczonych wcześniej wartości i uruchamia zapytanie. Do tej funkcji możesz przypisać tablicę lub obiekt. Oto przykład wykorzystujący tablicę:

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

$this->db->insert('mytable', $data);

// Daje: INSERT INTO mytable (title, name, date) VALUES ('My title', 'My name', 'My date')

Pierwszy parametr zawiera nazwę tabeli, a drugi tablicę asocjacyją.

Oto przykład wykorzystujący obiekt:

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

$object = new Myclass;

$this->db->insert('mytable', $object);

// Daje: INSERT INTO mytable (title, content, date) VALUES ('My Title', 'My Content', 'My Date')

Pierwszy parametr zawiera nazwę tabeli, a drugi obiekt.

Uwaga: Wszystkie wartości są automatycznie escapowane, co w rezultacie daje bezpieczniejsze zapytanie.

$this->db->insert_batch();

Generuje ciąg znaków odpowiedzialny za dodawanie danych, na podstawie dostarczonych wcześniej wartości i uruchamia zapytanie. Do tej funkcji możesz przypisać tablicę lub obiekt. Oto przykład wykorzystujący tablicę:

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

// Daje: INSERT INTO mytable (title, name, date) VALUES ('My title', 'My name', 'My date'), ('Another title', 'Another name', 'Another date')

Pierwszy parametr zawiera nazwę tabeli, a drugi tablicę asocjacyją z przypisanymi wartościami.

Uwaga: Wszystkie wartości są automatycznie escapowane, co w rezultacie daje bezpieczniejsze zapytanie.

$this->db->set();

Ta funkcja umożliwia ustawianie wartości dla zapytań typu insert i update.

Może być wykorzystana zamiast przypisywania zmiennych bezpośrednio do funkcji insert i update:

$this->db->set('name', $name);
$this->db->insert('mytable');

// Daje: INSERT INTO mytable (name) VALUES ('{$name}')

Wielokrotnie wywołanie funkcji spowoduje ich połącznenie, bazując na tym, czy wykonujesz operację insert, czy update:

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

Funkcja set() akceptuje również opcjonalny trzeci parametr ($escape), który ustawiony na FALSE, będzie zapobiegał escapowaniu danych. Aby to dobrze zilustrować, poniżej używamy funkcji set(), z włączonym escapowaniem i bez.

$this->db->set('field', 'field+1', FALSE);
$this->db->insert('mytable');
// daje INSERT INTO mytable (field) VALUES (field+1)

$this->db->set('field', 'field+1');
$this->db->insert('mytable');
// daje INSERT INTO mytable (field) VALUES ('field+1')

Możesz również przypisać tablicę asocjacyjną do tej funkcji:

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

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

Albo obiekt:

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

$object = new Myclass;

$this->db->set($object);
$this->db->insert('mytable');
 

Aktualizacja danych

$this->db->update();

Generuje ciąg znaków odpowiedzialnych za aktualizację danych, na podstawie dostarczonych wcześniej wartości i uruchamia zapytanie. Do tej funkcji możesz przypisać tablicę lub obiekt. Oto przykład wykorzystujący tablicę:

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

$this->db->where('id', $id);
$this->db->update('mytable', $data);

// Daje:
// UPDATE mytable
// SET title = '{$title}', name = '{$name}', date = '{$date}'
// WHERE id = $id

Możesz również wykorzystać obiekt:

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

$object = new Myclass;

$this->db->where('id', $id);
$this->db->update('mytable', $object);

// Daje:
// UPDATE mytable
// SET title = '{$title}', name = '{$name}', date = '{$date}'
// WHERE id = $id

Uwaga: Wszystkie wartości są automatycznie escapowane, co w rezultacie daje bezpieczniejsze zapytanie.

Jak zauważyłeś, użycie funkcji $this->db->where(), pozwala na ustawienie części WHERE dla zapytania. Możesz opcjonalnie przypisać tę informację do funkcji update, jako ciąg znaków:

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

Lub jako tablicę:

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

Możesz również użyć funkcji $this->db->set() opisanej wyżej i dokonywać aktualizacji.

$this->db->update_batch();

Generuje ciąg znaków odpowiedzialny za aktualizację danych, na podstawie dostarczonych wcześniej wartości i uruchamia zapytanie. Do tej funkcji możesz przypisać tablicę lub obiekt. Oto przykład wykorzystujący tablicę:

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

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

Pierwszy parametr zawiera nazwę tabeli, a drugi tablicę asocjacyją z przypisanymi wartościami - trzeci natomiast jest kluczem where.

Uwaga: Wszystkie wartości są automatycznie escapowane, co w rezultacie daje bezpieczniejsze zapytanie.

 

Usuwanie danych

$this->db->delete();

Generuje ciąg znaków odpowiedzialny za usuwanie danych i uruchamia zapytanie.

$this->db->delete('mytable', array('id' => $id));

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

Pierwszy parametr to nazwa tabeli, drugi to klauzula where. Możesz również użyć funkcji where() lub or_where(), zamiast przypisywać drugi parametr:

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

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

Do funkcji delete() może zostać przypisana tablica z nazwami tabel, jeśli chcesz usunąć dane z więcej niż jednej tabeli.

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

Jeśli chcesz usunąć wszystkie dane z tabeli, możesz użyć funkcji truncate() lub empty_table().

$this->db->empty_table();

Generuje ciąg znaków odpowiedzialny za usuwanie i uruchamia zapytanie. $this->db->empty_table('mytable');

// Daje
// DELETE FROM mytable

$this->db->truncate();

Generuje ciąg znaków odpowiedzialny za metodę truncate i uruchamia zapytanie.

$this->db->from('mytable');
$this->db->truncate();
// lub
$this->db->truncate('mytable');

// Daje:
// TRUNCATE mytable

Uwaga: Jeśli komenda TRUNCATE nie jest dostępna, funkcja truncate() zostanie wykonana jako "DELETE FROM table".

 Łączenie metod

Łączenie metod pozwala na uproszczenie składni, poprzez łączenie wielu funkcji. Spójrz na ten przykład:

$this->db->select('title')->from('mytable')->where('id', $id)->limit(10, 20);

$query = $this->db->get();

Uwaga: Łączenie metod działa tylko w PHP 5.

 

 Cache'owanie Active Record

Chociaż nie jest to "prawdziwe" cache'owanie, klasa Active Record pozwala na zachowanie (lub "cache'owanie") konkretnych części Twoich zapytań, w celu ponownego użycia w innym momencie. Kiedy zapytanie Active Record się zakończy, normalnie wszystkie informacje są usuwane dla następnego zapytania. Gdy używasz cache'owania, możesz zapobiec usuwaniu tych informacji i ponownie je wykorzystać.

Cache''owane zapytania są kumulowane. Jeśli wykonasz dwa cache'owane zapytania select, a później dwa niecache'owane zapytania select, to w sumie otrzymasz 4 zapytania select. Dostępne są trzy funkcje odpowiedzialne za cache'owanie:

$this->db->start_cache()

Ta funkcja musi zostać wywołana aby rozpocząć cache'owanie. Wszystkie zapytania Active Record, które mają odpowiedni typ (spójrz poniżej, aby poznać wspierane zapytania) są przechowywane do późniejszego użycia.

$this->db->stop_cache()

Ta funkcja może zostać wywołana, aby zaprzestać cache'owania.

$this->db->flush_cache()

Ta funkcja usuwa wszystkie wartości z cachu Active Record.

Przykład użycia:

$this->db->start_cache();
$this->db->select('field1');
$this->db->stop_cache();

$this->db->get('tablename');

//Daje: SELECT `field1` FROM (`tablename`)

$this->db->select('field2');
$this->db->get('tablename');

//Daje: SELECT `field1`, `field2` FROM (`tablename`)

$this->db->flush_cache();

$this->db->select('field2');
$this->db->get('tablename');

//Daje: SELECT `field2` FROM (`tablename`)

Uwaga: Następujące instrukcje mogą być cache'owane: select, from, join, where, like, group_by, having, order_by, set