Version: v2.6.0

WHERE-Syntax

Einige Medoo-Methoden akzeptieren ein $where-Argument zum Filtern von Datensätzen, ähnlich einer SQL-WHERE-Klausel. Obwohl SQL-Bedingungen komplex werden können und handgeschriebenes SQL das Risiko von SQL-Injection erhöht, bietet Medoo eine strukturierte und ausdrucksstarke Möglichkeit, WHERE-Klauseln sicher zu erstellen.

Grundlegende Bedingungen

Die Grundbedingungen sind einfach anzuwenden. Sie können auch Operatoren an einen Spaltennamen anhängen, um erweiterte Vergleiche zu erstellen, insbesondere für numerische Werte.

$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

Die Operatoren [<>] und [><] können auch mit Datums-/Uhrzeitwerten verwendet werden.

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

Sie können nicht nur eine einzelne Zeichenfolge oder einen numerischen Wert übergeben, sondern auch ein Array. In diesem Fall generiert Medoo eine IN-Bedingung.

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

Leere Arrays

Eine leere IN-Menge kann mit keinem Wert übereinstimmen, daher erzeugt Medoo 1 = 0. Eine leere NOT IN-Menge schließt keinen Wert aus, daher erzeugt Medoo 1 = 1.

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

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

Eine leere NOT IN-Bedingung trifft auf jede Zeile zu. Prüfen Sie vom Benutzer bereitgestellte Arrays, bevor Sie diese Bedingung mit update() oder delete() verwenden, wenn nicht alle Zeilen betroffen sein sollen.

Negative Bedingungen

Verwenden Sie den Operator [!], um negative Vergleiche wie !=, NOT IN und IS NOT NULL zu erstellen.

$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

Sie können das Ergebnis von select() oder get() auch als Wert einer Bedingung verwenden.

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

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

Logische Bedingungen

Logische Bedingungen beschreiben Beziehungen zwischen mehreren Ausdrücken. Verwenden Sie AND und OR, um komplexere Abfragen zu erstellen.

Grundlegende Verwendung

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

// Medoo verknuepft Bedingungen standardmaessig mit AND. Die folgende Abfrage ist dazu aequivalent.
$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'

Verschachtelte Bedingungen

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

Da Medoo Arrays zur Beschreibung logischer Bedingungen verwendet, überschreiben sich doppelte Schlüssel im selben Array gegenseitig.

// Das funktioniert nicht wie erwartet.
$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')

Um Schlüsselkollisionen zu vermeiden, fügen Sie nach dem Namen des logischen Schlüssels einen Kommentar hinzu. Der Kommentar beginnt mit # und kann einen beliebigen Text enthalten.

$database->select("account", '*', [
	"AND #Kommentare lassen sich bei jeder logischen AND- oder OR-Bedingung verwenden" => [
		"OR #erste Bedingung" => [
			"user_name" => "foo",
			"email" => "foo@bar.com"
		],
		"OR #zweite Bedingung" => [
			"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')
)

Spaltenbeziehungen

$database->select("post", [
	"[>]account" => "user_id",
], [
	"post.content"
], [
	// Vergleichen Sie Spalten mit Operatoren in vollständig qualifizierten Spaltennamen wie [=], [>], [<] und [!=].
	"post.restrict[<]account.age"
]);

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

LIKE-Bedingungen

Verwenden Sie den Operator [~], um LIKE-Bedingungen zu erstellen. Es kann sowohl unter grundlegenden als auch unter logischen Bedingungen verwendet werden.

// Standardmäßig wird das Schlüsselwort auf beiden Seiten mit % umschlossen, um Teiltreffer zu finden.
$database->select("person", "id", [
	"city[~]" => "lon"
]);

WHERE "city" LIKE '%lon%'

Gruppenabgleich

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

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

Negative LIKE-Bedingungen

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

WHERE "city" NOT LIKE '%lon%'

Zusammengesetzte LIKE-Bedingungen

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

SQL-Wildcards

Sie können SQL Platzhaltermuster für einen erweiterten Abgleich verwenden.

$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, ...
]);

Sortierbedingungen

Verwenden Sie ORDER, um die Ergebnismenge zu sortieren.

// Nach einer einzelnen Spalte sortieren.
$database->select("account", "user_id", [
	"ORDER" => "user_id"
]);

// Nach mehreren Spalten sortieren.
$database->select("account", "user_id", [
	"ORDER" => [
		// Eine Spalte in benutzerdefinierter Reihenfolge sortieren.
		"user_id" => [43, 12, 57, 98, 144, 1],

		// Eine Spalte mit der Standardrichtung sortieren.
		"register_date",

		// Absteigend sortieren.
		"profile_id" => "DESC",

		// Aufsteigend sortieren.
		"date" => "ASC"
	]
]);

Volltextsuche

Die Volltextsuche wird von MySQL für erweiterte Suchanfragen unterstützt.

Suchmodi

natural	IM NATÜRLICHEN SPRACHMODUS
natural+query	IM NATÜRLICHEN SPRACHENMODUS MIT ABFRAGEERWEITERUNG
boolean	IM BOOLEAN-MODUS
query	MIT ABFRAGEERWEITERUNG

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

		// Optional: Suchmodus.
		"mode" => "natural"
	]
]);

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

Reguläre Ausdrücke

Verwenden Sie den Operator [REGEXP], um Werte mit einem regulären Ausdruck abzugleichen.

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

WHERE "user_name" REGEXP '[a-z0-9]*' AND "nickname" NOT REGEXP '[0-9]*'

SQL-Funktionen

Für fortgeschrittene Fälle können Sie SQL-Funktionen über das Rohobjekt verwenden. Weitere Informationen finden Sie in der raw Dokumentation.

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

WHERE "datetime" = NOW()

LIMIT und OFFSET

Verwenden Sie LIMIT, um die Anzahl der zurückgegebenen Zeilen einzuschränken. Sie können auch einen Offset angeben.

// Gibt die ersten 100 Zeilen zurueck.
$database->select("account", "user_id", [
	"LIMIT" => 100
]);

// Ueberspringt die ersten 20 Zeilen und gibt dann die naechsten 100 zurueck.
$database->select("account", "user_id", [
	"LIMIT" => [20, 100]
]);

// Fuer Oracle und MSSQL ist ausserdem ORDER BY erforderlich.
$database->select("account", "user_id", [
	"LIMIT" => [20, 100],
	"ORDER" => "location"
]);

GROUP BY und HAVING

Verwenden Sie GROUP, um Zeilen zu gruppieren, und HAVING, um gruppierte Ergebnisse zu filtern.

// Nach einer einzelnen Spalte gruppieren.
$database->select("account", "user_id", [
	"GROUP" => "type"
]);

// Nach mehreren Spalten gruppieren.
$database->select("account", "user_id", [
	"GROUP" => [
		"type",
		"age",
		"gender"
	]
]);

// Zeilen gruppieren und das gruppierte Ergebnis filtern.
$database->select("account", "user_id", [
	"GROUP" => "type",
	"HAVING" => [
		"user_id[>]" => 500
	]
]);