L'extension de la classe MySQLi

Je veux être en mesure de créer des classes qui étendent la classe MySQLi pour exécuter toutes les requêtes SQL.

$mysql = new mysqli('localhost', 'root', 'password', 'database') or die('error connecting to the database');

Je ne sais pas comment le faire sans que la mondialisation de l' $mysql objet à utiliser dans mes autres méthodes ou classes.

class Blog {

public function comment() {
    global $mysql;

    //rest here
}

}

Toute aide serait appréciée.

Grâce.

InformationsquelleAutor bennn | 2009-11-30

3

Ma suggestion est de créer un Singleton DataAccess classe instancier cette classe dans un fichier de configuration global et de l'appeler dans votre Blog de la classe comme $query = DataAccess::query("SELECT * FROM blog WHERE id = ".$id).

Regarder dans le pattern Singleton, c'est assez facile à comprendre designpattern. Parfait pour cette situation.

Votre DataAccess classe peut avoir plusieurs méthodes comme query, fetchAssoc, numRows, checkUniqueValue, transactionStart, transactionCommit, transactionRollback etc etc. Ces fonctions pourraient également être configuré comme une Interface qui obtient mis en œuvre par le DataAccess classe. De cette façon, vous pouvez facilement étendre votre DataAccess classe pour de multiples systèmes de gestion de base de données.

Ci-dessus assez bien décrit mon DataAccess modèle.
- Si j'utilise des singletons, serait-il créer une nouvelle connexion à la base de données à chaque fois que son nom?
- Non, c'est l'idée de Singleton. Vous créez une instance et que vous gardez à l'aide de cette instance en l'appelant statique. Donc, vous avez 1 db de connexion pour toutes les classes / controllers / etc vues.
- Ben merci pour votre aide, cela a parfaitement fonctionné!
- Vous êtes les bienvenus!
InformationsquelleAutor Ben

Je travaille sur quelque chose de semblable. Je suis heureux de ce singleton classe qui encapsule la connexion de base de données.

<?php
class db extends mysqli
{
protected static $instance;
protected static $options = array();
private function __construct() {
$o = self::$options;
//turn of error reporting
mysqli_report(MYSQLI_REPORT_OFF);
//connect to database
@parent::__construct(isset($o['host'])   ? $o['host']   : 'localhost',
isset($o['user'])   ? $o['user']   : 'root',
isset($o['pass'])   ? $o['pass']   : '',
isset($o['dbname']) ? $o['dbname'] : 'world',
isset($o['port'])   ? $o['port']   : 3306,
isset($o['sock'])   ? $o['sock']   : false );
//check if a connection established
if( mysqli_connect_errno() ) {
throw new exception(mysqli_connect_error(), mysqli_connect_errno()); 
}
}
public static function getInstance() {
if( !self::$instance ) {
self::$instance = new self(); 
}
return self::$instance;
}
public static function setOptions( array $opt ) {
self::$options = array_merge(self::$options, $opt);
}
public function query($query) {
if( !$this->real_query($query) ) {
throw new exception( $this->error, $this->errno );
}
$result = new mysqli_result($this);
return $result;
}
public function prepare($query) {
$stmt = new mysqli_stmt($this, $query);
return $stmt;
}    
}

À utiliser que vous pouvez avoir quelque chose comme ceci:

<?php
require "db.class.php";
$sql = db::getInstance();
$result = $sql->query("select * from city");
/* Fetch the results of the query */ 
while( $row = $result->fetch_assoc() ){ 
printf("%s (%s)\n", $row['Name'], $row['Population']); 
} 
?>

J'aime cette classe comme un exemple de Singleton, mais serait chipoter avec la nécessité impérieuse d' query() et prepare() depuis le mysqli OO API fournit déjà de ceux-ci.
Ce qui est excellent. Bookmarked. !

InformationsquelleAutor Yada

Vous pouvez utiliser le PHP du mot-clé extends juste pour toute autre catégorie:

class MyCustomSql extends mysqli {
public function __construct($host, $user, $password, $database) {
parent::__construct($host, $user, $password, $database);
}
public function someOtherMethod() {
}
}
$sql = new MyCustomSql('localhost', 'root', 'password', 'database') or die('Cannot connect!');

ou une meilleure utilisation de l'objet de l'agrégation à la place de l'héritage:

class MySqlManipulator {
private $db;
public function __construct($host, $user, $password, $database) {
$this->db   = new mysqli($host, $user, $password, $database);
}
public function someOtherMethod() {
return $this->db->query("SELECT * FROM blah_blah");
}
}
$mysqlmanipulator = new MySqlManipulator('localhost', 'root', 'password', 'database') or die('Cannot connect!');

C'est un buter solution beause en AUCUNE façon Blog est une extension de la classe mysqli. Il utilise simplement, de ne pas s'étendre avec de nouvelles fonctionnalités à condition d'accès aux données.
Il est clair du Blog lui-même ne peut pas être une sous-classe de l'objet de base de données, j'ai utilisé pour répondre à la question, non pas pour juger la conception de l'application.

InformationsquelleAutor Emre Yazici

Ma méthode standard est de faire un singleton classe qui agit en tant que base de données de l'accesseur, et une classe de base que tout nécessitant un tel accès hérite.

Donc:

class Base {
protected $db;
function __construct(){
$this->db= MyDBSingleton::get_link();
//any other "global" vars you might want 
}
}
class myClass extends Base {
function __construct($var) {
parent::__construct();//runs Base constructor
$this->init($var);
}
function init($id) {
$id=(int) $id;
$this->db->query("SELECT * FROM mytable WHERE id=$id");
//etc.
}
}

InformationsquelleAutor dnagirl

0

Ont un coup d'oeil à AOP, qui lève des exceptions pour vous de les attraper si une requête échoue. Il est largement utilisé et testé de sorte que vous ne devriez pas avoir de problème à trouver des solutions existantes tout en l'utilisant.

Pour l'injecter dans votre blog de la classe:
```
class Blog {
private $_db;
public function __construct(PDO $db) {
$this->_db = $db
}
public function comment() {
return $this->_db->query(/*something*/);
}
}
```
InformationsquelleAutor chelmertz

Vous devez vous connecter pour publier un commentaire.