Una tabla con datos de una base de datos MySQL con PrimeFaces (Paso a paso)

Hola gente,

una vez más con PrimeFaces, esta vez iremos un poco más allá, crearemos una tabla que mostrará datos de una base de datos MySQL. Además está tabla permitirá ordenar y filtrar y paginar los datos. Un "chiche!".

Como en el tutorial anterior, nos basaremos en el proyecto inicial creado en el post: "Primeros pasos con PrimeFaces, Eclipse y Tomcat (Paso a paso)"

Vamos a comenzar con una modificando el Filtro (LoginFilter.java) y nos aseguramos que la nueva versión contenga las líneas que muestro en negrita a continuación:

private boolean noProteger(String urlStr) {
  /*
  * Este es un buen lugar para colocar y programar todos los patrones que
  * creamos convenientes para determinar cuales de los recursos no
  * requieren protección. Sin duda que habría que crear un mecanizmo tal
  * que se obtengan de un archivo de configuración o algo que no requiera
  * compilación.
  */
  if (urlStr.indexOf("/login.xhtml")!= -1)
    return true;
  if (urlStr.indexOf("/javax.faces.resource/") != -1)
    return true;
  return false;
}

Luego en la clase LoginBean

  FacesContext.getCurrentInstance().addMessage(null, msg);
  context.addCallbackParam("estaLogeado", logeado);
  if (logeado)
    context.addCallbackParam("view", "ventas.xhtml");
}

A raíz de esta modificación, ya estoy arrepentido de haber hecho el post anterior ya que la intención fue dar una idea genérica de como se hace para proteger recursos mediante algún sistema de control de acceso con artefactos Web Java, pero por simplista he caído en lo burdo, a este sistema le falta mucho y las falencias son grandes y es debido a que no se trata de un tema trivial, veré si en el futuro me redimo y vemos algo un poco más adecuado a la realidad, por ejemplo Spring Security, en fin ya veremos las ganas y el tiempo que son dos cosas que no regalan ni se compran.

Bien hecha la mea culpa comencemos.

Creando un DataSource accesible mediante JNDI

Para definir un recurso de este tipo, solo debemos crear un archivo xml llamada "context.xml" en la carpeta WebContent/META-INF cuyo contenido debe ser:

<?xml version="1.0" encoding="UTF-8"?>
<Context>
  <Resource auth="Container" description="BD Practico" 

     name="jdbc/practico" type="javax.sql.DataSource" 

     password="xxxxx" driverClassName="com.mysql.jdbc.Driver"

     maxIdle="2" maxWait="5000" validationQuery="select 1"

     username="root" url="jdbc:mysql://localhost:3306/practico" maxActive="4" />
  <WatchedResource>WEB-INF/web.xml</WatchedResource>
  <WatchedResource>META-INF/context.xml</WatchedResource>

</Context>

Sin entrar en mucho detalle acerca de la definición del pool de conexiones, solo diremos que los datos principales que contiene este archivo son aquellos referidos a los que requiere el driver JDBC los cuales he resaltado en negrita, un atributo fundamental es el nombre de recurso que estamos creado que es "jdbc/practico" y colocar la password correcta.

Una vez que disponemos de este archivo debemos colocar en el classpath el driver JDBC de MySQL que pueden descargar desde aquí: http://cdn.mysql.com/Downloads/Connector-J/mysql-connector-java-5.1.23.zip, una vez que descarguen este archivo deben descomprimir solo mysql-connector-java-5.1.23-bin.jar que se encuentra dentro del zip y copiarlo o linkearlo (como ya hemos visto) dentro de la carpeta WebContent/WEB-INF/lib

Obteniendo una conexión del pool y alacenandola en el contexto global de la aplicación

Ya hemos realizado la configuración necesaria para que Tomcat cree un pool de conexiones al iniciar, es nuestro trabajo ahora obtener una referencia a ese pool y pedirle una conexión a la base de datos para ser utilizada en la aplicación. Es buena práctica hacer esto una sola vez y al inicio de la aplicación. Afortunadamente la especificación web de java nos provee de una serie de herramientas para poder hacerlo, en este caso haremos uso de los métodos callback de control de ciclo de vida, también se los llama listeners, usaremos particularmente el listener a nivel de contexto, el cual posee dos métodos que son llamados por el contenedor (tomcat) cuando se inicia y cuando finaliza.

Crear un listener es muy sencillo, se trata de una clase java que debe implementar para este caso la interface ServletContextListener y estar marcado con la anotación @WebListener, el código se muestra a continuación:

package ar.com.magm.web.listeners;

import java.sql.Connection;
import java.sql.SQLException;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;
import javax.sql.DataSource;

@WebListener
public class InitListener implements ServletContextListener {  public InitListener() { }

