Introducción a MySQL: Conceptos Básicos

 En esta entrada comenzaremos a  trabajar con el popular  manejador de Base de Datos MySQL, vamos a ir avanzando desde lo más sencillo hasta llegar a cierto nivel de complejidad, en esta entrada se darán algunos conceptos, su instalación.

Comencemos con varios conceptos importantes antes de ir a la acción, como siempre indicando que son simples resúmenes o mejor dicho, son conceptos propios con los que se desea explicar de manera sencilla algún tema, sin más preámbulo veamos los conceptos:

Que es MySQL??

Es un Manejador o Gestor de base de datos relacional, multiusuario basado en el estándar SQL sus siglas en ingles Structure Query Language (Lenguaje de Consulta Estructurado en español).

Lenguaje de Consulta Estructurado ( SQL)

 Es el lenguaje mediante el cual realizamos diferentes operaciones en nuestros sistemas o manejadores Bases de Datos, para manipular los datos a medida que esto vaya siendo necesario. El estándar SQL es utilizado en diferentes gestores de base de dato como por ejemplo ORACLE, POSTGRESQL,SQLSERVER y MySQL por supuesto.

Manejador de Bases de Datos

Los manejadores de base de datos son programas que utilizamos para manipular la información y la creación de bases de datos para nuestros sistemas, entre los más conocidos tenemos:

-ORACLE

-MySQL.

-SQLSERVER.

-POSTGRESQL

-Microsoft Access.

Entre otros.

Ya sabemos que es un manejador de base de datos pero Que es una Bases de Datos??

Es el lugar donde guardamos la información relacionada a un sistema para ser manipulada cuando esto sea necesario, entendiendo por sistema un conjunto de componentes o información relacionada entre sí para llegar a un fin.

Una vez conocido estos conceptos generales procedamos a conocer más sobre el gestor de Base de Datos MySQL

Ya sabemos que es MySQL, pero que podemos hacer con él??

MySQL nos sirve para la administración de bases de datos, podemos realizar desde realizar operaciones básicas como creación de bases de datos, inserción, actualización y eliminación de registros, hasta la creación de funciones, procedimientos almacenados, trigger, que hacen que la gestión de nuestras bases de datos sean más eficientes.

Bueno ya que conocemos un poco vayamos al trabajo con MySQL.

Primero Instalación de MySQL

Para Windows personalmente lo he trabajado con paquetes como el XAMPP o el WAMP que traen el servidor MySQL ya instalado, también instala el cliente de MySQL, además traen un Servidor APACHE y el PHP que con instalarlos solo debes de realizar tus proyectos y guardarlos en la carpeta correspondiente, en Linux lo podemos instalar ejecutando el siguiente comando en la terminal:

Instalamos el servidor MySQL

$ apt-get install mysql-server

Instalamos el Cliente MySQL

$ apt-get install mysql-client

Ya teniendo instalado MySQL en nuestro equipo estamos listos para la acción.

Si estamos en Windows para trabajar con MySQL entramos a simbología del sistema dando click en el botón de inicio, ejecutar y colocamos cmd y presionamos enter (intro), una vez en la pantalla de simbología del sistema nos ubicamos en el bin de la carpeta mysql bien sea de XAMPP o WAMP colocando lo siguiente, en caso del XAMPP ejecutando el siguiente comando

cd  c:\xampp\mysql\bin

una vez en esta carpeta ingresamos de la siguiente manera:

mysql -u root –p

Al ejecutar este comando el terminal te pedirá la clave del usuario root normalmente esta en blanco luego de este entramos en nuestro cliente MySQL y nos aparecerá algo como esto

C:\xampp\mysql\bin>mysql -u root -p

Enter password:

Welcome to the MySQL monitor.  Commands end with ; or \g.

Your MySQL connection id is 23

Server version: 5.1.41 Source distribution

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql>

Cabe destacar que el paquete del XAMPP también instala un modo grafico al cual podemos acceder mediante el navegador con la siguiente URL

http://localhost/phpmyadmin/

Si estamos en Ubuntu trabajaremos desde la terminal utilizando el cliente MySQL accediendo de esta manera

$mysql -u root -p

Al igual que se indico para Windows te pedirá la clave del usuario root normalmente esta en blanco y ya entramos en nuestro cliente MySQL nos mostrara algo como esto

carlos@carlos-desktop:~$ mysql -u root -p

Enter password:

Welcome to the MySQL monitor.  Commands end with ; or \g.

