Duda con PDO y mi clase

[neodani]

Buenas,

Haber si me podéis aclarar estas cinco dudas que me surgen al crear mis propias clases :)

Utilizo PDO para conectarme a la base de datos.

1) Según he leído no hace falta sanar las variables que vienen por GET O POST ya que PDO se encarga automáticamente, es correcto? leído aquí... http://www.arzion.com/empresa-de-int...-datos-con-PDO

2) Cuando la aplicación entre en producción debo quitar esta línea verdad?
$db->setAttribute(CountPDO::ATTR_ERRMODE, CountPDO::ERRMODE_EXCEPTION);

3) Para utilizar PDO en mi clase "categoria" ¿lo estoy haciendo bien, o existe otra forma mejor?

Código PHP:

<?php
require_once("configBD.php");
 
class db{
    /*** Declare instance ***/
    private static $instance = NULL;
 
    /**
    *
    * the constructor is set to private so
    * so nobody can create a new instance using new
    *
    */
    private function __construct() {
      /*** maybe set the db name here later ***/
    }
 
    /**
    *
    * Return DB instance or create intitial connection
    *
    * @return object (PDO)
    *
    * @access public
    *
    */
    public static function getInstance() {
 
    if (!self::$instance)
        {
        //self::$instance = new PDO('mysql:dbname='.$bd.';host='.$servidor.'', $user, $pass);;
        self::$instance = new PDO("mysql:host=localhost;dbname=codelab", 'root', 'jupiter');; //asi funciona y con variables NO.
        self::$instance-> setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        }
    return self::$instance;
    }
 
    /**
    *
    * Like the constructor, we make __clone private
    * so nobody can clone the instance
    *
    */
    private function __clone(){
    }
 
} /*** end of class ***/
 
class Categoria{
    private $nombreCategoria;
    
    // Listar todas las categorias de la base de datos
    public function listarCategorias(){
        $query = sprintf("SELECT nombre FROM categorias");
        $comando = DB::getInstance()->prepare($query);
        $comando->execute();
 
        while( $datos = $comando->fetch() ) {
        // Imprimimos resultados
        echo $datos[0].'<br />';
        }
    }
 
    // Agrega una nueva categoria
    public function agregarCategoria($nombre){
        $this->nombreCategoria=$nombre;
        $query = sprintf("INSERT INTO categorias (nombre) values ('$this->nombreCategoria')");
        $comando = DB::getInstance()->prepare($query);
        $comando->execute();
    }
}
$cat = new Categoria();
$cat->listarCategorias();
$cat->agregarCategoria('nueva_cat');
 
?>
 

4) Debería tener separado la conexión a la base de datos o dentro de la clase categoría? Es necesario tener una clase global para la conexión a la base de datos. O con la utilización de PDO esto me lo puedo ahorrar?

5) Haciéndolo como en el ejemplo que puse arriba, cuantas instancias utilizo? Utilizo una ya que cuando se llama al metodo agregarCategoria() reutiliza la instancia de listarcategorias()?

Muchas gracias de antemano!

[portalmana]

Bueno no tengo del todo claro lo de PDO, puesto que hace poco estoy investigando el tema....
Pero con respecto a tus inquietudes lo que tengo entendido y saque en limpio es lo siguiente:
1> Si es cierto, pero si usas las sentencias preparadas y aparte utilizas en tus consulta o ? o :categoria que son los placeholders o marcadores, que indican que en ese lugar va a ir un valor. En ese caso si la variable es sanada, no en el caso que ya pases la consulta directamente.

2> Generalmente en producción, se trata de no volcar errores por pantalla que puedan dar información de la estructura de tu base, pero si capturas todos los errores y los cambias por otro tipo de mensaje quizás no tengas problemas.

3> Lo que sacaría es el uso del sprintf de:
$query = sprintf("SELECT nombre FROM categorias");
No tiene mucho sentido pues no das formato ni insertas variables a la consulta.
Lo mismo que en $query = sprintf("INSERT INTO categorias (nombre) values ('$this->nombreCategoria')"); pues ya le pasas la variable
Generalmente se usa para consultas prefabricadas y tu solo le pasas los parametros...
En el segundo caso podrías variar por ejemplo

Código PHP:

$sql = "INSERT INTO categorias (nombre) values (%s) ";
$query= sprintf( $sql, $this->nombreCategoria );
 

O puedes usar las consultas preparadas de PDO con los marcadores, que en el enlace que dejas te muestra como se hace.

4> En lo personal me parece mas practico tener una clase separada como la tienes.