  public void contextInitialized(ServletContextEvent sce) {
    DataSource fuenteDatos = null;
    Context ctx;
    try {
      ServletContext sc = sce.getServletContext();
      ctx = new InitialContext();
      fuenteDatos = (DataSource) ctx.lookup("java:comp/env/jdbc/practico");

      Connection cn = fuenteDatos.getConnection();

      sc.setAttribute("datasource", cn);

    } catch (NamingException e) {
      throw new RuntimeException(e.getMessage());
    } catch (SQLException e) {
      throw new RuntimeException(e.getMessage());
    }
  }

  public void contextDestroyed(ServletContextEvent sce) { }

}

En las líneas:

ServletContext sc = sce.getServletContext();
ctx = new InitialContext();
fuenteDatos = (DataSource) ctx.lookup("java:comp/env/jdbc/practico");
Obtenemos una referencia al recurso mediante JNDI y el nombre que establecimos en el archivo de configuración.

La línea:

Connection cn = fuenteDatos.getConnection();

Obtiene la conexión.

La línea: 

sc.setAttribute("datasource", cn);

almacena en el contexto global de la aplicación la instancia de la conexión con el nombre datasource.

Una vez que contamos con este listener es muy sencillo acceder desde la aplicación a esta conexión.

Bien hasta aquí no hemos tocado un tema importante, a que base de datos nos conectamos, pues bien es una base de datos que he utilizado desde hace años para diversos ejemplos y la pueden descargar desde aquí, el archivo es BDDump.sql y se encuentra dentro de archivos.zip. Una vez descargado el zip y descomprimido el archivo .sql, y desde una consola escribimos:

$ mysql --user=UnUsuarioVálido --password=LaClave < BDDump.sql

Esto creará la base de datos practico en la instancia de MySQL.

Creando la vista del usuario

Ahora crearemos la vista del usuario, se trata como ya hemos visto antes de un archivo .xhtml, en este caso "ventas.xhtml", en este archivo crearemos una tabla en la cual mostraremos información de ventas que saldrán de la siguiente consulta SQL:

SELECT 

  YEAR(fecha) AS anio, 

  MONTH(fecha) AS mes, 

  zona, 

  cliente, 

  SUM(importe*cantidad) AS ventas 

FROM 

  dw_ventasfact v INNER JOIN clientes c ON v.idCliente=c.idCliente 

                  INNER JOIN zonas z ON z.idZona=c.idZona 

GROUP BY 

  zona, 

  cliente, 

  anio, 

  mes 

ORDER BY 

  anio,

  mes,

  zona,

  cliente

Para nuestro caso una venta tiene los atributos que se muestran en la imagen, o sea: año, mes, zona, cliente e importe de venta. Para representar cada venta (cada hecho), o cada fila que retorne la consulta, crearemos una clase java.

Ahora veremos el código de la vista, o sea del archivo "ventas.xhtml":

<html xmlns="http://www.w3c.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:f="http://java.sun.com/jsf/core"
      xmlns:p="http://primefaces.org/ui">
<h:head></h:head>
<h:body style="text-align:center">
  <h:form>

    <p:dataTable id="tablaDeDatos" var="venta"
      value="#{ventasBean.ventas}" widgetVar="tablaDeVentas"
      emptyMessage="No hay ventas con este criterio de filtrado"
      filteredValue="#{ventasBean.ventasFiltradas}" paginator="true"
      rows="10" style="width:800px">

      <f:facet name="header">
        <p:outputPanel>
          <h:outputText value="Buscar en todos:" />
          <p:inputText id="globalFilter" onkeyup="tablaDeVentas.filter()" style="width:150px" />

        </p:outputPanel>
      </f:facet>

      <p:column id="zonaCol" filterBy="#{venta.zona}" headerText="Zona"
        filterMatchMode="exact" filterOptions="#{ventasBean.zonasOptions}">
        <h:outputText value="#{venta.zona}" />
      </p:column>

      <p:column id="clienteCol" filterBy="#{venta.cliente}"
        headerText="Cliente" filterMatchMode="startsWith">
        <h:outputText value="#{venta.cliente}" />
      </p:column>


      <p:column id="anioCol" filterBy="#{venta.anio}" headerText="Año"
        filterMatchMode="startsWith">
        <h:outputText value="#{venta.anio}" />
      </p:column>

      <p:column id="mesCol" filterBy="#{venta.mesLetra}" headerText="Mes"
        filterMatchMode="exact" filterOptions="#{ventasBean.mesesOptions}">
        <h:outputText value="#{venta.mesLetra}" />
      </p:column>

      <p:column id="ventasCol" headerText="Importe Venta" style="text-align:right">
        <h:outputText value="#{venta.ventaFormat}"/>
      </p:column>

    </p:dataTable>
  </h:form>

