Ver Mensaje Individual
  #22 (permalink)  
Antiguo 07/08/2011, 15:05
thehack
 
Fecha de Ingreso: abril-2010
Mensajes: 151
Antigüedad: 14 años
Puntos: 1
Respuesta: problemas con instanciar una classe

jejejeje bueno eh terminado algunas cosas hasta los momento e echo consultas y no me ha dado error no se si estare empezando por buen pie les coloco mi codigo

1: config.inc.php
Código PHP:
Ver original
  1. define('db_host', "localhost");  // SERVIDOR
  2. define('db_name', "nombre de la db");  // NOMBRE DE LA BASE DE DATOS
  3. define('db_user', "usuario");  // USUARIO DE LA BASE DE DATOS
  4. define('db_pass', "contraseña");  // CONTRASEÑA
  5. define('db_persist', 0);

2:config.class.php
Código PHP:
Ver original
  1. <?php
  2. Class Conf{
  3.     private  $_dbhost;
  4.     private  $_dbname;
  5.     private  $_dbuser;
  6.     private  $_dbpass;
  7.     private  $_db_persist;
  8.     static $_instance;
  9.  
  10.    private function __construct(){
  11.       require TS_ROOT.'/config.inc.php';
  12.                 $this->_dbhost = db_host;
  13.         $this->_dbname = db_name;
  14.         $this->_dbuser = db_user;
  15.         $this->_dbpass = db_pass;
  16.         $this->_db_persist = db_persist;
  17.    }
  18.  
  19.    private function __clone(){ }
  20.  
  21.    public static function getInstance(){
  22.       if (!(self::$_instance instanceof self)){
  23.          self::$_instance=new self();
  24.       }
  25.       return self::$_instance;
  26.    }
  27.  
  28.    public function getUserDB(){
  29.       $var = $this->_dbuser;
  30.       return $var;
  31.    }
  32.  
  33.    public function getHostDB(){
  34.       $var=$this->_dbhost;
  35.       return $var;
  36.    }
  37.  
  38.    public function getPassDB(){
  39.       $var=$this->_dbpass;
  40.       return $var;
  41.    }
  42.  
  43.    public function getDB(){
  44.       $var=$this->_dbname;
  45.       return $var;
  46.    }
  47.  
  48. }

3:db.php

