PLSQL REGEXP_SUBSTR

"El lenguaje de base siempre es demasiado cuadrado" es lo que siempre eh dicho, no por ello puedo decir que lo encuentro aburrido ya que sin este lenguaje nadamas no podriamos obtener información de manera precisa respaldada y bueno, todo lo bueno que nos dejan las bases de datos.

Ahora solo les hablare de una función que es de mucha ayuda en otros lenguajes, tales como java, javascript, php, entre otros. Se trata nada mas y nada menos que de la funcion REGEXP_SUBSTR
la cual nos permite hacer un substring a la cadena que pasamos como parametro, dejando en un arreglo ( columna ) el resultado esperado.


Sin mas por el momento, vamos al grano...


Suponiendo que tenemos una  cadena como la siguiente.


"En|inovania.blogspot.com|siempre|encuentro|respuestas|a|mis|dudas"

En este caso la cadena esta separada por el caracter [ | ] el cual sera nuestro separador ( antes de continuar aclaro estar trabajando con PLSQL Developer, pero la funcion es la misma en otros id's ), comenzando con un bloque anonimo creamos nuestras variables.

--declaracion de un bloque anonimo
declare 
  --declaracion de variables
   TYPE t_separador IS TABLE OF TABLA.COLUMNA%type;--SE PASA EL TIPO DE DATO QUE SEA LO QUE SEPARAREMOS
   vt_dato t_separador;
   is_cadena_str VARCHAR2( 100 );
begin
  --asignacion de valor a variable
  is_cadena_str:= 'En|inovania.blogspot.com|siempre|encuentro|respuestas|a|mis|dudas';
  --impresion de contenido de variable
  dbms_output.put_line('is_cadena_str: ' ||  is_cadena_str );
  --fin del bloque anonimo
end;

Aquí, lo que da como resultado este bloque anónimo es una muestra el valor de la variable con el texto que anteriormente dijimos.

A continuación se se parsea la cadena guardandola en la variable vt_dato.

select valor
    bulk collect into vt_dato
    from (
        select regexp_substr(is_cadena_str,'[^|]+', 1, level) as valor from dual
        connect by regexp_substr(is_cadena_str, '[^|]+', 1, level) is not null
    );

Los campos de la función en el orden que los va pidiendo:
1.- is_cadena_str : cadena que queremos parsear,
2.- '[^|]+' : expresion que nos ayuda a separar la cadena por el caracter |
3.- 1 : El numero de consecutivos a seguir dependiendo cada separador, si se pone 2 deja a un lado la primera posicion del resultado es decir de ser 8 los valores resultado de esta cadena solo seran 7.
4.- level: undefined. required : true.


Ya para finalizar recorremos el resultado en un for loop mostrando nuestra cadena dentro del arreglo, colection, tabla.

  for a in vt_dato.first .. vt_dato.last loop
      dbms_output.put_line( 'valor de vt_dato( ' || a || ' ): ' || vt_dato( a ) || '' );
    end loop;

Dejando como salida.

is_cadena_str: En|inovania.blogspot.com|siempre|encuentro|respuestas|a|mis|dudas
valor de vt_dato( 1 ): En
valor de vt_dato( 2 ): inovania.blogspot.com
valor de vt_dato( 3 ): siempre
valor de vt_dato( 4 ): encuentro
valor de vt_dato( 5 ): respuestas
valor de vt_dato( 6 ): a
valor de vt_dato( 7 ): mis
valor de vt_dato( 8 ): dudas

No olvides dejarme tus comentarios. si hay algo que se me paso, escribe y daré respuesta.


Hasta la proxima.

Funciones personalizadas en EXCEL

Recientemente me encuentro con un problema que me esta dando vueltas en la cabeza, resulta que buque una función en especifico en excel, la cual trata lo siguiente.

Tengo dos series

Se requiere evaluar si cada uno  de los valores en la serie 2 existe en la serie 1

Dejando de esta manera es como resulta mas fácil identificar que valores están repetidos para ello es necesario entrar al modo edición de módulos de Excel.

En el menú Insertar--> Modulo

Function busqueda_en_rango(valor As Integer, rango As Range) As Integer
    Dim count As Integer
    count = 0
    For Each celda In rango.Cells
        If celda.Value = valor Then
            count = count + 1
        End If
    Next celda
    If count = 0 Then
        busqueda_en_rango= 0
    Else
        busqueda_en_rango= 1
    End If
End Function

Y es así como pasamos la función en la celda que queremos comparar

dejando como resultado el valor 1 en caso de existir y 0 en caso de no existir en la serie

Espero sus comentarios, sus opiniones cuentan. nos vemos a la proxima.

Uso de JDBC

La conexión a base de datos desde java es un punto indispensable de nuestras aplicaciones, para ello tenemos la librería JDBC  ( Java Database Connectivity ) la cual no permite genera una conexión segura a la base de datos, hablando de Oracle como db.

Por otro lado tenemos el enlace a MySQL desde java. Pero... eso lo vemos después.

Los métodos que estarán presentes en nuestros objetos serán, conectar y desconectar, pero antes de ello es necesario agregar la librería a nuestro pom en caso de tenerlo, la dependencia es la siguiente.

        <dependency>
           <groupId>com.oracle</groupId>
           <artifactId>ojdbc6</artifactId>
           <version>11.2.0.3</version>
       </dependency>
    

De lo contrario si tu proyecto no cuenta con un archivo pom.xml, la segunda opción es agregar un jar al proyecto, para ello lo puedes descargar de aquí.

Una vez que ya se tiene el driver, lo siguiente es crear los métodos anteriormente mencionados, para ello creamos una clase.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author decodemy.blogspot.com
 */
public class JDBCConnection {

    /**
     * Establece la coneccion a una base de datos Oracle mediante JDBC
     *
     * @param user Usuario de db
     * @param pass Password de db
     * @param stringConnection Cadena de conexion para crear enlace
     * @throws java.sql.SQLException Throws exception SQL
     * @throws java.lang.ClassNotFoundException Throws Class Not fownd
     * @return connection
     */
    public Connection conectar(
        String user, 
        String pass, 
        String stringConnection
    ) throws SQLException, ClassNotFoundException {
        
        Connection con = null;
        Class.forName("oracle.jdbc.OracleDriver");
        con = DriverManager.getConnection(stringConnection, user, pass);
        if (con == null) {
            throw new SQLException("Connection is null");
        }
        return con;
    }
    
    /**
     * metodo creado para cerrar la conexion
     * @param con conexion a cerrar
     * @return true or false
     */
    public boolean desconectar( Connection con ){
        try {
            con.close();
            if( con == null )
                return true;
            else
                return false;
        } catch (SQLException ex) {
            Logger.getLogger(JDBCConnection.class.getName()).log(Level.SEVERE, null, ex);
        }
        return false;
    }
}

Esta clase permite conectar y desconectar una instancia a base de datos, su implementación la dejamos de la siguiente manera.

Creamos una clase que herede la clase anterior, con " extends JDBCConnection  ", para después agregar nuestra cadena de conexión.

Nota: la cadena de conexión contiene el balanceo para poder diferenciar entre los nodos donde se encuentra nuestra base. Quedando de la siguiente manera

String stringDeConeccion = "jdbc:oracle:thin:@ ( DESCRIPTION = ( ADDRESS = ( PROTOCOL = TCP )( HOST = IP_DEL_SERVIDOR_DB ) ( PORT = PUERTO_DEL_SERVIDOR_DB ) ) ( CONNECT_DATA = ( SERVICE_NAME=sie ) ) )";

con ello tenemos una cadena de coneccion a la cual podemos agregar mas address para ir haciendo a su vez un balanceo entre los nodos.

El método de consulta queda así.

    public Consulta() {
        Connection con;
        PreparedStatement stmt = null;
        StringBuilder query = new StringBuilder();
        try {
            con = conectar("usuario", "password", sdc);
            query.append("SELECT COUNT(*) AS TOTAL FROM EMPLEADOS");
            stmt = con.prepareStatement(query.toString());
            ResultSet rs = stmt.executeQuery();
            while (rs.next()) {
                System.out.println(rs.getInt("TOTAL"));
            }
            desconectar(con);
        } catch (ClassNotFoundException | SQLException err) {
            System.err.println("Error en consulta " + err.getMessage());
        }
    }

De esta manera el metodo conectar y desconectar que creamos en la clase JDBCConnection quedan heredados en nuestra clase dao.

Mas adelante les mostrare como hacer diferentes llamados a base desde java, invocando funciones, strore procedure, querys sencillos como se tiene ahorita, entre otras cosas.


No olvides dejar tu comentario al respecto, de esa manera conoceré tu opinión.

Nos vemos pronto.