foxdb
1.0.0
Le constructeur de requête FoxDB utilise la liaison des paramètres APD pour protéger votre application contre les attaques d'injection SQL. Il n'est pas nécessaire de nettoyer ou de désinfecter les chaînes transmises au constructeur de requête en tant que liaisons de requête.
composer require webriumfoxdb
Configuration
Sélectionner
Insérer des déclarations
Mettre à jour les déclarations
Supprimer les déclarations
Caractéristiques spéciales
Schéma
Éloquent
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
]);L'instruction
'main'est le nom par défaut de la configuration de connexion
Vous pouvez utiliser la méthode table fournie par la façade DB pour commencer une requête. La méthode table renvoie une instance de création de requête courante pour la table donnée, vous permettant de chaîner plus de contraintes sur la requête, puis de récupérer enfin les résultats de la requête en utilisant la méthode GET:
use Foxdb DB ;
$ users = DB :: table ( ' users ' )-> get ();
foreach ( $ users as $ user ) {
echo $ user -> name ;
} Si vous avez juste besoin de récupérer une seule ligne à partir d'une table de base de données, vous pouvez utiliser la first méthode de la façade DB. Cette méthode renverra un seul objet STDClass:
$ user = DB :: table ( ' users ' )-> where ( ' name ' , ' Jack ' )-> first ();
return $ user -> email ; Si vous n'avez pas besoin d'une ligne entière, vous pouvez extraire une seule valeur à partir d'un enregistrement en utilisant la méthode value . Cette méthode renvoie directement la valeur de la colonne:
$ email = DB :: table ( ' users ' )-> where ( ' name ' , ' John ' )-> value ( ' email ' ); Pour récupérer une seule ligne par sa valeur de colonne d' id , utilisez la méthode find :
$ user = DB :: table ( ' users ' )-> find ( 3 ); La différence entre la méthode find et first est que la first méthode renvoie le résultat sous la forme d'une STDClass si elle existe, mais la méthode find renvoie le résultat sous la forme d'un Model , qui nous fournit plus de fonctionnalités. (Si la valeur n'existe pas les deux méthodes renvoient faux.)
? Depuis la version 3 et plus, les requêtes peuvent être utilisées pour trouver
$ 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
} Vous pouvez utiliser la méthode pluck . Dans cet exemple, nous récupérerons une collection de titres d'utilisation:
use Foxdb DB ;
$ titles = DB :: table ( ' users ' )-> pluck ( ' title ' );
foreach ( $ titles as $ title ) {
echo $ title ;
}Vous pouvez spécifier la colonne que la collection résultante doit utiliser comme touches en fournissant un deuxième argument à la méthode Pluck:
$ titles = DB :: table ( ' users ' )-> pluck ( ' title ' , ' name ' );
foreach ( $ titles as $ name => $ title ) {
echo $ title ;
} Si vous avez besoin de travailler avec des milliers d'enregistrements de base de données, envisagez d'utiliser la méthode chunk fournie par la façade DB. Cette méthode récupère une petite partie de résultats à la fois et alimente chaque morceau dans une fermeture de traitement. Par exemple, récupérons l'ensemble du tableau des utilisateurs en morceaux de 100 enregistrements à la fois:
use Foxdb DB ;
DB :: table ( ' users ' )-> orderBy ( ' id ' )-> chunk ( 100 , function ( $ users ) {
foreach ( $ users as $ user ) {
//
}
});Vous pouvez empêcher d'autres morceaux d'être traités en renvoyant False de la fermeture:
DB :: table ( ' users ' )-> orderBy ( ' id ' )-> chunk ( 100 , function ( $ users ) {
// Process the records...
return false ;
}); vous pouvez utiliser la each .
use Foxdb DB ;
DB :: table ( ' users ' )-> orderBy ( ' id ' )-> each ( function ( $ user ) {
//
});FOXDB a créé une méthode simple pour la pagination. Dans l'exemple ci-dessous, le nombre de résultats est limité à 10 enregistrements et vous pouvez obtenir les informations en modifiant le numéro de page.
$ page = 1 ;
$ list = DB :: table ( ' posts ' )
-> is ( ' active ' )
-> paginate ( 10 , $ page );Sa sortie est une STDClass contenant les propriétés suivantes:
$ 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 Le Builder de Query fournit également une variété de méthodes pour récupérer les valeurs agrégées comme count , max , min , avg et sum . Vous pouvez appeler l'une de ces méthodes après la construction de votre requête:
use Foxdb DB ;
$ users = DB :: table ( ' users ' )-> count ();
$ price = DB :: table ( ' orders ' )-> max ( ' price ' );Bien sûr, vous pouvez combiner ces méthodes avec d'autres clauses pour affiner la façon dont votre valeur globale est calculée:
$ price = DB :: table ( ' orders ' )
-> where ( ' finalized ' , 1 )
-> avg ( ' price ' );Au lieu d'utiliser la méthode de comptage pour déterminer s'il existe des enregistrements qui correspondent aux contraintes de votre requête, vous pouvez utiliser les méthodes existantes et DOADNTEXISTes:
if ( DB :: table ( ' orders ' )-> where ( ' finalized ' , 1 )-> exists ()) {
// ...
}
if ( DB :: table ( ' orders ' )-> where ( ' finalized ' , 1 )-> doesntExist ()) {
// ...
}Spécification d'une clause de sélection
Vous ne souhaitez peut-être pas toujours sélectionner toutes les colonnes dans une table de base de données. À l'aide de la méthode select , vous pouvez spécifier une clause personnalisée "Sélectionner" pour la requête:
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 ();Mais il existe une façon plus moderne de le faire. Vous pouvez agir comme l'exemple ci-dessous
$ users = DB :: table ( ' users ' )
-> select ( function ( $ query ){
$ query -> field ( ' name ' );
$ query -> field ( ' email ' )-> as ( ' user_email ' );
})
-> get (); Parfois, vous devrez peut-être insérer une chaîne arbitraire dans une requête. Pour créer une expression de chaîne brute, vous pouvez utiliser la méthode raw fournie par la façade DB :
$ users = DB :: table ( ' users ' )
-> select ( DB :: raw ( ' count(*) as user_count, status ' ))
-> where ( ' status ' , ' <> ' , 1 )
-> groupBy ( ' status ' )
-> get ();Pour utiliser le paramètre dans RAW comme l'exemple ci-dessous
DB::raw('count(?)',['id'])
️ Des déclarations brutes seront injectées dans la requête en tant que chaînes, vous devriez donc être extrêmement prudent pour éviter de créer des vulnérabilités d'injection SQL.
Mais à cette fin, il est préférable d'utiliser la méthode suivante pour éviter l'attaque SQL injection
$ users = DB :: table ( ' users ' )
-> select ( function ( $ query ){
$ query -> count ( ' * ' )-> as ( ' user_count ' )
$ query -> field ( ' status ' );
})
-> get (); Dans cette structure, vous avez accès au field , count , sum , avg , min , max , all , as méthodes.
Au lieu d'utiliser la méthode DB :: RAW, vous pouvez également utiliser les méthodes suivantes pour insérer une expression brute dans différentes parties de votre requête. N'oubliez pas que FoxDB ne peut garantir qu'une requête utilisant des expressions brutes est protégée contre les vulnérabilités d'injection SQL.
Les méthodes Whereraw et OrwheRaw peuvent être utilisées pour injecter une clause brute "où" dans votre requête. Ces méthodes acceptent un tableau facultatif de liaisons comme deuxième argument:
$ orders = DB :: table ( ' orders ' )
-> whereRaw ( ' price > IF(state = "TX", ?, 100) ' , [ 200 ])
-> get ();Les méthodes de présentation et d'Orhavingraw peuvent être utilisées pour fournir une chaîne brute comme valeur de la clause "Avoir". Ces méthodes acceptent un tableau facultatif de liaisons comme deuxième argument:
$ orders = DB :: table ( ' orders ' )
-> select ( ' department ' , DB :: raw ( ' SUM(price) as total_sales ' ))
-> groupBy ( ' department ' )
-> havingRaw ( ' SUM(price) > ? ' , [ 2500 ])
-> get ();Le constructeur de requêtes peut également être utilisé pour ajouter des clauses de jointure à vos requêtes. Pour effectuer une "jointure intérieure" de base, vous pouvez utiliser la méthode de jointure sur une instance de créateur de requête. Le premier argument transmis à la méthode de jointure est le nom du tableau que vous devez rejoindre, tandis que les arguments restants spécifient les contraintes de colonne pour la jointure. Vous pouvez même rejoindre plusieurs tables dans une seule requête:
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 ();Dans FoxDB, vous pouvez le faire plus facilement
$ users = DB :: table ( ' users ' )
-> select ( ' users.* ' , ' orders.price ' )
-> join ( ' orders.user_id ' , ' users.id ' )
-> get (); Dans cette structure, vous entrez le nom du tableau que vous souhaitez rejoindre avec sa clé étrangère ( 'orders.user_id' ) puis la clé principale ( 'user.id' ).
Si vous souhaitez effectuer une "jointure de gauche" ou "jointure droite" au lieu d'une "jointure intérieure", utilisez les méthodes de gauche ou de droite. Ces méthodes ont la même signature que la méthode de jointure:
$ users = DB :: table ( ' users ' )
-> leftJoin ( ' posts ' , ' users.id ' , ' = ' , ' posts.user_id ' )
-> get (); $ users = DB :: table ( ' users ' )
-> rightJoin ( ' posts ' , ' users.id ' , ' = ' , ' posts.user_id ' )
-> get ();Vous pouvez utiliser la méthode Crossjoin pour effectuer une "jointure croisée". Les jointures croisées génèrent un produit cartésien entre la première table et la table jointe:
$ sizes = DB :: table ( ' sizes ' )
-> crossJoin ( ' colors ' )
-> get ();Vous pouvez utiliser la méthode de la méthode de Builder de Query pour ajouter "où" Clauses à la requête. L'appel le plus élémentaire à la méthode où nécessite trois arguments. Le premier argument est le nom de la colonne. Le deuxième argument est un opérateur, qui peut être l'un des opérateurs pris en charge de la base de données. Le troisième argument est la valeur à comparer avec la valeur de la colonne.
Par exemple, la requête suivante récupère les utilisateurs où la valeur de la colonne des votes est égale à 100 et la valeur de la colonne d'âge est supérieure à 35:
$ users = DB :: table ( ' users ' )
-> where ( ' votes ' , ' = ' , 100 )
-> where ( ' age ' , ' > ' , 35 )
-> get ();Pour plus de commodité, si vous souhaitez vérifier qu'une colonne est = à une valeur donnée, vous pouvez transmettre la valeur comme deuxième argument à la méthode où. FOXDB supposera que vous souhaitez utiliser l'opérateur =:
$ users = DB :: table ( ' users ' )-> where ( ' votes ' , 100 )-> get ();Comme mentionné précédemment, vous pouvez utiliser tout opérateur pris en charge par votre système de base de données:
$ 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 ();Lorsque vous chaîn, les appels au créateur de requêtes sont de la méthode, les clauses "où" seront réunies en utilisant l'opérateur et de l'opérateur. Cependant, vous pouvez utiliser la méthode Orwhere pour rejoindre une clause à la requête à l'aide de l'opérateur OR. La méthode ou où elle accepte les mêmes arguments que la méthode où:
$ users = DB :: table ( ' users ' )
-> where ( ' votes ' , ' > ' , 100 )
-> orWhere ( ' name ' , ' John ' )
-> get ();Si vous avez besoin de regrouper une condition "ou" entre parenthèses, vous pouvez passer une fermeture comme premier argument à la méthode ou où:
$ users = DB :: table ( ' users ' )
-> where ( ' votes ' , ' > ' , 100 )
-> orWhere ( function ( $ query ) {
$ query -> where ( ' name ' , ' Abigail ' )
-> where ( ' votes ' , ' > ' , 50 );
})
-> get ();L'exemple ci-dessus produira le SQL suivant:
select * from users where votes > 100 or (name = 'Abigail' and votes > 50)
Les méthodes whereNot et orWhereNot peuvent être utilisées pour annuler un groupe donné de contraintes de requête. Par exemple, la requête suivante exclut les produits qui sont en autorisation ou qui ont un prix inférieur à dix:
$ products = DB :: table ( ' products ' )
-> whereNot ( function ( $ query ) {
$ query -> where ( ' clearance ' , true )
-> orWhere ( ' price ' , ' < ' , 10 );
})
-> get (); La méthode whereBetween vérifie que la valeur d'une colonne se situe entre deux valeurs:
$ users = DB :: table ( ' users ' )
-> whereBetween ( ' votes ' , [ 1 , 100 ])
-> get (); La méthode whereNotBetween Vérifie que la valeur d'une colonne se situe en dehors de deux valeurs:
$ users = DB :: table ( ' users ' )
-> whereNotBetween ( ' votes ' , [ 1 , 100 ])
-> get (); La méthode whereIn vérifie que la valeur d'une colonne donnée est contenue dans le tableau donné:
$ users = DB :: table ( ' users ' )
-> whereIn ( ' id ' , [ 1 , 2 , 3 ])
-> get (); La méthode whereNotIn vérifie que la valeur de la colonne donnée n'est pas contenue dans le tableau donné:
$ users = DB :: table ( ' users ' )
-> whereNotIn ( ' id ' , [ 1 , 2 , 3 ])
-> get (); La méthode whereNull vérifie que la valeur de la colonne donnée est nul:
$ users = DB :: table ( ' users ' )
-> whereNull ( ' updated_at ' )
-> get (); La méthode whereNotNull vérifie que la valeur de la colonne n'est pas nul:
$ users = DB :: table ( ' users ' )
-> whereNotNull ( ' updated_at ' )
-> get (); La méthode whereDate peut être utilisée pour comparer la valeur d'une colonne avec une date:
$ users = DB :: table ( ' users ' )
-> whereDate ( ' created_at ' , ' 2016-12-31 ' )
-> get (); La méthode whereMonth peut être utilisée pour comparer la valeur d'une colonne à un mois spécifique:
$ users = DB :: table ( ' users ' )
-> whereMonth ( ' created_at ' , ' 12 ' )
-> get (); La méthode whereDay peut être utilisée pour comparer la valeur d'une colonne à un jour spécifique du mois:
$ users = DB :: table ( ' users ' )
-> whereDay ( ' created_at ' , ' 31 ' )
-> get (); La méthode whereYear peut être utilisée pour comparer la valeur d'une colonne à une année spécifique:
$ users = DB :: table ( ' users ' )
-> whereYear ( ' created_at ' , ' 2016 ' )
-> get (); La méthode whereTime peut être utilisée pour comparer la valeur d'une colonne avec un temps spécifique:
$ users = DB :: table ( ' users ' )
-> whereTime ( ' created_at ' , ' = ' , ' 11:20:45 ' )
-> get (); La méthode whereColumn peut être utilisée pour vérifier que deux colonnes sont égales:
$ users = DB :: table ( ' users ' )
-> whereColumn ( ' first_name ' , ' last_name ' )
-> get (); Vous pouvez également transmettre un opérateur de comparaison à la méthode whereColumn :
$ users = DB :: table ( ' users ' )
-> whereColumn ( ' updated_at ' , ' > ' , ' created_at ' )
-> get (); La méthode orderBy vous permet de trier les résultats de la requête par une colonne donnée. Le premier argument accepté par la méthode orderBy devrait être la colonne que vous souhaitez trier, tandis que le deuxième argument détermine la direction du tri et peut être ASC ou DESC:
$ users = DB :: table ( ' users ' )
-> orderBy ( ' name ' , ' desc ' )
-> get ();Pour trier par plusieurs colonnes, vous pouvez simplement invoquer l'ordre par autant de fois que nécessaire:
$ users = DB :: table ( ' users ' )
-> orderBy ( ' name ' , ' desc ' )
-> orderBy ( ' email ' , ' asc ' )
-> get (); Les méthodes latest et oldest vous permettent de commander facilement les résultats par date. Par défaut, le résultat sera commandé par la colonne created_at de la table. Ou, vous pouvez passer le nom de la colonne que vous souhaitez trier:
$ user = DB :: table ( ' users ' )
-> latest ()
-> first ();La méthode inrandomorder peut être utilisée pour trier les résultats de la requête au hasard. Par exemple, vous pouvez utiliser cette méthode pour récupérer un utilisateur aléatoire:
$ randomUser = DB :: table ( ' users ' )
-> inRandomOrder ()
-> first ();groupBy et les méthodes having des méthodes Comme vous pouvez vous y attendre, le groupBy et having méthodes peuvent être utilisés pour regrouper les résultats de la requête. La signature de la méthode having est similaire à celle de la méthode où:
$ users = DB :: table ( ' users ' )
-> groupBy ( ' account_id ' )
-> having ( ' account_id ' , ' > ' , 100 )
-> get ();Vous pouvez transmettre plusieurs arguments à la méthode groupby pour se regrouper par plusieurs colonnes:
$ users = DB :: table ( ' users ' )
-> groupBy ( ' first_name ' , ' status ' )
-> having ( ' account_id ' , ' > ' , 100 )
-> get ();Pour construire des déclarations plus avancées, consultez la méthode d'assistance.
Vous pouvez utiliser le skip et take des méthodes pour limiter le nombre de résultats renvoyés de la requête ou pour sauter un nombre donné de résultats dans la requête:
$ users = DB :: table ( ' users ' )-> skip ( 10 )-> take ( 5 )-> get (); Alternativement, vous pouvez utiliser les méthodes limit et offset . Ces méthodes sont fonctionnellement équivalentes aux méthodes de prise et de saut, respectivement:
$ users = DB :: table ( ' users ' )
-> offset ( 10 )
-> limit ( 5 )
-> get (); Le Builder de Query fournit également une méthode insert qui peut être utilisée pour insérer des enregistrements dans la table de base de données. La méthode d'insertion accepte un tableau de noms et valeurs de colonne:
DB :: table ( ' users ' )-> insert ([
' email ' => ' [email protected] ' ,
' votes ' => 0
]); Si le tableau a un ID d'incrémentation automatique, utilisez la méthode insertGetId pour insérer un enregistrement, puis récupérer l'ID:
$ id = DB :: table ( ' users ' )-> insertGetId (
[ ' email ' => ' [email protected] ' , ' votes ' => 0 ]
);En plus d'insérer des enregistrements dans la base de données, le constructeur de requête peut également mettre à jour les enregistrements existants à l'aide de la méthode de mise à jour. La méthode de mise à jour, comme la méthode d'insertion, accepte un tableau de paires de colonnes et de valeur indiquant les colonnes à mettre à jour. La méthode de mise à jour renvoie le nombre de lignes affectées. Vous pouvez contraindre la requête de mise à jour à l'aide des clauses:
$ affected = DB :: table ( ' users ' )
-> where ( ' id ' , 1 )
-> update ([ ' votes ' => 1 ]);Le constructeur de requête fournit également des méthodes pratiques pour incrémenter ou décrémenter la valeur d'une colonne donnée. Ces deux méthodes acceptent au moins un argument: la colonne à modifier. Un deuxième argument peut être fourni pour spécifier le montant par lequel la colonne doit être incrémentée ou décrémentée:
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 ();Vous pouvez utiliser la syntaxe la plus agréable, qui en plus de raccourcir le code, aide également à rendre le code plus lisible
Pour créer des requêtes basées sur Boolean, vous pouvez utiliser des méthodes true et false ou is des méthodes
$ 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 ();Vous n'avez pas besoin d'utiliser la méthode où vos requêtes consécutivement. Vous pouvez utiliser la méthode ou utiliser ou à la place ou où.
Exemple:
DB :: table ( ' users ' )
-> is ( ' active ' )
-> and ( ' credit ' , ' > ' , 0 )
-> or ( ' vip ' , true )
-> get (); DB :: table ( ' users ' )
-> in ( ' id ' , [ 1 , 5 , 10 ])
-> get ();D'autres méthodes sont également disponibles, comme les méthodes suivantes:
not(..) / orNot(..)
in(..) / notIn(..) / orIn(..) / orNotIn(..)
like(..) / orLike(..)
null(..) / orNull(..) / notNull(..) / orNotNull(..)
date(..) / orDate(..)
year(..) / orYear(..)
month(..) / orMonth(..)
day(..) / orDay(..)
time(..) / orTime(..)