Código PHP:
Ver original
  1. /*
  2.  
  3.     CLASE PARA TRABAJAR CON LA BASE DE DATOS
  4.    
  5.     METODOS DE LA CLASE DB:
  6.    
  7.     tsdatabase()
  8.     connect()
  9.     query()
  10.     select()
  11.     update()
  12.     replace()
  13.     insert()
  14.     delete()
  15.     data()
  16.     fetch_objects()
  17.     fetch_assoc()
  18.     num_rows()
  19.     free()
  20.     insert_id()
  21.     error()
  22. */
  23.  
  24. /* Clase encargada de gestionar las conexiones a la base de datos */
  25. Class tsDatabase{
  26.  
  27.    private $servidor;
  28.    private $usuario;
  29.    private $password;
  30.    private $base_datos;
  31.    private $link;
  32.    private $_querys;
  33.    static $_instance;
  34.  
  35.    /*La función construct es privada para evitar que el objeto pueda ser creado mediante new*/
  36.    private function __construct(){
  37.       $this->setConexion();
  38.       $this->conectar();
  39.    }
  40.  
  41.    /*Método para establecer los parámetros de la conexión*/
  42.    private function setConexion(){
  43.       $conf = Conf::getInstance();
  44.       $this->servidor=$conf->getHostDB();
  45.       $this->base_datos=$conf->getDB();
  46.       $this->usuario=$conf->getUserDB();
  47.       $this->password=$conf->getPassDB();
  48.    }
  49.  
  50.    /*Evitamos el clonaje del objeto. Patrón Singleton*/
  51.    private function __clone(){ }
  52.  
  53.    /*Función encargada de crear, si es necesario, el objeto. Esta es la función que debemos llamar desde fuera de la clase para instanciar el objeto, y así, poder utilizar sus métodos*/
  54.    public static function getInstance(){
  55.       if (!(self::$_instance instanceof self)){
  56.          self::$_instance=new self();
  57.       }
  58.          return self::$_instance;
  59.    }
  60.  
  61.    /*Realiza la conexión a la base de datos.*/
  62.    private function conectar(){
  63.       $this->link=mysql_connect($this->servidor, $this->usuario, $this->password);
  64.       mysql_select_db($this->base_datos,$this->link);
  65.       mysql_query("set names 'utf8'");
  66.       mysql_query("set character set utf8");
  67.    }
  68.  
  69.  
  70.    // METODO PARA HACER UNA CONSULTA
  71.     // INPUT: $query
  72.     // OUTPUT: $result
  73.     function query($q){
  74.     $this->_querys++;
  75.         // HACIENDO CONSULTA Y RETORNANDO
  76.         return mysql_query($q);
  77.     }
  78.     // METODO PARA HACER UN SELECT
  79.     // INPUT:
  80.     //      $table | NOMBRE DE LA TABLA
  81.     //      $fields | CAMPOS A SELECCIONAR DE LA TABLA
  82.     //      $where | CONDICION DE LA CONSULTA
  83.     //      $order | ORDEN DE LOS RESULTADOS
  84.     //      $limit | LIMITE DE RESULTADOS
  85.     // OUTPUT: $result
  86.     function select($table, $fields, $where = NULL, $order = NULL, $limit = NULL){
  87.  
  88.          $this->_querys++;
  89.  
  90.         // CREANDO LA CONSULTA
  91.         $q = 'SELECT '.$fields.' FROM '.$table;
  92.         if($where) $q .= ' WHERE '.$where;
  93.         if($order) $q .= ' ORDER BY '.$order;
  94.         if($limit) $q .= ' LIMIT '.$limit;
  95.         // HACIENDO CONSULTA Y RETORNANDO
  96.         return mysql_query($q);
  97.     }
  98.     // METODO PARA HACER UN UPDATE
  99.     // INPUT:
  100.     //      $table | NOMBRE DE LA TABLA
  101.     //      $pairs | CAMPOS Y VALORES A ACTUALIZAR
  102.     //      $where | CONDICION DE LA CONSULTA
  103.     // OUTPUT: status
  104.     function update($table, $pairs, $where){
  105.  
  106.         $this->_querys++;
  107.         // DESCOMPONER CAMPOS DE UN ARRAY
  108.         if(is_array($pairs)) $fields = implode(", ", $pairs);
  109.         else $fields = $pairs;
  110.         // ARMANDO CONSULTA
  111.         $q = 'UPDATE '.$table.' SET '.$fields.' WHERE '.$where;
  112.         // REALIZANDO CONSULTA
  113.         $result = mysql_query($q);
  114.         // RETORNANDO ESTADO
  115.         if($result) return true;
  116.         else return false;
  117.     }
  118.     // METODO PARA HACER UN REPLACE
  119.     // INPUT:
  120.     //      $table | NOMBRE DE LA TABLA
  121.     //      $fields | CAMPOS A REEMPLAZAR
  122.     //      $values | VALORES A REEMPLAZAR
  123.     // OUTPUT: status
  124.     function replace($table, $fields, $values){
  125.  
  126.         $this->_querys++;
  127.         // ARMANDO CONSULTA
  128.         $q = "REPLACE INTO $table ($fields) VALUES ($values)";
  129.         // REALIZANDO CONSULTA
  130.         $result = mysql_query($q);
  131.         // RETORNANDO ESTADO
  132.         if($result) return true;
  133.         else return false;
  134.     }
  135.     // METODO PARA HACER UN INSERT
  136.     // INPUT:
  137.     //      $table | NOMBRE DE LA TABLA
  138.     //      $fields | CAMPOS
  139.     //      $values | VALORES
  140.     // OUTPUT: status
  141.     function insert($table, $fields, $values){
  142.  
  143.         $this->_querys++;
  144.         // ARMANDO CONSULTA
  145.         $q = 'INSERT INTO '.$table.' ('.$fields.') VALUES ('.$values.')';
  146.         // REALIZANDO CONSULTA
  147.         $result = mysql_query($q);
  148.         // RETORNANDO ESTADO
  149.         if($result) return true;
  150.         else return false;
  151.     }
  152.     // METODO PARA HACER UN DELETE
  153.     // INPUT:
  154.     //      $table | NOMBRE DE LA TABLA
  155.     //      $where | CONDICION
  156.     // OUTPUT: status
  157.     function delete($table, $where){
  158.  
  159.         $this->_querys++;
  160.         // ARMANDO CONSULTA
  161.         $q = 'DELETE FROM '.$table.' WHERE '.$where;
  162.         // REALIZANDO CONSULTA
  163.         $result = mysql_query($q);
  164.         // RETORNANDO ESTADO
  165.         if($result) return true;
  166.         else return false;
  167.     }
  168.     // METODO PARA HACER UNA CONSULTA Y OBTENER OBJETOS
  169.     // INPUT:
  170.     //      $table | NOMBRE DE LA TABLA
  171.     //      $fields | CAMPOS A SELECCIONAR DE LA TABLA
  172.     //      $where | CONDICION DE LA CONSULTA
  173.     //      $order | ORDEN DE LOS RESULTADOS
  174.     //      $limit | LIMITE DE RESULTADOS
  175.     // OUTPUT: $result
  176.     function data($table, $fields, $where =NULL, $order = NULL, $limit = NULL){
  177.  
  178.         $this->_querys++;
  179.         // CREANDO LA CONSULTA
  180.         $q = 'SELECT '.$fields.' FROM '.$table;
  181.         if($where) $q .= ' WHERE '.$where;
  182.         if($order) $q .= ' ORDER BY '.$order;
  183.         if($limit) $q .= ' LIMIT '.$limit;
  184.         // HACIENDO CONSULTA
  185.         $result = mysql_query($q);
  186.         // CREANDO Y RETORNANDO OBJETOS
  187.         if($result) return mysql_fetch_object($result);
  188.         else return false;
  189.     }
  190.     // METODO PARA CREAR OBJETOS DESDE UNA CONSULTA
  191.     // INPUT: $result
  192.     // OUTPUT: $objs
  193.     function fetch_objects($result){
  194.         if(!is_resource($result)) return false;
  195.         while($obj = mysql_fetch_object($result)) $objs[] = $obj;
  196.         return $objs;
  197.     }
  198.     // METODO PARA CREAR ARRAY DESDE UNA CONSULTA
  199.     // INPUT: $result
  200.     // OUTPUT: array
  201.     function fetch_assoc($result){
  202.         if(!is_resource($result)) return false;
  203.         return mysql_fetch_assoc($result);
  204.     }
  205.     // METODO PARA CREAR ARRAY DESDE UNA CONSULTA
  206.     // INPUT: $result
  207.     // OUTPUT: array
  208.     function fetch_array($result,$array = NULL){
  209.         if(!is_resource($result)) return false;
  210.         while($row = mysql_fetch_assoc($result)) $array[] = $row;
  211.         return $array;
  212.     }
  213.     // METODO PARA OBTENER EL VALOR DE UNA ROW
  214.     // INPUT: $result
  215.     // OUTPUT: array
  216.     function fetch_row($result){
  217.         return mysql_fetch_row($result);
  218.     }
  219.     // METODO PARA CONTAR EL NUMERO DE RESULTADOS
  220.     // INPUT: $result
  221.     // OUTPUT: num_rows
  222.     function num_rows($result){
  223.         if(!is_resource($result)) return false;
  224.         return mysql_num_rows($result);
  225.     }
  226.     // METODO PARA LIBERAR MEMORIA
  227.     // INPUT: $result
  228.     // OUTPUT: void
  229.     function free($result = 0){
  230.         return mysql_free_result($result);
  231.     }
  232.     // METODO PARA RETORNAR EL ULTIMO ID DE UN INSERT
  233.     // INPUT: void
  234.     // OUTPUT: status
  235.     function insert_id(){
  236.  
  237.       $this->_querys++;
  238.       return mysql_insert_id($this->_dblink);
  239.     }
  240.     // METODO PARA RETORNAR LOS ERRORES
  241.     // INPUT: void
  242.     // OUTPUT: status
  243.     function error(){
  244.       return mysql_error($this->_dblink);
  245.     }
  246.  
  247. }