5> Si utilizas una instancia, pues estas usando un patrón singleton, es decir tu no accedes directamente al constructor pues este es privado, entonces lo haces con DB::getInstance() que lo que hace es fijarse si ya se instancio la clase si es así te retorna la instancia que ya tiene si no genera la instancia y te la retorna...

Espero te sea de ayuda...
Saludos

[neodani]

Iniciado por portalmana

Bueno no tengo del todo claro lo de PDO, puesto que hace poco estoy investigando el tema....
Pero con respecto a tus inquietudes lo que tengo entendido y saque en limpio es lo siguiente:
1> Si es cierto, pero si usas las sentencias preparadas y aparte utilizas en tus consulta o ? o :categoria que son los placeholders o marcadores, que indican que en ese lugar va a ir un valor. En ese caso si la variable es sanada, no en el caso que ya pases la consulta directamente.

2> Generalmente en producción, se trata de no volcar errores por pantalla que puedan dar información de la estructura de tu base, pero si capturas todos los errores y los cambias por otro tipo de mensaje quizás no tengas problemas.

3> Lo que sacaría es el uso del sprintf de:
$query = sprintf("SELECT nombre FROM categorias");
No tiene mucho sentido pues no das formato ni insertas variables a la consulta.
Lo mismo que en $query = sprintf("INSERT INTO categorias (nombre) values ('$this->nombreCategoria')"); pues ya le pasas la variable
Generalmente se usa para consultas prefabricadas y tu solo le pasas los parametros...
En el segundo caso podrías variar por ejemplo

Código PHP:

$sql = "INSERT INTO categorias (nombre) values (%s) ";
$query= sprintf( $sql, $this->nombreCategoria );
 

O puedes usar las consultas preparadas de PDO con los marcadores, que en el enlace que dejas te muestra como se hace.

4> En lo personal me parece mas practico tener una clase separada como la tienes.

5> Si utilizas una instancia, pues estas usando un patrón singleton, es decir tu no accedes directamente al constructor pues este es privado, entonces lo haces con DB::getInstance() que lo que hace es fijarse si ya se instancio la clase si es así te retorna la instancia que ya tiene si no genera la instancia y te la retorna...

Espero te sea de ayuda...
Saludos

Muchas gracias portalmana, no pude responder antes por problemas en la conexión ADSL. Me aclaraste las dudas que tenía. Mil gracias.

Para usar los datos de acceso, en lugar de escribirlos hardcore en la la clase, verdad que puedo tener una clase llamada configBD y cogerlos desde ahí, de la siguiente forma?

Es correcto hacerlo así, cambiaríais algo?

Código PHP:

class ConfigBD{
    public $DBServer;
    public $DBName;
    public $UserName;
    public $Password;
    
    function __construct($DBServer,$UserName,$Password,$DBName){
        $this->DBServer=$DBServer;
        $this->UserName=$UserName;
        $this->Password=$Password;
        $this->DBName=$DBName;
    }
}
 

Código PHP:

class db{
    /*** Declare instance ***/
    private static $instance = NULL;
 
    /**
    *
    * the constructor is set to private so
    * so nobody can create a new instance using new
    *
    */
    private function __construct() {
      /*** maybe set the db name here later ***/
    }
 
    /**
    *
    * Return DB instance or create intitial connection
    *
    * @return object (PDO)
    *
    * @access public
    *
    */
    public static function getInstance() {
 
    if (!self::$instance)
        {
        $conexion = new ConfigBD("localhost","root","jupiter","codelab");
        self::$instance = new PDO("mysql:host=$conexion->DBServer;dbname=$conexion->DBName",$conexion->UserName,$conexion->Password);; //asi funciona y con variables NO.
        self::$instance-> setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        }
    return self::$instance;
    }
 
    /**
    *
    * Like the constructor, we make __clone private
    * so nobody can clone the instance
    *
    */
    private function __clone(){
    }
 
} /*** end of class ***/
 
class Categoria{
    private $nombreCategoria;
    
    // Listar todas las categorias de la base de datos
    public function listarCategorias(){
        $query = "SELECT nombre FROM categorias";
        $comando = DB::getInstance()->prepare($query);
        $comando->execute();
 
        while( $datos = $comando->fetch() ) {
        // Imprimimos resultados
        echo $datos[0].'<br />';
        }
    }
 
    // Agrega una nueva categoria
    public function agregarCategoria($nombre){
        $this->nombreCategoria=$nombre;
        $sql = "INSERT INTO categorias (nombre) values (%s) ";
        $query = sprintf( $sql, $this->nombreCategoria );
        $comando = DB::getInstance()->prepare($query);
        $comando->execute();
    }
}
$cat = new Categoria();
$cat->listarCategorias();
?>
 

Muchas gracias de antemano!

[neodani]

Aunque la gracia sería, llamarlo de esta forma no?

