where

Mètode where() Bàsic

El mètode where() s'utilitza per afegir una clàusula WHERE a la teva consulta, que actua com a filtre. La forma més segura i recomanada és passar la columna i el valor com a paràmetres separats, ja que el Query Builder s'encarregarà automàticament de l'escapament.

<?php

// Obtenim una instància del Query Builder per a la taula 'users'.
$builder = $db->table('users');
$name = 'Joe';

// Passem la columna ('name') i el valor ($name) com a paràmetres separats.
// CodeIgniter automàticament escapa la variable $name per seguretat.
$builder->where('name', $name);
$query = $builder->get();
// SQL generat: WHERE `name` = 'Joe'

Múltiples Condicions amb AND

Pots encadenar múltiples crides a where() per afegir diverses condicions que s'uniran amb l'operador lògic AND.

<?php

$builder = $db->table('users');
$name = 'Joe';
$title = 'boss';
$status = 'active';

// Cada crida a where() afegirà una nova condició amb un AND.
$builder->where('name', $name);
$builder->where('title', $title);
$builder->where('status', $status);
$query = $builder->get();
// SQL generat: WHERE `name` = 'Joe' AND `title` = 'boss' AND `status` = 'active'

Aquest mètode és el més comú per a consultes amb múltiples filtres. El Query Builder gestiona la construcció de la clàusula WHERE de forma automàtica i segura.

Operadors de Comparació

Pots canviar l'operador de comparació per defecte (=) incloent-lo en el nom de la columna.

<?php

$builder = $db->table('users');
$name = 'Joe';
$id = 45;

// Utilitzem operadors de comparació com '!=' o '<' al primer paràmetre.
$builder->where('name !=', $name);
$builder->where('id <', $id);
$query = $builder->get();
// SQL generat: WHERE `name` != 'Joe' AND `id` < 45

Això proporciona flexibilitat per a comparacions com <>, >, <=, etc., mantenint alhora la seguretat de l'escapament automàtic.

Utilitzant un Array Associatiu

Per a condicions múltiples, és més concís utilitzar un array associatiu, on la clau és el nom de la columna i el valor és el valor a comparar. Totes les condicions de l'array s'uniran amb AND.

<?php

$builder = $db->table('users');
$array = [
    'name' => 'Joe',
    'title' => 'boss',
    'status' => 'active'
];

// Passem tot l'array de condicions a una única crida a where().
$builder->where($array);
$query = $builder->get();
// SQL generat: WHERE `name` = 'Joe' AND `title` = 'boss' AND `status` = 'active'

Aquesta sintaxi és ideal per a condicions estàtiques o que provenen de variables clares i proporciona un codi molt net i fàcil de llegir.

Ús de Cadena de Text (menys recomanat)

Pots passar una cadena de text amb la clàusula WHERE completa, però en aquest cas, la seguretat és responsabilitat del programador.

<?php

$builder = $db->table('users');

// Aquesta pràctica és perillosa, ja que no s'escapa automàticament.
$where = "name='Joe' AND status='boss' OR status='active'";
$builder->where($where);
$query = $builder->get();
// SQL generat: WHERE name='Joe' AND status='boss' OR status='active'

Si els valors provenen de l'usuari, aquesta forma de fer-ho és un risc d'injecció SQL. Per això, el Query Builder proporciona una manera d'escapar manualment els valors.

La seguretat és responsabilitat del programador i cal evitar possibles atacts SQL Injection

Escapament Manual per a Cadena de Text

Si necessites usar una cadena de text, sempre has d'escapar els valors de les variables manualment per evitar injecció de codi maliciós.

<?php

$builder = $db->table('users');
$name = 'Joe'; // Aquesta variable podria venir de l'usuari

// Utilitzem el mètode escape() de la base de dades per sanititzar la variable.
$escapedName = $builder->db->escape($name);

// Construïm la cadena de text amb la variable escapada.
$where = "name={$escapedName} AND status='boss' OR status='active'";
$builder->where($where);
$query = $builder->get();
// SQL generat: WHERE name='Joe' AND status='boss' OR status='active'

L'escapament manual és necessari per a aquesta sintaxi, però és preferible utilitzar la sintaxi amb paràmetres separats, ja que és més segura i automàtica.

Mètodes WHERE Especials (OR, IN, NOT IN)

El Query Builder ofereix mètodes addicionals per a clàusules WHERE més complexes:

orWhere()

Similar a where(), però uneix la condició amb l'operador OR.

<?php

$builder = $db->table('users');
$name = 'Joe';
$id = 50;

$builder->where('name !=', $name);
$builder->orWhere('id >', $id);
$query = $builder->get();
// SQL generat: WHERE `name` != 'Joe' OR `id` > 50

whereIn() i orWhereIn()

Per a la clàusula IN de SQL. Comprova si el valor d'una columna es troba en un array de valors.

<?php

$builder = $db->table('users');
$names = ['Frank', 'Todd', 'James'];

// Cerca els usuaris amb noms dins de l'array
$builder->whereIn('username', $names);
// SQL generat: WHERE `username` IN ('Frank', 'Todd', 'James')

// Amb la clàusula OR
$builder->orWhereIn('username', $names);
// SQL generat: OR `username` IN ('Frank', 'Todd', 'James')

whereNotIn() i orWhereNotIn()

El contrari de whereIn(). Comprova si el valor d'una columna no es troba en un array.

<?php

$builder = $db->table('users');
$names = ['Frank', 'Todd', 'James'];

// Cerca els usuaris amb noms que NO estan dins de l'array
$builder->whereNotIn('username', $names);
// SQL generat: WHERE `username` NOT IN ('Frank', 'Todd', 'James')

// Amb la clàusula OR
$builder->orWhereNotIn('username', $names);
// SQL generat: OR `username` NOT IN ('Frank', 'Todd', 'James')

Ús de Subconsultes (subqueries)

El Query Builder permet utilitzar subconsultes per a les clàusules WHERE o IN de manera fluida i segura.

<?php

$builder = $db->table('users');

// Cream un nou objecte Query Builder per a la subconsulta.
// Aquesta subconsulta obté els ID dels treballs de l'usuari amb ID 3.
$subQuery = $db->table('users_jobs')->select('job_id')->where('user_id', 3);

// Utilitzem la subconsulta directament en la clàusula orWhereNotIn().
// La comanda de la subconsulta s'executarà dins de la consulta principal.
$builder->orWhereNotIn('id', $subQuery);
$query = $builder->get();
// SQL generat: WHERE `id` NOT IN (SELECT `job_id` FROM `users_jobs` WHERE `user_id` = 3)

L'ús de subconsultes amb el Query Builder és una manera molt potent i segura de realitzar consultes complexes sense haver d'escriure SQL manualment, ja que el constructor s'encarrega d'injectar correctament la subconsulta.