Your MySQL connection id is 141

Server version: 5.1.41-3ubuntu12.8 (Ubuntu)

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql>

Antes de comenzar con la creación de base de datos y las sentencias de MySQL se indicaran varios Tips para que nuestras consultas sean lo más óptimas, a medida que continúe el articulo nos iremos acostumbrando.

a)      Todas las sentencias SQL terminan en punto y coma “;“ esto es una regla del estándar SQL.

b)     En los nombres de las base de datos, tablas y los campos no pueden haber separación, si el nombre de la tabla es de dos silabas se sugiere que se utilice el underscore  para separar los nombres ejemplo:
     CREATE TABLE nombre_tabla;

c)      Las sentencias deben de ir en mayúsculas, excepto por los nombres de las bases de datos, tablas o campos de una tabla de nuestra base de datos, las funciones de MySQL siempre estarán en mayúscula, ejemplo: SELECT campo FROM database.tabla;

d)     Los nombres de las bases de datos, tablas y deben de hacer referencia a lo que estas guardaran, evitar en lo mayor posible abreviaciones de nombres de tablas, ya que mientras más claro sea el nombre más fácil de entender serán nuestras consultas. Ejemplo:      
    
Manera sugerida: 

    Base de datos: cine.

   Tabla: películas

   Campos:genero,director,actores

 Manera no sugerida:

     Base de datos: cine.
     Tabla: pel 
     Campos: gen, dir, act.  

        Aunque la creación de la base de datos y las tablas no daría error, de la manera en que se sugirió se hace referencia exacta a lo que se está almacenando y cualquier administrador de base de datos con solo ver los nombres de los campos y de la tabla entiende a que hace referencia.

e)       Se sugiere que los nombres de las tablas sean en plural ya que dentro de ellas se almacenaran una gran cantidad de registros, aunque esto no da ningún error al momento de trabajar es mas explicativo.

f)      Para velar por la integridad de nuestros datos debemos tener en cuenta que para cada tipo de dato hay un tipo de campo por lo que se sugiere que se almacenen datos en sus tipo esto evita errores, un error muy común es que las fechas se almacenen en campos tipo VARCHAR, debido a que pueden guardar la fecha en el formato que ellos quieren, esto es un error grave ya que al momento de hacer comparaciones entre fechas no será óptimo ya que están en campos de tipo string y no en su correspondiente que sería de tipo fecha, para dar formatos a fechas o hacer búsquedas de alguna existen funciones como date_format,DAY, etc.

Estas son simples sugerencias para que la administración de nuestras base de datos sean lo más optima posible, en los proyectos que he realizado he trabajado de esta manera y hasta ahora no he tenido ningún problema, aunque  cualquier sugerencia siempre será válida y tomada en cuenta incluso si tienen alguna otra convención diferente que ayude a optimizar la administración de bases de datos seria buena.

Bueno en este articulo aprendimos un poco sobre los conceptos básicos de los manejadores de base de datos en especial MySQL, vimos la instalación de de este gestor, también establecimos algunas convenciones para que el manejo de las consultas sea óptimo, espero que cree curiosidad, hay mucha más teoría que se puede investigar sobre MySQL, como sus motores de almacenamiento, tipos de datos, aunque de esto se hablara un poco cuando empecemos a trabajar con tablas, ya se está trabajando en el segundo artículo donde hablaremos del lenguaje de definición de datos en MySQL, comenzaremos el trabajo con sentencias de este pequeño tutorial de MySQL, un saludo, espero que les sea útil cualquier sugerencia es aceptada Feliz Año Nuevo!!.

Patrón de diseño Singleton PHP

En esta entrada hablaremos sobre el Patrón Singleton, veremos su objetivo e implementación.

Que es el Patrón Singleton??

El Patrón Singleton o instancia única es un método que se encarga de garantizar que una clase solo tenga una sola instancia, esto lo lleva a cabo declarando el constructor de nuestra clase privado de manera que no se pueda acceder directamente a este y creando un método por lo general llamado getInstance(), donde declararemos la instancia de nuestra clase.

 Características del Patrón Singleton:

a) La propia clase es la responsable de crear la única instancia, la cual debe garantizar que no se pueda crear ninguna otra (interceptando todas las peticiones para crear nuevos objetos) y proporcionando un solo punto de acceso a ella.

b) Si no se ha creado anteriormente (o sea, es la primera vez que se usa esta clase) se crea la instancia.