Código PHP:

class ConfigBD{
    public $DBServer;
    public $DBName;
    public $UserName;
    public $Password;
    
    function __construct(){
        $this->DBServer='localhost';
        $this->UserName='root';
        $this->Password='jupiter';
        $this->DBName='codelab';
    }
}
 

Y dentro de la clase DB

public static function getInstance() {

Código PHP:

if (!self::$instance)
        {
        $conexion = new ConfigBD();
        self::$instance = new PDO("mysql:host=$conexion->DBServer;dbname=$conexion->DBName",$conexion->UserName,$conexion->Password);; //asi funciona y con variables NO.
        self::$instance-> setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        }
    return self::$instance;
    }
 

No? así se solo se tendría que modificar la clase ConfigDB cada vez que quisieramos conectarnos a una base de datos distinta... pero pierde parte de la flexibilidad, aarrhh no me acaba de cuadrar esto... debería ser una clase estática no?

Gracias de antemano!

[portalmana]

Te comento yo lo que tengo es un archivo de configuración simplemente, no una clase con atributos solo para extraerle los datos. No se si se realizara así pero lo tengo de ese modo...
Archivo DBConfig.php

Código PHP:

<?php
define('OP_DB_CARPETA',     'mysqli');
define('OP_DB_DRIVER',      'mysql');
define('OP_DB_HOST',        'localhost');
define('OP_DB_USUARIO',     'root');
define('OP_DB_CLAVE',       '');
define('OP_DB_PUERTO',      3306);
define('OP_DB_BASE',        'base');
 

Y en la clase que realiza la conexión uso esas variables, en caso de cambiar de servidor solo cambio el archivo DBConfig.php igual en tu caso solo cambiarías la clase...

Saludos

[neodani]

Iniciado por portalmana

Te comento yo lo que tengo es un archivo de configuración simplemente, no una clase con atributos solo para extraerle los datos. No se si se realizara así pero lo tengo de ese modo...
Archivo DBConfig.php

Código PHP:

<?php
define('OP_DB_CARPETA',     'mysqli');
define('OP_DB_DRIVER',      'mysql');
define('OP_DB_HOST',        'localhost');
define('OP_DB_USUARIO',     'root');
define('OP_DB_CLAVE',       '');
define('OP_DB_PUERTO',      3306);
define('OP_DB_BASE',        'base');
 

Y en la clase que realiza la conexión uso esas variables, en caso de cambiar de servidor solo cambio el archivo DBConfig.php igual en tu caso solo cambiarías la clase...

Saludos

El problema que le veo de hacerlo así, es que si defines esas variables como globales, dentro del código no las puedes sobreescribir.
Acabo de probar tenerlas en un fichero aparte y funciona, pero si dentro del código de la clase a la base de datos intento volverlas a definir con otros valores no coge estos nuevos valores... siempre utiliza los del archivo, que son los primeros donde se definieron.

¿No te pasa lo mismo?

¿Qué harías si tuvieras que conectarte a más de una base de datos diferente dentro del mismo script?

Salu2!

[GatorV]

Para eso es importante separar responsabilidades, no es tarea de la clase de conexion extraer los parámetros, simplemente su tarea es interactuar con la base de datos, así si lo mantienes limpio puedes tener varias clases:

Código PHP:

require('db.php');
 
$db1 = new db(/*config db 1*/);
$db2 = new db(/*config db 2*/);
 

Es precisamente esta la razón por la que no conviene usar Singleton para clases conexión, lo mejor es usar un registro y de ahí obtener la clase.

Respecto a tu duda lo mejor es que tengas una forma de leer la configuración ya sea desde otro file, ini, xml, txt, etc. y lo pasas a tu clase, por ejemplo:

Código PHP:

require('config_reader.php');
require('db.php');
require('registry.php');
 
$config = new Config('params.ini');
$db = new db($config);
Registry::set('db', $db);
 

Saludos.

[portalmana]

Iniciado por neodani

El problema que le veo de hacerlo así, es que si defines esas variables como globales, dentro del código no las puedes sobreescribir.
Acabo de probar tenerlas en un fichero aparte y funciona, pero si dentro del código de la clase a la base de datos intento volverlas a definir con otros valores no coge estos nuevos valores... siempre utiliza los del archivo, que son los primeros donde se definieron.

¿No te pasa lo mismo?

¿Qué harías si tuvieras que conectarte a más de una base de datos diferente dentro del mismo script?

Salu2!

Yo defino eso como configuración básica y en la clase conexión tengo los atributos igualados a las variables globales y un método que me permite cambiar de base de datos que es generalmente lo único que cambio, no me a dado mayores problema.
Utilizo PDO pero no directamente, si no con una clase por encima que extiende de esta con una capa de abstracción pues en algunos servidores utilizo mysqli y solo cambio la clase de abstracción...

