Entendiendo el MVC

En esta entrada vamos a hablar un poco del MVC, con la intención de hacerlo entendible a personas que se estén iniciando con este patrón de diseño lo llevaremos desde un punto de vista sencillo y entendible para cualquiera que tenga nociones de programación.

Pondremos manos a la obra haciendo una pequeña definición de este patrón de diseño.


El Patrón MVC sus siglas en ingles significan Model View Controller que significa Modelo Vista Controlador, es una arquitectura de Software que define la separación de los datos que conforman la vista de la lógica de una aplicación.

Esto se hace con la finalidad de que cada una de las partes de una aplicación solo realice lo que está en su responsabilidad, además de que le da mayor entendimiento a nuestros desarrollos y los hace más fácil de mantener, ya que la parte del diseño solo tiene la cantidad de código de programación que necesita al igual que en la parte que conforma nuestro código del negocio solo se va a encontrar lógica de programación en el lenguaje que estemos trabajando (PHP en nuestro caso) y no como algunos estamos acostumbrados muchos a hacer cosas como estas:

Insertar un registro
Campo: 

Como vemos tenemos el código de nuestro negocio que es la inserción del registro y la vista en un mismo archivo cosa que no es de lo mas recomendable y es lo que este patrón desea evitar.

Ya sabemos que es lo que no quiere el MVC pero veamos en si lo que está detrás de sus siglas.

• V (View o Vista): Aunque la primera letra del patrón es la M decidí mejor hablar primero de la vista ya que es lo más sencillo de explicar al momento de trabajar con este patrón.
  

  La vista como su nombre lo indica es la parte visual, lo que el usuario final visualizara en su aplicación.

  La vista podemos establecerla como la primera fase de este patrón ya que la vista es la que comunica al usuario lo que quiere ver, esta tiene acceso directo al modelo como podemos observar en la imagen que tenemos en la parte superior y es esta la que transmite los datos a la aplicación para hacer el proceso que necesitemos

• M (Model o Modelo):El modelo es lugar donde se encuentra la lógica del negocio de nuestro desarrollo, es ahí donde se procesan todos los datos provenientes de la vista.
• C (Controller o Controlador): Es el encargado de hacer la conexión entre la parte visual y la lógica del negocio de nuestro desarrollo (MODELO), este se encarga de pasar los datos de la vista hacia el modelo y según la respuesta que este le entregue selecciona la vista a cargar pasando los datos provenientes del modelo.

Bien hasta ahora hemos visto la teoría de este patrón pero como se construye una aplicación con él??

Vamos a trabajar de la manera más básica posible, para ello vamos a trabajar un poco el PHP de manera estructurada aunque mayor provecho a este patrón se saca trabajando OOP; Planteemos un ejemplo que todo sistema debe de tener una gestión de usuarios, entonces normalmente cuando trabajábamos sin el patrón hacíamos algo como esto

Como podemos observar es un login básico que hace todo el proceso en la misma página, si llegara un usuario y se logueara correctamente lo haría, pero como vemos tenemos lo que yo llamo un arroz con mango en nuestro código, pasemos este pequeño login al patrón MVC.

Comencemos con la vista

login.php

Como podemos observar la vista de nuestro pequeño sistema de login es todo lo que corresponde al HTML dejando todo el proceso ya que este corresponde a la lógica de nuestro negocio la cual estará en el modelo.

Ahora nuestro modelo.
usuario.php

Como vemos en nuestro modelo hicimos una función ya que el modelo del usuario debería tener toda la lógica que corresponde a la gestión de estos, como registrar, modificar y eliminar usuarios, para el ejemplo fuera lo más sencillo posible trabaje con el login ya que es algo que normalmente se hace en cualquier tipo de sistema.

Pero el controlador donde queda??

Como vemos ya tenemos la parte visual de nuestro login y tenemos la parte del negocio de nuestra aplicación pero para que el controlador y donde queda?? Como ya definimos el controlador comunica los datos de la vista al modelo entonces como debe de ser este?? Algo como esto

usuariosController.php

Con este pequeño controlador podemos observar cual es la función de este, sencillamente pasar datos de la vista al modelo y según la respuesta cargar la vista que se necesite según los datos obtenidos del modelo, sencillo no??

Espero que esta entrada ayude a los que están comenzando a conocer este patrón de diseño a entenderlo un poco mejor lo hice lo más sencillo posible según mi criterio :-), saludos hasta una próxima entrada.

Hablando de Clases y Objetos POO

En un artículo anterior habíamos tocado el tema de las clases y los objetos desde el punto de vista del PHP aunque muy generalizado, en el día de hoy vamos a tocarlo un poco mas general de tal manera que podamos tener claro que son.

Cuando hablamos de un Objeto la teoría nos indica que es la instancia de una clase, en PHP mayormente asignado a una variable de esta manera

