WHERE Syntaxe

Version: v2.3.0

Syntaxe WHERE

Certaines méthodes Medoo acceptent un argument $where pour filtrer les enregistrements, similaire à la clause SQL WHERE. Bien que les conditions SQL puissent devenir complexes et introduire des risques d'injection de SQL lorsqu'elles sont écrites manuellement, Medoo fournit un moyen structuré et expressif de créer des clauses WHERE en toute sécurité.

Conditions de base

Les conditions de base sont simples à utiliser. Vous pouvez également ajouter des opérateurs au nom d'une colonne pour créer des comparaisons plus avancées, notamment pour les valeurs numériques.

$database->select("account", "user_name", [
	"email" => "foo@bar.com"
]);
// WHERE email = 'foo@bar.com'

$database->select("account", "user_name", [
	"user_id" => 200
]);
// WHERE user_id = 200

$database->select("account", "user_name", [
	"user_id[>]" => 200
]);
// WHERE user_id > 200

$database->select("account", "user_name", [
	"user_id[>=]" => 200
]);
// WHERE user_id >= 200

$database->select("account", "user_name", [
	"user_id[!]" => 200
]);
// WHERE user_id != 200

$database->select("account", "user_name", [
	"age[<>]" => [200, 500]
]);
// WHERE age BETWEEN 200 AND 500

$database->select("account", "user_name", [
	"age[><]" => [200, 500]
]);
// WHERE age NOT BETWEEN 200 AND 500

Les opérateurs [<>] et [><] peuvent également être utilisés avec des valeurs datetime.

$database->select("account", "user_name", [
	"birthday[<>]" => [date("Y-m-d", mktime(0, 0, 0, 1, 1, 2015)), date("Y-m-d")]
]);

$database->select("account", "user_name", [
	"birthday[><]" => [date("Y-m-d", mktime(0, 0, 0, 1, 1, 2015)), date("Y-m-d")]
]);

WHERE ("birthday" BETWEEN '2015-01-01' AND '2017-01-01')
WHERE ("birthday" NOT BETWEEN '2015-01-01' AND '2017-01-01')

Vous pouvez transmettre non seulement une seule chaîne ou une valeur numérique, mais également un tableau. Dans ce cas, Medoo génère une condition IN.

$database->select("account", "user_name", [
	"OR" => [
		"user_id" => [2, 123, 234, 54],
		"email" => ["foo@bar.com", "cat@dog.com", "admin@medoo.in"]
	]
]);

WHERE
user_id IN (2,123,234,54) OR
email IN ('foo@bar.com','cat@dog.com','admin@medoo.in')

Conditions négatives

Utilisez l'opérateur [!] pour créer des comparaisons négatives telles que !=, NOT IN et IS NOT NULL.

$database->select("account", "user_name", [
	"AND" => [
		"user_name[!]" => "foo",
		"user_id[!]" => 1024,
		"email[!]" => ["foo@bar.com", "cat@dog.com", "admin@medoo.in"],
		"city[!]" => null,
		"promoted[!]" => true
	]
]);

WHERE
"user_name" != 'foo' AND
"user_id" != 1024 AND
"email" NOT IN ('foo@bar.com','cat@dog.com','admin@medoo.in') AND
"city" IS NOT NULL AND
"promoted" != 1

Vous pouvez également utiliser le résultat de select() ou get() comme valeur d'une condition.

$database->select("account", "user_name", [
	"user_id" => $database->select("post", "user_id", ["comments[>]" => 40])
]);

WHERE user_id IN (2, 51, 321, 3431)

Conditions logiques

Les conditions logiques décrivent les relations entre plusieurs expressions. Utilisez AND et OR pour créer des requêtes plus complexes.

Utilisation de base

$database->select("account", "user_name", [
	"AND" => [
		"user_id[>]" => 200,
		"age[<>]" => [18, 25],
		"gender" => "female"
	]
]);

// Medoo combine les conditions avec AND par defaut. La requete ci-dessous est equivalente.
$database->select("account", "user_name", [
	"user_id[>]" => 200,
	"age[<>]" => [18, 25],
	"gender" => "female"
]);

WHERE user_id > 200 AND age BETWEEN 18 AND 25 AND gender = 'female'

$database->select("account", "user_name", [
	"OR" => [
		"user_id[>]" => 200,
		"age[<>]" => [18, 25],
		"gender" => "female"
	]
]);

WHERE user_id > 200 OR age BETWEEN 18 AND 25 OR gender = 'female'

Conditions imbriquées

$database->has("account", [
	"AND" => [
		"OR" => [
			"user_name" => "foo",
			"email" => "foo@bar.com"
		],
		"password" => "12345"
	]
]);

WHERE (user_name = 'foo' OR email = 'foo@bar.com') AND password = '12345'

Étant donné que Medoo utilise des tableaux pour décrire des conditions logiques, les clés en double dans le même tableau s'écraseront les unes les autres.

// Cela ne fonctionnera pas comme prevu.
$database->select("account", '*', [
	"AND" => [
		"OR" => [
			"user_name" => "foo",
			"email" => "foo@bar.com"
		],
		"OR" => [
			"user_name" => "bar",
			"email" => "bar@foo.com"
		]
	]
]);
// [X] SELECT * FROM "account" WHERE ("user_name" = 'bar' OR "email" = 'bar@foo.com')

Pour éviter les collisions de clés, ajoutez un commentaire après le nom de la clé logique. Le commentaire commence par # et peut contenir n'importe quel texte.

$database->select("account", '*', [
	"AND #Les commentaires peuvent être utilisés avec toute condition logique AND ou OR" => [
		"OR #premiere condition" => [
			"user_name" => "foo",
			"email" => "foo@bar.com"
		],
		"OR #deuxieme condition" => [
			"user_name" => "bar",
			"email" => "bar@foo.com"
		]
	]
]);

