Ayuda con mi modelo de objetos

[Computer XTress]

Hola ¿qué tal?

Tengo armado un conjunto de clases que vengo usando hace mucho ya para trabajar, y si bien funcionan y me ayudan bastante, creo que podria armar un modelo mucho mejor (tanto por haberlas usado como por haber leido).

Me gustaría mostrarles como es el "modelo" y que ustedes me den su opinion... qué podria cambiar para mejorarlo, para que sea más comodo trabajar.
(O si me conviene directamente usar uno nuevo y re-hacer todo)


Tengo por ejemplo las siguientes clases:

a. CLASE MySQL_CONEXION: Conecta a un servidor MySQL
b. CLASE MySQL_CONSULTA: Realiza una consulta a la BD
c. CLASE REGEX: Metodos para realizar controles rutinarios (seguridad)


Mi problema principal radica en que con mi modelo muchos objetos necesitan recibir como parametro a su vez otro objeto, por ejemplo para realizar una consulta necesito un objeto de cada uno de estos tres, y lo haría asi:

Código PHP:

   
// nivel 1 
$conexion = new mysql_conexion(); 
$regex = new regex(); 
 
// nivel 2 
$query = new mysql_consulta($conexion, $regex); 
$query2 = new mysql_consulta($conexion, $regex); 
 
 
$sql = "select * from autos"; 
 
$query->consulta($sql);  
   

Vi que esto se usa mucho pero a mi no me termina de convencer. Sobre todo cuando tengo que crear objetos de niveles más altos, a veces termino teniendo una cadena de objeto que recibe otro objeto muy larga.

Cuando empece a chusmear C# lo que note es que hacen algo parecido pero en vez de pasar objetos usan mucho más la herencia para sortear este asunto...


Me gustaria recibir algunos comentarios. Yo sigo leyendo y buscando soluciones por internet pero sin duda tener consejos y observaciones de gente con experiencia en OO me seria de gran ayuda.



Un saludo grande y muchas gracias

[pragone]

Iniciado por Computer XTress

Mi problema principal radica en que con mi modelo muchos objetos necesitan recibir como parametro a su vez otro objeto

Por qué es eso un problema?... creo que es de lo más normal.

Iniciado por Computer XTress

Sobre todo cuando tengo que crear objetos de niveles más altos, a veces termino teniendo una cadena de objeto que recibe otro objeto muy larga.

Pon un ejemplo para que veamos.

[GatorV]

Otra opción a lo que sugieres es que algunos metodos del objeto A, te regresen un objeto B, por decir:

Código PHP:

  $db = new mysql();
$rst = $db->Query( "SELECT * FROM tabla" );
while( $row = $rst->fetchRow() ) {
      var_dump( $row );
}  
   

Saludos.

[enriqueplace]

Iniciado por Computer XTress

Hola ¿qué tal?
Mi problema principal radica en que con mi modelo muchos objetos necesitan recibir como parametro a su vez otro objeto, por ejemplo para realizar una consulta necesito un objeto de cada uno de estos tres, y lo haría asi:

Tú problema es el repetido problema de la mayoría que consulta sobre POO, no ha leído sobre conceptos.

La POO es eso, objetos que se relacionan unos con otros, y en mi opinión, es fundamental que inicies por UML para tener una herramienta que te ayude a comprender los diseños.

Si tu aprendes UML no harías esta pregunta, ya que aparecen representaciones (flechas) en los diagramas que muestran todas las relaciones posibles entre los objetos:

• asociación
• dependencia
• herencia
• interfaz
• etc

POO no es solo sintaxis. Todos podemos hacer "$obj = new Obj()" y luego solo improvisamos.

PD: otro tema relacionado con los conceptos son las "convenciones"... las clases siempre van con la primera letra en mayúscula y la palabra se escribe en singular.

[Computer XTress]

Enrique:

Claro que no soy un experto, está claro que estoy aprendiendo (no se si lo aclaré arriba o no) y les pido consejos para fortalecer la teoría que vengo leyendo. Sobre UML me pareció muy bueno, no le habia dado tanta bolilla antes pero voy a seguir leyendo al respecto. Gracias.

Si supieras de algun TIP que puedas darme como para que yo vaya a investigar, te lo agradecería también.

Con respecto a POO no creas que soy un total ignorante, me empeño mucho en leer y estudiar y comprendo esos conceptos que nombras. Por supuesto, no con la misma profundida que vos ya que sos alguien mucho más experimentado, pero no creas que armo clases con funciones y luego uso asi mis objetos. Enserio, no soy tan tonto :)

La idea de este post es, en parte, es ir encontrando algunos hilos de los cuales empezar a tirar. La teoría es muy linda pero a la hora de hacer la práctica las cosas se nos complican un poco a los principiantes!



GatorV:

Si, definitivamente lo que propones es lo que necesito. Yo estaba pensando en hacer una clase tipo factory y tener cada consulta, en lo posible, en objetos diferentes de tipo "query" o algo asi. Antes se me embrollaba un poco el asunto de llevar control del #ID de consulta a la hora de liberar ó cosas así. GRACIAS por el tip.


Pragone: Posteo aquí algunas de las clases. Y si, tal vez sea que estoy un poco perseguido. :S


saludos y gracias a todos!

[Computer XTress]

Y aquí dejo algunas clases (que no son robadas de internet. Si me sirvieron de influencia algunas que encontré, obviamente)



CONEXION A BD