$objeto = new Clase();
var_dump($objeto)

el resultado seria

object(Clase)#1 (1) { ["var":"Clase":private]=> NULL } 

Como vemos la variable $objeto se convirtió justamente en eso en un Objeto o una instancia de la clase Clase donde por medio de esta instancia podemos acceder a sus métodos y atributos públicos por cierto.

Ok el concepto de objeto sencillo la instancia de una clase, pero entonces que es una clase, es ahí donde muchos autores nos complican la vida literalmente diciéndonos que es una abstracción de datos, donde el concepto de abstracción de datos es algo muy complicado por lo que muchos o huimos del concepto o sencillamente nos quedamos con dudas sobre este concepto.

En lo personal tenía algunas dudas con lo que era el concepto de una clase y abstracciones de datos pero esta semana creo que se me aclaro mucho por lo que decidí hacer este post, entonces comencemos con los conceptos que tanto nos cuesta a algunos.

Una clase: es simplemente una entidad compleja llevada a lo resumido pero como es esto?? Un ejemplo pudiera ser cuando necesitamos trabajar con animales, todos conocemos que existen muchas clasificaciones de los animales, ejemplo por lo que comen (herbívoros, carnívoros....) o por la forma que nacen (ovíparos, mamíferos...) pero todo esta complejidad la resumimos en una sola palabra es decir Animales. Que fácil no??, también podríamos decir que una clase es un tipo de datos creados por el desarrollador, pero como así?? Explico un poco mi experiencia y la de algunos profesores que he tenido, no sé si en algún momento alguien ha visto algo como esto

public function miMetodo(Animales $animal){
/*grupo de sentencias del metodo miMetodo*/
}

Como podemos observar el parámetro del método miMetodo es de tipo Animales pero donde está definido este tipo de datos??? En una clase que creamos llamada Animales, entonces también podríamos definir a una clase como la declaración de un tipo de dato creada por el desarrollador, un ejemplo de esto es en JAVA los desarrolladores de este lenguaje notaron que no había un buen soporte para el trabajo con las variables de tipo carácter, por esto crearon una clase llamada String que define este tipo de datos ejemplo

String var;

y así indicamos al lenguaje que trabajaremos la variable var como de tipo String una clase creada por JAVA y podemos acceder a todos sus métodos y atributos de esta.

Aunque la explicación de que es una clase fue algo larga creo que lleva lo complicado a lo simple tal cual como lo hace una clase, pero entonces en donde esta lo abstracto de las clases o mejor dicho que es una abstracción?? El concepto de abstracción va ligado al de la clase, como es esto?? Sencillamente lleva lo complejo a lo sencillo ya que se enfoca en el que hace y no en como lo hace con todo lo complejo que esto pueda ser.

Bueno espero que esta entrada sea del agrado de todos, es sencillamente un artículo que intenta llevar lo complicado del concepto de una clase a ser entendido de manera fácil tal cual y como lo hace una clase.

clase validación de datos

Buenas un poco abandonado el blog el día de hoy compartire una clase que realice para hacer validaciones, esta clase surge de un tema que planteaba en forosdelweb por una duda correspondiente al patrón MVC, según tenía entendido por un poco de experiencia con el framework cakePHP, la lógica de nuestros sistemas se encuentra en el controlador según entendia yo :-), resulta que esto era un error de concepto que tenia y los amigos del foro me ayudaron a entender y ver este error, luego de entender este concepto me genero otra duda donde realizar las validaciones?? en el controlador?? en el modelo?? según mi criterio si en el patrón MVC toda la lógica y el trabajo con los datos se hace con el modelo entonces las validaciones de los datos deve de ser en el modelo, entonces me dispuse a crear una clase para hacer las validaciones es una primera versión que hace la validación de manera correcta lo unico que se debe es llamar al método de la clase e indicar los parámetros para realizar la validacion

/**
/**
* Clase para realizar validaciones en el modelo
* Es utilizada para realizar validaciones en el modelo de nuestras clases.
*
* @author Carlos Belisario
*/
class Validacion
{
 protected $_atributos;
 protected $_error;
 public $mensaje;
 