c) Si existe ya anteriormente una instancia (es la segunda o más veces que se usa), se retorna la existente todas las veces que se solicite.

d) El constructor de la clase debe declararse como privado para que la clase no pueda ser instanciada directamente.

Implementación del Patrón Singleton:

class Ejemplo
{
   private static $instancia;
   private $contador;
   

   private function __construct()
   {
      echo "He creado un " . __CLASS__ . "\n";
      $this->contador = 0;
   }

   public static function getInstance()
   {
      if (  !self::$instancia instanceof self)
      {
         self::$instancia = new self;
      }
      return self::$instancia;
   }
   
   public function incrementar()
   {
      return ++$this->contador;
   }
   
   public function disminuir()
   {
      return --$this->contador;
   }
}

Como se indico en la teoría el constructor de la clase Ejemplo es privado, de manera que no se puede instanciar directamente la clase, por lo que declaramos un método que se encargue de instanciar  la clase, en este caso  es el método estático getInstance, este método lo que hace es una verificación de que si ya existe una instancia de la clase, sino existe ninguna se crea la instancia y se guarda en el atributo estático de la clase $instancia, y luego se retorna, pero que pasa si ya existe una instancia?? Sencillamente lo que hace es retornar la instancia que ya existía de la misma, veamos  nuestra clase Ejemplo en ejecución.

$instancia = Ejemplo::getInstance();
echo "instancia (incrementar): " . $instancia->incrementar();
$instancia2 = Ejemplo::getInstance();
echo "instancia2 (incrementar): " . $instancia2 ->incrementar();

El resultado por pantalla sería el siguiente:

He creado un Ejemplo
instancia (incrementar): 1
instancia2 (incrementar): 2

Porque si creamos dos instancias diferentes el contador siguió incrementándose en vez de reiniciarse?? Esto porque como se indico en la teoría el Patrón Singleton solo permite una sola instancia de la clase, al retornar la misma instancia el contador de esta no se reinicia y este sigue incrementándose.

Como nota adicional: Muchos cometemos el “error” de implementarle el patrón singleton a nuestras clases de base de datos, esto en un principio se creía que era bueno ya que te creaba una globalización de la instancia de este tipo de clase, con dudas y manos amigas nos indican que lo mejor para este tipo de clases es el patrón registry.

Bueno espero que el articulo sea del agrado de los lectores de este blog de programación saludos y cualquier comentario, critica es aceptada.

Referencias:

Desarrollador Senior

Wikipedia

Patrón Registry

Para esta entrada hablaremos un poco del Patrón de Diseño Registry,  y expondremos algunos de sus usos.

Primero veamos el código patrón:

/**
 * Registers objects and variables
 *
 * Makes objects and variables available to any level
 * of the application without having to keep track
 * of their existence.  Also useful for objects such
 * as database connectors that are used globaly and
 * not to be duplicated.
 *
 * PHP version 5
 */
 class registry
 {
     /**
      * Registry of variables and objects
      * @access private
      * @var array
      */
     static private $registry = array();
 
     /**
      * Adds an item to the registry
      * @access public
      * @param string item's unique name
      * @param mixed item
      * @return boolean
      */
     public function add($name, $item)
     {
         if (!self::exists($name)) {
             self::$registry[$name] = $item;
             return true;
         } else {
             return false;
         }
     }
 
     /**
      * Returns true if item is registered
      * @access public
      * @param string item's name
      * @return boolean
      */
     public function exists($name)
     {
         if (is_string($name)) {
             return array_key_exists($name, self::$registry);
         } else {
             throw new Exception('Registry item\'s name must be a string');
         }
     }
 
     /**
      * Returns registered item
      * @access public
      * @param string item's name
      * @return mixed (null if name is not in registry)
      */
     public function get($name)
     {
         if (self::exists($name)) {
             $return = self::$registry[$name];
         } else {
             $return = null;
         }
         return $return;
     }
 
     /**
      * Removes a registry entry
      * @access public
      * @param string item's name
      * @return boolean
      */
     public function remove($name)
     {
         if (self::exists($name)) {
             unset(self::$registry[$name]);
         }
         return true;
     }
 
     /**
      * Clears the entire registry
      * @access public
      * @return boolean
      */
     public function clear()
     {
         self::$registry = array();
     }
 }