Código PHP:

  class mysqldb_conexion {

    /* SERVER LOGIN */
    var $BaseDatos;
    var $Servidor;
    var $Usuario;
    var $Clave;

 
    /* ID de CONEXION */
    var $Conexion_ID = 0;


    /* ERROR STRING */
    var $error;


    /******************************************************************************
     *                                                                              *
     *                                METODOS                                          *
     *                                                                              *
     ******************************************************************************/


    /**************************************************************** CONSTRUCTOR */

    function mysqldb_conexion($bd) {

        // Si NO llega un array de datos, veo si es un archivo.
        if ( !is_array($bd) ) {

            // Si me pasan un archivo de configuración alternativo, controlo que exista.
            if ($bd != NULL && !file_exists($bd)) {
                $this->error("[<b>mysqldb_conexion</b>] Error al construir objeto: El archivo de conexion (".$config_file.") no existe.");
                return false;

            } else {

                include_once($bd);
            }
        }
        
        // Cargo la configuración del servidor MySQL
        $this->BaseDatos = $bd['0'];
        $this->Servidor = $bd['1'];
        $this->Usuario = $bd['2'];
        $this->Clave = $bd['3'];
    }


    /**************************************************************** DESSTRUCTOR */

    function destroy() {

        // Nos aseguramos de haber cerrado la conexión a la BD
        $this->cerrar();

        // 'destruimos' el objeto
        settype(&$this, 'null');
    }


    /*
     * Un metodo simple para mostrar errores al usuario. Si no recibe argumento, 
     * simplemente muestra el contenido de $this->error. Caso contrario, carga 
     * $this->error con un string.
     *
      ******************************************************************************/

    function error() {

        switch (func_num_args()) {

            case 1:
                $this->error = func_get_arg(0);
            break;

            default:
                return $this->error;
            break;
        }
    }


    /*
     * Metodo para conectarse a la Base de Datos.
     * Devolvera "false" si la conexión falla por alguna razón, y guardará un 
     * mensaje de error en $this->error, el que puede ser mostrado con 
     * $this->error()
     *
      ******************************************************************************/

    function conectar(){

        // Si ya existe una conexión abierta al intentar conectar, la cerramos.
        if ($this->Conexion_ID != "0") {
            $this->error("[<b>mysqldb_conexion</b>] Error al conectar a la Base de Datos: Ya existe una conexión activa, cierrela antes de volver a conectar.");
            return false;
        }
        
        // Conectamos al servidor
        if ( !($this->Conexion_ID = @mysql_connect($this->Servidor, $this->Usuario, $this->Clave)) ) {
            $this->error("[<b>mysqldb_conexion</b>] Error al conectar a la Base de Datos:<br/> MySQL: [".mysql_errno()."] ".mysql_error()."<br/>");
            return false;
         }

        // Seleccionamos la base de datos
        if ( !(mysql_select_db($this->BaseDatos, $this->Conexion_ID)) ) {
            $this->error("[<b>mysqldb_conexion</b>] Error al conectar a la Base de Datos:<br/>MySQL: [".mysql_errno()."] ".mysql_error()."<br/>");
            return false;
        }

         // Si todo salió bien, retornamos el ID de conexión (lo que antes usabamos como $link)
        return $this->Conexion_ID;
    }

 

    /*
     * Cerrr la conexion a la BD.
     *
      ******************************************************************************/

    function cerrar() {
        if ( !(mysql_close($this->Conexion_ID)) ) {
            $this->error("[<b>mysqldb_conexion</b>] Error al cerrar conexión:<br/>MySQL: [".mysql_errno()."] ".mysql_error()."<br/>");
            return false;
        }

        return true;
    }

} // FIN de la clase  
   

CONSULTAS A LA BD

Código PHP:

  
<?php

class mysqldb_consulta {

    /* Variables asociadas a consultas */
    var $Consulta_ID;
    var $conexion;


    /* Flag para limpiar automaticamente los resultados cuando sea necesario */
    var $qflag = 0;


    /* String para almacenar mensajes de error */
    var $error;


    /******************************************************************************
     *                                                                              *
     *                                METODOS                                          *
     *                                                                              *
     ******************************************************************************/


    /**************************************************************** CONSTRUCTOR */

    /*
     * Recibimos una referencia hacia un objeto mysqldb_conexion.
     *
     ******************************************************************************/

    function mysqldb_consulta(&$conexion) {
        if ($conexion != "") { $this->conexion = &$conexion; }
    }

    /**************************************************************** DESSTRUCTOR */
    function destroy() {

        // Nos aseguramos de limpiar la memoria utilizada para almacenar recordsets
        $this->free();

        // 'destruimos' el objeto
        settype(&$this, 'null');
    }



    /************************************** RECIBIR / CARGAR VARIABLES "GLOBALES" */

    /*
     * Un metodo simple para mostrar errores al usuario. Si no recibe argumento, 
     * simplemente muestra el contenido de $this->error. Caso contrario, carga 
     * $this->error con un string.
     *
      ******************************************************************************/

    function error() {

        switch (func_num_args()) {

            case 1:
                $this->error = func_get_arg(0);
            break;

            default:
                return $this->error;
            break;
        }
    }


    /*
     * Este metodo accede a $this->Consulta_ID:
     *
     * A. Retorna el identificador de consulta si se pasa un comando de consulta
     *    como argumento y esta se realiza satisfactoriamente. Si la consulta 
     *    no se realiza satisfactoriamente devolverá "false".
     *
     * B. Retorna el identificador de consulta si no se le pasan argumentos.
     *
      ******************************************************************************/

    function goquery() {

        switch (func_num_args()) {

            case 1:
                $this->Consulta_ID = func_get_arg(0);

                if(!$this->Consulta_ID) {
                    return false;
                }

                return true;
                break;

            default:
                return $this->Consulta_ID;
            break;
        }
    }


    /*
     * Realizamos un query a la base de datos. Devolvemos "false" y cargamos un 
     * mensaje de error si la consulta no se realizó satisfactoriamente.
     *
     * Si la consulta se realiza de forma satisfactoria devuelve "true".
     *
      ******************************************************************************/

    function consulta($sql) {

        if ($this->conexion->Conexion_ID == 0) {
            $this->error("[<b>mysqldb_consulta</b>] Imposible realizar consulta, no se ha establecido aún una conexión MySQL.<br/>");
            return false;
        }

        // SI la consulta es de tipo SELECT y QFLAG está levantado, limpiamos
        // la memoria de la consulta anterior.

        if ( strtolower(substr($sql,0,6)) == "select") {

            if ($this->qflag == 1) {
                @mysql_free_result($this->Consulta_ID);
                $this->qflag = 0;

            } else {

                $this->qflag = 1;
            }
        }


        if ( !($this->goquery(@mysql_query($sql, $this->conexion->Conexion_ID)))) {
            $this->error("[<b>mysqldb_consulta</b>] Error al ejecutar SQL:<br/>MySQL : ".mysql_error()."<br/>");
            return false;
        }

        return true;
    }


    /*
     * Devuelve el la cantidad de registros afectados por un update
     *
      ******************************************************************************/
    function affected() {
    
        switch (func_num_args()) {

            case 1:
                $this->affected = func_get_arg(0);
                break;

            default:
                return $this->affected;
            break;
        }
    }


    /*
     * Devuelve el nombre de un campo de una consulta 
     *
      ******************************************************************************/

    function nombrecampo($numcampo) {
        return mysql_field_name($this->Consulta_ID, $numcampo);
    }


