PostgreSQL 9.0 Final Liberado!!

No cabe duda que PostgreSQL ha evolucionado de manera asombrosa, no solo por la gran potencia que ha ido adquiriendo en estos ultimos años, si no tambien por la gran flexibilidad que le brinda al usuario desarrollador o administrador. Tal vez por eso es que lo converti en mi gestor de base de datos favorito :).

Recientemente se acaba de liberar la versión 9.0, lo cual viene hacer una de las versiones mas esperadas por muchos, principalmente porque una de sus grandes novedades es la replicación binaria ya desde su core, ademas de las diversas nuevas caracteristicas y mejoras, que incluyen:

  • Cambio en caliente de servidor primario
  • Replicacion continua
  • Actualización en sitio
  • Compilación en Windows de 64-bit
  • Facilidad de manejo de permisos en forma masiva
  • Bloques anonimos y parametros con nombre para llamar a stores procedures
  • Funciones de ventana y aggregates ordenados

Fuente: http://postgresql.org.pe/

Anuncios

Tutorial: Una forma rápida de usar Ibatis, Postgresql con Netbeans 6.7

Este es un pequeño tutorial en el cual trato de mostrar una forma rápida de como utilizar IBatis desde java para manejar persistencia de datos utilizando nuestro favorito postgresql como gestor de base de datos. Como siempre he dicho este blog no pretende mostrar la parte teórica, para eso ya existen varios sitios en donde podemos leerlo de forma debida, solo tratamos de mostrar el trabajo de manera rápida y practica. Bueno  manos a la obra; lo primero que debemos tener en cuenta que trabajaremos con la versión 2.3.4 de IBatis, hago esta aclaración debido a que actualmente existe una versión beta 5 de esta librería y aparentemente estas difieren por lo menos a la hora de la instancia y en la configuración de los xml, eso lo veremos en un post mas adelante. Una vez validado lo anterior, lo que debemos tener es la base de datos creada, para este caso por temas didácticos, utilizaremos la base de datos IBatisDemo la cual contiene una tabla llamada Productos con los campos mostrados en la imagen

Una vez creado la BD y la tabla, creamos el proyecto web al cual lo llamaremos WebAppIBatis y lo que haremos seria crear la siguiente estructura:

Como podran observar, ire indicando que significa cada archivo y mostrando el contenido para asi se pueda entender. Si se fijan en la parte de librerías ya tenemos anexadas las librerías de IBatis y el driver jdbc para postgresql respectivamente. Bueno según la estructura observamos un clase llamada ProductoBean, esta clase contiene los atributos necesarios para poder almacenar un registro de tipo Producto y asi ser mas manipulable, entonces la clase contendra la siguiente estructura:

package org.demo.bean;
/**
*
* @author nachxs
*/
public class ProductoBean {

    private int id_producto;
    private String desc_pro;
    private int stock;
    private String ind_vig;

    public int getId_producto() {
       return id_producto;
    }

    public void setId_producto(int id_producto) {
      this.id_producto = id_producto;
    }

    public String getDesc_pro() {
      return desc_pro;
    }

    public void setDesc_pro(String desc_pro) {
      this.desc_pro = desc_pro;
    }

    public int getStock() {
      return stock;
    }

    public void setStock(int stock) {
      this.stock = stock;
    }

    public String getInd_vig() {
      return ind_vig;
    }

    public void setInd_vig(String ind_vig) {
      this.ind_vig = ind_vig;
    }
}

Luego nos ubicamos en los archivos Conexion.xml que es el encargado de los parámetros de conexión a la base de datos  y tambbien el encargado de las referencias a todos los archivos xml que se puedan crear para mapear los consultas sql , como es el caso de Producto.xml el cual es el encargado de mapear las consultas sql que usaremos en este caso para la obtención de la información respectivamente:

Conexion.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMapConfig
   PUBLIC "-//ibatis.apache.org//DTD SQL Map Config 2.0//EN"
   "http://ibatis.apache.org/dtd/sql-map-config-2.dtd">