</h:body>
</html>

El resultado final se verá así:

Bien, ese es todo el código de la vista del cliente, la analizaremos por partes:

Este tag:

    <p:dataTable id="tablaDeDatos" var="venta"
      value="#{ventasBean.ventas}" widgetVar="tablaDeVentas"
      emptyMessage="No hay ventas con este criterio de filtrado"
      filteredValue="#{ventasBean.ventasFiltradas}" paginator="true"
      rows="10" style="width:800px">

define la tabla de datos que se llama "tablaDeDatos" (id="tablaDeDatos"), los valores que se mostrarán en la tabla se obtendrán de: ventasBean.ventas (value="#{ventasBean.ventas}") que es una lista de instancias de Venta que es la clase java que representa solo una venta y que aún no hemos creado, por cada instancia que se recorra de la lista se crea una variable llamada venta (var="venta"). La lista que se encuentra en ventasBean.ventas contiene todas las ventas que obtenemos de la consulta SQL, este componente permite que se apliuen filtros sobre esa lista y lo implementa utilizando una segunda lista, esta es: ventasBean.ventasFiltradas (filteredValue="#{ventasBean.ventasFiltradas}") lo bueno de esto es que no tenemos que preocuparnos mas que por definir esta lista en el server, PrimeFaces la mantiene por nosotros. La lista se paginará automáticamente y mostrará 10 filas por página, el ancho de la lista será de 800 píxeles (paginator="true" rows="10" style="width:800px"). También se podrá realizar una búsqueda global (en cualquier columna), está búsqueda y filtrado se produce en el cliente, por ello debemos definir el nombre que tendrá el elemento html (el widget) en el cliente y este será: tablaDeVentas (value="#{ventasBean.ventas}"). Por último diremos que si no existen items ante algún criterio de búsqueda se mostrará el mensaje: "No hay ventas con este criterio de filtrado" (emptyMessage="No hay ventas con este criterio de filtrado").

El filtro que mencioné en el último párrafo se fine con el tag:

 <p:inputText id="globalFilter" onkeyup="tablaDeVentas.filter()"   

   style="width:150px" />

El widget tablaDeVentas posee automáticamente un método llamada filter(), al cual se llamará cada vez que finalice la presión de una tecla (onkeyup), el método de filtrado descartará todas las filas en las cuales no se encuentre en algún lugar el valor que escribamos en el campo de entrada con id="globalFilter", esto es siempre así, el id debe ser ese y ningún otro, esto la verdad que no me gusta demasiado, pero en fin...

Ahora solo resta definir las columnas que mostraremos en esta tabla de datos.

La columna que muestra la zona se define el el tag:

<p:column id="zonaCol" filterBy="#{venta.zona}" headerText="Zona"
  filterMatchMode="exact" filterOptions="#{ventasBean.zonasOptions}">
  <h:outputText value="#{venta.zona}" />
</p:column>

Para todas las columnas definiremos un id, en este caso id="zonaCol", también el texto que se mostrará en la cabecera, en este caso: headerText="Zona", también definiemos cual es el componente que renderizará el valor en cada celda, en este caso lo hacemos con el tag:

<h:outputText value="#{venta.zona}" />

donde podemos ver que se utiliza el atributo zona del bean venta, recordemos que este bean lo definimos cuando definimos la tabla (var="venta"). 

No entraré en detalle sobre estos atributos para las próximas columnas.

Particularmente para la columna zona definimos un filtro que será una lista desplegable que contiene todas las zonas posibles, a esto lo hacemos en: filterOptions="#{ventasBean.zonasOptions}", el bean ventasBean poseerá una lista especial llamada zonasOptions que otorgará la lista de zonas que mencionamos. Además definimos que cada vez que se selccione una zona se realice una búsqueda por exactamente igual en: filterMatchMode="exact". El filtro en acción se ve así:

La columna que muestra el cliente se define el el tag:

<p:column id="clienteCol" filterBy="#{venta.cliente}"

  headerText="Cliente" filterMatchMode="startsWith">
  <h:outputText value="#{venta.cliente}" />
</p:column>

La diferencia más grande (amén del valor que se muestra) es el filtro, solo hemos definido que se buscará todos aquellos valores que comiencen con: filterMatchMode="startsWith", si no se define otra cosa se utiliza un campo de texto en el cual debemos escribir el criterio de filtrado como se ve en la siguiente imagen:

El resto de las columnas están definidas utilizando conceptos que hemos explicado ya, por ello omitiré explicaciones al respecto.

El bean que representa una venta.

Como ya he comentado antes, crearemos una clase java que representará cada venta y que instanciaremos en el bean que posee las listas de ventas más adelante.