    /*
     * Devuelve el número de campos de una consulta
     *
      ******************************************************************************/

    function numcampos() {
        return mysql_num_fields($this->Consulta_ID);
    }


    /*
     * Devuelve el número de registros de una consulta 
     *
      ******************************************************************************/

    function numrows() {
        return mysql_num_rows($this->Consulta_ID);
    }


    /*
     * Devuelve un array con los registros obtenidos
     *
      ******************************************************************************/

    function get_array() {
        return mysql_fetch_array($this->Consulta_ID, MYSQL_ASSOC);
    }


    /*
     * Muestra una tabla con los resultados de la consulta.
     *
     * Este método está pensado solo para testear resultados de consultas.
     *
      ******************************************************************************/

    function debug_results() {
        echo "<table border=1>\n
            <tr>";
 

        // mostramos los nombres de los campos
        for ($i = 0; $i < $this->numcampos(); $i++){
            echo "<td><b>".$this->nombrecampo($i)."</b></td>\n";
        }

        echo "</tr>\n";
        // mostrarmos los registros

         while ($row = mysql_fetch_row($this->Consulta_ID)) {

            echo "<tr> \n";

            for ($i = 0; $i < $this->numcampos(); $i++){
                echo "<td>".$row[$i]."</td>\n";
            }

            echo "</tr>\n
            </table>";
        }
    }


    /*
     * Mueve el índice del identificador de query al siguiente registro.
     *
      ******************************************************************************/

    function seek($indice) {

        if ( !(mysql_data_seek($this->Consulta_ID, $indice))) {
            $this->error("[<b>mysqldb_consulta</b>] Error al intentar mover índice:<br/>MySQL: <b>[".mysql_errno()."]</b> ".mysql_error()."<br/>");
            return false;
        }

        return true;
    }


    /*
     * Limpiamos los resultados de una consulta
     *
      ******************************************************************************/

    function free() {

        if (qflag == 1) {

            if (! (@mysql_free_result($this->Consulta_ID))) {
                $this->error("[<b>mysqldb_consulta</b>]Error liberando identificador:<br/>MySQL: <b>[".mysql_errno()."]</b> ".mysql_error()."<br/>");
                return false;
            }

            $this->qflag = 0;

            return true;
        }
    }

} // FIN CLASE

?>   

[bulter]

Podrias hacer lo aun mejor por ejemlo aqui tengo una adaptador para SELECT de la base de datos:

Código PHP:

  <?php 
