Extendiendo la clase MySQLi

Question

Quiero poder crear clases que extiendan la clase MySQLi para realizar todas sus consultas SQL.

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

No sé cómo hacer esto sin globalizar el objeto $ mysql para usar en mis otros métodos o clases.

class Blog {

public function comment() {
    global $mysql;

    //rest here
}

}

Cualquier ayuda sería apreciada.

Gracias.

Answer 1

Mi sugerencia es crear una clase Singleton DataAccess, instanciar esa clase en un archivo de configuración global y llamarla en su clase Blog como $ query = DataAccess :: query (" SELECT * FROM blog WHERE id = " ;. $ id) .

Observe el patrón Singleton, es un patrón de diseño bastante fácil de entender. Perfecto para esta situación.

Su clase DataAccess puede tener varios métodos como query , fetchAssoc , numRows , checkUniqueValue , transactionStart , transactionCommit , transacciónRollback , etc. Estas funciones también podrían configurarse como una interfaz que se implementa mediante la clase DataAccess. De esa manera, puede extender fácilmente su clase DataAccess para múltiples sistemas de administración de bases de datos.

Lo anterior describe más o menos mi modelo de DataAccess.

Answer 2

Estaba trabajando en algo similar. Estoy contento con esta clase de singleton que encapsula el inicio de sesión de la base de datos.

<?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;
    }    
}

Para usar puede tener algo como esto:

<?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']); 
} 
?>

Answer 3

Puede usar la palabra clave extendidas de PHP solo para cualquier otra clase:

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!');

o mejor use la agregación de objetos en lugar de la herencia:

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!');

Answer 4

Mi método estándar es hacer una clase singleton que actúa como el acceso a la base de datos, y una clase base de la que todo lo que requiere dicho acceso hereda.

Entonces:

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.
  }
}

Answer 5

Eche un vistazo a PDO , que arroja excepciones para usted para atrapar si una consulta falla. Es ampliamente utilizado y probado, por lo que no debería tener problemas para encontrar soluciones existentes mientras lo usa.

Para inyectarlo en tu clase de blog:

class Blog {

    private 
 Eche un vistazo a  PDO , que arroja excepciones para usted para atrapar si una consulta falla. Es ampliamente utilizado y probado, por lo que no debería tener problemas para encontrar soluciones existentes mientras lo usa. 

 Para inyectarlo en tu clase de blog: 

<*>db;

    public function __construct(PDO $db) {
        $this->_db = $db
    }

    public function comment() {
        return $this->_db->query(/*something*/);
    }

}