 /**
 * Metodo para indicar la regla de validacion
 * El método retorna un valor verdadero si la validación es correcta, de lo contrario retorna el objeto 
 * actual, permitiendo acceder al atributo Validacion::$mensaje ya que es publico
 */
 public function rules($rule = array(),$data)
 {
  
  if(!is_array($rule)){
   $this->mensaje = "las reglas deben de estar en formato de arreglo";
   return $this;
  }  
  foreach($rule as $key => $rules){
   $reglas = explode(',',$rules['regla']);
   if(array_key_exists($rules['name'],$data)){
    foreach($data as $indice => $valor){     
     if($indice === $rules['name']){
      foreach($reglas as $clave => $valores){ 
       $validator = $this->_getInflectedName($valores);        
       if(!is_callable(array($this, $validator))){
          throw new BadMethodCallException("No se encontro el metodo actual");
       }
       $respuesta = $this->$validator($rules['name'], $valor);        
      }
      break;
     }
    }
   }
   else{
    $this->mensaje[$rules['name']] = "el campo $value no esta dentro de la regla de validación o en el formulario";    
   }
  }  
  if(!$respuesta){
   return $this;
  }
  else{
   return true;
  }
 } 
 
 /**
 * Metodo inflector de la clase 
 * por medio de este metodo llamamos a las reglas de validacion que se generen
 */
 private function _getInflectedName($text)
 {
  $_validator = preg_replace('/[^A-Za-z0-9]+/',' ',$text);
  $arrayValidator = explode(' ',$_validator);    
  if(count($arrayValidator) > 1){
   foreach($arrayValidator as $key => $value){     
    if($key == 0){
     $validator .= "_".$value; 
    }
    else{     
     $validator .= ucwords($value);
    }
   }
  }
  else{
   $validator = "_".$_validator;
  }    
  return $validator;
 }
  
 /**
 * Metodo de verificacion de que el dato no este vacio o NULL
 * El metodo retorna un valor verdadero si la validacion es correcta de lo contrario retorna un valor falso
 * y llena el atributo validacion::$mensaje con un arreglo indicando el campo que mostrara el mensaje y el 
 * mensaje que visualizara el usuario
 */
 protected function _noEmpty($campo,$valor)
 {   
  if(isset($valor) && !empty($valor)){   
   return true;   
  }
  else{   
   $this->mensaje[$campo][] = "el campo $campo debe de estar lleno";
   return false;
  }
 }
 /**
 * Metodo de verificacion de tipo numerico
 * El metodo retorna un valor verdadero si la validacion es correcta de lo contrario retorna un valor falso
 * y llena el atributo validacion::$mensaje con un arreglo indicando el campo que mostrara el mensaje y el 
 * mensaje que visualizara el usuario
 */
 protected function _numeric($campo,$valor)
 {   
  if(is_numeric($valor)){
   return true;
  }  
  else{
   $this->mensaje[$campo][] = "el campo $campo debe de ser numerico";
   return false;
  }
 }
 
 /**
 * Metodo de verificacion de tipo email
 * El metodo retorna un valor verdadero si la validacion es correcta de lo contrario retorna un valor falso
 * y llena el atributo validacion::$mensaje con un arreglo indicando el campo que mostrara el mensaje y el 
 * mensaje que visualizara el usuario
 */
 protected function _email($campo,$valor)
 {
  if(preg_match("/^[a-z]+([\.]?[a-z0-9_-]+)*@[a-z]+([\.-]+[a-z0-9]+)*\.[a-z]{2,}$/",$valor)){     
   return true;
  } 
  else{
   $this->mensaje[$campo][] = "el campo $campo de estar en el formato de email usuario@servidor.com";
   return false;
  }
 }
}

el uso de la clase es muy sencillo aca dejo las pruebas que realice a la clase

$_POST['campo1'] = 1;
$_POST['campo2'] = "usuario@hotmail.com";
$datos = $_POST;
$validacion =  new Validacion();
$regla = array(
   array('name'=>'campo1','regla'=>'no-empty,numeric'),
   array('name'=>'campo2','regla'=>'no-empty,email')
  );
$validaciones = $validacion->rules($regla,$datos);
print_r($validaciones);

por ahora solo tengo tres reglas de validación son muy básicas y sencillas, espero que sea de su agrado si tienen alguna corrección o critica que hacer a la clase no hay ningun problema, saludos

MySQL: Lenguaje de Consulta de datos DQL Parte III

Continuando con el Lengaje de consulta de datos DQL, hablaremos de funciones que podemos utilizar para trabajar los datos que obtendremos en nuestras consultas y  las operaciones que podemos realizar con cada uno de estos datos, estas funciones nos ahorran trabajo al momento de mostrar los datos que necesitamos normalmente en nuestros sistemas facilitandonos mucho la vida al momento de trabajar con un lenguaje de programación sea este cual sea.

Bueno ya es hora de que conozcamos estas funciones que hablabamos en la introducción de este artículo, empezemos nuestra lista de funciones con una de las mas básicas y utilizadas:

a)COUNT(): Esta funciób ya la aviamos trabajado en el artículo anterior aunque no la habiamos explicado cual es su uso, lo que esta función hace es contar el numero de registros que devuelve una consulta, veamos un ejemplo:

SELECT COUNT(*) FROM tabla WHERE estatus = 1;