/** 
 * dGroup Framework 
 * 
 * @copyright   Copyright (c) 2007 dGroup Technologies 
 * @license     Виж license.txt 
 * @version     dGroup_Db_Adapter_Pdo_Select.php 0001 19-12-2007 14:42 (v0.0.1) 
 */ 
  
 require_once "Abstract.php"; 
  
 class dGroup_Db_Adapter_Pdo_Select{ 
    const DISTINCT     = 'distinct'; 
    const COLUMNS      = 'columns'; 
    const FROM         = 'from'; 
    const WHERE        = 'where'; 
    const GROUP        = 'group'; 
    const ORDER        = 'order'; 
    const LIMIT_COUNT  = 'limitcount'; 
    const LIMIT_OFFSET = 'limitoffset'; 
 
    protected $parts = array(self::FROM         => array(), 
                             self::DISTINCT     => false, 
                             self::WHERE        => array(), 
                             self::ORDER        => array(), 
                             self::LIMIT_COUNT  => null, 
                             self::LIMIT_OFFSET => null); 
     
    /** 
     * Where Bind Params 
     */          
    protected $_whereBindParam = array(); 
 
    /** 
     * PDO Object 
     */          
    protected $_connection; 
     
    protected $_distinct; 
     
    /** 
     * Взима текучия PDO адаптер 
     */          
    public function __construct($_connection){ 
        $this->_connection = $_connection; 
    } 
     
     /** 
     * Задава на заявката от къде трябва да избере данните. 
     *  
     * @param string|array $name Името на таблицата 
     * @param string|array $cols от кой редове да избира   
     * @throws  dGroup_Exception 
     * @return object                 
     */            
     
    public function from($name, $cols = "*"){ 
        return $this->_from($name, $cols); 
    }       
     
    private function _from($name, $cols){ 
        if(is_array($name)){ 
            $name = $this->parts[self::FROM]["table"] = implode(", ", $name); 
        }elseif(is_string($name)){ 
            $name = $this->parts[self::FROM]["table"] = $name; 
        }else{ 
            throw new dGroup_Exception("Таблиците трябва да бъдат записани в стринг или масив."); 
        } 
         
        if(is_array($cols)){ 
            $cols = $this->parts[self::FROM]["cols"] = implode(", ", $cols); 
        }elseif(is_string($cols)){ 
            $cols = $this->parts[self::FROM]["cols"] = $cols; 
        }else{ 
            throw new dGroup_Exception("Колоните трябва да бъдат записани в стринг или масив."); 
        } 
         
        return $this; 
    } 
     
    /** 
     * Задава на заявката, че трябва да избере само резултати който  
     * са различни. 
     *  
     * @param boolen $distinct (false - по подразбиране)     
     * @param string|array $cols полетата по който да търси разликата                
     */          
     
    public function distinct($distinct = false, $cols){ 
        $this->parts[self::DISTINCT] = (bool)$distinct; 
        if($cols){ 
            if(!is_array($cols)){ 
                $cols = array($cols); 
            } 
            $this->_distinct = implode($cols); 
        } 
         
        return $this; 
    } 
     
    /** 
     * Функцията where лимитира резултатите от базата данни, 
     * като показва определени данни който се изискват при  
     * извеждането от базата данни. 
     * Функцията има 1 задължителен параметър който е стринг 
     * и показва какво точно се търси. 
     * Пр: $dGroup->select()->from("dGroup", "*")->where("index = ?", 1) 
     * В този случей резултатите който ше бъдат изведини съдържат 
     * поле index със стойност 1. Зададените параметри за съвместимост 
     * нямат ограничен брой. 
     * Параметрите за съвместимост трябва да са зададени в същия ред  
     * както и при самата клауза. 
     * Пр: where("index = ? and title = ?", "dGroup", 1) 
     * В този случей ще се търси за index = dGroup и title = 1, а не за 
     * index = 1 и title = dGroup 
     * Ако вече е зададена 1 WHERE клауза се задава още една добавяйки 
     * AND. 
     * Пр: where("index = ?", 1)->where("title = ?", "dGroup")   
     *  
     * @param string $value 
     * @return: object                                                                                              
     */          
     
    public function where($value){ 
        if (func_num_args() > 1) { 
            $val = array(); 
            for($i=0;$i<=func_num_args()-1;$i++){ 
                $val[] = func_get_arg($i); 
            } 
            $value = $this->_where($value, $val); 
        } 
         
        if ($this->parts[self::WHERE]) { 
            $this->parts[self::WHERE][] = "AND ($value)"; 
        } else { 
            $this->parts[self::WHERE][] = "($value)"; 
        } 
         
        return $this; 
    } 
     
    /** 
     * Функцията _where замества всички ? със 
     * placeholder.       
     * 
     * @param string $value е неконфигурираната WHERE клауза      
     * @param array $val съдържа стойностите за който трябва да се търси в базата данни. Те също се използват за създаването на placeholder като пред тях се добавя двуеточие ":"     
     *                         
     * @return: string $_where                          
     */               
     
    public function _where($value, $val){ 
        $_keys = explode("?", $value); 
        $_where = ""; 
        for($i=0;$i<=count($_keys)-2;$i++){ 
           $_where .= $_keys[$i].":".$val[$i+1]; 
           $this->_whereBindParam[] = $val[$i+1]; 
            
        } 
 
        return $_where; 
    } 
     
    /** 
     * Функцията настройва параметрите при WHERE клаузата 
     *  
     * @param object $stmt           
     */          
     
    protected function _bind($stmt){ 
        $params = count($this->_whereBindParam); 
        for($i=0; $i<=$params-1; $i++){ 
            $stmt->bindParam(":".$this->_whereBindParam[$i], $this->_whereBindParam[$i]); 
        } 
    } 
     
    /** 
     * Настройва реда при който да се извежда информацията. 
     * Посоката по подразбиране е DESC. 
     *  
     * @param string|array $order  
     * @return Object                    
     */          
     
    public function order($order){ 
        if(!is_array($order)){ 
            $order = array($order); 
        } 
        foreach ($order as $value) { 
            $direction = "DESC"; 
            if (preg_match('/(.*)\s+(ASC|DESC)\s*$/i', $value, $result)) { 
                $value = trim($result[1]); 
                $direction = $result[2]; 
            } 
        } 
         
        $this->parts[self::ORDER][] = array($value, $direction); 
        return $this; 
    } 
     
    /** 
     * Настройва лимита на върнатите резултати. 
     *  
     * @param   int $count   
     * @param   int $offset              
     * @return  mixed 
     */          
     
    public function limit($count = null, $offset = null){ 
        $this->parts[self::LIMIT_COUNT]  = (int)$count; 
        $this->parts[self::LIMIT_OFFSET] = (int)$offset; 
        return $this; 
    } 
     
    /** 
     *  Слага кавички на стойноста му и я връща 
     *   
     * @param string $value           
     */          
    protected function quoteIdent($value){ 
        return ('"' . str_replace('"', '""', $value) . '"'); 
    } 
     
    /** 
     * Сглобява заявката след което я изпраща. 
     * Връщания резултат са резултатите взети от базата данни. 
     *  
     * @throws  dGroup_Exception 
     * @return Object                
     */          
    public function fetchAll(){ 
        $sql = "SELECT"; 
        if ($this->parts[self::DISTINCT]) { 
            $sql .= "\nDISTINCT ".$this->_distinct."\n\t"; 
        } 
         
        if($this->parts[self::FROM]){ 
            $sql .= "\n".$this->parts[self::FROM]["cols"]; 
            $sql .= "\nFROM\n\t"; 
            $sql .= "\n".$this->parts[self::FROM]["table"]."\n\t"; 
        } 
         
        if($this->parts[self::WHERE]){ 
            $sql .= "\nWHERE\n\t".implode("\n\t", $this->parts[self::WHERE]); 
        } 
         
        if ($this->parts[self::ORDER]) { 
            $sql .= "\nORDER BY\n\t"; 
            $l = array(); 
            foreach ($this->parts[self::ORDER] as $vals) { 
                if (is_array($vals)) { 
                    $l[] = $vals[0] . ' ' . $vals[1]; 
                } else { 
                    $l[] = $vals; 
                } 
            } 
            $sql .= implode(",\n\t", $l); 
        } 
         
        $count  = ""; 
        $offset = ""; 
        if($this->parts[self::LIMIT_OFFSET]){ 
            $offset = (int)$this->parts[self::LIMIT_OFFSET]; 
             
            //Това ще зададе максималната стойност която цяло число може да съдържа в РНР 
            $count = intval(9223372036854775807); 
        } 
         
        if($this->parts[self::LIMIT_COUNT]){ 
            $count = (int)$this->parts[self::LIMIT_COUNT]; 
        } 
         
        if($this->parts[self::LIMIT_COUNT] || $this->parts[self::LIMIT_OFFSET]){ 
            $sql .= " LIMIT $count"; 
            if ($offset > 0) { 
                $sql .= " OFFSET $offset"; 
            } 
        } 
 
        //Прави опит за изпращане и взимане на резултатите от заявката 
        try{ 
            $stmt = $this->_connection->prepare($sql); 
            $stmt->setFetchMode(PDO::FETCH_OBJ); 
    
            /** 
             * Проверяваме дали има WHERE клауза и ако има такава 
             * Викаме функцията _bind която ще зададе параметрите 
             */                         
            if($this->parts[self::WHERE]){ 
                $this->_bind($stmt); 
            } 
            $stmt->execute(); 
            $result = $stmt->fetchAll(); 
        }catch(PDOException $e){ 
            throw new dGroup_Exception($e->getMessage()); 
        } 
         
        return $result; 
    } 
 } 
?>   

Uso PDO .
Aun le falta muchisimo por hacer.

[Computer XTress]

Hola Bults, gracias por tu respuesta.

Me pregunto... ¿cual sería el objeto y las ventajas de usar este adaptador?

Saludos

[bulter]

La ventaja es que hace un SELECT seguro y el SQL query se forma como es debido de formar se, y ademas usa placeholders y con ellos la seguridad sube a tope:

Código PHP:

  $db->select()->from("table")->where("username = ? and password = ?", $username, $password);  
   

Esto es todo lo que tienes que hacer para validar un usuario, no tienes que filtrar las variables $username y $password, no tienes que hacer nada mas. La funccion where automatica mente cambia los "?" con su variable filtrada.

