Conociendo las clases POO setter y getter

En el día de hoy vamos a hablar un poco de un tema que aunque básico es importante al momento de crear nuestras clases y estos son los "setter y los geter".

Para dar una pequeña introducción al tema vamos a explicar que son cada uno de ellos, comenzando por el setter. Un setter es un método de una clase que sirve para asignarle un valor a un atributo de una clase.

Un poco de repaso de POO, un atributo son las características de un objeto, estos por buena práctica deben de ser de acceso privado, de tal manera que solo puedan ser modificados por la misma clase de la que son características y no por otra.

Continuando con lo que se refiere al metodo setter, cuando creamos este tipo de método estamos dando acceso a otros objetos o lugar de nuestra aplicación a indicar el valor de un atributo de nuestra clase, un ejemplo de este.

class MiClase
{
    private $atrbibutoClase;
    private $otroAtributo;
    public function setAtributoClase($atrbibutoClase)
    {
        $this->atrbibutoClase = $atrbibutoClase;
    }   
    public function setOtroAtributo($otroAtributo)
    {
        $this->otroAtributo = $otroAtributo;
    }   
}

Como posemos ver son metodos que asignan valor a cada atributo de nuestra clase
MiClase, de tal manera que podamos trabajar con los datos de esta.

Hasta aca esta sencillo nuestro trabajo con los setter, pero que con los tipos de datos que estos pueden recibir??

En Java por ejemplo este tipo de métodos se les indica el tipo de valor que reciben en el parámetro ya que java es exigente en cuanto a los tipos de datos que se le asignan a las variables y atributos, pero que con nuestro amado PHP.

Hasta el día de hoy nunca había tomado en cuenta la validación de tipo de dato que se da a los setter ya que tengo una clase con la que valido los datos al momento de estar trabajand, pero en el día de hoy foreando un poco en este tema en específico entendí que se puede o mejor dicho debe hacer la validación en nuestros métodos setter. Entonces como quedarian nuestros setter con validaciones??

Suponiendo que uno de los datos sea de tipo numerico quedaria de la siguiente manera.

<?php 
class MiClase
{
    private $atrbibutoClase;
    private $otroAtributo;
    public function setAtributoClase($atrbibutoClase)
    {
        if(is_numeric($atrbibutoClase)){
           $this->atrbibutoClase = $atrbibutoClase;
        }
        else{
             throw new Exception("EL dato debe de ser numerico");
        }
    }       
}
$class = new MiClase();
$class->setAtributoClase("hola");
?>

como vemos hacemos una validacion y sino lanzamos una excepcion indicando que el tipo de dato no es el correcto para este atributo de nuestra clase.

Como vemos aunque son métodos sencillos los setter en PHP tienen que tener un poco de lógica para hacer la validación de tipo de datos del mismo.

Ahora hablemos un poco de los getter, los getter son los métodos que retornan o muestran el valor de un atributo de nuestra clase. Entonces como quedaria nuestro getter??

public function getAtrbibutoClase()
{
    return $this->atrbibutoClase;
}

De esta manera al momento de tener una instancia de nuestro objeto MiClase solo con llamar a este método obtendriamos el valor de el atributo especificado.

Estos métodos de los que hablamos hoy son valiosamente útiles al momento de declarar nuestras clases ya que nos dan acceso a los atríbutos de la misma.

Espero que esta entrada sea de su agrado y que halla explicado bien la misma, cualquier sugerencia o corrección me la hacen saber, saludos.

Entendiendo el MVC II

Siguiendo un poco el consejo del amigo mr_robb me dispuse a llevar un poco lo que hicimos a POO en PHP, para ir mostrando como trabajar los modelos y controladores con esta forma de programar, naturalmente cambia todo lo que es nuestro código anterior ya que ahora trabajaremos clases para nuestros modelos y controladores, aunque en lo que es el trabajo deberian de llevar a lo mismo un pequeño login.

Como lo que se quiere es mostrar como trabajar con los controladores y modelos y no hemos creado una clase base para estos ni para la vista incluiremos e instanciaremos los mismos en el momento que sea el caso pertinente, bueno acontinuación el nuevo código de nuestros modelos

usuario.php

/**
*
*Clase Modelo para gestionar los Usuarios
*/
/*Traemos la clase para trabajar las conexiones con la base de datos*/
require_once("db.php");
class Usuario 
{
 /**
 *
 *Definicion de atributos
 */
 private $_connection;
 /**
 *
 * Metodo Constructor para inicializar la conexion con la DB
 */
 public function __construct()
 {  
  $this->_connection = new db();
 }
 /**
 *
 *Metodo que gestiona el login de la aplicacion
 */
 public function login($user,$password)
 {
  $login = $this->_connection->selectAll('users',array('user'=>$user,'password'=>$password));
  if(count($login > 0)){
   if($login[0]['estatus'] === 'habilitado'){
    return true;
   }
   else{
    return "deshabilitado";
   }
  }
  else{
   return false;
  }
 }
 /**
 *
 * Metodo para agregar los usuarios 
 */
 public function agregarUsuario($datos = array())
 {
  if(!is_array($datos)){
   return false;
  }
  $insert = $this->_connection->insert('users',$datos);  
  if($insert){
   return true;
  }
  else{
   return "fallo";
  }  
 } 
 /**
 *
 *Metodo para deshabilitar los usuarios
 */
 public function deshabilitarUsuario($user)
 {
  $update = $this->_connection->update('users',array('estatus'=>'deshabilitado'),array('user'=>$user));  
  if($insert){
   return true;
  }
  else{
   return "fallo";
  }  
 }
}

Como podemos observar es una clase donde hacemos toda la lógica que tiene que ver con la gestión de usuarios, dentro de la misma se instancia la clase DB para trabajar con la base de datos (la clase DB es la implementada en este artículo).

UsuariosController.php

session_start();
require_once("model/usuario.php");
class UsuariosController
{
 private $model = new Usuario(); 
 public function login($user,$pass)
 {
  if($_SERVER['REQUEST_METHOD'] == "POST"){ 
   $login = $this->model->login($user,$pass);
   if($login){
    $_SESSION['login'] = "si";
    header("location: index.php");
    exit;
   }
   elseif($login === "deshabilitado"){
    unset($_SESSION['login']);
    $_SESSION['messaje'] = "Usuario Deshabilitado";
    header("location:index.php");
    exit;
   }
   else{
    unset($_SESSION['login']);
    $_SESSION['messaje'] = "Usuario o Contraseña incorrecto";
    header("location:index.php");
    exit;
  }
  else{
   header("location:login.php");
   exit;
  }
 } 
}

En el caso del controlador podemos visualizar que es una clase que instancia el modelo y llama a sus métodos de la lógica segun una acción, en este caso solo indicamos la del login para no extendernos tanto, lo importante es que se vea que el controlador no tiene ninguna lógica del negocio como plantean algunas personas, sino que en este se llama a la lógica del mismo según la acción indicada y según el caso este llamara a la vista correspondiente.

También es importante destacar que por cada acción (método) del controlador que realicemos debemos de crear una vista (código html) de tal manera que este tenga a donde redirigir y mandar los mensajes al usuario si esto es pertinente.

Como podemos ver el MVC es más útil cuando se trabaja de manera orientada a objetos, aunque esta es solo una aplicación sencilla de un login, podemos ver algo mas avanzado sobre este patrón en este artículo MVC avanzado donde el autor nos muestra como crear las clases para gestionar controladores y vistas de una gran manera, espero que esta pequeña introducción a este patrón de diseño les sirva como base en lo referente a este patrón, saludos

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.