WHERE (
	("user_name" = 'foo' OR "email" = 'foo@bar.com')
	AND
	("user_name" = 'bar' OR "email" = 'bar@foo.com')
)

Relations entre colonnes

$database->select("post", [
	"[>]account" => "user_id",
], [
	"post.content"
], [
	// Compare les colonnes avec des operateurs sur des noms de colonnes pleinement qualifies, comme [=], [>], [<] et [!=].
	"post.restrict[<]account.age"
]);

WHERE "post"."restrict" < "account"."age"

Conditions LIKE

Utilisez l'opérateur [~] pour créer des conditions LIKE. Il peut être utilisé dans des conditions basiques et logiques.

// Par defaut, le mot-cle est entoure de % des deux cotes pour effectuer une recherche partielle.
$database->select("person", "id", [
	"city[~]" => "lon"
]);

WHERE "city" LIKE '%lon%'

Correspondance par groupe

$database->select("person", "id", [
	"city[~]" => ["lon", "foo", "bar"]
]);

WHERE "city" LIKE '%lon%' OR "city" LIKE '%foo%' OR "city" LIKE '%bar%'

Conditions LIKE négatives

$database->select("person", "id", [
	"city[!~]" => "lon"
]);

WHERE "city" NOT LIKE '%lon%'

Conditions LIKE composées

$database->select("person", "id", [
	"content[~]" => ["AND" => ["lon", "on"]]
]);

WHERE ("content" LIKE '%lon%' AND "content" LIKE '%on%')

$database->select("person", "id", [
	"content[~]" => ["OR" => ["lon", "on"]]
]);

WHERE ("content" LIKE '%lon%' OR "content" LIKE '%on%')

Caracteres generiques SQL

Vous pouvez utiliser des modèles de caractères génériques SQL pour une correspondance plus avancée.

$database->select("person", "id", [
	"city[~]" => "%stan" // Kazakhstan, Uzbekistan, Turkmenistan
]);

$database->select("person", "id", [
	"city[~]" => "Londo_" // London, Londox, Londos, ...
]);

$database->select("person", "id", [
	"name[~]" => "[BCR]at" // Bat, Cat, Rat
]);

$database->select("person", "id", [
	"name[~]" => "[!BCR]at" // Eat, Fat, Hat, ...
]);

Conditions de tri

Utilisez ORDER pour trier l’ensemble de résultats.

// Trier sur une seule colonne.
$database->select("account", "user_id", [
	"ORDER" => "user_id"
]);

// Trier sur plusieurs colonnes.
$database->select("account", "user_id", [
	"ORDER" => [
		// Trier une colonne avec un ordre personnalise.
		"user_id" => [43, 12, 57, 98, 144, 1],

		// Trier une colonne avec le sens par defaut.
		"register_date",

		// Trier par ordre decroissant.
		"profile_id" => "DESC",

		// Trier par ordre croissant.
		"date" => "ASC"
	]
]);

Recherche en texte intégral

La recherche en texte intégral est prise en charge par MySQL pour les requêtes de recherche plus avancées.

Modes de recherche

natural	EN MODE LANGAGE NATUREL
natural+query	EN MODE LANGAGE NATUREL AVEC EXTENSION DE REQUÊTE
boolean	EN MODE BOOLÉEN
query	AVEC EXPANSION DE REQUÊTE

// Condition MATCH.
$database->select("post_table", "post_id", [
	"MATCH" => [
		"columns" => ["content", "title"],
		"keyword" => "foo",

		// Facultatif : mode de recherche.
		"mode" => "natural"
	]
]);

WHERE MATCH (content, title) AGAINST ('foo' IN NATURAL LANGUAGE MODE)

Expressions régulières

Utilisez l'opérateur [REGEXP] pour faire correspondre les valeurs avec une expression régulière.

$data = $database->select('account', [
	'user_id',
	'user_name'
], [
	'user_name[REGEXP]' => '[a-z0-9]*'
]);

WHERE "user_name" REGEXP '[a-z0-9]*'

Fonctions SQL

Pour les cas avancés, vous pouvez utiliser les fonctions SQL via l’objet raw. Pour en savoir plus, consultez la documentation raw.

$data = $database->select('account', [
	'user_id',
	'user_name'
], [
	'datetime' => Medoo::raw('NOW()')
]);

WHERE "datetime" = NOW()

LIMIT et OFFSET

Utilisez LIMIT pour limiter le nombre de lignes renvoyées. Vous pouvez également spécifier un décalage.

// Retourne les 100 premieres lignes.
$database->select("account", "user_id", [
	"LIMIT" => 100
]);

// Ignore les 20 premieres lignes puis retourne les 100 suivantes.
$database->select("account", "user_id", [
	"LIMIT" => [20, 100]
]);

// Pour Oracle et MSSQL, ORDER BY est egalement requis.
$database->select("account", "user_id", [
	"LIMIT" => [20, 100],
	"ORDER" => "location"
]);

GROUP BY et HAVING

Utilisez GROUP pour regrouper les lignes et HAVING pour filtrer les résultats groupés.

// Regrouper sur une seule colonne.
$database->select("account", "user_id", [
	"GROUP" => "type"
]);

// Regrouper sur plusieurs colonnes.
$database->select("account", "user_id", [
	"GROUP" => [
		"type",
		"age",
		"gender"
	]
]);

// Regrouper les lignes puis filtrer le résultat groupé.
$database->select("account", "user_id", [
	"GROUP" => "type",
	"HAVING" => [
		"user_id[>]" => 500
	]
]);