[Computer XTress]

ajá... veo, esta bueno esto. Yo habia visto adaptadores pero solo para cambiar ó mas bien adaptar uan clase a diferentes motores de BD por ejemplo.

La voy a estudiar un poco más, grax por la data :)

saludos

[bulter]

Esto tambien ira con diferentes motores pero ahora no tengo tiempo para hacer lo . :)

Saludos bulter

[pragone]

Hola,

bulter, me gusta mucho la sintaxis con la que queda (aunque no puedo decir lo misma de los comentarios ), pero no has pensado en agregarle una función left_join que reciba la tabla y la condición de unión?... por lo que pude ver sólo puedes hacer productos cartesianos.

Computer Xtress, creo que lo que comentó GatorV es lo apropiado (así funciona de hecho la clase de bulter.... el método select no pertenece a la clase que puso sino a la clase de conexión a la base de datos).
Si me permites hacerte una recomendación adicional, me gusta siempre que hago una clase de acceso a BD que tenga built-in la capacidad de hacer accesos diferentes para lectura y escritura.

Aquí te dejo un ejemplo de clase que utilizo en PHP5DBObject... un framework para ActiveRecord en el que estoy trabajando, puedes ver un ejemplo del concepto en http://pragone.com/proyectos/php5dbo...ork-en-php5/10 ... se monta sobre MDB2 de PEAR:

Código PHP:

  <?php 
/* 
 
PHP5DBObject is a PHP5 Framework for easing the access to the DB from your application 
Copyright (C) 2007  Paolo Ragone 
 
This file is part of PHP5DBObject. 
 
PHP5DBObject is free software: you can redistribute it and/or modify 
it under the terms of the GNU Lesser General Public License as published by 
the Free Software Foundation, either version 3 of the License, or any later version. 
 
PHP5DBObject is distributed in the hope that it will be useful, 
but WITHOUT ANY WARRANTY; without even the implied warranty of 
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
GNU Lesser General Public License for more details. 
 
You should have received a copy of the GNU Lesser General Public License 
along with PHP5DBObject.  If not, see <http://www.gnu.org/licenses/lgpl.html>. 
 
 
 */ 
 
/** 
 * This class implements a convenience method to access the DB and perform queries. 
 * The main benefit of this class is that it already takes care of using (optionally) two different connections: one for all read-related queries and one for manipulation/write queries. 
 *  
 * Using a class like this is a good idea for some reasons: 
 * - Scalability: Probably the first DB-related scalability action you'll take is to use a master-slave replicated environment, when that time comes you'll regret not having separated all read from write queries. 
 * - Security: One good way to achieve the point above is to use different users/passwords to access the DB. This also allows you to (under certain circumstances) have better security. 
 * 
 * Possible ways to enhance: 
 * - Create options: 
 *   - convert dates... to automagically convert  
 *     date, time and timestamp to unix timestamp 
 * @package PHP5DBObject 
 * @subpackage db 
 * @version 1.0 
 * @author Paolo Ragone <[email protected]> 
 * @link http://pragone.com -> Author's Home Page 
 * @copyright Copyright (c) 2007, Paolo Ragone 
 * @license http://opensource.org/licenses/lgpl-license.php GNU Lesser General Public License 
 * filesource 
 */ 
 
 
require_once 'MDB2.php'; 
 
/** 
 * This class implements a convenience method to access the DB and perform queries. 
 * The main benefit of this class is that it already takes care of using (optionally) two different connections: one for all read-related queries and one for manipulation/write queries. 
 *  
 * Using a class like this is a good idea for some reasons: 
 * - Scalability: Probably the first DB-related scalability action you'll take is to use a master-slave replicated environment, when that time comes you'll regret not having separated all read from write queries. 
 * - Security: One good way to achieve the point above is to use different users/passwords to access the DB. This also allows you to (under certain circumstances) have better security. 
 * 
 * @package PHP5DBObject 
 * @subpackage db 
 *  
 */ 
class RWDBAccess implements DBManager { 
     
    /** 
     * The MDB2 read-only connection. In case only a read-write connection was specified, this will reference the same $conn_w connection 
     * @var MDB2_Connection 
     * @see RWDBAccess::$conns_w 
     */ 
    protected $conn_r = null; 
     
    /** 
     * The MDB2 write-only connection 
     * @var MDB2_Connectin 
     */ 
    protected $conn_w = null; 
     
    /** 
     * Constructor method for the class. It creates "lazy connections" to the DB (connections that are actualy established only when the first query is executed). It expects an associative array with some of the following keys: 'ro' (read only), 'wo' (write only) and/or rw (read write). Which must contain the dsn's or configuration arrays expected by MDB2 factory method. 
     * You should provide at least a connection for read access and one for write access, this can be either: ro & rw, rw & wo, ro & rw, only a rw. 
     *  
     */ 
    function __construct($dsn) { 
        if (isset($dsn['wo'])) $dsn_w = 'wo'; 
        elseif (isset($dsn['rw'])) $dsn_w = 'rw'; 
        else throw new RWDBAccessException("You must supply a valid DSN with write access (either 'wo' or 'rw')"); 
         
        if (isset($dsn['ro'])) $dsn_r = 'ro'; 
        elseif (isset($dsn['rw']) && is_array($dsn['rw'])) $dsn_r = 'rw'; 
        else throw new RWDBAccessException("You must supply a valid DSN with read access (either 'ro' or 'rw')"); 
         
        $temp =& MDB2::factory($dsn[$dsn_w]); 
        if (PEAR::isError($temp)) throw new RWDBAccessException('Error creating write connection to the database, error: ' . $temp->getMessage()); 
        $this->conn_w =& $temp; 
         
        if ($dsn_r != $dsn_w) { 
            $temp =& MDB2::factory($dsn[$dsn_r]); 
            if (PEAR::isError($temp)) throw new RWDBAccessException('Error creating read connection to the database, error: ' . $temp->getMessage()); 
            $this->conn_r =& $temp; 
        } else { 
            $this->conn_r =& $this->conn_w; 
        } 
        $this->conn_r->setFetchMode(MDB2_FETCHMODE_ASSOC); 
    } 
     
    function __destruct() { 
        if (MDB2::isConnection($this->conn_w)) $this->conn_w->disconnect(); 
        $this->conn_w = null; 
        if ($this->conn_r != null && MDB2::isConnection($this->conn_r)) $this->conn_r->disconnect(); 
        $this->conn_r = null; 
    } 
     
