PdoOne
4.10
PDoOne. C'est un simple wrapper pour la bibliothèque PDO de PHP compatible avec SQL Server (2008 R2 ou supérieur), MySQL (5,7 ou plus) et Oracle (12,1 ou plus).
Cette bibliothèque essaie de travailler le plus vite possible . La plupart des opérations sont de simples gestions de chaînes / tableau et fonctionnent dans le métal nu de la bibliothèque PDO, mais il permet également de créer un ORM en utilisant l'extension EFTec / PDoOneorm.
Tourner ceci
$ stmt = $ pdo -> prepare ( " SELECT * FROM myTable WHERE name = ? " );
$ stmt -> bindParam ( 1 , $ _POST [ ' name ' ], PDO :: PARAM_STR );
$ stmt -> execute ();
$ result = $ stmt -> get_result ();
$ products =[];
while ( $ row = $ result -> fetch_assoc ()) {
$ product []= $ row ;
}
$ stmt -> close ();dans ce
$ products = $ pdoOne
-> select ( " * " )
-> from ( " myTable " )
-> where ( " name = ? " ,[ $ _POST [ ' name ' ]])
-> toList ();ou en utilisant l'ORM (en utilisant la bibliothèque EFTec / PDoOneorm)
ProductRepo // this class was generated with echo $pdoOne()->generateCodeClass(['Product']); or using the cli.
:: where ( " name = ? " ,[ $ _POST [ ' name ' ]])
:: toList ();| Exampleticketphp | Exemple de cupcakes | Exemple de recherche | Exemple de méthode différente |
|---|---|---|---|
 |  |  |