El resultado nos dira cuantos son los registros cuyo estatus es igual a 1, esta consulta es muy util al momento de dar numeros mientras administramos nuestras DB.

b) SUM(): Con esta función realizamos la suma de los valores que se encuentran en un campo especifico, la sintaxis de esta sentencia es la siguiente

SELECT SUM(campo) FROM tabla;

Como resultado de esta consulta obtendremos el valor de la suma de todos los valores que tienen el campo "campo".

c)AVG(): Esta función nos calcula un averaje del campo seleccionado un pequeño ejemplo:

SELECT AVG(campo) FROM tabla;


Esto nos dara un average del campo que seleccionemos.

Nota: Antes de continuar cabe destacar que las funciones que nombramos anteriormente exectuando la funcion COUNT trabaja mayormente con la cláusula GROUP BY, ya que mayormente cuando queremos un averaje por ejemplo de un deporte queremos saberlo por deportista, igualmente una suma.

d)DISTINCT(): Esta funcion nos da como resultados los distintos valores que se encuentran en el campo especificado, en un ejemplo si existen mil registros que tienen el nombre carlos, cien que tienen el nombre luis nos dara como resultado carlos y luis una sola vez. Ejemplo:

SELECT DISTINCT(campo) FROM tabla;

e)MAX(): Esta funcion nos da como resultado el valor máximo que tiene un campo en una tabla, la sintaxis al igual que las funciones anteriores es la siguiente

SELECT MAX(campo) FROM tabla;

f)MIN(): Esta función es la inversa a la descrita anteriormente, ya que la misma nos devuelve el valor mínimo que existe en un campo de la base de datos, sintaxis:

SELECT MIN(campo) FROM tabla;

g)CONCAT(): Con esta función concatenamos el valor de dos campos, la sintaxis de la misma es la siguiente:

SELECT CONCAT(campo1,'valor con el que se concatenara',campo2);

Veamoslo en un ejemplo:

SELECT CONCAT(nombre,', ',apellido) FROM datos_personales;

El resultado nos concatenara el nombre y el apellido separados por una coma.

Nota: Si se desea concatenar con un espacio en blanco con tan solo darle un espacio entre las comillas del segundo parámetro obtendremos el resultado requerido.

h)DATE_FORMAT(): Esta función la utilizamos para darle el formato a nuestros campos de tipo fecha, la sintaxis de esta funcion es a siguiente:

SELECT DATE_FORMAT(campo_date,'%formato'); los formátos de la función DATE_FORMAT los tenemos acontinuación:

Especificador	Descripción
%a	Día de semana abreviado (Sun..Sat)
%b	Mes abreviado (Jan..Dec)
%c	Mes, numérico (0..12)
%D	Día del mes con sufijo inglés (0th, 1st, 2nd, 3rd, ...)
%d	Día del mes numérico (00..31)
%e	Día del mes numérico (0..31)
%f	Microsegundos (000000..999999)
%H	Hora (00..23)
%h	Hora (01..12)
%I	Hora (01..12)
%i	Minutos, numérico (00..59)
%j	Día del año (001..366)
%k	Hora (0..23)
%l	Hora (1..12)
%M	Nombre mes (January..December)
%m	Mes, numérico (00..12)
%p	AM o PM
%r	Hora, 12 horas (hh:mm:ss seguido de AM o PM)
%S	Segundos (00..59)
%s	Segundos (00..59)
%T	Hora, 24 horas (hh:mm:ss)
%U	Semana (00..53), donde domingo es el primer día de la semana
%u	Semana (00..53), donde lunes es el primer día de la semana
%V	Semana (01..53), donde domingo es el primer día de la semana; usado con %X
%v	Semana (01..53), donde lunes es el primer día de la semana; usado con %x
%W	Nombre día semana (Sunday..Saturday)
%w	Día de la semana (0=Sunday..6=Saturday)
%X	Año para la semana donde domingo es el primer día de la semana, numérico, cuatro dígitos; usado con %V
%x	Año para la semana, donde lunes es el primer día de la semana, numérico, cuatro dígitos; usado con %v
%Y	Año, numérico, cuatro dígitos
%y	Año, numérico (dos dígitos)
%%	Carácter '%' literal

Fuente: Manual de MySQL

Los usos de esta función los podemos ver en este artículo  donde se mostraban algunos de los usos que se le da a esta útil función que utilizamos para formatear nuestras fechas.

Estas son algunas de las funciones que nos ofrece MySQL para trabajar los datos que obtenemos, existen otras que podemos encontrar en el manual oficial de este manejador de base de datos.

Operaciones que se pueden realizar en nuestras Consultas con MySQL

En nuestras consultas podemos realizar operaciones aritméticas y lógicas, veamos un poco de estas.