La clase se llama: ar.com.magm.model.Venta y el código es:

package ar.com.magm.model;

import java.io.Serializable;

import java.text.DecimalFormat;

public class Venta implements Serializable {

  private static final long serialVersionUID = 8060348552656940209L;

  public static long getSerialversionuid() {

    return serialVersionUID;

  }

  private int anio;

  private String cliente;

  private int mes;

  private String mesLetra;

  private double venta;

  private String zona;

  public Venta(String zona, String cliente, int anio, int mes,

               String mesLetra, double venta) {

    super();

    this.zona = zona;

    this.cliente = cliente;

    this.anio = anio;

    this.mes = mes;

    this.mesLetra = mesLetra;

    this.venta = venta;

  }

  public int getAnio() {

    return anio;

  }

  public String getCliente() {

    return cliente;

  }

  public int getMes() {

    return mes;

  }

  public String getMesLetra() {

    return mesLetra;

  }

  public double getVenta() {

    return venta;

  }

  public String getVentaFormat() {

    DecimalFormat df = new DecimalFormat("0.00");

    return df.format(venta);

  }

  public String getZona() {

    return zona;

  }

}

No hay mucho que decir de este bean, solo que tenemos un par de getters especiales, por un lago uno que nos retorna el nombre del mes getMesLetra() y el importe formateado getVentaFormat().

El bean manejado por faces que mantiene las listas de ventas.

Bien, es hora de crear el controlador que es una clase llamada ar.com.magm.web.primefaces.VentasBean y cuya configuración en faces-config.xml es: 

<managed-bean>
  <managed-bean-name>ventasBean</managed-bean-name>
  <managed-bean-class>ar.com.magm.web.primefaces.VentasBean</managed-bean-class>
  <managed-bean-scope>session</managed-bean-scope>
</managed-bean>

Notemos que el scope de este bean es session, si la lista fuese común a todos los usuarios, el scope correcto sería application ya que no sería necesario crear más instancias. En algún post futuro haremos uso de esto.

El código completo del bean es el siguiente:

package ar.com.magm.web.primefaces;

import java.io.Serializable;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.List;

import javax.faces.context.FacesContext;

import javax.faces.model.SelectItem;

import javax.servlet.ServletContext;

import ar.com.magm.model.Venta;

public class VentasBean implements Serializable {

  private static final long serialVersionUID = -6690574219803425728L;

  private String[] meses = new String[] { "Enero", "Febrero", "Marzo",

    "Abril", "Mayo", "Junio", "Julio", "Agosto", "Septiembre",

    "Octubre", "Noviembre", "Diciembre" };

  private String sql = "SELECT year(fecha) as anio, month(fecha) as mes, zona, cliente, sum(importe*cantidad) as ventas FROM dw_ventasfact v INNER JOIN clientes c ON v.idCliente=c.idCliente INNER JOIN zonas z ON z.idZona=c.idZona GROUP BY zona, cliente, anio, mes ORDER BY anio,mes,zona,cliente";

  private List<Venta> ventas;

  private List<Venta> ventasFiltradas;

  private List<String> zonas;

  public VentasBean() {

    processList(null);

  }

  public SelectItem[] getMesesOptions() {

    SelectItem[] r = new SelectItem[13];

    r[0] = new SelectItem("", "Todos");

    for (int t = 0; t < meses.length; t++)

      r[t + 1] = new SelectItem(meses[t], meses[t]);

    return r;

  }

  public List<Venta> getVentas() {

    return ventas;

  }

  public List<Venta> getVentasFiltradas() {

    return ventasFiltradas;

  }

  public SelectItem[] getZonasOptions() {

    SelectItem[] r = new SelectItem[zonas.size() + 1];

    r[0] = new SelectItem("", "Todas");

    for (int t = 0; t < zonas.size(); t++)

      r[t + 1] = new SelectItem(zonas.get(t), zonas.get(t));

    return r;

  }

  private void processList(Object args[]) {

    ventas = new ArrayList<Venta>();

    zonas = new ArrayList<String>();

    ServletContext sc = (ServletContext) FacesContext.getCurrentInstance()

                                        .getExternalContext().getContext();

    Connection cn = (Connection) sc.getAttribute("datasource");

    try {

      PreparedStatement pst = cn.prepareStatement(sql);

      if (args != null) {

        for (int t = 0; t < args.length; t++) {

          pst.setObject(t + 1, args[t]);

        }

      }

      ResultSet rs = pst.executeQuery();

      while (rs.next()) {

        String zona = rs.getString("zona");

        Venta venta = new Venta(zona, rs.getString("cliente"),

                                rs.getInt("anio"), rs.getInt("mes"),

                                meses[rs.getInt("mes") - 1], 

                                rs.getDouble("ventas"));

        ventas.add(venta);

        if (!zonas.contains(zona))

          zonas.add(zona);

      }

    } catch (SQLException e) {

      e.printStackTrace();

    }

  }