Si nos fijamos es una clase estática  por lo que podemos acceder a sus métodos sin necesidad de instanciar la clase, dentro de sus métodos los principales son el método add()  y el método get(), mediante estos métodos vamos a llenar la instancia y a mostrar el resultado de la instancia, pero como lo hacemos?? Para crear un valor en el patrón registry usamos el método add este nos pide dos parámetros el primero es el nombre que va a llevar el valor y el segundo es el valor como tal de este veamoslo con un ejemplo:

registry::add('nombre','aca esta el valor que deseamos mostrar');

Sencillamente asignamos a nombre en  esta instancia el valor: aca esta el valor que deseamos mostrar, sencillo no y como utilizamos o se muestra el valor que acabamos de asignar?? Utilizando el método get(),  de esta manera:

echo registry::get('nombre');

El resultado nos mostraría por pantalla “aca esta el valor que deseamos mostrar”, fácil verdad?? Los demás métodos nos sirven para validación de que exista un índice, limpiar e incluso un quitar índice agregado mediante una llamada a este patrón, fácil verdad??

Que nos permite hacer el Patrón Registry??

Sencillamente nos permite mantener y modificar valores e instancias entre clases diferentes e incluso fuera de las mismas (es un concepto personal si alguien tiene objeción la puede realizar y así aprendemos más), a medida que veamos el código se entenderá mas este pequeño concepto,  un pequeño ejemplo:

a.php

class a
{
  public function llenar($valor)
 {
  registry::add('indice',$valor);
 }
}

b.php

class b
{  
 public function mostrar()
 {
  echo registry::get('indice');
 }
}

Index.php

require_once("registry.php");
require_once("a.php");
require_once("b.php");

 $a = new a();
 $b = new b();
 $a->llenar("hola");
 $b->mostrar(); 

Si se fijan en la primera clase asignamos a nuestro patrón registry un valor, en la segunda clase sencillamente mostramos el valor del índice que llenamos en la primera clase sencillo su uso no?? Veamos ahora los demás métodos en acción

b.php

class b
 {  
 public function mostrar($indice)
 {
  if(registry::exists($indice)){
   echo registry::get('indice');
  } 
  else{
   echo "El valor buscado no existe";
  }
 }
 }

re-declaramos la clase b para utilizar más métodos de nuestro patrón registry
index.php

$a = new a();
 $b = new b();
 $a->leer("hola");
 $b->mostrar('indice');
 registry::remove('indice');
 $b->mostrar('indice'); 

Si se fijan usamos el método exists para realizar una validación, y usamos el método remove para eliminar un índice que ya no necesitamos que pasaría si ejecutáramos el código expuesto??  El resultado seria “holaEl valor buscado no existe”, aunque las dos veces la función mostrar indico el mismo “índice“ no nos dio el mismo resultado, esto se debe a que utilizamos el método remove para eliminar un índice que no era más necesario, al volverlo a llamar este no existía y por eso en la validación nos mostró el mensaje de que no existe.

El patrón registry tiene muchos usos, uno de ellos puede ser una clase para conexión, en ese caso especial lo que hace el patrón registry es que solo obtengamos una instancia para un manejador de base de datos, pero a su vez podamos instanciar la clase con otro tipo de manejador.

Espero que el artículo sea de agrado y que haya logrado transmitir su funcionalidad, como siempre digo cualquier crítica o sugerencia es aceptada, hasta una próxima oportunidad saludos.

¿Qué hay de nuevo en MySQL 5.5?

Oracle llevará a cabo una presentación online con la que dar a conocer las novedades de la nueva versión final del popular sistema de gestión de bases de datos.

24/12/2010 - Bajo el título Whats New: MySQL 5.5 and MySQL Enterprise Edition, Oracle llevará a cabo un nuevo seminario online gratuito en donde podremos conocer las características de la nueva versión MySQL 5.5 (mejoras en rendimiento y velocidad, mayor escalabilidad, InnoDB como motor de almacenamiento por defecto...)

Whats New: MySQL 5.5 and MySQL Enterprise Edition se llevará a cabo el próximo 18 de enero, tendrá una duración aproximada de una hora, tras la que se abrirá un turno de preguntas y respuestas, y será llevado a cabo íntegramente en inglés.

Aquellos que lo deseen pueden adelantarse a este webseminar de Oracle, accediendo al manual de MySQL 5.5 desde dev.mysql.com.

Interesados pueden encontrar información dacerca del horario, contenido, inscripción.. en Whats New: MySQL 5.5 and MySQL Enterprise Edition desde www.mysql.com.

Fuente: DesarrolloWeb

Clases y métodos abstractos en PHP.

