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

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