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

Código PHP:
Ver original
  1. <?php
  2. /*
  3.  
  4.     CLASE PARA TRABAJAR CON LA BASE DE DATOS
  5.    
  6.     METODOS DE LA CLASE DB:
  7.    
  8.     tsdatabase()
  9.     connect()
  10.     query()
  11.     select()
  12.     update()
  13.     replace()
  14.     insert()
  15.     delete()
  16.     data()
  17.     fetch_objects()
  18.     fetch_assoc()
  19.     num_rows()
  20.     free()
  21.     insert_id()
  22.     error()
  23. */
  24.  
  25.  
  26. class tsDatabase {
  27.     var $dbhost;
  28.     var $dbname;
  29.     var $dbuser;
  30.     var $dbpass;
  31.     var $dbpersist;
  32.     var $dblink;
  33.  
  34.     // ESTE ES EL CONSTRUCTOR
  35.     // CONECTA Y SELECCIONA UNA BASE DE DATOS
  36.     // INPUT: VOID
  37.     // OUTPUT: $dblink
  38.     function tsDatabase(){
  39.         // DEFINICION DE VARIABLES
  40.         $this->dbhost = db_host;
  41.         $this->dbname = db_name;
  42.         $this->dbuser = db_user;
  43.         $this->dbpass = db_pass;
  44.         $this->db_persist = db_persist;
  45.         // CONECTAR
  46.         $this->dblink = $this->connect();
  47.         return $this->dblink;
  48.        
  49.     }
  50.     // METODO PARA SELECCIONAR Y CONECTAR A LA BASE DE DATOS
  51.     // INPUT:
  52.     // OUTPUT: instancia de la clase
  53.     function &getInstance(){
  54.         global $tsdb;
  55.         static $database;
  56.        
  57.         if( !is_a($database, 'tsDatabase') ){
  58.             // Backwards compatibility
  59.             if( is_a($tsdb, 'tsDatabase') ){
  60.                 $database =& $tsdb;
  61.             }
  62.             // Instantiate
  63.             else{
  64.                 $database = new tsDatabase();
  65.                 $tsdb =& $database;
  66.             }
  67.         }
  68.         return $database;
  69.     }
  70.  
  71.     // METODO PARA CONECTAR A LA BASE DE DATOS
  72.     // INPUT: void
  73.     // OUTPUT: $db_link
  74.     function connect() {
  75.         // CONEXION PERSISTENTE?
  76.         if($this->db_persist) $db_link = mysql_pconnect($this->dbhost, $this->dbuser, $this->dbpass);
  77.         else $db_link = mysql_connect($this->dbhost, $this->dbuser, $this->dbpass);
  78.         // NO SE PUDO CONECTAR?
  79.         if(empty($db_link)) die(N_ACCESS);
  80.         // SELECCIONAR BASE DE DATOS
  81.         mysql_select_db($this->dbname);
  82.         // ASIGNAR CONDIFICACION
  83.         mysql_query("set names 'utf8'");
  84.         mysql_query("set character set utf8");
  85.         // REGRESAR LA CONEXCION
  86.         return $db_link;
  87.     }
  88.     // METODO PARA HACER UNA CONSULTA
  89.     // INPUT: $query
  90.     // OUTPUT: $result
  91.     function query($q){
  92.         global $tsCore;
  93.         $tsCore->querys++;
  94.         // HACIENDO CONSULTA Y RETORNANDO
  95.         return mysql_query($q);
  96.     }
  97.     // METODO PARA HACER UN SELECT
  98.     // INPUT:
  99.     //      $table | NOMBRE DE LA TABLA
  100.     //      $fields | CAMPOS A SELECCIONAR DE LA TABLA
  101.     //      $where | CONDICION DE LA CONSULTA
  102.     //      $order | ORDEN DE LOS RESULTADOS
  103.     //      $limit | LIMITE DE RESULTADOS
  104.     // OUTPUT: $result
  105.     function select($table, $fields, $where = NULL, $order = NULL, $limit = NULL){
  106.         global $tsCore;
  107.         //$tsCore->querys++;
  108.                  // CREANDO LA CONSULTA
  109.         $q = 'SELECT '.$fields.' FROM '.$table;
  110.         if($where) $q .= ' WHERE '.$where;
  111.         if($order) $q .= ' ORDER BY '.$order;
  112.         if($limit) $q .= ' LIMIT '.$limit;
  113.         // HACIENDO CONSULTA Y RETORNANDO
  114.         return mysql_query($q);
  115.     }
  116.     // METODO PARA HACER UN UPDATE
  117.     // INPUT:
  118.     //      $table | NOMBRE DE LA TABLA
  119.     //      $pairs | CAMPOS Y VALORES A ACTUALIZAR
  120.     //      $where | CONDICION DE LA CONSULTA
  121.     // OUTPUT: status
  122.     function update($table, $pairs, $where){
  123.         global $tsCore;
  124.         $tsCore->querys++;
  125.         // DESCOMPONER CAMPOS DE UN ARRAY
  126.         if(is_array($pairs)) $fields = implode(", ", $pairs);
  127.         else $fields = $pairs;
  128.         // ARMANDO CONSULTA
  129.         $q = 'UPDATE '.$table.' SET '.$fields.' WHERE '.$where;
  130.         // REALIZANDO CONSULTA
  131.         $result = mysql_query($q);
  132.         // RETORNANDO ESTADO
  133.         if($result) return true;
  134.         else return false;
  135.     }
  136.     // METODO PARA HACER UN REPLACE
  137.     // INPUT:
  138.     //      $table | NOMBRE DE LA TABLA
  139.     //      $fields | CAMPOS A REEMPLAZAR
  140.     //      $values | VALORES A REEMPLAZAR
  141.     // OUTPUT: status
  142.     function replace($table, $fields, $values){
  143.         global $tsCore;
  144.         $tsCore->querys++;
  145.         // ARMANDO CONSULTA
  146.         $q = "REPLACE INTO $table ($fields) VALUES ($values)";
  147.         // REALIZANDO CONSULTA
  148.         $result = mysql_query($q);
  149.         // RETORNANDO ESTADO
  150.         if($result) return true;
  151.         else return false;
  152.     }
  153.     // METODO PARA HACER UN INSERT
  154.     // INPUT:
  155.     //      $table | NOMBRE DE LA TABLA
  156.     //      $fields | CAMPOS
  157.     //      $values | VALORES
  158.     // OUTPUT: status
  159.     function insert($table, $fields, $values){
  160.         global $tsCore;
  161.         $tsCore->querys++;
  162.         // ARMANDO CONSULTA
  163.         $q = 'INSERT INTO '.$table.' ('.$fields.') VALUES ('.$values.')';
  164.         // REALIZANDO CONSULTA
  165.         $result = mysql_query($q);
  166.         // RETORNANDO ESTADO
  167.         if($result) return true;
  168.         else return false;
  169.     }
  170.     // METODO PARA HACER UN DELETE
  171.     // INPUT:
  172.     //      $table | NOMBRE DE LA TABLA
  173.     //      $where | CONDICION
  174.     // OUTPUT: status
  175.     function delete($table, $where){
  176.         global $tsCore;
  177.         $tsCore->querys++;
  178.         // ARMANDO CONSULTA
  179.         $q = 'DELETE FROM '.$table.' WHERE '.$where;
  180.         // REALIZANDO CONSULTA
  181.         $result = mysql_query($q);
  182.         // RETORNANDO ESTADO
  183.         if($result) return true;
  184.         else return false;
  185.     }
  186.     // METODO PARA HACER UNA CONSULTA Y OBTENER OBJETOS
  187.     // INPUT:
  188.     //      $table | NOMBRE DE LA TABLA
  189.     //      $fields | CAMPOS A SELECCIONAR DE LA TABLA
  190.     //      $where | CONDICION DE LA CONSULTA
  191.     //      $order | ORDEN DE LOS RESULTADOS
  192.     //      $limit | LIMITE DE RESULTADOS
  193.     // OUTPUT: $result
  194.     function data($table, $fields, $where =NULL, $order = NULL, $limit = NULL){
  195.         global $tsCore;
  196.         $tsCore->querys++;
  197.         // CREANDO LA CONSULTA
  198.         $q = 'SELECT '.$fields.' FROM '.$table;
  199.         if($where) $q .= ' WHERE '.$where;
  200.         if($order) $q .= ' ORDER BY '.$order;
  201.         if($limit) $q .= ' LIMIT '.$limit;
  202.         // HACIENDO CONSULTA
  203.         $result = mysql_query($q);
  204.         // CREANDO Y RETORNANDO OBJETOS
  205.         if($result) return mysql_fetch_object($result);
  206.         else return false;
  207.     }
  208.     // METODO PARA CREAR OBJETOS DESDE UNA CONSULTA
  209.     // INPUT: $result
  210.     // OUTPUT: $objs
  211.     function fetch_objects($result){
  212.         if(!is_resource($result)) return false;
  213.         while($obj = mysql_fetch_object($result)) $objs[] = $obj;
  214.         return $objs;
  215.     }
  216.     // METODO PARA CREAR ARRAY DESDE UNA CONSULTA
  217.     // INPUT: $result
  218.     // OUTPUT: array
  219.     function fetch_assoc($result){
  220.         if(!is_resource($result)) return false;
  221.         return mysql_fetch_assoc($result);
  222.     }
  223.     // METODO PARA CREAR ARRAY DESDE UNA CONSULTA
  224.     // INPUT: $result
  225.     // OUTPUT: array
  226.     function fetch_array($result){
  227.         if(!is_resource($result)) return false;
  228.         while($row = mysql_fetch_assoc($result)) $array[] = $row;
  229.         return $array;
  230.     }
  231.     // METODO PARA OBTENER EL VALOR DE UNA ROW
  232.     // INPUT: $result
  233.     // OUTPUT: array
  234.     function fetch_row($result){
  235.         return mysql_fetch_row($result);
  236.     }
  237.     // METODO PARA CONTAR EL NUMERO DE RESULTADOS
  238.     // INPUT: $result
  239.     // OUTPUT: num_rows
  240.     function num_rows($result){
  241.         if(!is_resource($result)) return false;
  242.         return mysql_num_rows($result);
  243.     }
  244.     // METODO PARA LIBERAR MEMORIA
  245.     // INPUT: $result
  246.     // OUTPUT: void
  247.     function free($result){
  248.         return mysql_free_result($result);
  249.     }
  250.     // METODO PARA RETORNAR EL ULTIMO ID DE UN INSERT
  251.     // INPUT: void
  252.     // OUTPUT: status
  253.     function insert_id(){
  254.       global $tsCore;
  255.       $tsCore->querys++;
  256.       return mysql_insert_id($this->dblink);
  257.     }
  258.     // METODO PARA RETORNAR LOS ERRORES
  259.     // INPUT: void
  260.     // OUTPUT: status
  261.     function error(){
  262.       return mysql_error($this->dblink);
  263.     }
  264.    
  265.    
  266.    
  267. }
  268. ?>

mi class de la db como la declaro

asi $tsdb =& tsDatabase::getInstance();