ese es mi codigo a la db como lo utilizo

Código PHP:
Ver original
  1. include TS_CLASS."Conf.class.php";
  2. include TS_CLASS."c.db.php";        // FUNCIONES PARA LA DB
  3.  
  4. $db = tsDatabase::getInstance();


ejemplo de una clase donde hago consultas a la DB

Código PHP:
Ver original
  1. class Portal  {
  2.  
  3.     // INSTANCIA DE LA CLASE
  4.        static $_instance;
  5.     // INSTANCIA DE LA CLASE
  6.        public static function getInstance(){
  7.       if (!(self::$_instance instanceof self)){
  8.          self::$_instance = new Portal();
  9.       }
  10.          return self::$_instance;
  11.    }
  12.  
  13. /** getFavorites()
  14.      * @access public
  15.      * @param
  16.      * @return array
  17.      */
  18.      public function getFavorites(){
  19.      
  20. $db =  tsDatabase::getInstance();
  21. $tsCore = tsCore::getInstance();
  22. $tsUser = tsUser::getInstance();
  23.         //
  24.         $query = $db->select("p_favoritos","COUNT(fav_id) AS total","fav_user = {$tsUser->uid}");
  25.         $total = $db->fetch_assoc($query);
  26.         $db->free($query);
  27.         if($total['total'] > 0)
  28.             $pages = $tsCore->getPagination($total['total'], 20);
  29.         else return false;
  30.         //
  31.         $query = $db->query("SELECT f.fav_id, p.post_id, p.post_category, p.post_title, p.post_date, p.post_comments, p.post_puntos, p.post_private, u.user_name, c.c_nombre, c.c_seo, c.c_img FROM p_favoritos AS f LEFT JOIN p_posts AS p ON f.fav_post_id = p.post_id LEFT JOIN u_miembros AS u ON p.post_user = u.user_id LEFT JOIN p_categorias AS c ON c.cid = p.post_category WHERE p.post_status = 0 AND f.fav_user = {$tsUser->uid} ORDER BY f.fav_date DESC LIMIT {$pages['limit']}");
  32.         $data['data'] = $db->fetch_array($query);
  33.         $db->free($query);
  34.         //
  35.         $data['pages'] = $pages;
  36.         //
  37.         return $data;
  38.      }
  39.  
  40. }


esta bien los pasos que hasta el momento e realizado consultas a la db

Última edición por thehack; 07/08/2011 a las 15:07 Razón: Edit algo mal escrito