En esta nueva entrada retomando lo que refiere a la Programación Orientada a Objetos hablaremos un poco de las clases y métodos abstractos y cómo trabajar este tipo de clases.
Una clase abstracta: Es aquella a la que no podemos acceder directamente desde ella, sino a través de sus derivados, pero la abstracción va mas allá de eso wikipedia nos indica en resumidas cuenta la abstracción se enfoca mas en que hace que en cómo se hace??. Pero como aplicamos esto a nuestras clases?? En PHP la declaración de una clase abstracta se hace mediante la palabra “abstract” seguido de la palabra “class” y nombre de la clase ejemplo:

abstract class nombreClase

Pero en que nos ayuda una clase abstracta?? Esta permite que utilicemos las características de un objeto para crear nuevos objetos a partir de esta, veámoslo con un ejemplo, suponiendo que tengamos una clase abstracta llamada animales, los atributos o características de esta nos sirven también para clases como mamíferos, o clase ovíparos ya que estos siguen siendo una derivación de los animales, veamos un ejemplo de la implementación con nuestro ejemplo:
Animales.php

abstract class animales
{
 abstract function nacer(); 
}

mamiferos.php

class mamiferos extends animales
{
 public function nacer()
 {
  echo "los mamiferos nacen del parto de la madre";
 }
}

oviparos.php

class oviparos extends animales
{
 public function nacer()
 {
  echo "los oviparos nacen de los huevos";
 }
}

Si nos fijamos la clase abstracta animal tiene un método abstracto llamado nacer, los métodos abstractos al igual que las clases son un servicio que se presta a las clases derivadas, ya que este tipo de clase no limita a una sola característica, es acá cuando vemos el “que hace” y “no como lo hace” que nos indica el autor del articulo de wikipedia, si nos fijamos nuestra clase animales tiene el método abstracto llamado nacer esto es lo que hace, como lo hace?? Esto lo declaramos en sus derivadas que en nuestro caso son mamíferos y ovíparos.
Hasta aca hemos visto un poco la implementación de las clases abstractas, pero al principio indicábamos que una clase abstracta no puede ser accedida directamente, sino a través de sus clases derivadas, entonces que pasaría si intentamos instanciar una clase abstracta??

abstract class animales
{
 abstract function nacer(); 
}

$animales = new animales();

Nos indicaría el siguiente error: “Fatal error: Cannot instantiate abstract class animales”, o que pasaría sino declaramos el método nacer en la clase ovíparos e intentamos acceder directamente al método nacer de la clase animales??

class oviparos extends animales
{
 public function comer()
 {
  /*código del metodo*/
 }
}
$oviparos = new oviparos();
$oviparos->nacer();

Nos indicaría el siguiente error “Fatal error: Class oviparos contains 1 abstract method and must therefore be declared abstract or implement the remaining methods (animales::nacer)”

Si traducimos el error nos indica que la clase ovíparos tiene un método abstracto que debe de ser implementado o sencillamente declarar la clase abstracta.

A pesar de este error no todas los métodos de las clases abstractas deben de ser implementados, incluso hay clases abstracta en la que se declaran métodos públicos para acceder desde sus derivados un ejemplo:

Animales.php

abstract class animales
{
 abstract function nacer();
 public function fauna(){
  echo "los animales pertenecen a la fauna silvestre";
 } 
}

Ovíparos.php

require_once(“aninales.php”);
class oviparos extends animales
{
 public function nacer()
 {
  echo "los oviparos nacen de los huevos";
 }
}
$oviparos = new oviparos();
$oviparos->fauna();

si nos fijamos declaramos un método que es público para todos los animales directamente dentro de la clase abstracta, aunque no se pueda acceder a esta directamente con new animal() se puede acceder a este método sin necesidad de ser implementado en sus derivadas
Las clases abstractas nos dan uno de los principios de la Programación Orientada a Objetos (POO) que es la abstracción de los datos lo cual nos brinda una gran ayuda al momento de realizar nuestros sistemas.
Espero que este artículo sea de utilidad, cualquier corrección o sugerencia no duden en realizarla, saludos

Creacion de Graficos en documentos PDF con FPDF y JGRAPH

Para esta nueva entrada realizaremos reportes estadísticos mediante gráficos de torta, utilizando la librería FPDF y JGRAPH.

Materiales necesarios:
-Librería FPDF descargar
-Librería JGRAPG, descargar