<sqlMapConfig>
 <transactionManager type="JDBC" >
   <dataSource type="SIMPLE">
    <property name="JDBC.Driver" value="org.postgresql.Driver"/>
    <property name="JDBC.ConnectionURL" value="jdbc:postgresql://localhost:5432/IBatisDemo"/>
    <property name="JDBC.Username" value="postgres"/>
    <property name="JDBC.Password" value="sistemasx"/>
   </dataSource>
 </transactionManager>
 <sqlMap resource="org/demo/xml/Producto.xml" />
</sqlMapConfig>

Productos.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap
   PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN"
   "http://ibatis.apache.org/dtd/sql-map-2.dtd" >
    <sqlMap namespace="Productos">
        <typeAlias alias="Productos" type="org.demo.bean.ProductoBean"/>

        <select id="getProducto" parameterClass="int" resultClass="Productos">
          SELECT id_producto, desc_pro FROM "Productos" WHERE id_producto = #value#
        </select>

        <select id="getProductos" resultClass="Productos">
          SELECT id_producto, desc_pro FROM "Productos"
        </select>
    </sqlMap>

Como podemos observar en este último archivo, estamos mapeando las consultas sql que utilizaremos, vemos que cada tag select tiene un id que es el identificador de cada consulta, tiene un parameterClass, el cual este nos ayuda a enviar parámetros de entrada ya sea datos primitivos como int, long, etc. así como también clases ya sea un bean por ejemplo y el resultClass el cual permitirá almacenar las respuestas a la consultas, en este caso estamos usando ProductoBean, el cual lo asociamos a un alias llamado Productos, según como se indica en el archivo Productos.xml.

Una vez terminado de revisar los archivos mostrados anteriormente, lo que hacemos ahora es crear un Servlet, el cual lo utilizaremos para poder invocar a nuestra consultas, según sea el caso; para esto haremos lo siguiente:

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package org.demo.action;
import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.Reader;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.demo.bean.ProductoBean;

/**
 *
 * @author nachxs
 */

public class Consultar extends HttpServlet {

    /**
     * Processes requests for both HTTP <code>GET</code> and <code>POST</code> methods.
     * @param request servlet request
     * @param response servlet response
     * @throws ServletException if a servlet-specific error occurs
     * @throws IOException if an I/O error occurs
     */

    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        try {
            String resource = "org/demo/xml/Conexion.xml";
            Reader reader = Resources.getResourceAsReader(resource);
            SqlMapClient sqlMap = SqlMapClientBuilder.buildSqlMapClient(reader);
            String idPro = request.getParameter("id_pro");
            ProductoBean producto = (ProductoBean) sqlMap.queryForObject("getProducto", Integer.parseInt(idPro));
            out.println("<table border='1'>");
            out.println("<tr>");
            out.println("<td>ID</td>");
            out.println("<td>Producto</td>");
            out.println("</tr>");
            out.println("<tr>");
            out.println("<td>" + producto.getId_producto() + "</td>");
            out.println("<td>" + producto.getDesc_pro() + "</td>");
            out.println("</tr>");
            out.println("<table>");
        } catch(Exception ex)  {
            out.println(ex.getMessage());
        } finally {
            out.close();
        }
    }

    /**
     * Handles the HTTP <code>GET</code> method.
     * @param request servlet request
     * @param response servlet response
     * @throws ServletException if a servlet-specific error occurs
     * @throws IOException if an I/O error occurs
     */

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        processRequest(request, response);
    }

    /**
     * Handles the HTTP <code>POST</code> method.
     * @param request servlet request
     * @param response servlet response
     * @throws ServletException if a servlet-specific error occurs
     * @throws IOException if an I/O error occurs
     */
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        processRequest(request, response);
    }

    /**
     * Returns a short description of the servlet.
     * @return a String containing servlet description
     */
    @Override
    public String getServletInfo() {
        return "Short description";
    }// </editor-fold>
}

Como podrán darse cuenta dentro de la variable resource tenemos la ruta en donde se encuentra ubicado el archivo xml con los parametros de conexion, en este caso Conexion.xml, y luego en esta linea sqlMap.queryForObject(“getProducto”, Integer.parseInt(idPro)) podemos observar como invocamos a la consulta que se encuentra dentro del archivo xml Productos.xml, identificado con getProducto enviando como parametro de entrada el código de producto y eso se recepciona en ProductoBean para luego ser leido mas facilmente.