  public void setVentasFiltradas(List<Venta> ventasFiltradas) {

    this.ventasFiltradas = ventasFiltradas;

  }

}

Como pueden ver en el constructor se llama al método que llena la lista de ventas (List<Venta> ventas) processList(), lo hace en base a los datos obtenidos de la consulta sql además llena una lista con las zonas (List<String> zonas). También es necesario mencionar como obtenemos la conexión que almacenamos en el contexto general, primero obtenemos el contexto:

ServletContext sc = (ServletContext) FacesContext.getCurrentInstance()

                                     .getExternalContext().getContext();

Luego usamos el contexto para obtener la conexión:

Connection cn = (Connection) sc.getAttribute("datasource");

La lista List<Venta> ventasFiltrada junto a los métodos setVentasFiltradas() y getVentasFiltradas() es lo único que necesitamos para que los filtros se procesen correctamente del lado del server.

El método getVentas() es el fundamental, el que provee los datos iniciales de la lista de ventas y el que se utiliza para generar las listas filtradas.

Por último los métodos getMesesOptions() y getZonasOptions() retornan un arreglo de objetos SelectItem que utilizará el componente tabla para renderizar los filtros de las columnas de zona y mes.

Bien, esto es todo por ahora, recuerden que disponen del proyecto eclipse completo en: https://github.com/magm3333/workspace-pftuto

Tutorial anterior: http://jmagm.blogspot.com/2013/02/login-y-control-de-acceso-basico-con.html
Próximo tutorial: http://jmagm.blogspot.com/2013/02/pantalla-principal-con-menu-estilo-dock.html

Saludos

Mariano

Recursividad en MYSQL con Java

Hola Estimd@s,

he sacado algunas cosas del baúl y las quiero compartir, en este caso se trata de una clase Java que permite ejecutar consultas recursivas en MySQL, la idea surgió a partir de una necesidad en primera instancia y luego me base en la forma en que DB2 la lleva a cabo. Tengo la idea (cuando me haga de algún tiempo) de escribir algún articulo relacionado con recursividad en DB2 ya que es muy útil y por demás interesante. Por ahora solo esto.
Pueden descargar la clases desde aquí:

• SQLRecursivo
• Test

Copio el readme.txt que escribí para poder usar esta clase.

Esta clase está basada en la idea de recursividad de DB2.
La clase ar.com.magm.jdbc.SQLRecursivo permite implementar recursividad en MySQL. 
Aún no está bien testeada la indexación que es fundamental cuando se trabaja con muchos datos

La tabla con la que funciona la demo (clase Test) es:

CREATE TABLE `practico`.`arbol` ( 
    `idPadre` integer NOT NULL,
    `idHijo` integer NOT NULL, 
    `cantidad` integer NOT NULL, 
    PRIMARY KEY (`idPadre`, `idHijo`) 
)

Agunos datos:

INSERT INTO `practico`.`arbol` VALUES  
 (3,8,1),
 (5,6,3),
 (2,5,2),
 (1,4,2),
 (1,3,2),
 (1,2,1);
 
 Forma el siguiente árbol:
 
 1
 +--2
 |  +--5
 |     +--6
 |
 +--3
 |  +--8
 |
 +--4

El uso es muy simple, solo hay que crear una instancia de la clase SQLRecursivo, el constructor pide
una conexión JDBC, ejemplo;

SQLRecursivo sqlRec = new SQLRecursivo(cn);

Luego llamar al método recursivo(consultaInicial, aliasTablaPadre, consultaRecursiva, indexKey)

Este método retornará el resultado en forma de ResultSet.

Los parámetros son:

@param consultaInicial 
  consulta que produce la población inicial de datos.
@param aliasTablaPadre 
  alias que se utilizará en la consulta recursiva para la tabla padre
@param consultaRecursiva 
  consulta que obtiene el resto de los datos en forma recursiva. 
         Esta consulta contiene la lógica de corte de cotrol.
  Se hace referencia a la tabla padre con: //TablaPadre//
@param indexKey
         representa la clave del índice/indices que se crearán sobre la
  tabla padre, la forma es: 
  (opciones indice1)\t(clave indice1)\n(opciones indice2)\t(clave indice2), 
  en otras palabras el \n determina la cantidad de índices a crear, 
  el \t separa las opciones de la clave. 
  Para no crear ningún índice enviar "" o null. 
  Ejemplo: 
    UNIQUE CLUSTERED\tidHijo,idFiltroArbol,idFiltroGeneral\nNONCLUSTERED\tcc 
  Se crearán: 
    CREATE UNIQUE CLUSTERED INDEX IX0_##TablaPadre ON ##TablaPadre (idHijo,idFiltroArbol,idFiltroGeneral) 
    y 
    CREATE NONCLUSTERED INDEX IX1_TablaPadre ON ##TablaPadre (cc)
  