Muchas veces al momento de estar realizando nuestros sistemas necesitamos reportes estadísticos en los mismo, mayormente lo que se necesita es un documento con los datos en formato PDF, es ahí donde utilizamos la librería FPDF, esta es una librería formada por una clase cuyos métodos nos ayudan a generar los documentos PDF, para mayor información en su sitio oficial http://www.fpdf.org/. Pero esta librería por sí sola no nos permite generar gráficos estadísticos es ahí donde entra la participación de la librería JGRAP, la cual es una librería que nos permite generar gráficos estadísticos escrita en PHP, para mas información de JGRAPH su sitio oficial es http://jpgraph.net/ .
Pero como trabajar estas librerías juntas??
En esta ocasión realizaremos una clase llamada reporte que extiende de FPDF y dentro de sus métodos utilizaremos uno para generar los gráficos mediante JGRAPH. Vamos a la acción.
Como Se indico lo primero que haremos es crear una clase que extiende FPDF esto para poder acceder a los métodos de esta librería y así crear nuestro documento PDF

class Reporte extends FPDF
{
     public function __construct($orientation='P', $unit='mm', $format='A4')
  {
   parent::__construct($orientation, $unit, $format);
 } 
}

Si nos fijamos el constructor de nuestra clase sobrescribe al constructor de la clase FPDF, de manera que cuando instanciamos nuestra clase si le damos algún parámetro el mismo pasara también a la clase padre.

Luego crearemos un método para generar los gráficos, en este articulo solo trabajaremos con los gráficos de tarta, si es necesario otro tendríamos que hacer algunas modificaciones a nuestro método.

public function gaficoPDF($datos = array(),$nombreGrafico = NULL,$ubicacionTamamo = array(),$titulo = NULL)
 { 
  //construccion de los arrays de los ejes x e y
  if(!is_array($datos) || !is_array($ubicacionTamamo)){
   echo "los datos del grafico y la ubicacion deben de ser arreglos";
  }
  elseif($nombreGrafico == NULL){
   echo "debe indicar el nombre del grafico a crear";
  }
  else{ 
   #obtenemos los datos del grafico  
   foreach ($datos as $key => $value){
    $data[] = $value[0];
    $nombres[] = $key; 
    $color[] = $value[1];
   } 
   $x = $ubicacionTamamo[0];
   $y = $ubicacionTamamo[1]; 
   $ancho = $ubicacionTamamo[2];  
   $altura = $ubicacionTamamo[3];  
   #Creamos un grafico vacio
   $graph = new PieGraph(600,400);
   #indicamos titulo del grafico si lo indicamos como parametro
   if(!empty($titulo)){
    $graph->title->Set($titulo);
   }   
   //Creamos el plot de tipo tarta
   $p1 = new PiePlot3D($data);
   $p1->SetSliceColors($color);
   #indicamos la leyenda para cada porcion de la tarta
   $p1->SetLegends($nombres);
   //Añadirmos el plot al grafico
   $graph->Add($p1);
   //mostramos el grafico en pantalla
   $graph->Stroke("$nombreGrafico.png"); 
   $this->Image("$nombreGrafico.png",$x,$y,$ancho,$altura);  
  } 
 }

Si se fijan dentro de los paramtros de nuestro método tenemos:
$datos: Es un arreglo asociativo con los datos que se desean graficar, para nuestro ejemplo es la cantidad de alumnos aprobados y reprobados de un salón de clase. El arreglo que contendrá los datos debe de tener la siguiente estructura.

Array(‘nombredeldato’=>array(valor,colorEnTarta));

Cada uno de los valores tendrá que ser mediante este formato para obtener el grafico en la manera deseada.
$nombreGrafico: Es el nombre que llevara la imagen del grafico que se creara, el método “gaficoPDF” lo que hace es crear una imagen por medio de la librería JGRAPH y luego llamar a la misma desde FPDF para obtener así el grafico dentro del documento PDF, entonces este parámetro será el nombre con que se guardara nuestra imagen del grafico en nuestro servidor.

$ubicacionTamaño: Este parámetro es un arreglo donde indicaremos el lugar y el tamaño dentro de la página que deseemos que se encuentre nuestro grafico, el formato es el siguiente

array(posicionx,posicionY,ancho,alto);

$titulo: Es la única variable que será opcional, esto por motivado a que muchas veces colocamos el titulo desde FPDF y no es necesario colocárselo al grafico, pero si en algún momento es necesario solo con indicar este parámetro el titulo del grafico sera colocado en nuestra imagen por medio de JGRAPH.
Ahora que conocemos los parámetros que debemos indicarle a nuestro método solo nos queda instanciar la clase y llamar al metodo gaficoPDF de la misma para obtener un documento PDF con un grafico estadístico.

