Diferencia entre revisiones de «Apache Derby»

Revisión actual del 15:48 30 jul 2013

Apache_Derby es una Base De Datos relacional de Software Libre, implementada completamente en Java.

Características

• Derby es muy liviano - cerca de 2 MB para el motor de la base y el driver JDBC embebido.
• Derby está basado en Java, JDBC y estándares SQL.
• Derby provee un driver JDBC que permite embeber a Derby en cualquier solución Java.
• Derby también soporta el modo cliente/servidor.
• Derby es facil de instalar, desplegar y usar.

Al ser una base de datos muy liviana es ideal para usarla en test unitarios.

Store Procedures en Derby

Derby una de las pocas bases de datos de este estilo que nos permite usar Store Procedures con mas de un parámetro de output. De esta manera, es posible utilizar Derby para simular el compartamiento de Store Procedures en bases más complejas.

Ejemplo

En Derby un Store Procedure es en realidad un objeto que llama a una clase java (externa a la base de datos).

Si por ejemplo tenemos que probar el llamado a un store procedure de Oracle, para realizar la Prueba Unitaria, crearemos en Java una clase que simule el comportamiento del store procedure en Oracle: ante determinados parametros de entrada, debera devolver parametros de salida válidos.

Los parametros de salida (OUT) y los parametros de entrada y salida (IN OUT) del procedure tienen que ser del tipo array en el metodo java.

El Store Procedure en Derby

package com.dosideas.derby;
import java.sql.*;
public class DerbyProcedures {
     public static void simuloComportamientoStore(int codigo, int[] codError, String[] desError)
     {
           if (codigo == 1) 
           { 
                 codError[0]=-1;
                 desError[0]="Error 1";
           }
           
           if (codigo == 2) 
           { 
                 codError[0]=-2;
                 desError[0]="Error 2";
           };
     }
}

La ejecución

package com.dosideas.derby;
import java.sql.*;
public class Prueba {

     public static void main(String[] args) {
         try {         
           //Creamos la conexión a Derby
           Connection conn  = DriverManager.getConnection("jdbc:derby:TestDB;create=true");
        

           //Creamos el Store Procedure en Derby
           stmt = conn.createStatement();
           stmt.execute("create procedure simuloComportamientoStore"+
                        "(IN codigo INTEGER, " +
                        " OUT codError INTEGER, OUT desError VARCHAR(500)) " +
                        " parameter style java language java external name " +
                        " 'com.dosideas.derby.DerbyProcedures.simuloComportamientoStore'");
           stmt.close();

           //Invocamos al Store Procedure
           int codigo = 2;
           CallableStatement cstmt = conn.prepareCall("call simuloComportamientoStore(?,?,?)");
           cstmt.setInt(1, codigo);
           cstmt.registerOutParameter(2, Types.INTEGER);
           cstmt.registerOutParameter(3, Types.VARCHAR);  
           cstmt.execute();

           int cod = cstmt.getInt(2);
           String des = cstmt.getString(3);
           cstmt.close();

           conn.close();

           //Mostramos el resultado
           System.out.println("Resultado --> " + String.valueOf(cod)+" "+des);

           //Eliminamos el Store Procedure
           Statement stmt = conn.createStatement();
           stmt.execute("drop procedure simuloComportamientoStore");
           stmt.close();
         } 
         catch (SQLException e) {
           e.printStackTrace();
         }
     }
}

Package en Derby

Para simular un package en Derby se tiene que crear un procedure que simule ser un package. Por ejemplo, si nosotros necesitamos invocar al procedure SIMULAR_PROCEDURE del package SIMULAR_PACKAGE debemos crear un procedure que se llame SIMULAR_PACKAGE.SIMULAR_PROCEDURE.

<tsql sql="sql">CREATE procedure SIMULAR_PACKAGE.SIMULAR_PROCEDURE( INOUT CODIGO VARCHAR(15), OUT DESCRIPCION)</tsql>

El procedimiento para simular el package desde java es el mismo que para un procedure.

Funciones propias

Para crear una función propia o una que existe en otras bases y en Deby no, se puede crear una clase java que exponga un método con la funcionalidad requerida y crear una función en Derby apuntando al método de la clase java.

En este ejemplo se agrega la función "REPLACE".

public final class ReplaceDerby {

   public static String replace(final String str, final String target,
           final String replacement) {
       return str.replace(target, replacement);
   }

} Una vez creada la clase se debe generar una libreria "customDerbyReplace.jar".

<tsql sql="sql"> CALL SQLJ.INSTALL_JAR('d:\customDerbyReplace.jar', 'CUSTOMFUNCTIONS.Replace', 0); </tsql> Mediante esta llamada se registrar la librería en la base de datos.

<tsql sql="sql"> CALL SYSCS_UTIL.SYSCS_SET_DATABASE_PROPERTY('derby.database.classpath', 'CUSTOMFUNCTIONS.Replace'); </tsql> Mediante esta llamada se indica que se agregue la librería al classpath para poder ser utilizada.

<tsql sql="sql"> CREATE FUNCTION REPLACE(str VARCHAR(50), target VARCHAR(50), replacement VARCHAR(50)) RETURNS VARCHAR(50) PARAMETER STYLE JAVA NO SQL LANGUAGE JAVA EXTERNAL NAME 'com.parivero.derby.ReplaceDerby.replace' ; </tsql> Por último se crea la función con la referencia al método de nuestra clase.

Ahora podemos utilizar la función "REPLACE" en nuestro código.

<tsql sql="sql"> select replace(columna1,'bb','xx') from TABLA; </tsql>

Ver también

• Página oficial de Apache Derby
• Guía de inicio rápido