Ejemplo de abstraccion

[atrianaster]

He visto muchas veces que haces referencia al Patrón Registry. Aquí les dejo la implementación y espero que este aporte les sirva de algo.

Implementacion del Patron Registry en PHP5

Código PHP:

<?php
/**
* Registers objects and variables
*
* Makes objects and variables available to any level
* of the application without having to keep track
* of their existence.  Also useful for objects such
* as database connectors that are used globaly and
* not to be duplicated.
*
* PHP version 5
*/
class registry
{
    /**
     * Registry of variables and objects
     * @access private
     * @var array
     */
    static private $registry = array();
 
    /**
     * Adds an item to the registry
     * @access public
     * @param string item's unique name
     * @param mixed item
     * @return boolean
     */
    public function add($name, &$item)
    {
        if (!self::exists($name)) {
            self::$registry[$name] = $item;
            return true;
        } else {
            return false;
        }
    }
 
    /**
     * Returns true if item is registered
     * @access public
     * @param string item's name
     * @return boolean
     */
    public function exists($name)
    {
        if (is_string($name)) {
            return array_key_exists($name, self::$registry);
        } else {
            throw new Exception('Registry item\'s name must be a string');
        }
    }
 
    /**
     * Returns registered item
     * @access public
     * @param string item's name
     * @return mixed (null if name is not in registry)
     */
    public function &get($name)
    {
        if (self::exists($name)) {
            $return = self::$registry[$name];
        } else {
            $return = null;
        }
        return $return;
    }
 
    /**
     * Removes a registry entry
     * @access public
     * @param string item's name
     * @return boolean
     */
    public function remove($name)
    {
        if (self::exists($name)) {
            unset(self::$registry[$name]);
        }
        return true;
    }
 
    /**
     * Clears the entire registry
     * @access public
     * @return boolean
     */
    public function clear()
    {
        self::$registry = array();
    }
}
?>
 

Como Usar?

Código PHP:

<?php
require_once 'registry.php';
 
//sets and registers a variable
$item = 'Here is a registered variable';
registry::add('Variable', $item);
 
/**
* Test class that echos a registered variable
*/
class test
{
    private $item;
 
    public function __construct() {
        $this->item = registry::get('Variable');
    }
 
    public function get() {
        echo '<p>'.$this->item.'</p>';
    }
}
 
//will return "Here is a registered variable"
$test = new test();
$test->get();
 
//tests if "Variable" exists
if (registry::exists('Variable')) {
    echo '<p>"Variable" exists</p>';
} else {
    echo '<p>"Variable" does not exists</p>';
}
 
//tests if "variable" exists
if (registry::exists('variable')) {
    echo '<p>"variable" exists</p>';
} else {
    echo '<p>"variable" does not exists</p>';
}
 
//removes "Variable"
registry::remove('Variable');
?>
 

Fuente http://desarrolladorsenior.blogspot....ry-en-php.html

Saludos.

[GatorV]

@atrianaster

Gracias por tu aporte, pero te recomendaría dos cosas, una no uses &get ya que ya no se necesita usar & para las referencias, recuerda que a partir de PHP5 todo se pasa por referencia directamente y usar & te marcará un notice.

Por otro lado, si tus funciones son estaticas, usa el operador static en tus funciones ya que si lo haces como lo tienes te van a generar muchos E_NOTICES al tratar de accesar a un método no estático de forma estática.

Saludos.

[atrianaster]

@GatorV gracias por tus recomendaciones, aquí les dejo la clase terminada.

Código PHP:

/**
* Registers objects and variables
*
* Makes objects and variables available to any level
* of the application without having to keep track
* of their existence.  Also useful for objects such
* as database connectors that are used globaly and
* not to be duplicated.
*
* PHP version 5
*
* @author Arley Triana Morín <[email protected]>
*/
class Registry
{
    /**
     * Registry of variables and objects
     * @access static private
     * @var array
     */
    static private $registry = array();
 
    /**
     * Adds an item to the registry
     * @access static public 
     * @param string item's unique name
     * @param mixed item
     * @return boolean
     */
    static public function add($name, $item)
    {
        if (!self::exists($name)) {
            self::$registry[$name] = $item;
            return true;
        } else {
            return false;
        }
    }
 
    /**
     * Returns true if item is registered
     * @access static public
     * @param string item's name
     * @return boolean
     */
    static public function exists($name)
    {
        if (is_string($name)) {
            return array_key_exists($name, self::$registry);
        } else {
            throw new Exception('Registry item\'s name must be a string');
        }
    }
 