$pdf=new Reporte();//creamos el documento pdf
$pdf->AddPage();//agregamos la pagina
$pdf->SetFont("Arial","B",16);//establecemos propiedades del texto tipo de letra, negrita, tamaño
//$pdf->Cell(40,10,'hola mundo',1);
$pdf->Cell(0,5,"GRAFICO REALIZADO CON FPDF Y JGRAPH",0,0,'C');
$pdf->gaficoPDF(array('aprobados'=>array(1,'red'),'reprobados'=>array(1,'blue')),'Grafico',array(20,40,100,50),'grafico');
$pdf->Output();

Sencillamente en este código instanciamos la clase Reportes y llamamos a varios de los métodos de la librería FPDF para crear el documento PDF y mediante el método creado en este tutorial creamos un grafico de tarta.
Les dejo el código completo del artículo:

/*
clase para reportes 
autor Carlos Belisario
*/

require_once("fpdf/fpdf.php");
require_once('jpgraph/inc/jpgraph.php');
require_once('jpgraph/inc/jpgraph_pie.php');
require_once ("jpgraph/inc/jpgraph_pie3d.php");
class Reporte extends FPDF
{
     public function __construct($orientation='P', $unit='mm', $format='A4')
  {
   parent::__construct($orientation, $unit, $format);
 } 
public function gaficoPDF($datos = array(),$nombreGrafico = NULL,$ubicacionTamamo = array(),$titulo = NULL)
 { 
  //construccion de los arrays de los ejes x e y
  if(!is_array($datos) || !is_array($ubicacionTamamo)){
   echo "los datos del grafico y la ubicacion deben de ser arreglos";
  }
  elseif($nombreGrafico == NULL){
   echo "debe indicar el nombre del grafico a crear";
  }
  else{ 
   #obtenemos los datos del grafico  
   foreach ($datos as $key => $value){
    $data[] = $value[0];
    $nombres[] = $key; 
    $color[] = $value[1];
   } 
   $x = $ubicacionTamamo[0];
   $y = $ubicacionTamamo[1]; 
   $ancho = $ubicacionTamamo[2];  
   $altura = $ubicacionTamamo[3];  
   #Creamos un grafico vacio
   $graph = new PieGraph(600,400);
   #indicamos titulo del grafico si lo indicamos como parametro
   if(!empty($titulo)){
    $graph->title->Set($titulo);
   }   
   //Creamos el plot de tipo tarta
   $p1 = new PiePlot3D($data);
   $p1->SetSliceColors($color);
   #indicamos la leyenda para cada porcion de la tarta
   $p1->SetLegends($nombres);
   //Añadirmos el plot al grafico
   $graph->Add($p1);
   //mostramos el grafico en pantalla
   $graph->Stroke("$nombreGrafico.png"); 
   $this->Image("$nombreGrafico.png",$x,$y,$ancho,$altura);  
  } 
 } 
}
$pdf=new Reporte();//creamos el documento pdf
$pdf->AddPage();//agregamos la pagina
$pdf->SetFont("Arial","B",16);//establecemos propiedades del texto tipo de letra, negrita, tamaño
//$pdf->Cell(40,10,'hola mundo',1);
$pdf->Cell(0,5,"GRAFICO REALIZADO CON FPDF Y JGRAPH",0,0,'C');
$pdf->gaficoPDF(array('aprobados'=>array(1,'red'),'reprobados'=>array(1,'blue')),'Grafico',array(20,40,100,50),'grafico');
$pdf->Output(); 

el resultado seria el siguiente:

Espero que le sea de utilidad a alguien cualquier correccion o sugerencia no duden es hacerla saludos

Funciones en PHP

Para esta entrada antes de seguir con lo que respecta a las clases, hablare un poco de las funciones en PHP, esto motivado a que los metodos de las clases se componen por funciones y para los que comenzamos aveces nos es dificil entender el funcionamiento de estas, entonces una funcion que es??

Una funcion es un fragmento de código que utilizamos para realizar una tarea o accion especifica, se declaran mediante la palabra "function" seguido de los parentesis "()", y el código que va dentro de esta se encierra entre corchetes.
ejemplo de declaracion de una funcion:

function nombreDeFuncion()
{
  echo "Este es el codigo de la funcion";
}