    /** 
     * This function returns one row from a select query. 
     */ 
    public function &getOneRow($sql, $params, $data_types = null) { 
        if (empty($params)) { 
            $result = $this->conn_r->query($sql); 
        } else { 
            $st = $this->conn_r->prepare($sql); 
            $result = $st->execute($params); 
        } 
        $result->setResultTypes($data_types); 
        if (PEAR::isError($result)) throw new RWDBAccessException("Error executing query:\n$sql\nOn connection: $connection\nError:" . $result->getMessage()); 
         
        $row = $result->fetchRow(); 
        $result->free(); 
        return $row; 
    } 
 
    public function &getMultipleRows($sql, $params, $data_types = null) { 
        if (empty($params)) { 
            $result = $this->conn_r->query($sql, $data_types); 
        } else { 
            $st = $this->conn_r->prepare($sql, $data_types); 
            $result = $st->execute($params); 
            $st->free(); 
        } 
        if (PEAR::isError($result)) throw new RWDBAccessException("Error executing read query:\n$sql\nError:" . $result->getMessage()); 
         
        $res = array(); 
        while ($row = $result->fetchRow()) { 
            $res[] = $row; 
        } 
        $result->free(); 
        return $res; 
    } 
     
    public function execute($sql, $params) { 
        if (empty($params)) { 
            $result = $this->conn_w->exec($sql); 
        } else { 
            $st = $this->conn_w->prepare($sql, null, MDB2_PREPARE_MANIP); 
            $result = $st->execute($params); 
            $st->free(); 
        } 
        if (PEAR::isError($result)) throw new RWDBAccessException("Error executing query:\n$sql\nOn connection: $connection\nError:" . $result->getMessage()); 
        return $result; 
    } 
 
    public function execute_r($sql, $params) { 
        if (empty($params)) { 
            $result = $this->conn_r->exec($sql); 
        } else { 
            $st = $this->conn_r->prepare($sql, null, MDB2_PREPARE_MANIP); 
            $result = $st->execute($params); 
            $st->free(); 
        } 
        if (PEAR::isError($result)) throw new RWDBAccessException("Error executing query:\n$sql\nOn connection: $connection\nError:" . $result->getMessage()); 
        return $result; 
    } 
 
    public function insert($sql, $params) { 
        if (empty($params)) { 
            $result = $this->conn_w->exec($sql); 
        } else { 
            $st = $this->conn_w->prepare($sql); 
            $result = $st->execute($params); 
            $st->free(); 
        } 
        if (PEAR::isError($result)) throw new RWDBAccessException("Error executing query:\n$sql\nOn connection: $connection\nError:" . $result->getMessage()); 
        return $this->conn_w->lastInsertID(); 
    } 
} 
 
class RWDBAccessException extends Exception { 
    public function __construct($message) { 
        parent::__construct($message, 0); 
    } 
     
    public function __toString() { 
        return __CLASS__ . ": {$this->message}\n"; 
    } 
} 
 
?>   

[bulter]

Paragone como dije anteriormente me falta mucho for hacer ;) y no solo inter join si no muchas cosas mas ;) Pero ahora tengo otras cosas por hacer ;)

aunque no puedo decir lo misma de los comentarios

Ya supongo

Conexion:

Mysql.php

Código PHP:

  <?php
/**
 * dGroup Framework
 *
 * @copyright    Copyright (c) 2007 dGroup Technologies
 * @license      Виж license.txt
 * @version      dGroup_Db_Adapter_Mysql.php 0001 18-12-2007 23:55 (v0.0.1)
 */

/**
 * dGroup_Exception
 */
 require_once "Exception.php";
 
/**
 * dGroup_Db_Adapter_Pdo_Abstract
 */
 require_once "Abstract.php";
 
 /**
 * dGroup_Db_Adapter_Pdo_Abstract
 */
 require_once "Select.php";
 
 class dGroup_Db_Adapter_Pdo_Mysql extends dGroup_Db_Adapter_Pdo_Abstract{
    private $_connect;
    public $_access;
    
    /**
     * Тази функция въвежда информация в базата данни.
     * 
     * @param string $into (Таблицата където ще се въвежда)
     * @param  array $values (Колоните в който ще се въвежда и техните стойности)
     * @throws  dGroup_Exception
     * @return int (Броя на засегнатите редове)                    
     */         
    public function insert($into, $values){
        if(!is_array($values)){
            throw new dGroup_Exception("Стойностите за въвеждане и техните полета трябва да бъдат записани в масив");
        }
        
        if(!is_string($into)){
            throw new dGroup_Exception("Името на таблицата трябва да бъде стринг.");
        }
        
        //Въвеждане в базата данни
        $result = $this->_insert($into, $values);
        
        return $result;
    }
    
    public function select(){
        return new dGroup_Db_Adapter_Pdo_Select($this->_connection);
    }
 }
?>   

Abstract.php

Código PHP:

  <?php