Se recomienda probar en el test las siguientes consultas:

String consultaInicial = "SELECT idPadre,idHijo FROM arbol where idPadre=1"; //Obtiene el árbol completo

para obtener el árbol completo o:
String consultaInicial = "SELECT idPadre,idHijo FROM arbol where idPadre=2"; //Obtiene el subarbol del nodo 2

En la consulta recursiva se puede (y en general se debe) hacer referencia a la tabla padre (consulta inicial),
esto se hace con la expresión: //TablaPadre//, esto se puede ver en el ejemplo. La tabla tiene un alias, 
que este ejemplo es 'padre' y es el segundo argumento del método recursivo.  Por ello en la consulta se ve:  
... a.idPadre=padre.idHijo


String consultaRecursiva = "SELECT a.idPadre,a.idHijo FROM arbol a,//TablaPadre// WHERE a.idPadre=padre.idHijo";

Enjoy 

Mariano

Video curso: Montar MySQL + Mondrian + OpenI + Tomcat6

Gente:

He confeccionado un Video curso con estas caracteríticas:

Objetivo:

Instalar y configurar un entorno OLAP utilizando tecnología Open Source, en este caso en particular: MySQL, Apache Tomcat 6, Mondrian y OPenI 2 - Alpha. Todo esto, mediante videos y audio.

---

Objetivos secundarios:

Instalar Java, Instalar MySQL y herramientas, crear una BD y poblarla, creando luego el DataWharehouse, instalar y configurar Apache Tomcat 6, instalar y configurar Mondrian (creando un Datasource y un esquema con un cubo), instalar y configurar OpenI 2 Alpha de tal manera de poder crear analsis OLAP ad hoc.

Enjoy

Instalación de MySQL y herramientas Parte 2

Hola a todos, Iñigo, Damián ¿cómo anda eso? Ja Ja Ja. En fin veo que se han despertado algunas cosas interesantes, paralelas al eje principal, bien, se las dejemos a los comentarios, yo particularmente y disponiendo de otro tiempito continuaré con esta historia.

Presuponemos, para continuar, que tenemos instalado MySQL, lo cual tratamos en el post anterior.

Lo que sigue es MySQL Administrator, que esta en la versión 1.1.9, podemos bajarla de: http://dev.mysql.com/downloads/administrator/1.1.html.

Bien, hagan doble click en mysql-administrator-1.1.9-win.msi, presionen Next> y en la próxima pantalla acepten los términos de la licencia y presionen Next >, en la pantalla que sigue, si desean cambiar la carpeta destino por defecto, presionen Change y la seleccionan, de cualquier manera presionen Next >, seleccionen Complete y luego Next>, en la pantalla resumen presionen Install. Luego de unos instantes les debería aparecer esta pantalla:

No se preocupen, no escribiré este post solo para hacer esta pavada.

Primera cosa, bastante piola, que se instala con esta herramienta es el MySQL System Tray Monitor, lo ejecutan d

esde Inicio/Programas/MySQL/ MySQL System Tray, esta opción ha estado presente hace rato, pero ahora es más fácil de acceder. La función de esta herramienta es principalmente mostrarnos y administrar el estado de la instancia del motor, buen momento

para hablar de instancia. Una instancia es la copia del código del motor en memoria, esta copia no tiene interfaz visual, solo es un algoritmo que escucha peticiones

por un puerto y responde a las mismas, puede estar en 2 estados (corriendo o parada) ni hablar que si la instancia está parada no se podrá acceder a las BD que la misma alberga. A propósito de esto, es la instancia la que administra las BD, una instancia puede administrar varias BD.

Forma del icono cuando la instancia está en funcionamiento, dicho de otra manera, cuando motor está corriendo.

Forma del icono cuando la instancia está parada.

Presionando botón derecho en este icono aparecerá un menú bastante intuitivo, el cual nos permitirá cambiar de estados la instancia, configurarla, acceder a algunas de las herramientas, cambiar las preferencias del monitor.

Solo me explayaré en algunas partes relevantes de la configuración de instancia, opción Configure Instance:

Seleccionando Service Control/Configure Service aparece la pantalla anterior, de la cual destacaremos que el Launch MySQL server automatically, debe estar seleccionado si queremos que nuestro servidor arranque con el SO, El campo Config Filename contiene la ruta del archivo de configuración de la instancia (DBM_Config_File), en Server Features pueden seleccionar algunas características avanzadas que el server soporta, por ejemplo soporte de transacciones InnoDB y/o BDB, también la posibilidad de utilizar el protocolo Named Pipes, el campo Path to binary: apunta a la carpeta en donde se encuentran los ejecutables que forman parte del motor.

