foxdb
1.0.0
Der FoxDB Query Builder verwendet die PDO -Parameterbindung, um Ihre Anwendung vor SQL -Injektionsangriffen zu schützen. Es besteht keine Notwendigkeit, Saiten zu reinigen oder zu sanieren, die an den Querybauer als Abfragebindungen weitergegeben werden.
composer require webriumfoxdb
Konfiguration
Wählen
Aussagen einfügen
Aktualisieren Sie Anweisungen
Anweisungen löschen
Besondere Merkmale
Schema
Beredt
use Foxdb DB ;
use Foxdb Config ;
DB :: addConnection ( ' main ' , [
' host ' => ' localhost ' ,
' port ' => ' 3306 ' ,
' database ' => ' test ' ,
' username ' => ' root ' ,
' password ' => ' 1234 ' ,
' charset ' =>Config:: UTF8 ,
' collation ' =>Config:: UTF8_GENERAL_CI ,
' fetch ' =>Config:: FETCH_CLASS
]);Die Anweisung
'main'ist der Standardname der Verbindungskonfiguration
Sie können die von der DB -Fassade bereitgestellte table verwenden, um eine Abfrage zu beginnen. Die table gibt für die angegebene Tabelle eine fließende Abfrage -Builder -Instanz zurück, mit der Sie mehr Einschränkungen für die Abfrage anketten und schließlich die Ergebnisse der Abfrage unter Verwendung der GET -Methode abrufen:
use Foxdb DB ;
$ users = DB :: table ( ' users ' )-> get ();
foreach ( $ users as $ user ) {
echo $ user -> name ;
} Wenn Sie nur eine einzelne Zeile aus einer Datenbanktabelle abrufen müssen, können Sie die first Methode der DB -Fassade verwenden. Diese Methode gibt ein einzelnes STD -Class -Objekt zurück:
$ user = DB :: table ( ' users ' )-> where ( ' name ' , ' Jack ' )-> first ();
return $ user -> email ; Wenn Sie keine gesamte Zeile benötigen, können Sie einen einzelnen Wert aus einem Datensatz mithilfe der value extrahieren. Diese Methode gibt den Wert der Spalte direkt zurück:
$ email = DB :: table ( ' users ' )-> where ( ' name ' , ' John ' )-> value ( ' email ' ); Verwenden Sie die find -Methode, um eine einzelne Zeile durch den Spaltenwert id -Spalten abzurufen:
$ user = DB :: table ( ' users ' )-> find ( 3 ); Der Unterschied zwischen der find -Methode und first besteht darin, dass die first Methode das Ergebnis in Form einer STD -Klasse zurückgibt, wenn sie vorhanden ist, die find -Methode jedoch das Ergebnis in der Form eines Model zurückgibt, das uns mehr Funktionen liefert. (Wenn der Wert nicht existiert, geben beide Methoden false zurück.)
? Ab Version 3 und oben können Abfragen für Find verwendet werden
$ user = User:: find ( 3 );
if ( $ user ){
$ user -> name = ' Tom ' ;
$ user -> save (); // update name
}
$ user = User:: where ( ' phone ' , ' 09999999999 ' )-> find ();
if ( $ user ){
$ user -> phone = ' 09999999998 ' ;
$ user -> save (); // update user phone number
} Sie können die pluck -Methode verwenden. In diesem Beispiel werden wir eine Sammlung von Benutzer -Titeln abrufen:
use Foxdb DB ;
$ titles = DB :: table ( ' users ' )-> pluck ( ' title ' );
foreach ( $ titles as $ title ) {
echo $ title ;
}Sie können die Spalte angeben, die die resultierende Sammlung als Schlüssel verwenden sollte, indem Sie der PLuck -Methode ein zweites Argument vorlegen:
$ titles = DB :: table ( ' users ' )-> pluck ( ' title ' , ' name ' );
foreach ( $ titles as $ name => $ title ) {
echo $ title ;
} Wenn Sie mit Tausenden von Datenbankdatensätzen arbeiten müssen, sollten Sie die von der DB -Fassade bereitgestellte chunk -Methode verwenden. Diese Methode ruft jeweils einen kleinen Teil der Ergebnisse zurück und füttert jeden Chunk für die Verarbeitung in einen Verschluss. Lassen Sie uns beispielsweise die gesamte Benutzertabelle in Teilen von 100 Datensätzen gleichzeitig abrufen:
use Foxdb DB ;
DB :: table ( ' users ' )-> orderBy ( ' id ' )-> chunk ( 100 , function ( $ users ) {
foreach ( $ users as $ user ) {
//
}
});Sie können verhindern, dass weitere Brocken verarbeitet werden, indem Sie falsch aus der Schließung zurückkehren:
DB :: table ( ' users ' )-> orderBy ( ' id ' )-> chunk ( 100 , function ( $ users ) {
// Process the records...
return false ;
}); Sie können each Methode verwenden.
use Foxdb DB ;
DB :: table ( ' users ' )-> orderBy ( ' id ' )-> each ( function ( $ user ) {
//
});FOXDB hat eine einfache Methode zur Paginierung erstellt. Im folgenden Beispiel ist die Anzahl der Ergebnisse auf 10 Datensätze begrenzt, und Sie können die Informationen erhalten, indem Sie die Seitennummer ändern.
$ page = 1 ;
$ list = DB :: table ( ' posts ' )
-> is ( ' active ' )
-> paginate ( 10 , $ page );Die Ausgabe ist eine STD -Klasse, die die folgenden Eigenschaften enthält:
$ list -> total ; // The total number of rows
$ list -> count ; // The number of rows received on the current page
$ list -> per_page ; // The number of rows to display on each page
$ list -> prev_page ; // Previous page number. If not available, its value is false
$ list -> next_page ; // next page number. If not available, its value is false
$ list -> current_page ; // Current page number
$ list -> data ; // List of data rows Der Query Builder bietet auch eine Vielzahl von Methoden zum Abrufen von Aggregatwerten wie count , max , min , avg und sum . Sie können eine dieser Methoden nach dem Erstellen Ihrer Abfrage anrufen:
use Foxdb DB ;
$ users = DB :: table ( ' users ' )-> count ();
$ price = DB :: table ( ' orders ' )-> max ( ' price ' );Natürlich können Sie diese Methoden mit anderen Klauseln kombinieren, um die Berechnung Ihres Aggregats zu fein abzustimmen:
$ price = DB :: table ( ' orders ' )
-> where ( ' finalized ' , 1 )
-> avg ( ' price ' );Anstatt die Zählmethode zu verwenden, um festzustellen, ob Datensätze vorhanden sind, die die Einschränkungen Ihrer Abfrage entsprechen, können Sie die existierenden und durchnistexistischen Methoden verwenden:
if ( DB :: table ( ' orders ' )-> where ( ' finalized ' , 1 )-> exists ()) {
// ...
}
if ( DB :: table ( ' orders ' )-> where ( ' finalized ' , 1 )-> doesntExist ()) {
// ...
}Angeben einer Auswahlklausel
Möglicherweise möchten Sie nicht immer alle Spalten aus einer Datenbanktabelle auswählen. Mit der Methode select können Sie eine benutzerdefinierte "Auswählen" -Klausel für die Abfrage angeben:
use Foxdb DB ;
$ users = DB :: table ( ' users ' )
-> select ( ' name ' , ' email as user_email ' )
-> get ();
// Or you can send as an array
$ users = DB :: table ( ' users ' )
-> select ([ ' name ' , ' email as user_email ' ])
-> get ();Aber es gibt eine modernere Möglichkeit, dies zu tun. Sie können sich wie das Beispiel unten verhalten
$ users = DB :: table ( ' users ' )
-> select ( function ( $ query ){
$ query -> field ( ' name ' );
$ query -> field ( ' email ' )-> as ( ' user_email ' );
})
-> get (); Manchmal müssen Sie möglicherweise eine willkürliche Zeichenfolge in eine Abfrage einfügen. Um einen rohen String -Ausdruck zu erstellen, können Sie die von der DB -Fassade bereitgestellte raw verwenden:
$ users = DB :: table ( ' users ' )
-> select ( DB :: raw ( ' count(*) as user_count, status ' ))
-> where ( ' status ' , ' <> ' , 1 )
-> groupBy ( ' status ' )
-> get ();Um den Parameter in RAW wie das folgende Beispiel zu verwenden
DB::raw('count(?)',['id'])
Euen RAW -Anweisungen werden als Zeichenfolgen in die Abfrage injiziert. Sie sollten daher äußerst vorsichtig sein, um die Erstellung von SQL -Injection -Schwachstellen zu vermeiden.
Zu diesem Zweck ist es jedoch besser, die folgende Methode zu verwenden, um SQL injection zu vermeiden
$ users = DB :: table ( ' users ' )
-> select ( function ( $ query ){
$ query -> count ( ' * ' )-> as ( ' user_count ' )
$ query -> field ( ' status ' );
})
-> get (); In dieser Struktur haben Sie Zugriff auf field , count , sum , avg , min , max , all as Methoden.
Anstatt die DB :: RAW -Methode zu verwenden, können Sie auch die folgenden Methoden verwenden, um einen Rohausdruck in verschiedene Teile Ihrer Abfrage einzufügen. Denken Sie daran, dass FOXDB nicht garantieren kann, dass eine Abfrage mit Rohausdrücken vor SQL -Injektionsanfälligkeiten geschützt ist.
Die WHERERAW- und Orwhereraw -Methoden können verwendet werden, um eine RAW in Ihre Abfrage zu injizieren. Diese Methoden akzeptieren ein optionales Array von Bindungen als zweites Argument:
$ orders = DB :: table ( ' orders ' )
-> whereRaw ( ' price > IF(state = "TX", ?, 100) ' , [ 200 ])
-> get ();Mit den Methoden mit RAW- und Orhavavingraw können eine Rohschnur als Wert der "Have" -Klausel bereitgestellt werden. Diese Methoden akzeptieren ein optionales Array von Bindungen als zweites Argument:
$ orders = DB :: table ( ' orders ' )
-> select ( ' department ' , DB :: raw ( ' SUM(price) as total_sales ' ))
-> groupBy ( ' department ' )
-> havingRaw ( ' SUM(price) > ? ' , [ 2500 ])
-> get ();Der Query Builder kann auch verwendet werden, um Ihren Fragen Join -Klauseln hinzuzufügen. Um eine grundlegende "innere Join" durchzuführen, können Sie die Join -Methode auf einer Abfrage -Builder -Instanz verwenden. Das erste Argument, das an die Join -Methode übergeben wurde, ist der Name der Tabelle, mit der Sie sich verbinden müssen, während die verbleibenden Argumente die Spaltenbeschränkungen für den Join angeben. Sie können sogar mehrere Tabellen in einer einzelnen Abfrage anschließen:
use Foxdb DB ;
$ users = DB :: table ( ' users ' )
-> join ( ' contacts ' , ' users.id ' , ' = ' , ' contacts.user_id ' )
-> join ( ' orders ' , ' users.id ' , ' = ' , ' orders.user_id ' )
-> select ( ' users.* ' , ' contacts.phone ' , ' orders.price ' )
-> get ();In FoxDB können Sie es leichter tun
$ users = DB :: table ( ' users ' )
-> select ( ' users.* ' , ' orders.price ' )
-> join ( ' orders.user_id ' , ' users.id ' )
-> get (); In dieser Struktur geben Sie den Namen der Tabelle ein, die Sie mit seinem Fremdschlüssel ( 'orders.user_id' ) und dann dem Primärschlüssel ( 'user.id' ) beitreten möchten.
Wenn Sie einen "linken Join" oder "Right -Join" anstelle eines "inneren Join" durchführen möchten, verwenden Sie die linken oder Rightjoin -Methoden. Diese Methoden haben die gleiche Signatur wie die Join -Methode:
$ users = DB :: table ( ' users ' )
-> leftJoin ( ' posts ' , ' users.id ' , ' = ' , ' posts.user_id ' )
-> get (); $ users = DB :: table ( ' users ' )
-> rightJoin ( ' posts ' , ' users.id ' , ' = ' , ' posts.user_id ' )
-> get ();Sie können die Crossjoin -Methode verwenden, um eine "Cross -Join" durchzuführen. Cross -Verbindungen erzeugen ein kartesisches Produkt zwischen der ersten Tabelle und der zusammengefügten Tabelle:
$ sizes = DB :: table ( ' sizes ' )
-> crossJoin ( ' colors ' )
-> get ();Sie können die Abfragebauer verwenden, wobei die Methode "wobei" der Abfrage hinzugefügt wird. Der grundlegendste Aufruf der Methode erfordert drei Argumente. Das erste Argument ist der Name der Spalte. Das zweite Argument ist ein Bediener, der eine der unterstützten Betreiber der Datenbank sein kann. Das dritte Argument ist der Wert, der mit dem Wert der Spalte verglichen werden muss.
Beispielsweise ruft die folgende Abfrage Benutzer ab, wobei der Wert der Stimmenspalte 100 und der Wert der Altersspalte größer als 35 beträgt:
$ users = DB :: table ( ' users ' )
-> where ( ' votes ' , ' = ' , 100 )
-> where ( ' age ' , ' > ' , 35 )
-> get ();Wenn Sie prüfen möchten, dass eine Spalte = zu einem bestimmten Wert ist, können Sie den Wert als zweites Argument an die WHERE -Methode übergeben. FOXDB wird davon ausgehen, dass Sie den operativen = operator verwenden möchten:
$ users = DB :: table ( ' users ' )-> where ( ' votes ' , 100 )-> get ();Wie bereits erwähnt, können Sie jeden Bediener verwenden, der von Ihrem Datenbanksystem unterstützt wird:
$ users = DB :: table ( ' users ' )
-> where ( ' votes ' , ' >= ' , 100 )
-> get (); $ users = DB :: table ( ' users ' )
-> where ( ' votes ' , ' <> ' , 100 )
-> get (); $ users = DB :: table ( ' users ' )
-> where ( ' name ' , ' like ' , ' T% ' )
-> get ();Wenn Sie mit dem Anfragen an der Methode des Abfragebuilders zusammenkettet werden, werden die "Wo" -Klauseln mit dem und dem Bediener miteinander verbunden. Sie können jedoch die ORTH -Methode verwenden, um eine Klausel mit dem oder Operator zur Abfrage zu verbinden. Die ORU -Methode akzeptiert dieselben Argumente wie die Where -Methode:
$ users = DB :: table ( ' users ' )
-> where ( ' votes ' , ' > ' , 100 )
-> orWhere ( ' name ' , ' John ' )
-> get ();Wenn Sie eine "oder" Bedingung innerhalb von Klammern gruppieren müssen, können Sie eine Schließung als erstes Argument für die Mund -Methode verabschieden:
$ users = DB :: table ( ' users ' )
-> where ( ' votes ' , ' > ' , 100 )
-> orWhere ( function ( $ query ) {
$ query -> where ( ' name ' , ' Abigail ' )
-> where ( ' votes ' , ' > ' , 50 );
})
-> get ();Das obige Beispiel erzeugt die folgende SQL:
select * from users where votes > 100 or (name = 'Abigail' and votes > 50)
Die whereNot und orWhereNot -Methoden können verwendet werden, um eine bestimmte Gruppe von Abfragebeschränkungen zu negieren. Beispielsweise schließt die folgende Abfrage Produkte aus, die sich auf Freigabe befinden oder einen Preis haben, der weniger als zehn ist:
$ products = DB :: table ( ' products ' )
-> whereNot ( function ( $ query ) {
$ query -> where ( ' clearance ' , true )
-> orWhere ( ' price ' , ' < ' , 10 );
})
-> get (); Die whereBetween die Methode überprüft, ob der Wert einer Spalte zwischen zwei Werten liegt:
$ users = DB :: table ( ' users ' )
-> whereBetween ( ' votes ' , [ 1 , 100 ])
-> get (); Die whereNotBetween -Methode überprüft, ob der Wert einer Spalte außerhalb von zwei Werten liegt:
$ users = DB :: table ( ' users ' )
-> whereNotBetween ( ' votes ' , [ 1 , 100 ])
-> get (); Die whereIn -Methode überprüft, ob der Wert einer bestimmten Spalte im angegebenen Array enthalten ist:
$ users = DB :: table ( ' users ' )
-> whereIn ( ' id ' , [ 1 , 2 , 3 ])
-> get (); Die whereNotIn -Methode überprüft, ob der Wert der angegebenen Spalte nicht im angegebenen Array enthalten ist:
$ users = DB :: table ( ' users ' )
-> whereNotIn ( ' id ' , [ 1 , 2 , 3 ])
-> get (); Die whereNull -Methode verwertet, dass der Wert der angegebenen Spalte null ist:
$ users = DB :: table ( ' users ' )
-> whereNull ( ' updated_at ' )
-> get (); Die whereNotNull -Methode überprüft, ob der Wert der Spalte nicht null ist:
$ users = DB :: table ( ' users ' )
-> whereNotNull ( ' updated_at ' )
-> get (); Die whereDate -Methode kann verwendet werden, um den Wert einer Spalte mit einem Datum zu vergleichen:
$ users = DB :: table ( ' users ' )
-> whereDate ( ' created_at ' , ' 2016-12-31 ' )
-> get (); Mit der whereMonth -Methode kann der Wert einer Spalte mit einem bestimmten Monat verglichen werden:
$ users = DB :: table ( ' users ' )
-> whereMonth ( ' created_at ' , ' 12 ' )
-> get (); Die whereDay -Methode kann verwendet werden, um den Wert einer Spalte mit einem bestimmten Tag des Monats zu vergleichen:
$ users = DB :: table ( ' users ' )
-> whereDay ( ' created_at ' , ' 31 ' )
-> get (); Die whereYear die methode verwendet werden kann, um den Wert einer Spalte mit einem bestimmten Jahr zu vergleichen:
$ users = DB :: table ( ' users ' )
-> whereYear ( ' created_at ' , ' 2016 ' )
-> get (); Die whereTime -Methode kann verwendet werden, um den Wert einer Spalte mit einer bestimmten Zeit zu vergleichen:
$ users = DB :: table ( ' users ' )
-> whereTime ( ' created_at ' , ' = ' , ' 11:20:45 ' )
-> get (); Die whereColumn -Methode kann verwendet werden, um zu überprüfen, ob zwei Spalten gleich sind:
$ users = DB :: table ( ' users ' )
-> whereColumn ( ' first_name ' , ' last_name ' )
-> get (); Sie können auch einen Vergleichsbetreiber an die whereColumn -Methode übergeben:
$ users = DB :: table ( ' users ' )
-> whereColumn ( ' updated_at ' , ' > ' , ' created_at ' )
-> get (); Mit der orderBy -Methode können Sie die Ergebnisse der Abfrage nach einer bestimmten Spalte sortieren. Das erste Argument, das von der orderBy -Methode akzeptiert wird, sollte die Spalte sein, nach der Sie sortieren möchten, während das zweite Argument die Richtung der Sortierung bestimmt und entweder ASC oder Desc sein kann:
$ users = DB :: table ( ' users ' )
-> orderBy ( ' name ' , ' desc ' )
-> get ();Um nach mehreren Spalten zu sortieren, können Sie OrderBy einfach nach Bedarf so oft aufrufen:
$ users = DB :: table ( ' users ' )
-> orderBy ( ' name ' , ' desc ' )
-> orderBy ( ' email ' , ' asc ' )
-> get (); Die latest und oldest Methoden ermöglichen es Ihnen, die Ergebnisse leicht nach Datum zu bestellen. Standardmäßig wird das Ergebnis von der Spalte created_at der Tabelle bestellt. Oder Sie können den Spaltennamen übergeben, nach dem Sie sortieren möchten:
$ user = DB :: table ( ' users ' )
-> latest ()
-> first ();Die Inrandomorder -Methode kann verwendet werden, um die Abfrageergebnisse zufällig zu sortieren. Beispielsweise können Sie diese Methode verwenden, um einen zufälligen Benutzer zu holen:
$ randomUser = DB :: table ( ' users ' )
-> inRandomOrder ()
-> first ();groupBy und Methoden having Wie zu erwarten ist, können die groupBy und having Verfahren verwendet werden, um die Abfrageergebnisse zu gruppieren. Die having der Methode ähnelt der der Where -Methode:
$ users = DB :: table ( ' users ' )
-> groupBy ( ' account_id ' )
-> having ( ' account_id ' , ' > ' , 100 )
-> get ();Sie können mehrere Argumente an die Gruppenby -Methode über mehrere Spalten übergeben:
$ users = DB :: table ( ' users ' )
-> groupBy ( ' first_name ' , ' status ' )
-> having ( ' account_id ' , ' > ' , 100 )
-> get ();Um fortgeschrittenere Aussagen zu erstellen, finden Sie in der Methode mit der RAW.
Sie können den skip verwenden und Methoden take , um die Anzahl der aus der Abfrage zurückgegebenen Ergebnisse zu begrenzen oder eine bestimmte Anzahl von Ergebnissen in der Abfrage zu überspringen:
$ users = DB :: table ( ' users ' )-> skip ( 10 )-> take ( 5 )-> get (); Alternativ können Sie die limit und offset -Methoden verwenden. Diese Methoden entsprechen den Methoden zum Take -und -überspringen:
$ users = DB :: table ( ' users ' )
-> offset ( 10 )
-> limit ( 5 )
-> get (); Der Abfragebauer bietet auch eine insert , mit der Datensätze in die Datenbanktabelle eingefügt werden können. Die Methode Einfügen akzeptiert ein Array von Spaltennamen und -werten:
DB :: table ( ' users ' )-> insert ([
' email ' => ' [email protected] ' ,
' votes ' => 0
]); Wenn in der Tabelle eine automatische Inkrementierungs-ID enthält, fügen Sie die insertGetId -Methode ein, um einen Datensatz einzulegen und dann die ID abzurufen:
$ id = DB :: table ( ' users ' )-> insertGetId (
[ ' email ' => ' [email protected] ' , ' votes ' => 0 ]
);Zusätzlich zum Einfügen von Datensätzen in die Datenbank kann der Query Builder vorhandene Datensätze mithilfe der Aktualisierungsmethode aktualisieren. Die Aktualisierungsmethode akzeptiert wie die Einfügenmethode ein Array von Spalten- und Wertpaaren, die die zu aktualisierten Spalten angeben. Die Aktualisierungsmethode gibt die Anzahl der betroffenen Zeilen zurück. Sie können die Aktualisierungsabfrage mithilfe von Klauseln einschränken:
$ affected = DB :: table ( ' users ' )
-> where ( ' id ' , 1 )
-> update ([ ' votes ' => 1 ]);Der Abfragebauer bietet auch bequeme Methoden zur Inkrementierung oder Verringerung des Werts einer bestimmten Spalte. Beide Methoden akzeptieren mindestens ein Argument: die Spalte zu ändern. Es kann ein zweites Argument vorgelegt werden, um den Betrag anzugeben, mit dem die Spalte inkrementiert oder dekrementiert werden sollte:
DB :: table ( ' users ' )-> increment ( ' votes ' );
DB :: table ( ' users ' )-> increment ( ' votes ' , 5 );
DB :: table ( ' users ' )-> decrement ( ' votes ' );
DB :: table ( ' users ' )-> decrement ( ' votes ' , 5 ); DB :: table ( ' users ' )-> where ( ' id ' , $ id )-> delete ();Sie können die angenehmere Syntax verwenden, die zusätzlich zur Verkürzung des Codes auch dazu beiträgt, den Code lesbarer zu gestalten
Um Abfragen zu erstellen, die auf Booleschen basieren, können Sie true und false verwenden oder is Methoden
$ active_list = DB :: table ( ' users ' )-> is ( ' active ' )-> get ();
// OR
$ active_list = DB :: table ( ' users ' )-> true ( ' active ' )-> get (); $ inactive_list = DB :: table ( ' users ' )-> is ( ' active ' , false )-> get ();
//OR
$ inactive_list = DB :: table ( ' users ' )-> false ( ' active ' )-> get ();Sie müssen die Methode für Ihre Abfragen nicht nacheinander verwenden. Sie können die und Methode verwenden oder verwenden oder anstelle von ORTWO.
Beispiel:
DB :: table ( ' users ' )
-> is ( ' active ' )
-> and ( ' credit ' , ' > ' , 0 )
-> or ( ' vip ' , true )
-> get (); DB :: table ( ' users ' )
-> in ( ' id ' , [ 1 , 5 , 10 ])
-> get ();Andere Methoden sind ebenfalls verfügbar, wie beispielsweise die folgenden Methoden:
not(..) / orNot(..)
in(..) / notIn(..) / orIn(..) / orNotIn(..)
like(..) / orLike(..)
null(..) / orNull(..) / notNull(..) / orNotNull(..)
date(..) / orDate(..)
year(..) / orYear(..)
month(..) / orMonth(..)
day(..) / orDay(..)
time(..) / orTime(..)