/**
 * dGroup Framework
 *
 * @copyright   Copyright (c) 2007 dGroup Technologies
 * @license     Виж license.txt
 * @Version     dGroup_Db_Adapter_Pdo_Abstract.php 0001 18-12-2007 23:56 (v0.0.1)
 */
 
 require_once "Exception.php";
 
 abstract class dGroup_Db_Adapter_Pdo_Abstract{
    
    /**
     * Връзка с базата данни
     */
    public $_connection;
    
    /**
     * PDO тип.
     */
    private $_pdoType = "mysql";
    
    /**
     * Заявка към базата данни
     */
    private $_query;
    
    /**
     * Задава конфигурацията за влизане в базата данни
     * и прави опит за свързване към нея.
     * 
     * @param array $_config (Потребителско име, парола, хост и името на базата данни.)     
     *           
     */         
    public function __construct(array $_config = array()){
        $this->_config = $_config;
        $this->_connect();
    }
    
    /**
     * Създаване на PDO DSN за адаптера.
     *
     * @param array $_config (Данните за вход към базата данни)      
     * @return string
     */
    
    private function _dsn(){
        $dsn = $this->_config;
        
        //Не предаваме потребителското име и парола
        unset($dsn['username']);
        unset($dsn['password']);
        
        foreach ($dsn as $key => $val) {
            $dsn[$key] = "$key=$val";
        }
        
        return $this->_pdoType . ':' . implode(';', $dsn);
    }
    
    /**
     * Създаване на PDO обект и връзка към базата данни.
     *      
     * @param   array $_config (Данните за вход към базата данни)       
     * @throws  dGroup_Exception
     * @return  void
     */
    
    public function _connect(){
    
        // Ако вече се е създала връзката няма смисъл да се създава на ново
        if($this->_connection){
            return;
        }
        
        //Взимане на dsn
        $dsn = self::_dsn();
        
        //Проверка дали PDO разширението е заредено
        if (!extension_loaded('pdo')) {
            throw new dGroup_Exception('PDO разширението не е намерено');
        }
        
        //Проверка дали PDO драйвърът е зареден
        if (!in_array($this->_pdoType, PDO::getAvailableDrivers())) {
            throw new dGroup_Exception($this->_pdoType . ' драйверът не е инсталиран.');
        }
        
        //Опит за връзка с базата данни
        try {
        
            $this->_connection = new PDO($dsn, $this->_config["username"], $this->_config["password"]);
            $this->_connection->setAttribute(PDO::ATTR_EMULATE_PREPARES, TRUE);
            $this->_connection->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

        } catch (PDOException $e) {
        
            throw new dGroup_Exception($e->getMessage(), $e);
            
        }
    }
    
    /**
     * Затваряне на връзка с базата данни
     *
     * @return void
     */
    
    public function closeConnection(){
        $this->_connection = null;
    }
    
    /**
     * Въвеждане в базата данни
     * Тази функция разделя масива такаче индекса му става името на полето
     * където ще се въвежда информацията, а неговата стойност ще бъде
     * стойноста която трябва да бъде въведена
     * 
     * @param string $table (Името на таблицата където ще се въвеждат данните)
     * @param array $bind (Имената на полетата и стойностите)                         
     * @return int (Броя на засегнатите редове)
     */              
    
    public function _insert($table, array $bind){
        if(!is_array($bind)){
            throw new dGroup_Exception("За да въведете информация в базата данни трябва
                                        да запишете имената на полетата и техните стойности
                                        във масив.");
        }
    
        $cols = array();
        $vals = array();
        
        /**
         * Записваме ключа и неговата стойност в два различни масива
         * който ще представляват полетата и техните стойности.
         * При всяко предаване на стойноста на полета в масива
         * той се филнтрира и му се добавят кавички.
         */                                   
        foreach($bind as $col => $val){
            $cols[] = $col;
            $vals[] = "'".htmlspecialchars(addslashes(trim($val)))."'";
        }
        
        $this->_query = "INSERT INTO ". $table. ' (' . implode(', ', $cols) . ') '
                                      . 'VALUES (' . implode(', ', $vals) . ')';
        
        $result = $this->query($this->_query);
        return $result;
    }
    
    /**
     * Тази функция подготвя заявката за изпълнение
     * 
     * @param:  string $sql (Заявката към базата данни)         
     * @throws  dGroup_Exception
     * @return  mixed 
     */         
    
    private function _prepare($sql){
        try {
            $stmt = $this->_connection->prepare($sql);
        } catch (PDOException $e) {
            throw new dGroup_Exception($e->getMessage());
        }
        
        return $stmt;
    }
    
    /**
     * Пращане на заявката към базата данни
     * 
     * @param   string $sql (Заявката към базата данни)   
     * @return  int
     */         
    
    public function query($sql){
        $stmt = $this->_prepare($sql);
        $stmt->execute((array)$sql);

        return $this->rowCount($stmt);
    }
    
    /**
     * Тази функция брой колко бров колони са били засегнати при 
     * Добавянето, Триенето или Обновяването на таблицата, от базата данни.
     * 
     * @param dGroup_Statement $stmt
     * @throws  dGroup_Exception
     * @return int (Номера на всички засегнати редове)        
     */         
    public function rowCount($stmt){
        try {
            return $stmt->rowCount();
        } catch (PDOException $e) {
            throw new dGroup_Exception($e->getMessage());
        }
    }
 }
?>   

Exception.php

Código PHP:

  <?php
/**
 * dGroup Framework
 *
 * @copyright   Copyright (c) 2007 dGroup Technologies
 * @license     Виж license.txt
 * @Version     Exception.php 0001 %Date% %Time% (v0.0.1)
 */
 
class dGroup_Db_Exception extends Exception
{}
?>   

Estos dos tan poco estan terminados pero es algo de que podeis aprovechar ;)
Claro no es todo hay un archivo mas con el que trabaja todo el framework en el que estoy trabajando :)

[Computer XTress]

Creo que voy a armar un objeto que realice la conexion e instancie a su vez objetos que puedan realizar consultas.

Por lo que veo ustedes trabajan con frameworks, igualmente entiendo las funcionalidades...

Gracias por la info, algo bueno de todo esto voy a sacar ;)

saludos!

edu

[enriqueplace]

Iniciado por Computer XTress

Enrique:

Claro que no soy un experto, está claro que estoy aprendiendo (no se si lo aclaré arriba o no) y les pido consejos para fortalecer la teoría que vengo leyendo. Sobre UML me pareció muy bueno, no le habia dado tanta bolilla antes pero voy a seguir leyendo al respecto. Gracias.

Tú preguntas, nosotros te respondemos. Nadie asume que eres experto, pero te estoy recalcando tu debilidad evidente para que la soluciones.

Iniciado por Computer XTress

Si supieras de algun TIP que puedas darme como para que yo vaya a investigar, te lo agradecería también.

Repasar nuevamente POO, no puedes argumentar que es un "problema" que estás usando objetos dentro de objetos, cuando conceptualmente es básico.

Iniciado por Computer XTress

Con respecto a POO no creas que soy un total ignorante, me empeño mucho en leer y estudiar y comprendo esos conceptos que nombras. Por supuesto, no con la misma profundida que vos ya que sos alguien mucho más experimentado, pero no creas que armo clases con funciones y luego uso asi mis objetos. Enserio, no soy tan tonto :)

Nunca dije que lo fueras, pero nuevamente, por las dudas que planteas (como la mayoría que dice saber de POO cuando se lo recalca) es conveniente que vuelvas a repasar los conceptos (y eso no debería ser ninguna ofensa para nadie).

Iniciado por Computer XTress

La idea de este post es, en parte, es ir encontrando algunos hilos de los cuales empezar a tirar. La teoría es muy linda pero a la hora de hacer la práctica las cosas se nos complican un poco a los principiantes!

Mm.... eres un poco terco , justamente, lo que veo es que estás fallando en la teoría y haciendo pruebas sin base solida.