Ahora seleccionando Startup Variables/General Parameters veremos la pantalla anterior, solo trataremos algunos de los parámetros que se encuentran en esta categoría, ya que de ser necesario hablaremos de otros aspectos en el momento oportuno.

Algunos de los campos son por de más sencillos de entender, por ejemplo TCP Port, que no es ni más ni menos que el puerto TCP por el que la instancia escuchará peticiones TCP/IP, este numerito de puerto lo deberemos tener muy presente ya que lo utilizaremos para conectarnos desde JDBC, el valor por defecto, y recomiendo dejarlo así, es 3306.

Base Directory es el HOME de MySQL, o sea, el lugar en donde se encuentra instalado, es necesario tener bien definida esta variable ya que le sirve a muchas herramientas para encontrar otras relativas a ese directorio.

Data Directory es la carpeta a partir de la cual se almacenaran las BD.

Todos estos valores se almacenan en un archivo, podemos seleccionar cual presionando el botón Choose Option File, es por demás recomendable hacer una copia de este archivo.

Ahora utilicemos el administrador, para ejecutarlo, pueden buscarlo en Inicio/Programas/MySQL/MySQL Administrator o si tienen activado el Monitor, presionen botón derecho y seleccionen MySQL Administrator.

Esta primera pantalla la encontrarán en otras herramientas, es la que nos facilita las conexiones, pueden definir conexiones, darles un nombre y luego volver a utilizarlas más adelante solo seccionándola por el nombre (Combo Stored Connection), presionando el botón [...] de los tres puntitos pueden acceder al administrador de conexiones, tema no muy relevante, además muy intuitivo, se los dejo a ustedes.

Bien el resto de los campos son:

Server Host, aquí colocaremos el nombre del host o bien su número IP, en este caso hemos utilizado el nombre que hace referencia a la máquina local localhost, existe un número IP asociado a este nombre y es 127.0.0.1 o loopback address.

Port: es el puerto TCP, en el cual está escuchando peticiones el servidor, por defecto MySQL utiliza 3306.

Username y Password: obviamente son los datos de la cuenta que deberá ser autenticada, tanto el nombre de usuario como la contraseña la configuramos cuando instalamos el servidor, eran, Usuario=root Password=root.

Una vez que rellenamos los datos presionamos Ok.

Bien una vez que entramos al administrador podremos realizar múltiples tareas como copias de seguridad, administración de Bases de datos y sus objetos (tablas, vistas, etc.), administrar usuarios, etc. Todas ellas muy intuitivas, en general cuando debamos hacer algo en adelante, si requerimos el uso de alguna de las herramientas visuales, me explayaré en ese momento.

Si alguno quiere que le envíe los post de este blog en formato pdf, me lo hace saber.

Hasta la próxima

Instalación de MySQL y herramientas Parte 1

Tardé en el segundo post, lo que sucede es que estoy “hasta las manos”, mi hijita cumple años.

En fin, en este post, instalaremos MySQL y algunas herramientas de administración para el motor, MySQL es una de las herramientas que utilizaremos para los distintos ejemplos.

Antes que nada, no pretendan de este post en particular aprender mucho de MySQL, solo lo instalaremos y a medida que necesitemos hacer algo, lo aprenderemos con el detalle suficiente.

MySQL es un motor de Bases de Datos Relacional de código abierto, NMSP que significa no solo Microsoft Plataforma o sea (¡¡¡¡¡¡MULTIPLATAFORMA!!!!!) , muy potente por cierto, podemos encontrar más información a cerca de MySQL en http://dev.mysql.com/.

Vale la pena aclarar que NMSP es de factoría propia, que nadie le eche la culpa a nadie más que a mí.

A la hora de escribir esto la versión disponible es 5.0.19, podemos bajarla de: http://dev.mysql.com/downloads/mysql/5.0.html

También vamos a instalar:

-MySQL Administrator, que esta en la versión 1.1.9, podemos bajarla de: http://dev.mysql.com/downloads/administrator/1.1.html. Con esta GUI podremos realizar tareas administrativas de alto nivel.

-MySQL Query Browser, que esta en la versión 1.1.20, podemos bajarla de:

http://dev.mysql.com/downloads/query-browser/1.1.html. Con esta herramienta podremos ejecutar y ver los resultados de sentencias SQL, trabajar y administrar scripts y tratar con los metadatos de las bases de datos.

