DaoOne
3.30
DaoOne . C'est un simple wrapper pour Mysqli
Cette bibliothèque est aussi rapide que possible. La plupart des opérations sont de simples gestions de chaînes/tableaux.
Remarque : Cette version est déplacée vers https://github.com/EFTEC/PdoOne
PdoOne fait le même travail mais il fonctionne avec la bibliothèque PDO (au lieu de MySQLi). Actuellement, PdoOne fonctionne avec Mysqli et SqlSrv mais il possède de nombreuses autres fonctionnalités qui ne seront pas présentes sur DaoOne
Installer via composer
le compositeur nécessite eftec/pdoone
Cette bibliothèque pourrait fonctionner en tandem avec eftec/ DaoOne .
Changez la classe, au lieu d'utiliser eftec/ DaoOne -> eftec/pdoone
Exemple:
Avant:
/** @var eftec DaoOne $db */
$ db = null ;Après:
/** @var eftecPdoOne $db */
$ db = null ;Avant:
$ db = new DaoOne ( ' 127.0.0.1 ' , ' root ' , ' abc.123 ' , ' sakila ' );Après:
$ db = new DaoOne ( ' mysql ' , ' 127.0.0.1 ' , ' root ' , ' abc.123 ' , ' sakila ' ); // check 'mysql' Si nous utilisons DaoOne ::runGen(false), alors nous devons vérifier le résultat. runGen ( DaoOne ) renvoie un objet mysqli_result. runGen (PdoOne) renvoie un objet pdostatement.
Avant:
$ result = $ db -> runGen ( false ); // it returns a mysqli_result
$ result -> fetch_assoc ();
$ result -> free_result ();Après:
$ result = $ db -> runGen ( false ); // it returns a pdostatement
$ result -> fetch ( PDO :: FETCH_ASSOC );
$ result = null ;Tourne ça
$stmt->bind_param("s", $_POST['name']);
$stmt->execute();
$result = $stmt->get_result();
if($result->num_rows === 0) exit('No rows');
while($row = $result->fetch_assoc()) {
$ids[] = $row['id'];
$names[] = $row['name'];
$ages[] = $row['age'];
}
var_export($ages);
$stmt->close();
dans ce
$products=$dao
->select("*")
->from("myTable")
->where("name = ?",[$_POST['name']])
->toList();
Ajoutez à composer.json l’exigence suivante, puis mettez à jour composer.
{
"require" : {
"eftec/ DaoOne " : " ^3.15 "
}
}ou installez-le via cli en utilisant
le compositeur nécessite eftec/ DaoOne
Téléchargez simplement le fichier lib/ DaoOne .php et enregistrez-le dans un dossier.
$ dao = new DaoOne ( " 127.0.0.1 " , " root " , " abc.123 " , " sakila " , "" );
$ dao -> connect ();où
$ sql = " CREATE TABLE `product` (
`idproduct` INT NOT NULL AUTO_INCREMENT,
`name` VARCHAR(45) NULL,
PRIMARY KEY (`idproduct`)); " ;
$ dao -> runRawQuery ( $ sql ); $ sql = " insert into `product`(name) values(?) " ;
$ stmt = $ dao -> prepare ( $ sql );
$ productName = " Cocacola " ;
$ stmt -> bind_param ( " s " , $ productName ); // s stand for string. Also i =integer, d = double and b=blob
$ dao -> runQuery ( $ stmt );remarque : vous pouvez également insérer à l'aide d'une insertion de chaîne procédurale ($table,$schema,[$values])
$ dao -> runRawQuery ( ' insert into `product` (name) values(?) '
, array ( ' s ' , ' cocacola ' ));Il renvoie une mysqli_statement.
$ sql = " select * from `product` order by name " ;
$ stmt = $ dao -> prepare ( $ sql );
$ dao -> runQuery ( $ stmt );
$ rows = $ stmt -> get_result ();
while ( $ row = $ rows -> fetch_assoc ()) {
var_dump ( $ row );
}
Cette déclaration doit être traitée manuellement.
Il renvoie un tableau associatif.
$ sql = " select * from `product` order by name " ;
$ stmt = $ dao -> prepare ( $ sql );
$ dao -> runQuery ( $ stmt );
$ rows = $ stmt -> get_result ();
$ allRows = $ rows -> fetch_all ( MYSQLI_ASSOC );
var_dump ( $ allRows ); try {
$ sql = " insert into `product`(name) values(?) " ;
$ dao -> startTransaction ();
$ stmt = $ dao -> prepare ( $ sql );
$ productName = " Fanta " ;
$ stmt -> bind_param ( " s " , $ productName );
$ dao -> runQuery ( $ stmt );
$ dao -> commit (); // transaction ok
} catch ( Exception $ e ) {
$ dao -> rollback ( false ); // error, transaction cancelled.
}Il démarre une transaction
Il valide une transaction.
Il annule une transaction.
Si c'est vrai (par défaut), alors il génère une erreur si une erreur se produit. Si faux, alors l'exécution continue
C'est vrai si la base de données est connectée sinon, c'est faux.
Vous pouvez également créer une requête procédurale.
Exemple:
$ results = $ dao -> select ( " * " )-> from ( " producttype " )
-> where ( ' name=? ' , [ ' s ' , ' Cocacola ' ])
-> where ( ' idproducttype=? ' , [ ' i ' , 1 ])
-> toList (); Génère une commande de sélection.
$ results = $ dao -> select ( " col1,col2 " )->. . .Génère la requête : select col1,col2 ....
$ results = $ dao -> select ( " select * from table " )->. . .Génère la requête : sélectionnez * dans la table ....
Génère une commande de sélection.
$ results = $ dao -> select ( " col1,col2 " )-> distinct (). . .Génère la requête : select distinct col1,col2 ....
Remarque : ->distinct('unique') renvoie select unique ..
Génère une commande from.
$ results = $ dao -> select ( " * " )-> from ( ' table ' ). . .Génère la requête : sélectionnez * dans la table
$tables peut être une table unique ou une construction SQL. Par exemple, la commande suivante est valide :
$ results = $ dao -> select ( " * " )-> from ( ' table t1 inner join t2 on t1.c1=t2.c2 ' ). . .Génère une commande Where.
$ results = $ dao -> select ( " * " )
-> from ( ' table ' )
-> where ( ' p1=1 ' ). . .Génère la requête : sélectionnez * dans la table où p1=1
Remarque : ArrayParameters est un tableau comme suit : type, valeur.
Où type est i=integer, d=double, s=string ou b=blob. En cas de doute, utilisez "s"
Exemple de arrayParameters :
['i',1 ,'s','bonjour' ,'d',20.3 ,'s','world']
$ results = $ dao -> select ( " * " )
-> from ( ' table ' )
-> where ( ' p1=? ' ,[ ' i ' , 1 ]). . .Génère la requête : sélectionnez * dans la table où p1=?(1)
$ results = $ dao -> select ( " * " )
-> from ( ' table ' )
-> where ( ' p1=? and p2=? ' ,[ ' i ' , 1 , ' s ' , ' hello ' ]). . .Génère la requête : sélectionnez * dans la table où p1=?(1) et p2=?('hello')
Note. où pourrait être niché.
$ results = $ dao -> select ( " * " )
-> from ( ' table ' )
-> where ( ' p1=? ' ,[ ' i ' , 1 ])
-> where ( ' p2=? ' ,[ ' s ' , ' hello ' ]). . .Génère la requête : sélectionnez * dans la table où p1=?(1) et p2=?('hello')
Vous pouvez également utiliser :
$ results = $ dao -> select ( " * " )-> from ( " table " )
-> where ([ ' p1 ' => ' Coca-Cola ' , ' p2 ' => 1 ])
-> toList ();Génère la requête : sélectionnez * dans la table où p1=?(Coca-Cola) et p2=?(1)
Génère une commande de commande.
$ results = $ dao -> select ( " * " )
-> from ( ' table ' )
-> order ( ' p1 desc ' ). . .Génère la requête : select * from table order by p1 desc
Génère une commande de groupe.
$ results = $ dao -> select ( " * " )
-> from ( ' table ' )
-> group ( ' p1 ' ). . .Génère la requête : sélectionnez * dans le groupe de tables par p1
Génère une commande de groupe.
$ results = $ dao -> select ( " * " )
-> from ( ' table ' )
-> group ( ' p1 ' )
-> having ( ' p1>? ' , array ( ' i ' , 1 )). . .Génère la requête : sélectionnez * dans le groupe de tables par p1 ayant p1>?(1)
Remarque : Avoir pourrait être imbriqué avoir()->avoir()
Remarque : Avoir pourrait être sans paramètres avoir('col>10')
Exécutez la génération de requête.
Notez que si returnArray est vrai, il renvoie un tableau associatif. si returnArray est faux alors il renvoie un mysqli_result
Remarque : Il réinitialise les paramètres actuels (tels que la sélection actuelle, depuis, où, etc.)
C'est une macro de runGen. Il renvoie un tableau associatif ou null.
$ results = $ dao -> select ( " * " )
-> from ( ' table ' )
-> toList ()C'est une macro de runGen. Il renvoie un mysqli_result ou null.
$ results = $ dao -> select ( " * " )
-> from ( ' table ' )
-> toResult ()C'est une macro de runGen. Il renvoie la première ligne (le cas échéant, sinon, il renvoie false) sous forme de tableau associatif.
$ results = $ dao -> select ( " * " )
-> from ( ' table ' )
-> first ()C'est une macro de runGen. Il renvoie la dernière ligne (le cas échéant, sinon, il renvoie false) sous forme de tableau associatif.
$ results = $ dao -> select ( " * " )
-> from ( ' table ' )
-> last ()Il est parfois plus efficace d’exécuter order() et first() car last() lit toutes les valeurs.
Il renvoie la commande sql.
$ sql = $ dao -> select ( " * " )
-> from ( ' table ' )
-> sqlGen ();
echo $ sql ; // returns select * from table
$ results = $ dao -> toList (); // executes the queryRemarque : cela 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 utilisant une liste de valeurs : où la première valeur est la colonne, la seconde est le type de valeur (i=integer,d=double,s=string,b=blob) et le deuxième tableau contient les valeurs.
$ dao -> insert ( " table "
,[ ' col1 ' , ' i ' ]
,[ 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=integer,d=double,s=string,b=blob) et la troisième est la valeur.
$ dao -> insert ( " table "
,[ ' col1 ' , ' i ' , 20 ]);Schéma et valeurs utilisant deux tableaux associatifs :
$ dao -> insert ( " table "
,[ ' col1 ' => ' i ' ]
,[ ' col1 ' => 20 ]);Schéma et valeurs utilisant un seul tableau associatif : Le type est calculé automatiquement.
$ dao -> insert ( " table "
,[ ' col1 ' => 20 ]);Génère une commande d'insertion.
$ dao -> insert ( " producttype "
,[ ' idproducttype ' , ' i ' , ' name ' , ' s ' , ' type ' , ' i ' ]
,[ 1 , ' cocacola ' , 1 ]);Utilisation d'une chaîne imbriquée (tableau unique)
$ dao -> from ( " producttype " )
-> set ([ ' idproducttype ' , ' i ' , 0 , ' name ' , ' s ' , ' Pepsi ' , ' type ' , ' i ' , 1 ])
-> insert ();Utilisation d'un ensemble multiple de chaînes imbriquées
$ dao -> from ( " producttype " )
-> set ( " idproducttype=? " ,[ ' i ' , 101 ])
-> set ( ' name=? ' ,[ ' s ' , ' Pepsi ' ])
-> set ( ' type=? ' ,[ ' i ' , 1 ])
-> insert ();ou (le type est défini, dans la mesure du possible, automatiquement par MySql)
$ dao -> from ( " producttype " )
-> set ( " idproducttype=? " ,[ ' i ' , 101 ])
-> set ( ' name=? ' , ' Pepsi ' )
-> set ( ' type=? ' , 1 )
-> insert ();Utilisation d'un ensemble déclaratif de chaîne imbriquée
$ dao -> from ( " producttype " )
-> set ( ' (idproducttype,name,type) values (?,?,?) ' ,[ ' i ' , 100 , ' s ' , ' Pepsi ' , ' i ' , 1 ])
-> insert ();Génère la requête : insérer dans producttype(idproducttype,name,type) valeurs(?,?,?) ....
Génère une commande d'insertion.
$ dao -> update ( " producttype "
,[ ' name ' , ' s ' , ' type ' , ' i ' ] //set
,[ 6 , ' Captain-Crunch ' , 2 ] //set
,[ ' idproducttype ' , ' i ' ] // where
,[ 6 ]); // where $ dao -> update ( " producttype "
,[ ' name ' => ' Captain-Crunch ' , ' type ' => 2 ] // set
,[ ' idproducttype ' => 6 ]); // where $ dao -> from ( " producttype " )
-> set ( " name=? " ,[ ' s ' , ' Captain-Crunch ' ]) //set
-> set ( " type=? " ,[ ' i ' , 6 ]) //set
-> where ( ' idproducttype=? ' ,[ ' i ' , 6 ]) // where
-> update (); // updateou
$ dao -> from ( " producttype " )
-> set ( " name=? " , ' Captain-Crunch ' ) //set
-> set ( " type=? " , 6 ) //set
-> where ( ' idproducttype=? ' ,[ ' i ' , 6 ]) // where
-> update (); // updateGénère la requête : update producttype set
name=?,type=? oùidproducttype=? ....
Génère une commande de suppression.
$ dao -> delete ( " producttype "
,[ ' idproducttype ' , ' i ' ] // where
,[ 7 ]); // where $ dao -> delete ( " producttype "
,[ ' idproducttype ' => 7 ]); // whereGénère la requête : supprimer du type de produit où
idproducttype= ? ....
Vous pouvez également supprimer via une chaîne de création DQL.
$ dao -> from ( " producttype " )
-> where ( ' idproducttype=? ' ,[ ' i ' , 7 ]) // where
-> delete (); $ dao -> from ( " producttype " )
-> where ([ ' idproducttype ' => 7 ]) // where
-> delete (); Génère la requête : supprimer du type de produit où
idproducttype= ? ....
La séquence est une alternative au champ AUTO_NUMERIC. Il utilise une table pour générer un identifiant unique.
La séquence utilisée est basée sur Snowflake de Twitter et elle est générée en fonction du temps (en microsecondes), de l'ID de nœud et d'une séquence. Cela génère une valeur LONG (int 64) qui est unique
$dao->nodeId=1; // optional
$dao->tableSequence='snowflake'; // optional
$dao->createSequence(); // it creates a table called snowflake and a function called next_snowflake()
$dao->getSequence() // string(19) "3639032938181434317"
$dao->getSequence(true) // returns a sequence by flipping some values.
$dao->getSequencePHP([unpredictable=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 gérer les collisions.
Si upredictable est vrai, alors il renvoie un nombre imprévisible (il retourne certains chiffres)
$dao->getSequencePHP() // string(19) "3639032938181434317"
$dao->getSequencePHP(true) // string(19) "1739032938181434311"