    /**
     * Returns registered item
     * @access static public
     * @param string item's name
     * @return mixed (null if name is not in registry)
     */
    static public function get($name)
    {
        if (self::exists($name)) {
            $return = self::$registry[$name];
        } else {
            $return = null;
        }
        return $return;
    }
 
    /**
     * Removes a registry entry
     * @access static public
     * @param string item's name
     * @return boolean
     */
    static public function remove($name)
    {
        if (self::exists($name)) {
            unset(self::$registry[$name]);
        }
        return true;
    }
 
    /**
     * Clears the entire registry
     * @access static public
     * @return boolean
     */
    static public function clear()
    {
        self::$registry = array();
    }
}
?>
 

Como Usar?

Código PHP:

<?php
require_once 'registry.php';
 
//sets and registers a variable
$item = 'Here is a registered variable';
registry::add('Variable', $item);
 
/**
* Test class that echos a registered variable
*/
class Test
{
    private $item;
 
    public function __construct() {
        $this->item = Registry::get('Variable');
    }
 
    public function get() {
        echo '<p>'.$this->item.'</p>';
    }
}
 
//will return "Here is a registered variable"
$test = new Test();
$test->get();
 
//tests if "Variable" exists
if (Registry::exists('Variable')) {
    echo '<p>"Variable" exists</p>';
} else {
    echo '<p>"Variable" does not exists</p>';
}
 
//tests if "variable" exists
if (Registry::exists('variable')) {
    echo '<p>"variable" exists</p>';
} else {
    echo '<p>"variable" does not exists</p>';
}
 
//removes "Variable"
Registry::remove('Variable');
?>
 

[neodani]

Buenas GatorV,

No te acabo de entender cuando dices:

Iniciado por GatorV

lo mejor es usar un registro y de ahí obtener la clase.

Respecto a tu duda lo mejor es que tengas una forma de leer la configuración ya sea desde otro file, ini, xml, txt, etc. y lo pasas a tu clase, por ejemplo:

Código PHP:

require('config_reader.php');
require('db.php');
require('registry.php');
 
$config = new Config('params.ini');
$db = new db($config);
Registry::set('db', $db);
 

Saludos.

Te agradecería mucho si pudieses ponerme un ejemplo para entender mejor como está implementado los archivos que pones de ejemplo: config_reader.php, db.php, registry.php y params.ini.

Muchas gracias de antemano!

[GatorV]

En el post arriba del que tienes, tienes un ejemplo del Registry, del de config es simplemente una clase que puede leer desde archivos ini, por ejemplo:

Código PHP:

<?php
class Config
{
    private $_config;
    public function __construct($sFile)
    {
        if (!file_exists($sFile)) {
            throw new Exception("Can't find file: $sFile");
        }
        
        $this->_config = parse_ini_file($sFile);
    }
    
    public function getConfig()
    {
        return $this->_config;
    }
}
 
class db {
    private $_username;
    private $_password;
    private $_host;
    private $_db;
    
    public function __construct(Config $config)
    {
        $config_data = $config->getConfig();
        $this->_username = $config_data['username'];
        $this->_password = $config_data['password'];
        $this->_host = $config_data['host'];
        $this->_db = $config_data['db'];
    }
}
 

Y un .ini:

Código:

username = "foo"
password = "baz"
host = "localhost"
db = "foobarbaz"

Saludos.

[portalmana]

No sabia pero en algunas de mis aplicaciones implemento algo parecido al patrón Registry...

Muy buenos aportes...
Saludos

[neodani]

GatorV,

Ya tengo los 4 ficheros

config_reader.php

Código PHP:

<?php
class Config
{
    private $_config;
    public function __construct($sFile)
    {
        if (!file_exists($sFile)) {
            throw new Exception("Can't find file: $sFile");
        }
        
        $this->_config = parse_ini_file($sFile);
    }
    
    public function getConfig()
    {
        return $this->_config;
    }
}
?>
 

db.php

Código PHP:

<?php
class db {
    private $_username;
    private $_password;
    private $_host;
    private $_db;
    
    public function __construct(Config $config)
    {
        $config_data = $config->getConfig();
        $this->_username = $config_data['username'];
        $this->_password = $config_data['password'];
        $this->_host = $config_data['host'];
        $this->_db = $config_data['db'];
    }
}
?>
 

registry.php

El código que publicó el compañero atrianaster

y

params.ini

Código:

username = "root"
password = "jupiter"
host = "localhost"
db = "codelab"