Necesitamos bajar también el driver Tipo 4 JDBC-3.0 (ese 3.0 no es la versión del driver sino del API JDBC que implementa) llamado MySQL ConnectorJ, actualmente en la versión 3.1.12 (esta última si es la versión del driver), desde la dirección: http://dev.mysql.com/downloads/connector/j/3.1.html, es fundamental contar con este paquete para crear conexiones desde aplicaciones Java hacia el motor MySQL, a su debido momento hablaremos con más detalle de este tema, por ahora solo lo bajamos y lo dejamos a mano para más tarde, hay que decir que este, no es un paquete instalable.

Bien, manos a la obra, instalemos MySQL, el servidor primero y las herramientas después.

Es un mito pensar que estos productos gratuitos, son buenos, pero muy complejos de instalar, utilizar y poner a punto, esto quedará totalmente de mistificado cuando corramos el instalador de MySQL.

Descomprimamos el archivo mysql-5.0.19-win32.zip y ejecutemos setup.exe

En la primera pantalla presionaremos Next >, en la segunda nos aseguramos que está marcado Typical y presionamos Next >, en la tercera presionamos Install.

Una vez que se terminen de copiar los archivos y aparezca la pantalla MySQL.com Sign-Up, marcamos Skip Sign-Up y presionamos Next >, luego aparecerá la pantalla Configure the MySQL Server Now, asegúrense que está marcada la casilla y presionen Next >. Aparecerá el asistente de configuración de MySQL que con algunas preguntas, para las cuales no hace falta ser un gurú de las bases de datos para contestarlas, aplicará una configuración inicial al motor, seguramente mejor que una por defecto. Les aconsejo que solo presionen Next > hasta la última pantalla (por supuesto, lean lo que dice en los distintas partes, siempre algo se aprende), marquen Modify Security Settings y coloquen (en minúsculas) en New root password: root y en Confirm: root, marquen también Enable root access from remote machines, en el futuro a lo mejor hacemos algo con eso, luego de todo este PESADÍSIMO trabajo presionen Next > y luego Execute.

Si todo estuvo bien les debería aparecer algo como:

Vieron que no es nada de otro mundo.

Probemos si funciona.

Con los valores de instalación por defecto el motor se ha instalado en: “C:\Archivos de programa\MySQL\MySQL Server 5.0”, los comandos y herramientas del motor se encuentran en la carpeta bin que está montada sobre la carpeta antes mencionada, o sea: “C:\Archivos de

programa\MySQL\MySQL Server 5.0\bin”, en esa carpeta se pueden encontrar, por ejemplo con MySQLInstanceConfig.exe, que es ni más ni menos que el asistente que corrimos hace un rato, también encontraremos mysql.exe, que es el Command Line Client (CLP) o interprete de comandos de MySQL. Si son demasiado vagos como para ejecutar la consola del sistema operativo, cambiarse al directorio donde se encuentran los comandos y ejecutar mysql.exe, en esta versión viene algo muy piola que es un acceso directo al CLP lo encuentran en Inicio/Programnas/MYSQL/MySQL Server 5.0/MySQL Command Line Client.

Yo lo hice como Dios manda, “a manivela”, si no me creen vean la próxima captura de pantalla.

Que hice?

Me cambié al directorio “C:\Archivos de programa\MySQL\MySQL Server 5.0\bin”

Ejecuté: mysql –u root –p y luego escribí la clave que es root, a eso ya lo sabemos, lo configuramos anteriormente, de esta manera se conectan a la instancia del motor (una instancia es el código del motor ejecutándose en memoria) utilizando la cuenta root, o sea son el Dios del motor.

Escribí el comando show databases; (no olviden el punto y coma después de escribir cada comando), este comando muestra todas las bases de datos (BD) que el motor tiene actualmente catalogadas, en otras palabras las BD que está manejando.

Escribí: use mysql; esto me conecto a la BD llamada mysql

Escribí: show tables; esto genera un listado de las tablas de la BD a la que estamos conectados actualmente.

Escribí: select host, user, password from user; o sea, consulté las columnas host, user y password de la tabla user perteneciente a la BD mysql.

Como? Ya nos conectamos al motor, vimos las BD, nos conectamos a una en particular e hicimos una consulta SQL, SI SI SI y SI, es así de fácil, y con las otras herramientas lo será más aún.

Finalmente escribí: exit; y me fui. (no olviden los puntos y coma)

Bien ya instalamos y probamos que el motor funciona, en la próxima instalaremos las otras herramientas.

Pufff, esto es un laburo bárbaro, a este editor de blog le falta bastánte funcionalidad, pero bueno...

Se dan cuenta porque tardo tanto es postear, y todavía no arrancamos con lo interesante.

Saludos a todos y deséenle un muy feliz cumple a mi hermosa hija Catalina a la cual amo demasiado.

Hasta la próxima.