PD: en lo personal me considero "el experto más ignorante" y nunca dejo de ir a los manuales una y otra vez, y me equivoco también en tonterías, pero trato de cometer siempre "errores nuevos".

[Computer XTress]

A ver, no quiero terminar dando una charla de cómo se hacen las cosas, pero estas confundido en tu forma de encarar esta clase de situaciones.... pude haber dicho lo que para vos es un disparate... pero aún asi, seguimos en la misma, al iniciar en algo uno siempre dice disparates

¿Acaso yo vine aca a decir "Hola soy un genio de los objetos y quiero que me digan que le falta a mi modelo para ser aún más perfecto".. ?

no, lo pregunte humildemente, contando que estaba empezando hace poco y venia leyendo mientras programaba


En mi opinion creo que deberías evaluar el contenido y el propósito real de tus respuestas, ya ves, los demas dieron buena ayuda y vos solo diste tu nota de experto crítico... para mi no tiene sentido.


En fin, todo lo que vos decis que tengo que hacer "LEER Y REPASAR" yo ya lo se y lo hago... la próxima intentá postear algo que me deje más ayuda..


bye! :)

eD

[enriqueplace]

Bien, repasemos entonces: por favor, relee conceptos sobre POO porque la afirmación que haces sobre el uso de objetos es, justamente, la razón de la programación orientada a objetos.

En particular, las relaciones "asociación" y "dependencia", el concepto de "composición" ("los objetos se componen por otros objetos") y con especial énfasis en "principios de diseño orientado a objetos" (google), que te permitirán visualizar mejor cómo enfrentar un problema de diseño.

Iniciado por Computer XTress

A ver, no quiero terminar dando una charla de cómo se hacen las cosas, pero estas confundido en tu forma de encarar esta clase de situaciones.... pude haber dicho lo que para vos es un disparate... pero aún asi, seguimos en la misma, al iniciar en algo uno siempre dice disparates

¿Acaso yo vine aca a decir "Hola soy un genio de los objetos y quiero que me digan que le falta a mi modelo para ser aún más perfecto".. ?

no, lo pregunte humildemente, contando que estaba empezando hace poco y venia leyendo mientras programaba


En mi opinion creo que deberías evaluar el contenido y el propósito real de tus respuestas, ya ves, los demas dieron buena ayuda y vos solo diste tu nota de experto crítico... para mi no tiene sentido.


En fin, todo lo que vos decis que tengo que hacer "LEER Y REPASAR" yo ya lo se y lo hago... la próxima intentá postear algo que me deje más ayuda..


bye! :)

eD

[Computer XTress]

Entiendo el punto. Voy a hacer enfasis en las temáticas que me sugerís expandir más.

Disculpa por el carácter de mi respuesta, la verdad ayer no tuve un buen día y tal vez fui sobre-reaccioné un poco.

Te dejo un saludo y gracias,

edu.

[enriqueplace]

Disculpas aceptadas, así da gusto discutir y poder cambiar de opinión

Te paso un link sobre principios de diseño (sorry la "auto-publicidad", tengo en mi propio blog un resumen de varios puntos) y en particular, ya que me ha servido mucho para entender cuando se está diseñando mal (pregunta recurrente, no creo que exista una respuesta única) es sobre refactoring: tienes una lista de mecanismos para corregir malos diseños, los cuales no se pueden aplicar todos uno detrás de otro (ya que muchos se anulan entre sí), solo sirven de guía para corregir nuestro código.

Un ejemplo: Extract Class versus Inline Class

Muy didácticos.

Iniciado por Computer XTress

Entiendo el punto. Voy a hacer enfasis en las temáticas que me sugerís expandir más.

Disculpa por el carácter de mi respuesta, la verdad ayer no tuve un buen día y tal vez fui sobre-reaccioné un poco.

Te dejo un saludo y gracias,

edu.

[Blade_Stom]

La verdad es que yo primero me pondría a mirar un poquito de UML xo bueno para ayudarte se me ha ocurrido que seguramente la clase esa de seguridad, como la vas a usar en muchos sitios.........deberías acerlo mediante herencia. Es decir, la clase esa de consultas a la base de datos seguramente tendra metodos que hagan uso del objeto ese REGEX.......no lo veo muy util.....veo mas util que hagas una clase seguridad y que la clase consulta de bases de datos hereda esos metodos de seguridad.

Luego supongo que tendras mas clases que hagan uso de esa clase seguridad.....pues lo mismo ....que hereden sus metodos.

Pero todo esto es muy subjteivo ya que imaginate que la clase SEGURIDAD tiene 100 metodos (espero que no xD) y que la clase consultaBD solo ace uso de 1 .......pues no te vendria nada bien hacer herencia ya que en cuanto crees un objeto miConsultaBD....estarías ocupando o reservando memoria para todo la clase ConsultaBD + para la clase heredada (SEGURIDAD).

Por ultimo comentar que a dia de hoy, (siempre dependiendo del uso que le des), no veo muy logico el hacer tanta clase para consultas BD ......ya que usando la clase "nueva" de php mysqli.......ya haces conexiones a la BD mediante orientacion a objetos........entonces yo pienso que las cosas que ya te dan medio hechas.......no hace falta hacerlas de nuevo.......
aunque en el caso de que necesites muchos metodos tuyos propios a la hora de hacer consultas, lo que puedes hacer es hacer una clase como la que tienes de ConsultasBD pero heredando la clase mysqli y añadiendo tus metodos propios(pero esta es solo mi recomendacion).........si alguno de ustedes no esta de acuerdo.......por favor expongan sus opiniones....




uN SALUDO.....y espero que te haya servido

[Computer XTress]

Blade gracias por responder.

Está bueno lo que propones de que la clase BD herede de la de seguridad. La mayoria de metodos de la clase Regex en realidad apuntan a comprobar strings que recibe el objeto de consultas, para "chequear" que sea algo válido y no puedan inyectar por ejemplo.

Voy a analizarlo bien, creo que lo que propones es una muy buena idea y tal vez podria modificar un poco la cuestión como para que se herede.

GRACIAS !

Con respecto a UML... estoy leyendo hace un par de días, la verdad me esta aclarando muchisimo las cosas! :)

Ahora mismo me voy a poner a ver sobre mysqli... a ver de que se trata...

Otro tema, volviendo a las regex.. en PHP5 veo que la mayoria usa filter_input() y funciones del estilo... esta todo mucho más simplificado, voy a tener que actualizar mi clase :P


Saludos y gracias!!