a)SUMA: Anteriormente vimos como sumar todos los datos de un campo, pero que si necesitamos el resultado de la suma de dos campos diferentes?? esto podemos hacerlo por medio del operador +, en nuestra consulta de tal manera que la consulta quede así:

SELECT campo1 + campo2 FROM tabla;

El resultado sera la suma de estos campos de cada uno de los registros, podemos hacerlo con la cantidad de campos que necesitemos en este caso solo se realizo con dos para mostrar la sencilles de la operación.

b)RESTA,MULTIPLICACIÓN Y DIVISIÓN: Tal cual como se indico en la suma podemos hacerlo con la operación de restar, multiplicar y dividir, lo que cambiaria es el  operador a utilizar, siendo los operadores los siguientes:

• Resta (-).
• Multiplicacion (*).
• División (/).

MySQL también  nos permite combinar estas operaciones para obtener resultados necesarios de campos ejemplo:

SELECT (campo1 + campo2) * campo2 - campo3 FROM tabla;

Sencillo la realización de operaciones aritméticas con MySQL verdad, pero que con las operaciones lógicas.

Las operaciones lógicas son un poco más complicadas al momento de trabajar en nuestras tablas ya que mayormente se utilizan las aritméticas pero también podemos hacer uso de estas, veamos como:

Las operaciones lógicas nos dan como resultados dos posibles valores verdadero/falso en el caso de MySQL 1 ó 0,y los operadores son al igual que se indico en la cláusula WHERE los siguientes:

• Mayor que (>).
• Menor que(>).
• Igual (=).
• Mayor Igual (>=).
• Menor Igual (<=).
• Diferente (<>).

Estos son los más usados para mayor información consultar el manual oficial de esta base de datos relacional.

En conclusión aprendimos hoy el trabajo con las funciones y operadores en nuestras consultas DQL, de manera que podamos realizar operaciones aritméticas y lógicas dentro de nuestras consultas teniendo como ventaja que esta nos ahorra realizar este tipo de operaciones con el lenguaje de programación que estemos trabajando nuestro proyecto.

Espero que esta entrada sea de su agrado cualquier sugerencia no duden en indicarla que sera tomada en cuenta, saludos hasta una próxima entrada donde seguiremos el tema de las consultas DQL en MySQL.

MySQL: Lenguaje de Consulta de datos DQL Parte II

Continuando con el Lenguaje de Consulta de Datos, vamos ha proseguir conociendo las consultas SELECT y sus cláusulas de manera de profundizar un poco mas en la manera en que obtendremos nuestros datos en con nuestras sentencias.

En el artículo anterior vimos como colocar condiciones a nuestras consultas y los distintos operadores que podemos usar para obtener únicamente los datos que necesitamos de nuestras tablas, también estudiamos un poco la cláusula ORDER BY para ordenar los datos obtenidos de nuestra sentencia, pero esto es solo una parte de lo que podemos realizar con el lenguaje de consulta de datos, continuemos con las cláusulas de este tipo de sentencias:

c)LIMIT: Este operador lo utilizamos para indicar la cantidad de resultados que mostraremos en una consulta,esta cláusula nos pide uno o dos parámetros donde indicamos la cantidad de registros que deseamos obtener, por ejemplo:

SELECT * FROM alumno LIMIT 5;

Con esta sentencia obtendremos como resultado los datos de los primeros 5 alumnos, la segunda forma de limitar es indicando un inicio y un fin de los registros que deseamos obtener, un ejemplo:

SELECT * FROM alumno LIMIT 2,10;

De esta manera obtendríamos los datos del tercer hasta el onceavo alumno de nuestra tabla, esto porque?? porque el primer índice que da como resultado MySQL de una tabla es 0.

d)GROUP BY: Como su nombre lo indica sirve para agrupar según un valor especifico, la sintaxis es la siguiente:
SELECT campos FROM tabla GROUP BY campo_agrupar;

Un ejemplo de uso:

SELECT nombre,COUNT(*) FROM empleado GROUP BY nombre;

el resultado nos mostrara los distintos nombres y cuantos hay de cada uno ejemplo


+---------------+---------------------+
| nombre    | COUNT(*) |
+---------------+---------------------+
| Juan         |     5                |
| carlos      |     3                |
| Luis         |     4                |
+--------------+- --------------------+


Estas son algunas de las cláusulas mas utilizadas al momento de trabajar con nuestras consultas de datos, para el próximo artículo hablaremos de la funciones que podemos utilizar al momento de obtener los datos por medio de nuestras consultas, hasta una próxima entrada.

MySQL: Lenguaje de Consulta de datos DQL Parte I

Para esta nueva entrada vamos a hablar sobre el lenguaje de consulta de datos, vamos a mostrar varias consultas que podemos aplicar mediante este tipo de lenguaje.