Ahora solo nos queda ir al archivo index.jsp y solo invocar al servlet de esta manera tan simple:

<%--
    Document   : index
    Created on : 28/11/2009, 10:10:19 AM
    Author     : nachxs
--%>

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
   "http://www.w3.org/TR/html4/loose.dtd">
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>JSP Page</title>
    </head>
    <body>
        <form action="Consultar" method="POST">
            ID Producto: <input type="text" name="id_pro" />
            <input type="submit" value="Consultar" />
        </form>
    </body>
</html>

y prácticamente eso seria todo, como verán no es nada difícil, y mas o menos esto seria el resultado:

PostgreSQL 8.4 liberado!!!

Es grato comunicarles que la version final de postgresql, la 8.4 ya esta disponible desde el dia de hoy, claro esta con algun tiempo de retraso, pero al parecer valio la pena la espera. Esta versión incluye muchas nuevas características y mejoras que de alguna manera harán la vida más fácil a muchos usuarios, algunas de las que se explican aqui. Un motivo mas para poder optar por este potente gestor.

6_300x250

Creando Roles con PL/pgsql

Hace poco desarrollando una pequeña aplicación web con JSP y Postgres como Base de Datos, me vi en la necesidad de escribir una función en pl/pgsql para crear roles, con la finalidad de poder administrar mis usuarios de una mejor manera. Uno de los inconveniente que tuve se debió a la forma de ejecutar la sentencia (Create Role “usuario”) dado que esta no se podía ejecutar de una manera simple como sentencia estática entonces revisando algo de información y buscando en la web encontré que la forma facil de hacerlo seria con el comando “Execute”, mas o menos como lo indico a continuacion:

query_role varchar(200);

….

query_role = ‘Create Role ” ‘ || usuario || ‘ ” Login Password ”’ || tu_password || ”’ NOSUPERUSER ….’;

Execute query_role;

….

De esta manera genere una funcion enviando como parametros “usuario” y “my_password” asi poder crear los roles. Lo mismo seria para las sentencias GRANT/REVOKE.

string_to_array = split ??

Una de los métodos que quizás mas utilizo o he utilizado en el desarrollo de aplicaciones Java es split, el cual esta contenido dentro de la clase string del JDK. Bueno, hace poco trabajando un procedimiento en PostgreSQL me vi en la necesidad de utilizar una función que haga casi lo mismo, estuve revisando información que nos proporciona PostgreSQL respecto al uso de algunas funciones y me tope con string_to_array, una función en la cual se le proporciona dos parámetros, una cadena en donde se realizara la busqueda, como por ejemplo “OpenSuse|Ubuntu|PCLinuxOS|MacOSX” y el otro parámetro seria el patrón de búsqueda, que para nuestro caso seria “|”, esto nos devolveria un array, osea prácticamente haría lo mismo que split. Como verán PostgreSQL de alguna forma nos ahorra el trabajo para algunos casos :P.

Instalando pgadmin3 1.8 en ubuntu 7.10

De forma rápida y sencilla podemos instalar pgadmin3 1.8, la versión mas reciente de este Administrador de base de datos PostgreSQL, el cual es muy sencillo de utilizar y muy útil por cierto. Lo primero que tenemos que hacer es bajar la llave publica:

wget -q -O – http://www.pgadmin.org/pgp/archive_key_debian_ubuntu.gpg | sudo apt-key add –

luego agregamos al sources.list lo siguiente:

deb [MIRROR URL]/pgadmin3/release/ubuntu gutsy pgadmin

donde [MIRROR URL] es el que ustedes eligan, aquí la lista de mirrors, por ejemplo en mi caso yo lo tengo así:

deb ftp://ftp2.br.postgresql.org/postgresql/pgadmin3/release/ubuntu gutsy pgadmin

una vez hecho esta solo nos queda:

sudo apt-get update
sudo apt-get install pgadmin3

PostgreSQL