Plus d'exemples:
Exemple MySQL PHP et PDO en utilisant PDOOne
Cette bibliothèque nécessite PHP 7.1 et plus, et elle nécessite l'extension PDO et l'extension PDO-MySQL (MySQL), PDO-SQLSRV (SQL Server) ou PDO-OCI (Oracle)
Éditez composer.json l'exigence suivante, puis mettez à jour le compositeur.
{
"require" : {
"eftec/PdoOne" : " ^4.0.1 "
}
}ou l'installez via CLI en utilisant
Le compositeur a besoin d'eftec / pdoone
Il suffit de télécharger le dossier lib de la bibliothèque et de mettre votre projet de dossier. Ensuite, vous devez inclure tous les fichiers inclus.
Créez une instance de la classe PDoOne comme suit. Ensuite, vous pouvez ouvrir la connexion à l'aide de la méthode connect () ou Open ()
use eftec PdoOne ;
// mysql
$ dao = new PdoOne ( " mysql " , " 127.0.0.1 " , " root " , " abc.123 " , " sakila " , "" );
$ conn -> logLevel = 3 ; // it is for debug purpose and it works to find problems.
$ dao -> connect ();
// sql server 10.0.0.1instance or (local)instance or machinenameinstance or machine (default instance)
$ dao = new PdoOne ( " sqlsrv " , " (local)sqlexpress " , " sa " , " abc.123 " , " sakila " , "" );
$ conn -> logLevel = 3 ; // it is for debug purpose and it works to find problems.
$ dao -> connect ();
// test (mockup)
$ dao = new PdoOne ( " test " , " anyy " , " any " , " any " , " any " , "" );
$ dao -> connect ();
// oci (oracle) ez-connect. Remember that you must have installed Oracle Instant client and added to the path.
$ cs = ' (DESCRIPTION =(ADDRESS = (PROTOCOL = TCP)(HOST = localhost)(PORT = 1521))(CONNECT_DATA =(SERVER = DEDICATED)(SERVICE_NAME = instancia1))) ' ;
$ dao = new PdoOne ( " oci " , $ cs , " sa " , " abc.123 " ); // oracle uses the user as the schema
$ conn -> logLevel = 3 ; // it is for debug purpose and it works to find problems.
$ dao -> connect ();
// oci (oracle) tsnnames (the environment variables TNS_ADMIN and PATH must be correctly configured), also tnsnames.ora must exists.
$ cs = ' instancia1 ' ;
$ dao = new PdoOne ( " oci " , $ cs , " sa " , " abc.123 " ); // oracle uses the user as the schema
$ conn -> logLevel = 3 ; // it is for debug purpose and it works to find problems.
$ dao -> connect ();où
$ dao = new pDoOne ("mysql", "127.0.0.1", "root", "ABC.123", "Sakila", "");
Oracle est difficile à installer. Dans Windows, à partir du dossier Bin d'Oracle Home, vous devez copier toute la DLL dans le dossier PHP et le dossier Apache.
Avec la méthode runrawquery () , nous pourrions exécuter une commande directement à PDO avec ou sans paramètres. Et il pourrait retourner un pdostament ou un tableau . C'est utile lorsque nous voulons de la vitesse.
RunrawQuery ($ rawsql, $ param, $ returnArray, $ fetchmode, $ fetchargument)
String $ rawsql La requête pour exécuter le tableau | null $ param [Type1, Value1, Type2, Value2] ou [Name1 => Value, Name2 = Value2] bool $ returnArray Si true (par défaut) puis il renvoie un tableau. Si false, il renvoie un pdostatement int $ fetchmode indique le mode à récupérer. Exemple: PDO :: fetch_assoc null $ fetchargument L'argument dumode fetch.
$ sql = ' select * from table where id=1 ' ;
$ pdoStatement = $ pdoOne -> runRawQuery ( $ sql ,[], false ); // [] are the parametersMais nous pourrions le changer pour retourner un tableau
$ sql = ' select * from table where id=1 ' ;
$ values = $ pdoOne -> runRawQuery ( $ sql ); // [] are the parametersNous pourrions également passer des paramètres.
$ values = $ con -> runRawQuery ( ' select * from table where id=? ' ,[ 20 ]); // with parameter
$ values = $ con -> runRawQuery ( ' select * from table where id=:name ' ,[ ' name ' => 20 ]); // with named parameter
$ values = $ con -> runRawQuery ( ' select * from table ' ,[]); // without parameter.Remarque, cette bibliothèque utilise des instructions préparées, il est donc exempt d'injection SQL (si vous utilisez des paramètres)
$ name = " O'hara " ;
$ values = $ con -> runRawQuery ( " select * from table where name=:name " ,[ ' name ' => $ name ]); // it works.✅
$ values = $ con -> runRawQuery ( " select * from table where name=? " ,[ $ name ]); // it works ok.✅
$ values = $ con -> runRawQuery ( " select * from table where name=' $ name ' " ); // it will crash.Avec la méthode runQuery (), nous avons pu exécuter une instruction préparée dans PDO. Il est utile lorsque nous voulons y passer des arguments. RunQuery () nécessite un PDO préparé .
Cette méthode n'est recommandée que si vous travaillez déjà avec les instructions APDE et que vous ne souhaitez adapter tout votre code.
$ sql = " insert into `product`(name) values(?) " ;
$ stmt = $ pdoOne -> prepare ( $ sql );
$ productName = " Cocacola " ;
$ stmt -> bind_param ( " s " , $ productName ); // s stand for a string. Also i =integer, d = double and b=blob
$ rows = $ pdoOne -> runQuery ( $ stmt );
$ allRows = $ rows -> fetch_all ( PDO :: FETCH_ASSOC );Vous pouvez utiliser le Builder Query pour construire votre commande. Vous pouvez vérifier le chapitre sur Query Builder (DQL) pour plus d'informations.
// query builder
$ pdoOne -> set ([ ' name ' => ' cocacola ' ])
-> from ( ' product ' )
-> insert ();La bibliothèque eftec pDoOneorm permet de créer un [orm] (#orm) de vos tables. Si vous êtes généré un ORM, vous pouvez utiliser le code suivant
ProductRepo:: toList ([ ' category ' => ' drink ' ]);Où ProductTrepo est une classe de service générée en utilisant l'ORM.
Par défaut, PDOOne exécute les requêtes dans le mode PDO :: fetch_assoc que vous pouvez modifier en exécutant les requêtes comme:
$ pdo -> setFechMode ( PDO :: FETCH_CLASS , ' stdClass ' )-> runRawQuery ( $ query );
// or you can run as
$ pdo -> runRawQuery ( $ query , null , true , false , null , PDO :: FETCH_CLASS , ' stdClass ' )PDoOne permet 5 types de dates.
Format SQL C'est le format comment la date est stockée dans la base de données. Cela dépend du type de base de données. Par exemple, MySQL pourrait utiliser le format YMD.
Format humain C'est le format à quoi ressemble l'utilisateur final.
Format de date ISO . C'est le format comment la valeur pourrait être transportée et sérialisée.
Timestamp : il compte le nombre de secondes après le 1-1-1970
Classe / PHP Classe : Il s'agit d'un objet DateTime .
Il existe 3 méthodes pour exécuter une transaction:
| Méthode | Description |
|---|---|
| StartTransaction () | Il commence une transaction. Selon la base de données de type, elle peut être empilée ou non. |
| commettre() | Commettre (et ferme) une transaction |
| rollback () | Rollback (et ferme) une transaction |
Exemple:
try {
$ sql = " insert into `product`(name) values(?) " ;
$ pdoOne -> startTransaction ();
$ result = $ pdoOne -> runRawQuery ( $ sql ,[ ' Fanta ' => $ productName ], false );
$ pdoOne -> commit (); // transaction ok
} catch ( Exception $ e ) {
$ pdoOne -> rollback ( false ); // error, transaction cancelled, the false means that it doesn't throw an exception if we want rollback.
}Renvoie True si le tableau existe (base de données / schéma actuel)
Renvoie les statistiques (en tant que tableau) d'une colonne d'une table.
$ stats = $ pdoOne -> statValue ( ' actor ' , ' actor_id ' );| min | max | AVG | somme | compter |
|---|---|---|---|---|
| 1 | 205 | 103.0000 | 21115 | 205 |
Renvoie toutes les colonnes d'une table
$ result = $ pdoOne -> columnTable ( ' actor ' );| colon | coltype | faire une collision | colpres | colocataire | Iskey | isidentité |
|---|---|---|---|---|---|---|
| acteur_id | petit | 5 | 0 | 1 | 1 | |
| prénom | varchar | 45 | 0 | 0 | ||
| nom de famille | varchar | 45 | 0 | 0 | ||
| Last_update | horodatage | 0 | 0 |
Renvoie toutes les clés étrangères d'une table (table source)
Crée un tableau à l'aide d'une définition et d'une clé primaire.
Remarque: vous pouvez générer un code pour créer un tableau à l'aide d'une table existante en exécutant CLI (sortie de classe de sortie)
php pdoone.php -database mysql -server 127.0.0.1 -Usser root -pwd ABC.123 -db Sakila -input Film -output Classcode
Exemple: (MySQL)
$ pdo -> createTable ( ' film ' ,
[
" film_id " => " smallint unsigned not null auto_increment " ,
" title " => " varchar(255) not null " ,
" description " => " text " ,
" release_year " => " year " ,
" language_id " => " tinyint unsigned not null " ,
" original_language_id " => " tinyint unsigned " ,
" rental_duration " => " tinyint unsigned not null default '3' " ,
" rental_rate " => " decimal(4,2) not null default '4.99' " ,
" length " => " smallint unsigned " ,
" replacement_cost " => " decimal(5,2) not null default '19.99' " ,
" rating " => " enum('G','PG','PG-13','R','NC-17') default 'G' " ,
" special_features " => " set('Trailers','Commentaries','Deleted Scenes','Behind the Scenes') " ,
" last_update " => " timestamp not null default CURRENT_TIMESTAMP on update CURRENT_TIMESTAMP "
],[
" film_id " => " PRIMARY KEY " ,
" title " => " KEY " ,
" language_id " => " FOREIGN KEY REFERENCES`language`(`language_id`) ON UPDATE CASCADE " ,
" original_language_id " => " FOREIGN KEY REFERENCES`language`(`language_id`) ON UPDATE CASCADE "
]); $ pdo -> createTable ( ' film ' ,
[
" film_id " => " smallint unsigned not null auto_increment " ,
" title " => " varchar(255) not null " ,
" description " => " text " ,
" release_year " => " year " ,
" language_id " => " tinyint unsigned not null " ,
" original_language_id " => " tinyint unsigned " ,
" rental_duration " => " tinyint unsigned not null default '3' " ,
" rental_rate " => " decimal(4,2) not null default '4.99' " ,
" length " => " smallint unsigned " ,
" replacement_cost " => " decimal(5,2) not null default '19.99' " ,
" rating " => " enum('G','PG','PG-13','R','NC-17') default 'G' " ,
" special_features " => " set('Trailers','Commentaries','Deleted Scenes','Behind the Scenes') " ,
" last_update " => " timestamp not null default CURRENT_TIMESTAMP on update CURRENT_TIMESTAMP "
], ' film_id ' ); Exemple (SQLSRV)
$ pdo -> createTable ( ' film ' ,
[
" film_id " => " int NOT NULL IDENTITY(1,1) " ,
" title " => " varchar(255) NOT NULL " ,
" description " => " text(2147483647) DEFAULT (NULL) " ,
" release_year " => " varchar(4) " ,
" language_id " => " tinyint NOT NULL " ,
" original_language_id " => " tinyint DEFAULT (NULL) " ,
" rental_duration " => " tinyint NOT NULL DEFAULT ((3)) " ,
" rental_rate " => " decimal(4,2) NOT NULL DEFAULT ((4.99)) " ,
" length " => " smallint DEFAULT (NULL) " ,
" replacement_cost " => " decimal(5,2) NOT NULL DEFAULT ((19.99)) " ,
" rating " => " varchar(10) DEFAULT ('G') " ,
" special_features " => " varchar(255) DEFAULT (NULL) " ,
" last_update " => " datetime NOT NULL DEFAULT (getdate()) "
],[
" language_id " => " FOREIGN KEY REFERENCES language(language_id) " ,
" original_language_id " => " FOREIGN KEY REFERENCES language(language_id) " ,
" film_id " => " PRIMARY KEY "
]);Il renvoie une liste de tableaux commandés par dépendance (Aucune dépendance à plus dépendante)
Remarque : Cette opération n'est pas infaillible car les tables pourraient avoir des références circulaires.
$ dao = new PdoOne ( ' sqlsrv ' , " (local)sqlexpress " , " sa " , " abc.123 " , " sakila " );
$ dao -> open ();
echo " <pre> " ;
var_dump ( $ dao -> tableSorted ( 3 , false , true )); // it returns the tables sortered
var_dump ( $ dao -> tableSorted ( 3 , true , true )); // it returns all the tables that can't be sortered
echo " </pre> " ;Il valide un tableau si le tableau correspond à la définition assivée par les valeurs.
$def=[
"film_id" => "int NOT NULL IDENTITY(1,1)",
"title" => "varchar(255) NOT NULL",
"description" => "text(2147483647) DEFAULT (NULL)",
"release_year" => "varchar(4)",
"language_id" => "tinyint NOT NULL",
"original_language_id" => "tinyint DEFAULT (NULL)",
"rental_duration" => "tinyint NOT NULL DEFAULT ((3))",
"rental_rate" => "decimal(4,2) NOT NULL DEFAULT ((4.99))",
"length" => "smallint DEFAULT (NULL)",
"replacement_cost" => "decimal(5,2) NOT NULL DEFAULT ((19.99))",
"rating" => "varchar(10) DEFAULT ('G')",
"special_features" => "varchar(255) DEFAULT (NULL)",
"last_update" => "datetime NOT NULL DEFAULT (getdate())"
];
$keys=[
"language_id" => "FOREIGN KEY REFERENCES language(language_id)",
"original_language_id" => "FOREIGN KEY REFERENCES language(language_id)",
"film_id" => "PRIMARY KEY"
];
var_dump(PdoOne::validateDefTable(self::getPdoOne(),self::TABLE,$def,$keys));
Il renvoie toutes les clés étrangères d'une table.
$ result = $ pdoOne -> foreignKeyTable ( ' actor ' );| collocal | tablem de table | colrem |
|---|---|---|
| client_id | client | client_id |
| location_id | de location | location_id |
| staff_id | personnel | staff_id |
Vous pouvez également construire une requête procédurale.
Exemple:
$ results = $ pdoOne -> select ( " * " )-> from ( " producttype " )
-> where ( ' name=? ' , [ ' Cocacola ' ])
-> where ( ' idproducttype=? ' , [ 1 ])
-> toList (); Indique les colonnes à retourner. L'argument est une commande SQL, il permet donc à toute opération de prendre en charge la base de données, y compris les fonctions, les constantes, les opérateurs, l'alias et autres.
$ results = $ pdoOne -> select ( " col1,col2 " ); //...Génère la requête: sélectionnez COL1, COL2 ....
$ results = $ pdoOne -> select ( " select * from table " ); //->...Génère la requête: sélectionner * dans le tableau ....
Génère une requête qui renvoie un nombre de valeurs. C'est une macro de la méthode select ()
$ result = $ pdoOne -> count ( ' from table where condition=1 ' ); // select count(*) from table where c..
$ result = $ pdoOne -> count ()-> from ( ' table ' )-> where ( ' condition=? ' ,[ 1 ]); // select count(*) from table where c..
$ result = $ pdoOne -> count ( ' from table ' , ' col1 ' ); // select count(col1) from table
$ result = $ pdoOne -> count ()-> from ( ' table ' ); // select count(*) from tableGénère une requête qui renvoie la valeur minimale d'une colonne. Si $ arg est vide, il utilise $ sql pour le nom de la colonne, c'est une macro de la méthode select ()
$ result = $ pdoOne -> min ( ' from table where condition=1 ' , ' col ' ); // select min(col) from table where c..
$ result = $ pdoOne -> min ( ' from table ' , ' col1 ' ); // select min(col1) from table
$ result = $ pdoOne -> min ( '' , ' col1 ' )-> from ( ' table ' ); // select min(col1) from table
$ result = $ pdoOne -> min ( ' col1 ' )-> from ( ' table ' ); // select min(col1) from tableGénère une requête qui renvoie la valeur maximale d'une colonne. Si $ arg est vide, il utilise $ sql pour le nom de la colonne, c'est une macro de la méthode select ()
$ result = $ pdoOne -> max ( ' from table where condition=1 ' , ' col ' ); // select max(col) from table where c..
$ result = $ pdoOne -> max ( ' from table ' , ' col1 ' ); // select max(col1) from tableGénère une requête qui renvoie la valeur de somme d'une colonne. Si $ arg est vide, il utilise $ sql pour le nom de la colonne, c'est une macro de la méthode select ()
$ result = $ pdoOne -> sum ( ' from table where condition=1 ' , ' col ' ); // select sum(col) from table where c..
$ result = $ pdoOne -> sum ( ' from table ' , ' col1 ' ); // select sum(col1) from tableGénère une requête qui renvoie la valeur moyenne d'une colonne. Si $ arg est vide, il utilise $ sql pour le nom de la colonne, c'est une macro de la méthode select ()
$ result = $ pdoOne -> avg ( ' from table where condition=1 ' , ' col ' ); // select avg(col) from table where c..
$ result = $ pdoOne -> avg ( ' from table ' , ' col1 ' ); // select avg(col1) from tableGénère une commande Select.
$ results = $ pdoOne -> select ( " col1,col2 " )-> distinct (); //...Génère la requête: sélectionnez COL1 distinct , COL2 ....
Remarque: -> Distinct ('UNIQUE') SELECT SELECT UNIQUE .
Génère une commande "à partir de" SQL.
$ results = $ pdoOne -> select ( " * " )-> from ( ' table ' ); //...Génère la requête: sélectionner * dans le tableau
$ Les tables pourraient être une seule table ou une construction SQL. Pour Examp, la commande suivante est valide:
$ results = $ pdoOne -> select ( " * " )-> from ( ' table t1 inner join t2 on t1.c1=t2.c2 ' ); //...Génère une commande où.
$ results = $ pdoOne -> select ( " * " )
-> from ( ' table ' )
-> where ( ' p1=1 ' ); //...L'où pourrait être exprimé de différentes manières.
Il est possible d'écrire le lieu sans paramètres comme suit:
$ results = $ pdoOne -> select ( " * " )-> from ( ' table ' )-> where ( " p1=1 and p2>2.5 or p3 like '%aa%' " ); $ aa = ' aa ' ;
$ results = $ pdoOne -> select ( " * " )-> from ( ' table ' )-> where ( " p1=? and p2>? or p3 like ? " ,[ 1
, 2.5
, " % $ aa % " ]);Ça fonctionne aussi
// (if there is only a single argument without a type)
$ results = $ pdoOne -> select ( " * " )-> from ( ' table ' )-> where ( " p1=? " ,[ 1 ]); // = where("p1=?",[1]);
// (if we don't define to where to put the value)
$ results = $ pdoOne -> select ( " * " )-> from ( ' table ' )-> where ( " p1 " ,[ 1 ]); // = where("p1=?",[1]); Il s'agit d'une définition raccourci d'une requête à l'aide d'un tableau associatif, où la clé est le nom de la colonne et la valeur est la valeur à comparer
Il ne fonctionne qu'avec l'égalité (=) et l'opérateur logique 'et' (le type est défini automatiquement)
// select * from table where p1='1' and p2='2.5' and p3='aa'
$ results = $ pdoOne -> select ( " * " )-> from ( ' table ' )-> where ([ ' p1 ' => 1
, ' p2 ' => 2.5
, ' p3 ' => ' aa ' ]); Il est également possible de spécifier le type de paramètre.
// select * from table where p1=1 and p2='2.5' and p3='aa'
$ results = $ pdoOne -> select ( " * " )-> from ( ' table ' )-> where ([ ' p1 ' =>[ 1 ]
, ' p2 ' =>[ 2.5 ]
, ' p3 ' =>[ ' aa ' ]]); Vous pouvez également utiliser un tableau associatif comme argument et des paramètres nommés dans la requête
$ results = $ pdoOne -> select ( " * " )-> from ( " table " )
-> where ( ' condition=:p1 and condition2=:p2 ' ,[ ' p1 ' => ' Coca-Cola ' , ' p2 ' => 1 ])
-> toList ();Génère la requête: Sélectionner * dans le tableau où condition =? (Coca-Cola) et condition2 =? (1)
Génère la requête: sélectionnez * dans le tableau où p1 = 1
Remarque: ArrayParameters est un tableau comme suit: Type, valeur.
Où le type est i = entier, d = double, s = chaîne ou b = blob. En cas de doute, utilisez "S" (voir le tableau ci-dessous)
Exemple deparamètres:
[1, «Hello», 20.3, «monde»]
$ results = $ pdoOne -> select ( " * " )
-> from ( ' table ' )
-> where ( ' p1=? ' ,[ 1 ]); //...Génère la requête: sélectionnez * dans le tableau où p1 =? (1)
$ results = $ pdoOne -> select ( " * " )
-> from ( ' table ' )
-> where ( ' p1=? and p2=? ' ,[ 1 , ' hello ' ]); //...Génère la requête: sélectionnez * dans le tableau où p1 =? (1) et p2 =? ('Bonjour')
Note. où pourrait être imbriqué.
$ results = $ pdoOne -> select ( " * " )
-> from ( ' table ' )
-> where ( ' p1=? ' ,[ 1 ])
-> where ( ' p2=? ' ,[ ' hello ' ]); //...Génère la requête: sélectionnez * dans le tableau où p1 =? (1) et p2 =? ('Bonjour')
Vous pouvez également utiliser:
$ results = $ pdoOne -> select ( " * " )-> from ( " table " )
-> where ([ ' p1 ' => ' Coca-Cola ' , ' p2 ' => 1 ])
-> toList ();Génère la requête: Sélectionnez * dans le tableau où p1 =? (Coca-Cola) et P2 =? (1)
Génère une commande d'ordre.
$ results = $ pdoOne -> select ( " * " )
-> from ( ' table ' )
-> order ( ' p1 desc ' ); //...Génère la requête: Sélectionner * From Table Order par P1 DESC
Génère une commande de groupe.
$ results = $ pdoOne -> select ( " * " )
-> from ( ' table ' )
-> group ( ' p1 ' ); //...Génère la requête: Sélectionner * dans le groupe de table par P1
Génère une commande ayant une commande.
Remarque: il utilise les mêmes paramètres que où ()
$ results = $ pdoOne -> select ( " * " )
-> from ( ' table ' )
-> group ( ' p1 ' )
-> having ( ' p1>? ' , array ( 1 )); //...Génère la requête: sélectionner * dans le groupe de table par P1 ayant P1>? (1)
Remarque: Avoir pourrait être imbriqué avoir () -> avoir ()
Remarque: Avoir peut être sans paramètres ayant («col> 10»)
Exécutez la requête Générer.
Remarque Si returnArray est vrai, il renvoie un tableau associatif. Si returnArray est faux, il renvoie un mysqli_result
Remarque: il réinitialise les paramètres actuels (tels que la sélection actuelle, à partir de, où, etc.)
C'est une macro de Rungen () . Il renvoie un tableau associatif ou un faux si l'opération échoue.
$ results = $ pdoOne -> select ( " * " )
-> from ( ' table ' )
-> toList (); Il renvoie un pdostatif à partir de la requête actuelle
Remarque: si vous souhaitez boucler l'instruction, vous pouvez utiliser fetchloop ()
Exemple :
$ stmt = $ pdoOne -> select ( " * " )
-> from ( ' table ' )
-> toPdoStatement ();
while ( $ row = $ stmt -> fetch ()) {
// do something
} Il récupère une requête pour chaque ligne.
Cette méthode peut être utilisée lorsque nous ne voulons pas lire toutes les informations à la fois, vous pouvez donc lire et traiter chaque ligne séparément
Exemple :
$ this -> select ( ' select id,name from table ' )
-> fetchLoop ( static function ( $ row ) { return ( $ row );}, PDO :: FETCH_ASSOC )Il renvoie un métacode (définitions) de chaque colonne d'une requête.
$ results = $ pdoOne -> select ( " * " )
-> from ( ' table ' )
-> toMeta (); ou
$ results = $ pdoOne -> toMeta ( ' select * from table ' ); résultat:
array(3) {
[0]=>
array(7) {
["native_type"]=>
string(4) "LONG"
["pdo_type"]=>
int(2)
["flags"]=>
array(2) {
[0]=>
string(8) "not_null"
[1]=>
string(11) "primary_key"
}
["table"]=>
string(11) "producttype"
["name"]=>
string(13) "idproducttype"
["len"]=>
int(11)
["precision"]=>
int(0)
}
[1]=>
array(7) {
["native_type"]=>
string(10) "VAR_STRING"
["pdo_type"]=>
int(2)
["flags"]=>
array(0) {
}
["table"]=>
string(11) "producttype"
["name"]=>
string(4) "name"
["len"]=>
int(135)
["precision"]=>
int(0)
}
}
C'est une macro de Rungen. Il renvoie un tableau indexé de la première colonne
$ results = $ pdoOne -> select ( " * " )
-> from ( ' table ' )
-> toListSimple (); // ['1','2','3','4'] Il renvoie un tableau associatif où la première valeur est la clé et la seconde est la valeur.
Si la deuxième valeur n'existe pas, il utilise l'index comme valeur (première valeur).
$ results = $ pdoOne -> select ( " cod,name " )
-> from ( ' table ' )
-> toListKeyValue (); // ['cod1'=>'name1','cod2'=>'name2'] C'est une macro de Rungen. Il renvoie un mysqli_result ou null.
$ results = $ pdoOne -> select ( " * " )
-> from ( ' table ' )
-> toResult (); // Il renvoie le premier scalaire (une valeur) d'une requête. Si $ colname est nul, il utilise la première colonne.
$ count = $ this -> count ( ' from product_category ' )-> firstScalar ();C'est une macro de Rungen. Il renvoie la première ligne le cas échéant, sinon elle renvoie FALSE, en tant que tableau associatif.
$ results = $ pdoOne -> select ( " * " )
-> from ( ' table ' )
-> first (); C'est une macro de Rungen. Il renvoie la dernière ligne (le cas échéant, sinon, il renvoie false) en tant que tableau associatif.
$ results = $ pdoOne -> select ( " * " )
-> from ( ' table ' )
-> last (); Parfois, il est plus efficace pour exécuter Order () et First () car Last () lit toutes les valeurs.
Il renvoie la commande et la chaîne SQL.
$ sql = $ pdoOne -> select ( " * " )
-> from ( ' table ' )
-> sqlGen ();
echo $ sql ; // returns select * from table
$ results = $ pdoOne -> toList (); // executes the queryRemarque: il ne réinitialise pas la requête.
Il existe quatre façons d'exécuter chaque commande.
Disons que nous voulons ajouter un entier dans la colonne Col1 avec la valeur 20
Schéma et valeurs à l'aide d'une liste de valeurs : où la première valeur est la colonne, la seconde est le type de valeur (i = entier, d = double, s = chaîne, b = blob) et le deuxième tableau contient les valeurs.
$ pdoOne -> insert ( " table "
,[ ' col1 ' ]
,[ 20 ]);Schéma et valeurs dans la même liste : où la première valeur est la colonne, la seconde est le type de valeur (i = entier, d = double, s = chaîne, b = blob) et le troisième est la valeur.
$ pdoOne -> insert ( " table "
,[ ' col1 ' , 20 ]);Schéma et valeurs à l'aide de deux tableaux associatifs :
$ pdoOne -> insert ( " table "
,[ ' col1 ' ]
,[ ' col1 ' => 20 ]);Schéma et valeurs à l'aide d'un seul tableau associatif : le type est calculé automatiquement.
$ pdoOne -> insert ( " table "
,[ ' col1 ' => 20 ]);Génère une commande insert.
$ pdoOne -> insert ( " producttype "
,[ ' idproducttype ' , ' name ' , ' type ' ]
,[ 1 , ' cocacola ' , 1 ]);Utilisation de la chaîne imbriquée (tableau unique)
$ pdoOne -> from ( " producttype " )
-> set ([ ' idproducttype ' , 0 , ' name ' , ' Pepsi ' , ' type ' , 1 ])
-> insert ();Utilisation de l'ensemble multiple de chaîne imbriquée
$ pdoOne -> from ( " producttype " )
-> set ( " idproducttype=? " ,[ 101 ])
-> set ( ' name=? ' ,[ ' Pepsi ' ])
-> set ( ' type=? ' ,[ 1 ])
-> insert ();ou (le type est défini, dans le possible, automatiquement par MySQL)
$ pdoOne -> from ( " producttype " )
-> set ( " idproducttype=? " ,[ 101 ])
-> set ( ' name=? ' , ' Pepsi ' )
-> set ( ' type=? ' , 1 )
-> insert (); $ pdoOne -> insertObject ( ' table ' ,[ ' Id ' => 1 , ' Name ' => ' CocaCola ' ]);Utilisation d'un ensemble déclaratif de chaîne imbriqué
$ pdoOne -> from ( " producttype " )
-> set ( ' (idproducttype,name,type) values (?,?,?) ' ,[ 100 , ' Pepsi ' , 1 ])
-> insert ();Génère la question: insérer dans ProductType (idProductType, nom, type) Valeurs (?,?,?) ....
Génère une commande insert.
$ pdoOne -> update ( " producttype "
,[ ' name ' , ' type ' ] //set
,[ 6 , ' Captain-Crunch ' , 2 ] //set
,[ ' idproducttype ' ] // where
,[ 6 ]); // where $ pdoOne -> update ( " producttype "
,[ ' name ' => ' Captain-Crunch ' , ' type ' => 2 ] // set
,[ ' idproducttype ' => 6 ]); // where $ pdoOne -> from ( " producttype " )
-> set ( " name=? " ,[ ' Captain-Crunch ' ]) //set
-> set ( " type=? " ,[ 6 ]) //set
-> where ( ' idproducttype=? ' ,[ 6 ]) // where
-> update (); // updateou
$ pdoOne -> from ( " producttype " )
-> set ( " name=? " , ' Captain-Crunch ' ) //set
-> set ( " type=? " , 6 ) //set
-> where ( ' idproducttype=? ' ,[ 6 ]) // where
-> update (); // updateGénère la requête: mettre à jour le jeu de produits ProductType
name=?,type=? oùidproducttype=? ....
Génère une commande delete.
$ pdoOne -> delete ( " producttype "
,[ ' idproducttype ' ] // where
,[ 7 ]); // where $ pdoOne -> delete ( " producttype "
,[ ' idproducttype ' => 7 ]); // whereGénère la requête: supprimer de ProductType où
idproducttype=? ....
Vous pouvez également supprimer via une chaîne DQL Builder.
$ pdoOne -> from ( " producttype " )
-> where ( ' idproducttype=? ' ,[ 7 ]) // where
-> delete (); $ pdoOne -> from ( " producttype " )
-> where ([ ' idproducttype ' => 7 ]) // where
-> delete (); Génère la requête: supprimer de ProductType où
idproducttype=? ....
Il est possible de mettre en cache éventuellement le résultat des requêtes. La durée de la requête est également définie dans la requête. Si le résultat de la requête n'est pas mis en cache, il est calculé normalement (exécution de la requête dans la base de données). Pour identifier une requête comme unique, le système génère un ID unique (UID) basé sur SHA256 créé avec la requête, les paramètres, les méthodes et le type de fonctionnement.
La bibliothèque ne fait aucune opération de cache directement, mais il permet de mettre en cache les résultats à l'aide d'une bibliothèque externe.
class CacheService implements eftec IPdoOneCache {
public $ cacheData =[];
public $ cacheCounter = 0 ; // for debug
public function getCache ( $ uid , $ family = '' ) {
if ( isset ( $ this -> cacheData [ $ uid ])) {
$ this -> cacheCounter ++;
echo " using cache n" ;
return $ this -> cacheData [ $ uid ];
}
return false ;
}
public function setCache ( $ uid , $ family = '' , $ data = null , $ ttl = null ) {
$ this -> cacheData [ $ uid ]= $ data ;
}
public function invalidateCache ( $ uid = '' , $ family = '' ) {
unset( $ this -> cacheData [ $ uid ]);
}
}
$ cache = new CacheService ();(2) Définit le service de cache
$ pdoOne = new PdoOne ( " mysql " , " 127.0.0.1 " , " travis " , "" , " travisdb " );
$ cache = new CacheService ();
$ $ pdoOne -> setCacheService ( $ cache );(3) Utilisez le cache comme suit, nous devons ajouter la méthode UseCache () dans n'importe quelle partie de la requête.
$ pdoOne -> select ( ' select * from table ' )
-> useCache ()-> toList (); // cache that never expires
$ pdoOne -> select ( ' select * from table ' )
-> useCache ( 1000 )-> toList (); // cache that lasts 1000ms. class CacheService implements eftec IPdoOneCache {
public function getCache ( $ uid , $ family = '' ) {
return apcu_fetch ( $ uid );
}
public function setCache ( $ uid , $ family = '' , $ data = null , $ ttl = null ) {
apcu_store ( $ uid , $ data , $ ttl );
}
public function invalidateCache ( $ uid = '' , $ family = '' ) {
// invalidate cache
apcu_delete ( $ uid );
}
}
$ cache = new CacheService ();La séquence est une alternative au champ Auto_Numeric (identité). Il a deux méthodes pour créer une séquence: le flocon de neige et la séquence . C'est une alternative de créer un GUID principalement parce qu'il renvoie un nombre (un GUID est généralement une chaîne qu'il est plus coûteux à indexer et à stocker)
Le but de la séquence est de créer un numéro unique qu'il n'est jamais répété.
$ dao -> nodeId = 1 ; // optional
$ dao -> tableSequence = ' snowflake ' ; // optional
$ dao -> createSequence (); // it creates a table (and it could create a store procedure) called snowflake and a function called next_snowflake(). You could create it only once.Il est possible de créer une nouvelle séquence sans aucune table. C'est rapide, mais il pourrait avoir des problèmes de collisions.
Il garantit un numéro libre de collision uniquement si nous ne faisons pas plus d'une opération par 0,0001 seconde , mais il ajoute également un pseudo numéro aléatoire (0-4095 basé dans le temps), donc les chances de collision sont 1/4095 (par deux opérations effectuées toutes les 0,0001 seconde). Il est basé sur le numéro de flocon de neige de Twitter. c'est-à-dire Vous êtes sûr des collisions si vous effectuez moins d'un million d'opérations par seconde (techniquement: 45 millions).
$ PDO-> GetSenelEPHP ([imprévisible = false]) Renvoie une séquence sans utiliser de table. Cette séquence est plus efficace que $ dao-> getSequence, mais elle utilise une valeur aléatoire pour traiter les collisions.
En cas de redirignable, il renvoie un nombre imprévisible (il retourne certains chiffres)
$ pdo -> getSequencePHP () // string(19) "3639032938181434317" $ dao -> getSequencePHP ( true ) // string(19) "1739032938181434311" $ pdo ->getSequence() // string(19) "3639032938181434317"
$ pdo -> getSequencePHP () // string(19) "3639032938181434317" $ pdo -> getSequence ( true ) // returns a sequence by flipping some values.
$ pdo -> getSequencePHP ( true ) // string(19) "1739032938181434311" | Champ | Description | Exemple |
|---|---|---|
| $ prefixbase | Si nous devons ajouter un préfixe à chaque table | $ this-> prefixbase = 'example_'; |
| $ internalcachecounter | Le compteur des coups de cache interne. | $ this-> internalcacheCounter =; |
| $ nodeid | Utilisé par séquence (flocon de neige). NODEID C'est l'identifiant du nœud. Il doit être compris entre 0..1023 | $ this-> nodeid = 3; |
| $ tablesequence | Le nom de la séquence de table (Snowflake) | $ this-> tablesequence = "tableseq1"; |
| $ masks0 | Si nous voulons générer un nombre imprévisible (utilisé par séquence) | $ this-> masks0 = [0,1,2,3,4]; |
| $ masques1 | Si nous voulons générer un nombre imprévisible (utilisé par séquence) | $ this-> masks1 = [4,3,2,1,0]; |
| $ databasetype | Le type actuel de base de données. Il est défini via le constructeur EL | echo $ this-> databasetype; |
| $ serveur | La machine serveur actuelle | Echo $ this-> serveur; |
| $ utilisateur | L'utilisateur actuel | echo $ this-> utilisateur; |
| $ pwd | Le mot de passe actuel | echo $ this-> pwd; |
| $ db | La base de données ou le schéma actuel (Oracle ignore cette valeur) | echo $ this-> db; |
| $ CARCET | Pour définir le charme par défaut. Il doit être défini via le constructeur | echo $ this-> charchet; |
| $ isopen | Il est vrai que si la base de données est connectée autrement, c'est faux | if ($ this-> isopen) {…}; |
| $ throwonerror | Si true (par défaut), il lance une erreur si cela se produit une erreur. Si faux, alors l'exécution continue | $ this-> ThrowonError = false; |
| $ Conn1 | L'instance de PDO. Vous pouvez le définir ou l'utiliser directement. | $ this-> conn1-> pdostatement (..); |
| $ TransactionOpen | Vrai si la transaction est ouverte | if ($ this-> TransactionOpen) {…}; |
| $ readonly | Si la base de données est en mode lecture uniquement ou non. Si vrai, nous devons éviter d'écrire dans la base de données | $ this-> readonly = true; |
| $ logfile | Nom de fichier complet du fichier journal. S'il est vide, il ne stocke pas de fichier journal. Le fichier journal est limité à 1 Mo | $ this-> logfile = "/ dossier / file.log"; |
| $ errortext | Il stocke la dernière erreur. Runget et Begintry le réinitialisent | echo $ this-> errortext; |
| $ isthrow | faire | $ this-> isthrow =; |
| $ LOGLEVEL | Il indique le niveau actuel du journal. 0 = pas de journal (pour la production), 3 = journal complet | $ this-> loglevel = 3; |
| $ LASTQUERY | Dernière requête exécutée | Echo $ this-> LastQuery; |
| $ lastparam | Les derniers paramètres. C'est un tableau associatif | echo $ this-> lastparam; |
Cette bibliothèque permet le chiffrement / décryptage des informations.
Pour définir le chiffrement, vous pouvez utiliser la commande suivante:
$ this -> setEncryption ( 12345678 , '' , ' INTEGER ' ); // the type of encryption is integer and it only works with integers. It doesn't use a salt value
$ this -> setEncryption ( ' password ' , ' some-salt ' , ' AES-256-CTR ' ); // the password, the salt and the type of encryption (aes-256-ctr), you can use other methods
$ this -> setEncryption ( ' passwrd ' , '' , ' SIMPLE ' ); // the type of encryption is simple and it only works with primitive values. It doesn't use a salt.Ensuite, vous pouvez crypter et décrypter une valeur en utilisant
$ encrypted = $ this -> encrypt ( $ original ); // encrypt $original
$ original = $ this -> decrypt ( $ encrypted ); // decrypt $encryptedExemple:
$ this -> setEncryption ( ' 12345 ' , ' salt-1234 ' ); // it will use AES-256-CTR, the password and the salt must be secret.
// create user
$ this -> set ([ ' username ' => 1 , ' password ' => $ this -> encrypt ( $ password )])
-> from ( ' user ' )
-> insert ();
// validate user
$ user = $ this -> select ([ ' username ' , ' password ' ])
-> from ( ' user ' )
-> where ([ ' username ' , ' password ' ],[ 1 , $ this -> encrypt ( $ password )])
-> first ();
// $user= if false or null then the user does not exist or the password is incorrect. Vous pouvez définir le niveau de journal sur 3. Le niveau de journal fonctionne lorsque l'opération échoue, plus le niveau de journal est élevé, puis il affiche la plupart des informations.
$ pdoOne -> logLevel = 3 ; // the highest for debug.Par défaut, PDoOne lance des erreurs PHP, mais nous pourrions l'éviter en définissant le champ $ throwonError sur false.
$ pdoOne -> throwOnError = false ; // it could be used in production. var_dump ( $ pdoOne -> lastQuery ); // it shows the last query
var_dump ( $ pdoOne -> lastParam ); // and it shows the last parameters.Si vide, il ne générera pas de fichier journal (à l'aide du fichier journal PHP)
$ pdoOne -> logFile = true ; PDoOne a certaines fonctionnalités disponibles uniquement dans CLI.
Exécutez la ligne suivante (dans le dossier lib)
php pdoonecli.php
(ou pointant vers le bon dossier)
php / var / web / fournisseur / eftec / lib / pdoonecli
Vous pouvez utiliser l'indicateur "-i" pour entrer en mode interactif.
Vous pouvez utiliser la touche Tab pour les valeurs de saisie semi-automatique (le cas échéant).
Remarque: vous pouvez également enregistrer et charger la configuration.
Connectez-vous à MySQL et générez un CSV à partir de la table "acteur"
# # via arguments
php pdoonecli --databasetype mysql --server 127.0.0.1 -u root -p abc.123 --database sakila -in actor -out csv
# # via user input (interactive)
php pdoonecli -i -in actor -out csvEnregistrer la configuration dans un fichier
php pdoonecli --databasetype mysql --server 127.0.0.1 -u root -p abc.123 --database sakila --saveconfig myconfigChargez la configuration à partir d'un fichier
php pdoonecli --loadconfig myconfig -in actor -out csvVous pouvez utiliser l'indicateur "-cli" pour générer les classes de référentiel
La CLI est interactive et permet de charger et d'enregistrer la configuration.
La fonctionnalité générera une classe de référentiel prêt à l'emploi.
Disons l'exemple suivant
mysql:
php pdoone.php --database mysql --server 127.0.0.1:3306 --User root -p ABC.123 -db Sakila - INPUT "ACTOR" --Output Classcode
SQLSRV:
php pdoone.php --database sqlsrv - server pcjc sqlexpress --User sa -p abc.123 -db sakila - Inter "acteur" --tutput Classcode
Il se connectera à la base de données MySQL, IP: 127.0.0.1 et la base de données Sakila, et il lira le tableau "Actor".
Il renverra le résultat suivant
/**
* Generated by PdoOne Version 1.28
* Class ActorRepo
*/
class ActorRepo
{
const TABLE = ' Actor ' ;
const PK = ' actor_id ' ;
/** @var PdoOne */
public static $ pdoOne = null ;
/**
* It creates a new table<br>
* If the table exists then the operation is ignored (and it returns false)
*
* @param array $definition
* @param null $extra
*
* @return array|bool|PDOStatement
* @throws Exception
*/
public static function createTable ( $ definition , $ extra = null ) {
if (! self :: getPdoOne ()-> tableExist ( self :: TABLE )) {
return self :: getPdoOne ()-> createTable ( self :: TABLE , $ definition , self :: PK , $ extra );
}
return false ; // table already exist
}
// .....
}Cette fonctionnalité générera une nouvelle classe de référentiel avec les opérations les plus courantes: insérer, liste, mettre à jour, supprimer, obtenir, compter, créer une table, table de dépôt et table tronquée
Pourquoi devons-nous générer une classe? (Au lieu de hériter un) Cette classe crud n'est qu'un point de départ. Le développeur pourrait modifier le code, ajouter de nouvelles méthodes, modifier la méthode précédente, etc.
Pour utiliser la classe, nous pourrions écrire le code suivant:
// 1) option 1, inject an instance of $pdo
ActorRepo:: setPdoOne ( $ pdoOne ); // it inject the current connect to the database
// 2) option 2.
// If the global variable $pdoOne exists, then it is injected. (unless it is defined by using setPdoOne()
$ pdoOne = new PdoOne ( " mysql " , " 127.0.0.1 " , " root " , " abc.123 " , " sakila " , "" );
$ pdoOne -> connect ();
// 3) option 3
// If the global function pdoOne() exists, then it is used for obtain the instance.
function pdoOne () {
global $ pdo ;
if ( $ pdo === null ) {
$ pdo = new PdoOne ( ' mysql ' , ' 127.0.0.1 ' , ' root ' , ' abc.123 ' , ' sakila ' );
}
return $ pdo ;
}
$ actorActorRepo :: get ( 2 ); // it will read the actor with the pk=2 and it will return as an array.
$ actors = $ actorArray =ActorRepo:: select (); // it returns all the rows.Alternativement, vous pouvez générer automatiquement le fichier PHP comme suit:
php pdoone.php -database mysql -server 127.0.0.1:3306 -Usser root -pwd ABC.123 -db sakila -input "acteur" -output Classcode> actorrepo.php
Remarque: le code manque de Tags PHP, d'espace de noms et d'utilisation, mais tout le reste est ici.
Il prendra une requête et renverra un code PHP avec la requête formatée.
Exemple:
php pdoone.php -database mysql -server 127.0.0.1:3306 -Usser root -pwd abc.123 -db sakila -input "select * from actor" -output selectcode
Il générera le code suivant:
/** @var array $result=array(["actor_id"=>0,"first_name"=>'',"last_name"=>'',"last_update"=>'']) */
$ result = $ pdo
-> select ( " * " )
-> from ( " actor " )
-> toList ();Il générera un tableau associatif (avec des valeurs par défaut) basé sur la requête ou le tableau sélectionné.
php pdoone.php -database mysql -server 127.0.0.1:3306 -Usser root -pwd abc.123 -db sakila -input "select * from Actor" -output arraycode
Il reviendra:
// ["actor_id"=>0,"first_name"=>'',"last_name"=>'',"last_update"=>'']Il renverra le résultat de la requête en tant que JSON
php pdoone.php -database mysql -server 127.0.0.1:3306 -Usser root -pwd abc.123 -db sakila -input "select * from Actor" -output json
Il reviendra:
[{ "actor_id" : " 1 " , "first_name" : " PENELOPE " , "last_name" : " GUINESS " , "last_update" : " 2006-02-15 01:34:33 " }
,{ "actor_id" : " 2 " , "first_name" : " NICK " , "last_name" : " WAHLBERG " , "last_update" : " 2006-02-15 01:34:33 " }
,{ "actor_id" : " 3 " , "first_name" : " ED " , "last_name" : " CHASE " , "last_update" : " 2006-02-15 01:34:33 " }
,{ "actor_id" : " 4 " , "first_name" : " JENNIFER " , "last_name" : " DAVIS " , " last_update " }]Il renverra le résultat de la requête en tant que JSON
php pdoone.php -database mysql -server 127.0.0.1:3306 -Usser root -pwd abc.123 -db sakila -input "select * from actor" -output csv
Il reviendra:
actor_id,first_name,last_name,last_update
1,"PENELOPE","GUINESS","2006-02-15 01:34:33"
2,"NICK","WAHLBERG","2006-02-15 01:34:33"
3,"ED","CHASE","2006-02-15 01:34:33"
4,"JENNIFER","DAVIS","2006-02-15 01:34:33"
Alternativement à la CLI, la bibliothèque a un visuel d'interface. Il fait tout le fonctionnement de la CLI.
Appelez simplement la méthode render ()
<?php
use eftec PdoOne ;
use mapache_commons Collection ;
include " ../vendor/autoload.php " ;
$ dao = new PdoOne ( " test " , " 127.0.0.1 " , " dummy " , " dummy " , " dummy " ); // we need any connection.
$ dao -> logLevel = 3 ;
$ dao -> render ();Il existe un exemple dans les exemples de dossiers / TESTUI.php
Les commandes suivantes sont généralement exécutées seule (pas dans une chaîne de méthodes)
| Méthode | Description | Exemple |
|---|---|---|
| CreateTable () | Crée le tableau et les index en utilisant la définition à l'intérieur du repo | TablapaRentRepo :: CreateTable (); |
| CreateForeIgnKeys () | Créez toutes les clés étrangères de la table | TablapaRentRepo :: CreateForeignKeys (); |
| dropTable () | Tomber sur la table | TablapaRentRepo :: droptable (); |
| tronquer() | Tronquer la table | TablapaRentRepo :: truncate (); |
| validTable () | Valider si la table n'a pas changé | $ ok = tablapaRentRepo :: validTable (); |
TablaParentRepo:: createTable ();
TablaParentRepo:: createForeignKeys ();
TablaParentRepo:: dropTable ();
TablaParentRepo:: truncate ();
// We don't have a method to alter a table.
$ ok =TablaParentRepo:: validTable (); // it returns true if the table matches with the definition stored into the clasLes opérateurs imbriqués sont des méthodes qui devraient se situer entre notre chaîne de méthodes.
Classrepo :: op () :: où () :: finalOp () est ✅
Classrepo :: op () :: op () :: où () laissera la chaîne ouverte
Par exemple:
// select *
// from table
// inner join table2 on t1=t2
// where col=:arg
// and col2=:arg2
// group by col
// having col3=:arg3
// order by col
// limit 20,30
$ results = $ pdo -> select ( ' * ' )
-> from ( ' table ' )
-> innerjoin ( ' table2 on t1=t2 ' )
-> where ( ' col=:arg and col2:=arg2 ' ,[ 20 , 30 ])
// it also works with ->where('col=:arg',20)->where('col2'=>30)
// it also works with ->where('col=?',20)->where('col2=?'=>30)
-> group ( ' col ' )
-> having ( ' col3=:arg3 ' , 400 )
-> order ( ' col ' )
-> limit ( ' 20,30 ' )
-> toList (); // end of the chain| Méthode | Description | Exemple |
|---|---|---|
| où() | Il ajoute un où la chaîne | TablaparentRepo :: où () |
| commande() | Il ajoute une commande à la chaîne | TablapaRentRepo :: order () |
| groupe() | il ajoute un groupe à la chaîne | TablaparentRepo :: groupe () |
| limite() | Il limite les résultats | TablapaRentRepo :: limit () |
| page() | C'est similaire à Limit mais il utilise la page | TablaparentRepo :: page () |
| innerjoin () | Il ajoute une jointure intérieure à la requête | TablaparentRepo :: innerjoin () |
| gauche() | Il ajoute une jointure à gauche à la requête | TablaparentRepo :: Left () |
| droite() | Il ajoute une bonne joints à la requête | TablaparentRepo :: right () |
Nous avons différentes méthodes pour générer une commande DQL (Query) dans notre base de données.
Si l'opération échoue, ils renvoient un faux et pourraient déclencher une exception.
Les méthodes suivantes devraient être à la fin de la chaîne. Exemples:
Classrepo :: op () :: op () :: tolist () est ✅
Classrepo :: op () :: tolist () :: op () déclenchera une exception
| Commande | Description | Exemple |
|---|---|---|
| Tolist () | Renvoie un éventail d'éléments | $ data = tableNamerepo :: tolist (); // Sélectionner * dans TablerePo $ data = tableNamerepo :: où ('a1 =?', [$ value]) :: tolist (); // Sélectionner * à partir de la valeur de TablerePo où A1 = $ |
| d'abord() | Renvoie une simple ligne | $ data = tableNamerepo :: First ($ pk); // Sélectionner * dans TablerePo où pk = $ pk (il renvoie toujours 1 ou zéro valeurs) $ data = tableNamerepo :: où ('a1 =?', [$ value]) :: premier (); // il renvoie la première valeur (ou false si elle n'est pas trouvée) |
| exister() | Renvoie vrai si une clé primaire existe | $ data = tableNamerepo :: exister ($ pk); // Renvoie True si l'objet existe. |
| compter() | Renvoie le nombre de lignes dans une requête | $ data = tableNamerepo :: count ($ conditions); $ data = tableNamerepo :: où ('a1 =?', [$ value]) :: count (); |
Les méthodes suivantes permettent d'insérer, de mettre à jour ou de supprimer des valeurs dans la base de données.
| Méthode | Description | Exemple |
|---|---|---|
| insérer | Il insère une valeur dans la base de données. Il pourrait retourner une identité | $ identité = tablapaRentRepo :: insert ($ obj); |
| mise à jour | Il met à jour une valeur dans la base de données. | TablapaRentRepo :: Update ($ obj); |
| supprimer | Il supprime une valeur de la base de données. | TablapaRentRepo :: Delete ($ obj); |
| DeleteByid | Il supprime une valeur (en utilisant la clé primaire comme condition) de la base de données. | TablapaRentRepo :: DeleteByid ($ pk); |
// where obj is an associative array or an object, where the keys are the name of the columns (case sensitive)
$ identity =TablaParentRepo:: insert ( $ obj );
TablaParentRepo:: update ( $ obj );
TablaParentRepo:: delete ( $ obj );
TablaParentRepo:: deleteById (id);Il est possible de valider le modèle. Le modèle est validé à l'aide des informations de la base de données, en utilisant le type de colonne, la longueur, si la valeur permet Null et si elle est l'identité (Auto Numeric).
$ obj =[ ' IdUser ' => 1 , ' Name ' ='John Doe'];
UserRepo:: validateModel ( $ obj , false ,[ ' _messages ' ]); // returns true if $obj is a valid User.Un tableau récursif est un tableau de chaînes avec des valeurs qu'il pourrait être lue ou obtenue ou comparée. Par exemple, pour rejoindre un tableau conditionnellement. PDoOne ne l'utilise pas directement mais _BasepDoonErepo l'utilise (_basepdoonErepo est une classe utilisée lorsque nous générons automatiquement une classe de service de référentiel).
Exemple
$ this -> select ( ' * ' )-> from ( ' table ' )-> recursive ([ ' table1 ' , ' table1.table2 ' ]);
// some operations that involves recursive
if ( $ this -> hasRecursive ( ' table1 ' )) {
$ this -> innerJoin ( ' table1 on table.c=table1.c ' );
}
if ( $ this -> hasRecursive ( ' table1.table2 ' )) {
$ this -> innerJoin ( ' table1 on table1.c=table2.c ' );
}
$ r = $ this -> toList (); // recursive is resetted. Il définit un tableau récursif.
Cette valeur est réinitialisée chaque fois qu'une méthode de chaîne se termine.
Il obtient le tableau récursif.
Il renvoie vrai si Recursive a une aiguille.
Si $ this-> récursif est ['*'], il renvoie toujours vrai.
$ this -> select ( ' * ' )-> from ( ' table ' )-> recursive ([ ' * ' ]);
$ this -> hasRecursive ( ' anything ' ); // it always returns true. | Bibliothèque | Insérer | findpk | hydrater | avec | temps |
|---|---|---|---|---|---|
| PDO | 671 | 60 | 278 | 887 | 3,74 |
| Pdoone | 774 | 63 | 292 | 903 | 4,73 |
| Moins | 1413 | 133 | 539 | 825 | 5 984 |
| Yiim | 2260 | 127 | 446 | 1516 | 8 415 |
| Yiimwithcache | 1925 | 122 | 421 | 1547 | 7 854 |
| Yii2m | 4344 | 208 | 632 | 1165 | 11 968 |
| Yii2marrayhydrate | 4114 | 213 | 531 | 1073 | 11,22 |
| Yii2mscalarhydrate | 4150 | 198 | 421 | 516 | 9 537 |
| Propel20 | 2507 | 123 | 1373 | 1960 | 11 781 |
| Propel20withcache | 1519 | 68 | 1045 | 1454 | 8 228 |
| Propel20formatondemand | 1501 | 72 | 994 | 1423 | 8 228 |
| Doctrinem | 2119 | 250 | 1592 | 1258 | 18 139 |
| Doctrinemwithcache | 2084 | 243 | 1634 | 1155 | 17 952 |
| Doctrinemarrayhydrate | 2137 | 240 | 1230 | 877 | 16,83 |
| Doctrinemscalarhydrate | 2084 | 392 | 1542 | 939 | 18 887 |
| Doctrinem avecproxies | 2119 | 252 | 1432 | 1960 | 19 822 |
| Éloquent | 3691 | 228 | 708 | 1413 | 12 155 |
PDOOne ajoute un peu de tête sur PDO, mais il est simple un wrapper pour l'OPD.
Cela signifie que vous êtes mis à jour PDOOne et que vous utilisez une classe générée par l'ORM. Cette classe doit être re-générée.
En un mot:
Chaque version majeure signifie qu'elle pourrait casser le vieux code. IE 1.0 -> 2.0
Chaque version mineure signifie qu'il ajoute une nouvelle fonctionnalité, c'est-à-dire 1.5 -> 1.6 (nouvelles méthodes)
Chaque version décimale signifie qu'il correcte / correcte / refactorisation d'une fonctionnalité précédente, c'est-à-dire 1.5.0 -> 1.5.1 (correctif)
4.10 2024-09-06
4.9.2 2024-08-20
4.9.1 2024-08-20
4.9 2024-08-02
4.8 2024-07-06
4.7.1 2024-06-07
4.7 2024-06-07
4.6.2 2024-03-02
4.6.1 2024-03-02
4.6 2024-03-02
4.4 2023-12-12
4.3.3 2023-09-05
4.3.2 2023-09-05
4.3.1 2023-09-02
4.3 2023-07-01
4.2 2023-04-07
4.1.2 2023-03-21
4.1.1 2023-03-21
4.1 2023-03-20
4.0.1 2023-03-11
4.00 2023-11-03
3.16 2023-12-02
3.15 2023-02-03
3.14 2023-01-30
3.13 2023-01-26
3.12.2 2022-09-03
3.12.1 2022-08-26
3.12 2022-08-14
3.11.1 2022-07-30
3.11 2022-07-30
3.10 2022-07-30
3.9 2022-07-23
3.8.1 2022-07-23
3.8 2022-07-22
3.7 2022-07-16
3.6 2022-07-07
3.5 2022-07-06
3.3 2022-06-27
3.2 2022-06-27
3.1.6 2022-06-24
3.1.5 2022-06-23
3.1.4 2022-06-21
3.1.3 2022-06-18
3.1.2 2022-06-18
3.1.1 2022-06-17
3.1 2022-06-11
3.0 2022-06-1
2.32 2022-03-20
2.31 2022-03-04
2.30 2022-02-28
2.29 2022-02-20
2.27 2022-02-19
2.26 2022-02-19
2.25 2022-02-01
2.24.1 2022-02-06
2.24 2022-02-06
2.23 2022-02-04
2.22.2 2022-02-01
2.22.1 2022-01-03
2.22 2022-01-30
2.21 2022-01-28
However, it is far from perfect.
2.20 2022-01-04
2.19
2.18
2.16
2.15 2021-07-24
2.14.3 2021-06-15
2.14.2 2021-06-13
2.14.1 2021-06-09
2.14 2021-06-04
_BasePdoOneRepo now works more closely with the class PdoOneQuery , so each query is a different instance.
[fix] PdoOne dateConvertInput() does not crash when the value is not a date.
[fix] PdoOne throwError() does not stack errors but still triggers the last error (if any).
[changes] ❗ PdoOne aggregate functions (sum,min,max,avg) now returns a value instead of generating a query.
$result=$pdo->sum('xxx')->firstScalar(); // before $result=$pdo->sum('xxx'); // maintenant
[fix] PdoOne generateCodeArray() used for the generation of classes, returns the correct name when it is set.
[changes] _BasePdoOneRepo : reset(),getQuery(),dropTable(),useCache(),limit(),newQuery(),order(),innerjoin(),left() ,right()
[changes] PdoOneQuery : Multiples changes.
2.13.1 2021-05-22
2.13 2021-04-17
2.12 2021-04-17
2.11.1 2021-04-17
2.11 2021-04-17
2.10.3 2021-04-14
2.10.2 2021-04-06
2.10.1 2021-04-05
2.10 2021-04-04
2.9.4 2021-03-22
2.9.3 2021-02-22
2.9.2 2021-02-18
2.9.1 2021-02-16
2.9 2021-02-16
2.8 2021-02-13
2.7.1 2021-01-21
2.7 2021-01-10
2.6.3 2020-10-16
2.6.2 2020-10-09
2.6.1 2020-09-24
2.6 2020-09-17
2.5 2020-09-13
2.4.1 2020-09-13
2.4 2020-09-06
2.3 2020-09-06
2.2.6 2020-09-03
2.2.5 2020-08-30
2.2.3 2020-08-23
2.2.2 2020-08-17
2.2.1 2020-08-16
2.2 2020-08-14
$ this -> setUseInternalCache ( true );
$ rows = $ this -> select ( ' * ' )-> from ( ' table ' )-> where ([ ' i ' => 1 ])-> toList (); // read from the database
// ...
$ rows2 = $ this -> select ( ' * ' )-> from ( ' table ' )-> where ([ ' i ' => 1 ])-> toList (); // read from memory
// ...
$ rows3 = $ this -> select ( ' * ' )-> from ( ' table ' )-> where ([ ' i ' => 2 ])-> toList (); // read from the database because the query is in
// memory but the parameters are different
echo $ this -> internalCacheCounter ; The internal cache is tested with runRawQuery (if returns an array), toList(), meta() and first()
2.0.1 2020-08-12
2.0 2020-08-11
1.55.1 2020-08-05
1.55 2020-8-05
1.54 2020-8-02
1.53 2020-7-27
1.52 2020-7-19
1.51 2020-7-18
1.50 2020-7-04
1.49 2020-6-19
1.48 2020-6-15
1.47 2020-6-14
1.46 2020-6-13
1.45.1 2020-6-11
1.45 2020-6-7
1.44.2 2020-6-3
1.44.1 2020-6-2
1.44 2020-5-31
1.43 2020-5-31
1.42 2020-5-29
1.41.2 2020-5-29
1.41.1 2020-5-28
1.41 2020-5-28
1.40.1 2020-5-27
1.40 2020-05-21
1.39 2020-05-12
1.38 2020-05-10
1.37 2020-05-03
1.36 2020-05-03
1.35.1 2020-04-30
1.35 2020-04-28
1.34.2 2020-04-27
1.34.1 2020-04-27
1.34 2020-04-27
1.33 2020-04-15
1.32.1 BasePdoOneRepo added version 2.0
1.32 2020-04-12
1.31.1 2020-04-11
1.31 2020-04-11
1.30 2020-04-10
1.29 2020-04-10
1.28.1 2020-04-06
1.28 2020-04-06
1.24 2020-03-26
1.23.1 2020-03-10
1.23 2020-03-10
1.22 2020-02-08
1.21 2020-02-07
1.20 2020-jan-25
1.19 2020-jan-15
1.16 2020-jan-14
1.15 2019-dec-29
1.14 2019-dec-26
1.13 2019-dec-26
1.12 2019-oct-20 Added argument (optional) ->toList($pdomodel) Added method ->toListSimple()
1.11 2019-oct-01 1.11 It is still compatible with php 5.6.Added to composer.json
1.10 2019-oct-01 1.10 Added method dateConvert(). Added trace to the throw.
1.9 2019-aug-10 1.8 republished
1.8 2019-aug-10 Added a date format. Methods dateSql2Text() and dateText2Sql()
1.7 2019-jun-23 Added some benchmark. It also solves a problem with the tags. Now: table.field=? is converted to table . field =?
1.6 2019-jun-22 affected_rows() returns a correct value.
1.5 2019-may-31 some cleanups. columnTable() returns if the column is nullable or not.
1.4 2019-may-30 insertobject()
1.3 2019-may-23 New changes
1.2 2019-may-22 New fixed.
1.1 2019-may-21 Some maintenance
1.0 2019-may-21 First version