Por último, el fichero donde los llamo (tuve que cambiar tu ejemplo de función "set" por la que definió atrianaster "add", imagino que es lo mismo.

Código PHP:

<?php
require('config_reader.php');
require('db.php');
require('registry.php');
 
$config = new Config('params.ini');
$db = new db($config);
Registry::add('db', $db);
 
?>
 

¿Ahora cómo juego con todo esto?... entiendo que haciéndolo de esta forma evitamos el usar el patrón singleton, esto nos proporciona la ventaja de que ahora sea posible conectarse a diferentes bases de datos desde el mismo script.
Ej. la base de datos master donde solo se escribiría, y la slave donde solo se harían lecturas, correcto?

Dentro de la clase db (fichero db.php) debería crear un nuevo método que fuese la conexión con PDO, así verdad?

Código PHP:

public function Conectar(){
        try {
            $dbh = new PDO("mysql:host=$this->_host;dbname=$this->_db", $this->_username, $this->_password);
            /*** echo a message saying we have connected ***/
            echo 'Connected to database';
        }
        catch(PDOException $e){
            echo $e->getMessage();
        }
    }
 

Y en el ejemplo/llamada hacer:

Código PHP:

<?php
require('config_reader.php');
require('db.php');
require('registry.php');
 
$config = new Config('params.ini');
$db = new db($config);
Registry::add('db', $db);
$db->Conectar();
?>
 

De forma que a partir de ese momento, seguiría utilizando la clase db normalmente y solo utilizaría el Registry::add(....) para hacer el paso previo a la conexión, todo bien hasta aquí? :S Debo de volverlo a utilizar en alguna ocasión más por si quiero hacer una consulta a la otra base de datos?

Gracias de antemano!

[GatorV]

El fichero db.php es solo un ejemplo, puedes usar directamente PDO y pasarle los datos, el ejemplo es a nivel teórico para que veas como funcionan las clases y como estan unidas.

Saludos.

[neodani]

Iniciado por GatorV

El fichero db.php es solo un ejemplo, puedes usar directamente PDO y pasarle los datos, el ejemplo es a nivel teórico para que veas como funcionan las clases y como estan unidas.

Saludos.

Una duda que me ha quedado después de practicar estos días...

Si al último ejemplo expuesto, lo llamo de la siguiente manera:

Código PHP:

<?php
 
require('config_reader.php');
require('db.php');
require('registry.php');
 
$config = new Config('params.ini');
$db = new db($config);
Registry::save('db', $db);
$db->Conectar();
$db->Conectar();
$db->Conectar();
 
?>
 

Me muestra el mensaje "Connected to database" tantas veces como llame al metodo Conectar(), ¿es posible que esté duplicando conexiones a la base de datos?

Vuelvo a poner el método Conectar():

Código PHP:

public function Conectar(){
        try {
            $dbh = new PDO("mysql:host=$this->_host;dbname=$this->_db", $this->_username, $this->_password);
            /*** echo a message saying we have connected ***/
            echo 'Connected to database';
        }
        catch(PDOException $e){
            echo $e->getMessage();
        }
    }
 

Debería entonces a parte del patrón Registry para cargar las variables de conexión a la base de datos, utilizar el patrón Singleton en mi clase db, tal y como estaba haciendo en un principio, para conseguir reutilizar la conexión existente y que no vaya creando conexiones cada vez que llamo al método Conectar()?

Gracias nuevamente por vuestra ayuda!

[abimaelrc]

Vuelve a leer el mensaje #7 de este tema.

[atrianaster]

@Neodani invoca al método Conectar() dentro del constructor de la clase db y utiliza Registry a para que te devuelva las instancias creadas anteriormente.

[neodani]

Iniciado por atrianaster

@Neodani invoca al método Conectar() dentro del constructor de la clase db y utiliza Registry a para que te devuelva las instancias creadas anteriormente.

Entiendo pues que efectivamente no hay que juntar el patron Registry con el singleton dentro de la clase db.

En el siguiente ejemplo intento conectarme a dos bases de datos diferentes y mostrar el contenido de una columna. Consigo que se conecte a las dos bases de datos pero a la hora de listar no acaba de funcionar.

Código PHP:

<?php
class db {
    private $_username;
    private $_password;
    private $_host;
    private $_db;
    
    public function __construct(Config $config)
    {
        $config_data = $config->getConfig();
        $this->_username = $config_data['username'];
        $this->_password = $config_data['password'];
        $this->_host = $config_data['host'];
        $this->_db = $config_data['db'];
        
        try {
            $dbh = new PDO("mysql:host=$this->_host;dbname=$this->_db", $this->_username, $this->_password);
            /*** echo a message saying we have connected ***/
            echo 'Connected to database';
        }
        catch(PDOException $e){
            echo $e->getMessage();
        }
    }
}
?>
 

Código PHP:

<?php
require('config_reader.php');
require('db.php');
require('registry.php');
 
class Categoria{
    private $nombreCategoria;
    
    // Listar todas las categorias de la base de datos
    public function listarCategorias($db){
        $query = "SELECT nombre FROM categorias";
        $comando = $db->prepare($query);
        $comando->execute();
 
        while( $datos = $comando->fetch() ) {
        // Imprimimos resultados
        echo $datos[0].'<br />';
        }
    }
}
 
//Cargo los datos del fichero .ini
$config_slave = new Config('params_slave.ini');
$config_master = new Config('params_master.ini');
//Creo el objeto de la base de datos
$db_slave = new db($config_slave);
$db_master = new db($config_master);
//Guardo las instancias diferentes con Registry
Registry::save('db_slave', $db_slave);
Registry::save('db_master', $db_master);
//Recupero las instancias con Registry
$db_slave=Registry::get('db_slave');
$db_master=Registry::get('db_slave');
 
$cat= new Categoria();
$cat->listarCategorias($db_slave);
 
?>
 

La salida por pantalla del error es:

Connected to databaseConnected to database

Fatal error: Call to undefined method db::prepare() in C:\wamp\www\00-laboratorio_test\secciones\class_categorias\Nueva\ ConectarCon2_BD\ejemplo1.php on line 29

Falla esta linea de la clase Categoria():
$comando = $db->prepare($query);
No puedo llamarlo de esta forma dentro de la clase categoria? incluso he intentado pasarle la instancia de la conexión por parametro pero da error.

¿Qué puede estar pasando?

Gracias de antemano!

[atrianaster]

No estas retornando la instancia de PDO en el constructor.
No me refería a que copiaras al método Conectar() literalmente en el constructor, ya que no es una buena practica de desarrollo. El constructor debe contener el código imprescindible para la correcta instanciación de la clase. Lo que te sugerí fue que instanciaras desde el constructor al método Conectar().

Saludos.

[neodani]

Iniciado por atrianaster

No estas retornando la instancia de PDO en el constructor.
No me refería a que copiaras al método Conectar() literalmente en el constructor, ya que no es una buena practica de desarrollo. El constructor debe contener el código imprescindible para la correcta instanciación de la clase. Lo que te sugerí fue que instanciaras desde el constructor al método Conectar().

Saludos.

Cierto, no estaba devolviendo la instancia creada.

He creado una variable $_conexion y ahí guardo la conexión y es la que retorno. bien no?
Pero cuando intento hacerlo tal y como sugieres no encuentro la forma de llamar al método conectar desde el constructor. ¿Puedes indicarme?

Código PHP:

<?php
class db {
    private $_username;
    private $_password;
    private $_host;
    private $_db;
    private $_conexion;
    
    public function __construct(Config $config)
    {
        $config_data = $config->getConfig();
        $this->_username = $config_data['username'];
        $this->_password = $config_data['password'];
        $this->_host = $config_data['host'];
        $this->_db = $config_data['db'];
        
        //db->Conectar();
    }
    private function Conectar(){
        try {
            $this->_conexion = new PDO("mysql:host=$this->_host;dbname=$this->_db", $this->_username, $this->_password);
            /*** echo a message saying we have connected ***/
            echo 'Connected to database';
        }
        catch(PDOException $e){
            echo $e->getMessage();
        }
        return $this->_conexion;
    }
}
?>
 

Muchas gracias de antemano!

[GatorV]

Usa $this->Conectar() para eso.

Saludos.

[atrianaster]

Positivo a eso era a lo que me refería anteriormente usa $this para invocar al metodo Conectar(), que contiene una referencia al objeto actual.

Si quieres ver el contenido de $this puedes utilizar la función var_dump($this); o de lo contrario busca un IDE que te permita debugear, yo en particular utilizo Netbeans IDE

Saludos.

[neodani]

Iniciado por atrianaster

Positivo a eso era a lo que me refería anteriormente usa $this para invocar al metodo Conectar(), que contiene una referencia al objeto actual.

Si quieres ver el contenido de $this puedes utilizar la función var_dump($this); o de lo contrario busca un IDE que te permita debugear, yo en particular utilizo Netbeans IDE

Saludos.

La clase ha quedado así, ya conecta con la base de datos pero no consigo ejecutar las consultas de la clase Categoria, puedes indicarme que estoy haciendo mal?

db.class

Código PHP:

<?php
class db {
    private $_username;
    private $_password;
    private $_host;
    private $_db;
    private $_conexion;
    
    public function __construct(Config $config)
    {
        $config_data = $config->getConfig();
        $this->_username = $config_data['username'];
        $this->_password = $config_data['password'];
        $this->_host = $config_data['host'];
        $this->_db = $config_data['db'];
        
        $this->Conectar();
    }
    private function Conectar(){
        try {
            $this->_conexion = new PDO("mysql:host=$this->_host;dbname=$this->_db", $this->_username, $this->_password);
            /*** echo a message saying we have connected ***/
            echo 'Connected to database';
        }
        catch(PDOException $e){
            echo $e->getMessage();
        }
        return $this->_conexion;
    }
}
?>
 

ejemplo1.php

Código PHP:

<?php
require('config_reader.php');
require('db.php');
require('registry.php');
 
class Categoria{
    private $nombreCategoria;
    
    // Listar todas las categorias de la base de datos
    public function listarCategorias($DbInstance){
        $query = "SELECT nombre FROM categorias";
        $comando = $DbInstance->prepare($query);
        $comando->execute();
 
        while( $datos = $comando->fetch() ) {
        // Imprimimos resultados
        echo $datos[0].'<br />';
        }
    }
}
 
//Cargo los datos del fichero .ini
$config_slave = new Config('params_slave.ini');
$config_master = new Config('params_master.ini');
//Creo el objeto de la base de datos
$db_slave = new db($config_slave);
$db_master = new db($config_master);
//Guardo las instancias diferentes con Registry
Registry::save('db_slave', $db_slave);
Registry::save('db_master', $db_master);
//Recupero las instancias con Registry
$db_slave=Registry::get('db_slave');
$db_master=Registry::get('db_slave');
 
$cat= new Categoria();
$cat->listarCategorias($db_slave);
 
?>
 

Error que me da
Connected to databaseConnected to database
Fatal error: Call to undefined method db::prepare() in C:\wamp\www\00-laboratorio_test\secciones\class_categorias\Nueva\ ConectarCon2_BD\ejemplo1.php on line 13

La linea es esta
$comando = $DbInstance->prepare($query);

¿Estoy pasandole mal la instancia a la clase Categoria???

[carlos_belisario]

una preguntita la instancia de esta linea siempre es del tipo db¿??

public function listarCategorias($DbInstance)

xq no se lo indicas como lo haces con otros metodos que he visto asi verificas si la instancia que le estas pasando realmente es del tipo db xq puede ser eso ya que por encima y con los pocos conocimientos que tengo en poo y pdo se ve correcta aunq noc si sea la manera de retornar un objeto verifica con is_object en el metodo listarCategorias si $Dbinstance es realmente un objeto xq a la vista es lo q no te esta reconociendo suerte espero te ayude

[atrianaster]

Sigues sin retornar la instancia en el constructor de la clase.

Código PHP:

return $this->Conectar();
 

[neodani]

Iniciado por atrianaster

Sigues sin retornar la instancia en el constructor de la clase.

Código PHP:

return $this->Conectar();
 

Gracias atrianaster,

Código PHP:

<?php
class db {
    private $_username;
    private $_password;
    private $_host;
    private $_db;
    private $_conexion;
    
    public function __construct(Config $config)
    {
        $config_data = $config->getConfig();
        $this->_username = $config_data['username'];
        $this->_password = $config_data['password'];
        $this->_host = $config_data['host'];
        $this->_db = $config_data['db'];
        
        return $this->Conectar();
    }
    private function Conectar(){
        try {
            $this->_conexion = new PDO("mysql:host=$this->_host;dbname=$this->_db", $this->_username, $this->_password);
            /*** echo a message saying we have connected ***/
            echo 'Connected to database';
        }
        catch(PDOException $e){
            echo $e->getMessage();
        }
        return $this->_conexion;
    }
}
?>
 

¿Cuál es el siguiente paso para que me liste los resultados?

Puedes confirmarme si esta parte la ves correcta?

Código PHP:

//Cargo los datos del fichero .ini
$config_slave = new Config('params_slave.ini');
$config_master = new Config('params_master.ini');
 
//Creo el objeto de la base de datos
$db_slave = new db($config_slave);
$db_master = new db($config_master);
 
//Guardo las instancias diferentes con Registry
Registry::save('db_slave', $db_slave);
Registry::save('db_master', $db_master);
 
//Recupero las instancias con Registry
$db_slave=Registry::get('db_slave');
$db_master=Registry::get('db_slave');
 
$cat= new Categoria();
$cat->listarCategorias($db_slave);
 

Esto me está matando!

[GatorV]

Que problema te da ahora?

[neodani]

Iniciado por GatorV

Que problema te da ahora?

El mismo de antes :(

Connected to databaseConnected to database
Fatal error: Call to undefined method db::prepare() in C:\wamp\www\00-laboratorio_test\secciones\class_categorias\Nueva\ ConectarCon2_BD\ejemplo1.php on line 13