Sencillo no?? para utilizar el codigo de esta funcion solo tendriamos que realizar un llamado a la misma, esto lo hacemos colocando el nombre de la funcion seguido de los parentesis ejemplo

function nombreDeFuncion()
{
  echo "Este es el codigo de la funcion";
}
nombreDeFuncion();

si ejecutamos este código como resultado tendriamos el texto que indicamos entre las comillas.

Hasta ahora hemos hablado de las funciones simples, pero las funciones van mas alla de esto ya que a estas podemos ingresarles parametros externos e incluso pedir que nos den un retorno, pero parametos?? retorno?? que es como se usa??.

Un parametro es un valor que le pasamos a la funcion en su llamado, para esto en la declaracion de la funcion debemos de indicar entre los parentesis el nombre de este y cuando llamemos a la misma debemos indicarle en los parentesis cual es el valor del mismo ejemplo:

function saludar($quien)
{
  echo "Hola ".$quien." como estas?
";
}
saludar("carlos");
saludar("pedro");
saludar("juan");

el resultado de estas llamadas nos da como resultado

hola carlos como estas
hola pedro como estas
hola juan como estas

sencillo no?? pero que pasa si no le pasamos ningun parametro al momento de hacer el llamado

saludar();

PHP nos daria el siguiente alerta "Warning: Missing argument 1 for saludar(), called in". Esto lo que nos indica sencillamente es que falta indicar el argumento de la funcion saludar, para evitarnos este tipo de error podemos declarar "parametros por defectos".

Un parametro por defecto es un parametro al cual se le asigna un valor al momento de declarar una funcion, esto nos da como ventaja que si a la funcion no se le pasa parametro este toma el valor que se le indico, por lo que PHP no nos enviaria el Warning que nos mostro al principio, y asi podriamos enviar un mensaje al usuario indicandole que debe indicar el valor veamoslo con un ejemplo

function saludar($quien = "valor por defecto")
{
  if($quien == "valor por defecto"){
    echo "debe indicar un valor a la funcion";
  }
  else{
     echo "Hola ".$quien." como estas?
";
  }
}

si se fijan hicimos un condicional para que si no se pasa ningn valor la funcion se lo indique al usuario, sencillo no??.

Ahora hablaremos un poco sobre el retorno, el retorno de una funcion es un valor que esta regresa despue de la ejecución, declaramos el retorno dentro de la funcion mediante la palabra return seguido del valor que se desea regresar ejemplo.

function sumar($valor1 = 0,$valor2 = 0)
{
  $resultado = $valor1 + $valor2;
  return $resultado;
}
echo sumar(1,1);

si ejecutamos este codigo el resultado sera en la pantalla la suma de los numeros que se pasa como parametro.

OJO: es importante diferenciar entre el retorno de una funcion y mostrar el mensaje de la misma, el retorno de la funcion es un valor que esta retorna al momento de su ejecucion y puede ser almacenado y utilizado en otra parte de nuestro codigo, en cambio el imprimir un mensaje dentro de la funcion solo nos mostrara el mensaje cuando se ejecute la misma, aca dejo un ejemplo que daba en foros del web cuando hacian esta pregunta Diferencia entre echo y return

bueno el uso de la funciones es muy amplio, como dije al principio en la POO se usa para declarar los metodos de nuestras clases, tambien para hacer rutinas de codigo les dejo un pequeño ejemplo:

function calcularEdad($fecha=NULL)
{
   $fe = explode("-",$fecha);    
   if($fe[1] == date("m")){
      $edad = date('Y')-$fe[0]-1;
   }
   elseif($fe[1] == date('m')){
      if($fe[2] < date('d'))
         $edad = date('Y')-$fe[0];
      }
      else{
         $edad = date('Y')-$fe[0]-1;
      }
   }
   else{
       $edad = date('Y')-$fe[0];
   }
   return $edad;
}
//la llamamos con la fecha en formato 'año-mes-dia'
echo calcularEdad('2010-12-20');

esta es una funcion que calcula la edad indicandole la fecha de nacimiento como parametro, la utilidad de la funcion esta en que si necesitamos hacer un registro donde calculemos la edad solo tenemos que llamar a esta funcion, si deseamos tener tambien uun formulario de edicion de registro y cambia la fecha de nacimiento, no tenemos que escribir otra vez este codigo sino que llamar a la funcion, espero que esta entrada sea util, es basico pero enseña algo que es necesario saludos y hasta una proxima entrada