ORM casero creado desde cero

[paloto]

Hola.

He estado trabajando en un ORM casero para conectar Php con MySql. Sus funciones son muy básicas (Select, Update, Insert, Delete, transacciones, etc.) pero puede ser interesante para alguien que como yo hasta hace poco, mezclaba código PHP con consultas Sql.

La explicación del ORM se encuentra en el blog de desarrollo del juego de Balonmano Online que estoy construyendo ( http://blog.bmtotal.net ) y la entrada concreta (parte de ella) la transcribo a continuación, por supuesto aquellos que puedan aportar alguna mejora o sugerencia que lo hagan, se lo agradezco, y a los que les parezca interesante pueden utilizar este código libremente.

-----------------------------------------------------------------------------------------

Para la elaboración de este ORM he creado las siguientes clases:
elemento: Clase de la que heredarán todas las que necesiten interactuar con la base de datos
Conexion: Clase encargada de establecer la conexión con Mysql (enviar, consultas, abrir conexion, etc.)
CondicionWhere: Clase que sirve para definir las condiciones de una consulta de selección, edición o borrado, es decir, definir los valores del "WHERE" de mysql.
CampoValor: Clase muy simple con dos propiedades; campo y valor. Sirve para pasar a las consultas de edición e inserción con la asignación de valores por campo.

Vamos a explicar las clases de una en una, para que quede mas claro, con ejemplos de código PHP.

Conexión
Esta clase se encarga de abrir la conexión con la base de datos y de enviar las consultas que le pasemos. La clase abre la conexión en el constructor y lo hace hacia la base de datos por defecto. Si queremos conectarnos con otra base de datos simplemente debemos pasarle los parametros de "servidor", "base_de_datos" y "password". El código php de la clase "Conexion" queda así:

Código php:

class Conexion {
 
//++++++++++++++++++
//Funciones de conexion
//++++++++++++++++++
 
function Conexion($servidor , $base_de_datos, $password) {
 
// Comprobamos si se han pasado parámetros, y si no se ha hecho, se definen los predeterminados
 
if ($servidor==null && $base_de_datos==null && $password==null){
    $servidor="Servidor";
    $base_de_datos="Nombre_Base_De_Datos";
    $password="Contraseña";
}
 
// Se intenta conectar a la base de datos, y si no se puede captura la excepcion y muestra el mensaje de error.
try {
    mysql_connect($servidor , $base_de_datos, $password);
}
catch (Exception $er){
    print("ERROR: " + $er);
}
}
 
// La siguiente función es la que envía las consultas a la base de datos. Ocurre lo mismo que en la anterior:
// Si se le pasa la base de datos como parametro lo envia a esa, si no, a la prederminada
 
public function Consulta($sql, $base_de_datos){
 
if ($base_de_datos==null){
    $base_de_datos="Nombre_Base_De_Datos";
}
 
if (! $res=mysql_db_query($base_de_datos, $sql)){
    echo mysql_error();
    exit;
}
return $res;
}
 
//A continuacion se muestran las funciones de transacciones, que lo que hacen es enviar consultas simples para iniciar, terminar e interrumpir transacciones.
 
public function iniciaTransaccion($base_de_datos){
 
if ($base_de_datos==null){
    $base_de_datos="Nombre_Base_De_Datos";
}
mysql_db_query($base_de_datos, "BEGIN;");
}
 
public function finalizaTransaccion($base_de_datos){
if ($base_de_datos==null){
    $base_de_datos="Nombre_Base_De_Datos";
}
mysql_db_query($base_de_datos, "COMMIT;");
}
 
public function interrumpeTransaccion($base_de_datos){
if ($base_de_datos==null){
    $base_de_datos="Nombre_Base_De_Datos";
}
mysql_db_query($base_de_datos, "ROLLBACK;");
}
 
}
 

Y así queda la clase Conexion.

[paloto]

A continuación, por orden de importancia, habría que explicar la clase "elemento", pero voy a hacerlo antes con "CampoValor" y "CondicionWhere", pues son más sencillas y se utilizan en la clase "elemento" por lo que será más fácil entenderla una vez explicadas estas.

CampoValor
Clase muy sencilla que define un tipo de objeto con dos propiedades: campo y valor.

Código php:

class CampoValor {
     public $campo;
     public $valor;
 
     function CampoValor($campo, $valor){
          $this->campo=$campo;
          $this->valor=$valor;
     }
}
 

CondicionWhere
Esta es una clase también bastante sencilla con dos parámetros llamados (en un exceso de creatividad) "parametro1", "parametro2" y un tercero llamado "operador". Esta función se encarga de definir las condiciones "WHERE" para las consultas. En un principio los parámetros eran tan simples como "campo", "valor" y "operador" de forma que simplemente se concatenaban "campo+operador+valor" dando por ejemplo, "id=35", sin embargo, me propuse prepararlo para consultas más complejas, y por este motivo abstraje más los parámetros de forma que se pudiera meter condiciones dentro de condiciones con diferentes niveles de prioridad, para crear por ejemplo, clausulas WHERE de este estilo: WHERE ((nombre LIKE 'Can%') AND ((nombre_cortisimo = 'CAN') OR (nombre_cortisimo = 'CNT'))).

Lo cierto es que no sé si me va a compensar pues me supuso más de un quebradero de cabeza pero finalmente funciona y de esta forma me cubro las espaldas.

La clase en sí es sencilla. Lo complicado es su utilización por parte de la clase "elemento", pero debemos tener claro que los parámetros que le pasamos al constructor de esta clase pueden ser: ("nombre", "Can%", "LIKE") es decir, 3 cadenas, o puede ser del tipo: ($Condicion1, $Condicion2, "OR"), es decir, dos objetos CondicionWhere y un operador que los una.

Código php:

class CondicionWhere {
 
public $parametro1;
public $parametro2;
public $operador;
 
function CondicionWhere($parametro1, $parametro2, $operador){
 
$this->parametro1=$parametro1;
$this->parametro2=$parametro2;
 
if ($operador==""){ // Si no se le pasa operador, pone "=" por defecto
    $this->operador="=";
}
else{
    $this->operador=$operador;
}
}
}
 

Bien, una vez entendida esta clase, estamos en disposición de meternos en el gran meollo, la clase "elemento".

[paloto]

elemento
Esta clase contiene las funciones principales de comunicación con la base de datos: Select, Update, Insert y Delete, además de dos funciones extras de uso interno como son SacarCampos y Recursiva (esta última no tiene un nombre muy adecuado, pero bueno, no sabía como llamarla) .

Esta clase no tiene constructor así que iré explicando método a método, pero debemos tener en cuenta que todo ello se encuentra entre las etiquetas:

Código php:

class elemento{
    public $tabla;
    ...
}
 

Empezaremos por una sencilla, SacarCampos($tabla), que se encarga de obtener un array con el tipo de dato de cada campo de la tabla que pasamos como parametro.

Código php:

function SacarCampos($tabla){
 
$consulta="SELECT COLUMN_NAME, DATA_TYPE FROM INFORMATION_SCHEMA.COLUMNS WHERE table_name = '$tabla'";
$cn=new Conexion();
$res=$cn->Consulta($consulta);
while($row=mysql_fetch_array($res)){
    $resultado[$row['COLUMN_NAME']]=$row['DATA_TYPE'];
}
return $resultado;
}
 

Del resto de métodos de la clase elemento me voy a centrar en el Update, pues utiliza la clase "CampoValor" y la clase "CondicionWhere" y a partir de él se pueden deducir el resto de métodos, pues estos serán inevitablemente, más sencillos.

Código php:

function Update($camposvalores, $condicion){ // El parametro $camposvalores es un array de CampoValor
 
$tabla=$this->tabla;
if ($camposvalores!="" && $tabla!="") //Comprobamos que los datos sean correctos
{
   $bdd_campos=$this->SacarCampos($tabla); // Obtenemos el array con el tipo de dato de los campos
   $consulta = "UPDATE $tabla SET "; // $consulta será la cadena que finalmente lanzaremos contra la base de datos
   foreach($camposvalores as $c){ // Recorremos el array de $camposvalores
   $consulta.=$c->campo."="; // Añadimos a la cadena de la consulta el campo y el operador de asignacion
   switch($bdd_campos[$c->campo]) // Comprobamos el tipo de dato para dcidir si ponemos comillas ( ' ) o no
   {
      case "char":
      case "varchar":
      case "date":
      case "tinytext":
      case "tinyblob":
      case "text":
      case "blob":
      case "mediumtext":
      case "mediumblob":
      case "longtext":
      case "longtext":
      case "datetime":
      $consulta.="'".$c->valor."', ";
      break;
      default:
      $consulta.=$c->valor.", ";
      break;
   }
}
 
if ($condicion !=null){ // Si le pasamos condiciones...
   $consulta=substr($consulta, 0, strlen($consulta)-2)." WHERE ";
   $cadena=$this->Recursiva($condicion); //Llamamos a la función "Recursiva" y obtenemos el valor de retorno
   $consulta.=$cadena; // Lo añadimos a la cadena de consulta y Violá!
}
$cn=new Conexion();
return $cn->Consulta($consulta);
}
 

Vale, una vez hemos explicado estos métodos, solo nos queda hacerlo con el método "Recursiva", que aunque no es muy extenso, a mi me parece el más complicade de implementar y de explicar, y es precisamente como su nombre indica, por tratarse de una función recursiva. No sé si es que son de lo más complicado de asumir/entender de la programación o simplemente a mi se me atraviesan especialmente, pero lo cierto es que tuve verdaderos problemas para crearla.

Código php:

function Recursiva($condicion){ // el parametro $condicion puede ser un objeto CondicionWhere o una cadena y lo comprobamos en el siguiente if
 
if(strlen($condicion->parametro1)>0){ // Si se trata de un objeto CondicionWhere...
$cadena.="("; // Añadimos el paréntesis de apertura para establecer la prioridad
$cadena.=$this->Recursiva($condicion->parametro1); //La función se llama a si misma para profundizar en el "parametro" del CondicionWhere.
// Para tenerlo mas o menos claro, construimos mentalmente $cadena.
// Hasta este momento $cadena vale esto: "(", si resulta que 4l "parametro1" de este CondicionWHERE
// resulta ser una cadena, irá por el else y $cadena pasará a valer "(NombreDelCampo".
// A continuación dejará un espacio y hará lo mismo con "operador", que irá por el else.
// igual con el "parametro2" de forma que al final la $cadena nos queda así (imaginemos que el operador es "=" ): "(NombreDelCampo = Valor)".
// Si se tratara de condiciones mas complejas, con unas dentro de otras, lo único que cambia es que se repetirá este proceso las veces necesarias construyendo finalmente la condición final.
 
$cadena.=" ";
$cadena.=$this->Recursiva($condicion->operador);
$cadena.=" ";
//Comprobar el campo
// Aquí comprobamos si hay que ponerle comillas ( ' ) al "parametro2".
$bdd_campos=$this->SacarCampos($this->tabla);
 
switch($bdd_campos[$condicion->parametro1])
{
case "char":
case "varchar":
case "date":
case "tinytext":
case "tinyblob":
case "text":
case "blob":
case "mediumtext":
case "mediumblob":
case "longtext":
case "longtext":
case "datetime":
   $marca="'";
   break;
default:
   $marca="";
   break;
}
 
$cadena.=$marca; // Si necesita comillas se las ponemos
$cadena.=$this->Recursiva($condicion->parametro2);
$cadena.=$marca; // Si necesita comillas se las ponemos
$cadena.=")";
}
else{
   $cadena.="$condicion";
}
return $cadena; // Devuelve la cadena para seguir construyéndola o para devolverla al método que llamó a este.
}
 

Llegado a este punto, para todo quede más claro, solo me falta mostrar la forma de usar estas clases y métodos.

Creamos una clase sencilla llamada "Lugar", creamos un objeto "Lugar", creamos el objeto CondicionWhere con varios CondicionWhere anidados y el array de CampoValor de asignación y llamamos a la función Update.

Código php:

class Lugar extends elemento
{
   public $id;
   public $nombre;
   public $nombre_corto;
   function Lugar(){
      $this->tabla="Lugar";
   }
}
$lug=new Lugar();
$con1=new CondicionWhere("nombre", "Can%", "LIKE");
$con2=new CondicionWhere("nombre_corto", "CAN");
$con3=new CondicionWhere("nombre_corto", "CNT");
$con4=new CondicionWhere($con2, $con3, "OR");
$con5=new CondicionWhere($con1, $con4, "AND");
 
$campos=array(new CampoValor("nombre", "ValorNombre"),
 
new CampoValor("nombre_corto", "ValorNombreCorto"));
 
$lug->Update($campos, $con5);
 

El resultado es que el ORM envía a la base de datos MySql la consulta siguiente:

UPDATE Lugar SET nombre_corto='ValorNombreCorto' WHERE ((nombre LIKE 'Can%') AND ((nombre_corto = 'CAN') OR (nombre_corto = 'CNT')))

No sé si he logrado explicarme correctamente, pero he de decir que yo mismo me pierdo al intentar seguir el camino de la aplicación cuando llega a esta función recursiva. El caso es que funciona correctamente después de muchas pruebas y modificaciones.

Si a alguien le parece interesante y quiere utilizar este código puede hacerlo y si desea tener el código completo (con los métodos Select, Insert y Delete) solo tiene que mandarme un correo electrónico o pedirlo en los comentarios y se lo enviaré con mucho gusto, igualmente si alguien tiene alguna duda o sugerencia sobre esto, puede ponerla también en los comentarios.

Un saludo

[GatorV]

Tema trasladado a PHP Orientado a Objetos.