DQL(): Data Query Lenguage o Lenguaje de Consulta de Datos, es el lenguaje que provee el estándar SQL para recuperar o mostrar los datos existentes dentro de nuestras bases de datos, esta conformado por las sentencias SELECT.

SELECT: Como lo indicamos este tipo de sentencias nos permite recuperar los datos de una base de datos, la sintaxis es sencilla.

SELECT campos FROM tabla;

Donde campos son los campos de la tabla que deseemos traer en nuestra consulta separados por coma (,) y tabla son las tablas de las que deseemos extraer los datos.

Cabe destacar que si en los campos se especifica el asterisco (*) se seleccionaran todos los datos de la tabla indicada, ejemplo:

SELECT * FROM tabla;


Fácil no??

Hasta acá hemos visto una sentencia SELECT simple donde traemos datos de una tabla especifica.


Dentro de las consultas SELECT tenemos cláusulas para colocar condiciones en nuestras consultas de maneras que podamos obtener los datos en forma que deseemos veamos cuales son:

a)ORDER BY: Esta cláusula nos sirve para indicar el orden en que se mostraran los datos obtenidos de nuestra consulta, la sintaxis es la siguiente:

SELECT campos FROM tabla ORDER BY campos_orden [DESC/ASC];

Donde campos_orden es por el campo que estará ordenado nuestro resultado, dando la prioridad a los primeros campos y separando cada uno por coma, [DESC/ASC] es si los queremos de forma ascendente o descendente, si indicamos el campo y no indicamos [DESC/ASC], el lo toma como si fuera ordenar ascendente por defecto,  veamos con un ejemplo:

Deseamos traer los datos personales de los trabajadores ordenados por el apellido:

SELECT nombre,apellido FROM empleado ORDER BY apellido,nombre;

En esta consulta Automáticamente al terminar de ordenar por apellido empieza a ordenar por el nombre por ejemplo si existen dos cuyo apellido sea PEREZ entonces ordena por el nombre

------------------------------
nombre       |  apellido|
-----------------------------
| ALBERTO | PEREZ  |
|PEDRO      | PEREZ   |
-------------------------------------

Aunque los dos tiene el mismo apellido el orden se da por el segundo campo indicado en nuestra consulta, como vimos no indicamos el DESC debido a que no es necesario cuando ordenamos de esta manera aunque hay autores que recomiendan usarlo.

b)WHERE: Esta cláusula nos permite ponerle condiciones a nuestras consultas, de manera de traer solo los campos deseados, su sintaxis es la siguiente:

SELECT campos FROM tabla WHERE campo1='condicion';

Donde campo1 es uno de los campos que estamos colocando como condicional para que nuestra consulta traiga los datos que deseamos, para hacer nuestras condiciones debemos tomar en cuenta los operadores de MySQL, veamos cuales son:

1.- = Signo igual: Lo usuamos en nuestras condiciones para indicar que traiga el dato mientras el valor en el campo sea igual a un valor dado ejemplo:

SELECT nombre FROM empleado WHERE apellido='perez';

El resultado de esta consulta serán todos los registros de nuestra tabla cuyo apellido sea PEREZ.

2.- <> Diferente: Este operador lo utilizamos para obtener los resultados mientras el valor en el campo sea diferente al valor dado, ejemplo:

SELECT nombre FROM empleado WHERE apellido<>'perez';

En este caso el resultado sera contrario al ejemplo anterior ya que solo obtendremos los registros que el apellido sea diferente de PEREZ.

3. > Mayor que: Este operador como su nombre lo indica lo utilizamos para traer datos que el valor del campo indicado sea mayor al campo dado ejemplo:

SELECT nombre,edad FROM empleado WHERE edad>17;

En este caso obtendremos a los empleados que sean mayor de edad, comparando que su edad sea mayor a 18 años.


4.- >= Mayor Igual que: Con este operador indicamos a nuestra condición que el resultado debe de ser mayor o igual a el valor establecido ejemplo

SELECT nombre,edad FROM empleado WHERE edad>=18;

En este caso también obtendríamos los empleados mayores de edad, pero como vemos el valor de la condición es algo diferente.

5.- < Menor que: Con este operador obtenemos los datos que son menores a un valor establecido, ejemplo:

SELECT nombre, edad FROM empleado WHERE edad<18;

Siguiendo con los ejemplo de las edades en este caso obtendríamos los empleados menores de edad.

6.- <= Menor Igual que: Es el inverso a Mayor igual que (>=), es decir mediante de este operador obtenemos los menores o iguales a cierta valor, ejemplo:

SELECT nombre,edad FROM empleado WHERE edad<=17;

7.-LIKE: Indicando este operador indicamos una coincidencia entre el campo y el valor indicado, para esto utilizamos los comodines (%), un pequeño ejemplo de esta sentencia:

SELECT * FROM table WHERE campo LIKE '%carlos%';

De esta manera obtendremos todos los campos donde en campo exista la palabra carlos por ejemplo:

juan carlos
carlos luis
jose carlos perez.

Este operador podemos utilizarlo en varios casos que presentamos a continuacion:

El comodin porcentaje (%): Lo utilizamos para indicar en el patron coincidencias de varios carácteres los posibles casos los mostramos a continuación:

1.- LIKE 'buscar%' : Del resultado de esta condición obtenemos todos los campos donde dentro del campo  "campo" exista la palabra buscar, seguido de cualquier cadena incluyendo también la palabra buscar, posibles resultados:

buscar.
buscar todo.
buscar_algo.

Entre otros posibles resultados.

2.-LIKE '%buscar': El resultado de esta condición es todos los campos indicados que terminen con la palabra buscar incluyendo también la misma palabra, por ejemplo:

buscar
vamos a buscar.

3.- LIKE '%buscar%': Con esta consulta obtenemos resultados que tengan una coincidencia con buscar bien sea al principio, entre cadenas o al final, incluyendo la misma palabra sola por ejemplo:

buscar.
buscar algo.
anda a buscar.
vamos a buscar algo.

Dentro del operador LIKE tambien tenemos otro comodin que mostraremos a continuación:


El comodin underscore (_) : Lo utilizamos en el operador LIKE para indicar que buscara en el patron las coincidencias con un solo carácter, a continuación los posibles casos.

1.-LIKE 'busca_': Los resultados solo seran los que contengan la palabra busca seguido de cualquier carácter, sin incluir la palabra busca solo por ejemplo:

buscar.
buscas

2.- LIKE '_ana': Los resultados seran los que coincidan con el patrón con cualquier primera letra, por ejemplo:

lana.
cana.

3.- LIKE 'ca_a': Con esta condición obtendremos los datos que coincidan con el patrón, siendo la tercera letra variable por ejemplo:

cama.
cana.
caza.
casa.

El operador LIKE es muy útil para trabajar nuestras consultas por medio de patrones y busquedas donde no conocemos completamente el dato.

Continuando con los operadores el siguiente es:

7.- El operador BETWEEN: Utilizado para indicar que el valor del campo este entre dos valores posibles, muy utilizado al momento de comparar  fechas, la sintaxis es la siguiente:

SELECT campo FROM tabla WHERE campo BETWEEN 'valor1' AND 'valor2';


Veamos un ejemplo:

SELECT nombre,fecha_ingreso FROMempleado WHERE fecha_ingreso BETWEEN '2010-01-10' AND '2010-01-20';

El resultado sera el nombre de los empleados y la fecha de ingreso que ingresaron entre el 10 de enero del 2010 y el 20 de enero del 2010, sencillo no??

8.-Operador AND: Lo utilizamos para unir dos o más condiciones, para que exista una respuesta se deben cumplir cada una de estas, la sintaxis es la siguiente:

SELECT campo FROM tabla WHERE campo1='condicion1' AND campo2='condicion2';

Si alguna de las condiciones no existe no retornara ningun valor esta consulta.

9.-Operador OR: Lo utilizamos para unir dos o mas condiciones, la diferencia con el AND es que para este caso al cumplirse alguna de las condiciones obtendremos un resultado, la sintaxis es la siguiente:

SELECT campo FROM tabla WHERE campo1='condicion1' OR campo2='condicion2';

Al existir coincidencia entre alguna de las condiciones e incluso ambas, la consulta retornara los resultados.

10.-Operador IN: Funciona al igual que el operador OR, pero indicando solo un campo, su sintaxis es la siguiente:

SELECT campo FROM tabla WHERE campo IN('valor1','valor2');

Seria equivalente a lo siguiente

SELECT campo FROM tabla WHERE campo='valor1' OR campo='valor2';


Estos son los operadores mas usados al momento de trabajar con MySQL, podemos obtener mas información sobre ellos en el manual oficial, cualquier otro que no se halla tomado en cuentan no duden en indicarlo.


Por esta entrada es todo, en la próxima continuaremos hablando sobre el Lenguaje de consulta de datos ya que es un tema bastante extenso, cualquier critica o sugerencia es aceptada, saludos

UPLOAD de Archivos Con PHP

Retomando el PHP en esta ocasión compartiremos una clase para subir archivos a nuestro sitio Web, para hacer esta operación utilizaremos la función copy, además trabajaremos con un formulario con un campos tipo file y el enctype "multipart/form-data" para trabajar con la variable $_FILE de PHP,  vamos a la acción.


Un UPLOAD de archivos consiste en subir un archivo de nuestra maquina a un Sitio Web alojado en un servidor, como logramos esto?? moviendo el archivo desde nuestra maquina bien sea mediante la funcion copy o move_uploaded_file(), en lo personal me gusta mas trabajar con la funcion copy, para ello seguiremos una serie de pasos que presentamos a continuación:

Lo primero que tenemos que hacer es crear un formulario

Si nos fijamos nuestro formulario además del método de envió, el nombre y la acción tiene un atributo mas que es enctype donde indicamos el tipo de datos que vamos a enviar por defecto este es application/x-www-form-urlencoded, pero cuando necesitamos enviar archivos necesitamos especificar "multipart/form-data" de manera que nuestro servidor entienda que se han enviado archivos mediante este formulario y podemos utilizar $_FILE


Una vez explicado que para poder subir archivos a nuestro servidor debemos usar este tipo de enctype veamos ahora la clase para subirlos y su implementación

/*

clase para subir archivos al servidor

autor: Carlos Belisario

*/
class upload
{
 #atributo para tener los archivos
 private $_file; 
 #atributo para obtener el peso maximo
 private $_maxSize;
 #atributo para obtener el tipo de archivos a subir
 private $_type;
 #atributo para la ruta donde sera subido el archivo
 private $_ruta;
 #iniciamos toda la magia pasamos como parametro el dato $_FILE['campo'],$destino
 public function __construct($file = NULL,$destino = NULL, $validate = array())
 {   
  if(count($file) === 0){
   echo "debe indicar el archivo que desea subir";
  }    
  else{
   $this->_file = $file;
   if(!empty($destino))
    $this->_ruta = $destino.'/'.$file['name'];      
   else
    $this->_ruta = $file['name'];   
   if(is_array($validate)){
    if(count($validate) > 0){
     if(array_key_exists('maximo',$validate))
      $this->_maxSize = $validate['maximo'];
     if(array_key_exists('tipo',$validate)){
      if(is_array($validate['tipo']))      
       $this->_type = $validate['tipo'];
      else
       echo "debe indicar los tipo de archivo en formato array";
     }
     $return = $this->validate();        
    }
   }
   else{
    $return = $this->uploadFile();   
   } 
   echo $return;     
  }
 }
 private function validate()
 {   
  if(file_exists($this->_ruta))
   $return = "el archivo ya existe en el servidor";  
  if(!empty($this->_maxSize)){    
   if($this->_maxSize < $this->_file['size'])    
    $return = "el tamaño del archivo es superior al soportado";
  }
  if(count($this->_type) > 0){  
   $tipo = explode('/',$this->_file['type']);
   if(!in_array($tipo[1],$this->_type))    
    $return = "no esta en el arreglo";         
  }  
  if(empty($return)){      
   $return = $this->uploadFile();   
  } 
  return $return;
 }
 private function uploadFile()
 {
  if(@copy($this->_file['tmp_name'],$this->_ruta))
   return "el archivo fue subido correctamente";  
  else
   return "ha ocurrido un error al subir el archivo ".$this->_file['name']."
 puede que la ruta indicada ".$this->_ruta." no sea correcta";  
 }
}

Si nos fijamos la forma de utilizar esta clase es indicando los parámetros al constructor de nuestras clases y automáticamente según los parámetros que se indiquen el automáticamente subirá el archivo los parámetros que tenemos son los siguientes:

$file: Este parámetro indicamos el valor recibido del formulario por medio de $_FILE de manera que tengamos disponibles todos los índices de este arreglo en nuestra clase.

$destino: En este parámetro indicamos la carpeta destino de nuestro archivo es decir donde quedaran guardados los archivos que subamos por nuestra clase. Si este vacio automáticamente lo guarda en el mismo nivel que esta el archivo en el árbol de carpetas de nuestro sitio.

$validate: Es un arreglo asociativo donde podemos indicar el tamaño máximo y el tipo de archivo que deseamos que sean subidos a nuestro servidor, de manera que si queremos solo JPG lo indicamos este array asociativo está compuesto de la siguiente manera

$validate = array('maximo'=>cantidad_maxima_en_byte,'tipo'=>array('tipoarchivo1',tipoarchivo2)); 

El índice máximo indica el tamaño máximo del archivo que deseamos subir, el índice tipo indicamos los tipos de archivos soportados.

Fácil no??

Pues entonces veamos la implementación

subir.php

require_once(upload.php);
$archivo = $_FILE['campo_archivo'];
$destino = 'Imagenes';
$validate = array('maximo'=>1048576,'tipo'=>array('jpg','png',gif));
$upload = new upload($archivo,$destino,$validate); 

con tan solo indicar los parametros al constructor de nuestra clase podremos subir nuestro archivo al servidor, espero que les sea util, cualquier sugerencia o mejora por favor indicarla y asi como siempre digo aprendemos todos en el caminos hasta una proxima entrada