Collection PL/SQL – TYPE TABLE OF

En Oracle el manejo de Collection es muy importante cuando se tiene varios datos no definidos. Ya que no existen los objetos por ser un lenguaje estructurado.

A continuación se detalla el uso de una Collection Simple.

Una Collection, se forma de dos partes: INDEX y VALUE. Donde el INDEX, será nuestra llave de acceso para localizar nuestro VALUE.

Para crear una Collection de este tipo se utilizan dos pasos:

1. Creación del tipo (type)

                Utilizamos la sentencia:

                  TYPE type_name IS TABLE OF XXXXX INDEX BY YYYYY;

                Dónde:

                               XXXXX : Indica el tipo de dato que almacenará nuestra  Collection (VALUE)

                               YYYYY : Indica el tipo de dato que utilizaremos para el INDEX.

                Es importante, notar que el INDEX, solo permite los tipos de datos: VARCHAR2 ó BINARY_INTEGER

                Ejemplo:

                                 TYPE estructura_t IS TABLE OF DATE INDEX BY VARCHAR2(255);

                                 INDEX: De tipo Varchar2

                                 VALUE: De tipo DATE

2. Creación de la Variable

                Con el tipo creado (declarado) procedemos a declarar la variable a utilizar:

                               estructura estructura_t;

Para agregar valores solo haremos lo siguiente (respetando los tipos de INDEX y VALUE declarados en el Tipo):

 estructura('MIERCOLES') := SYSDATE - 10;
estructura('LUNES') := SYSDATE;
estructura('MARTES') := SYSDATE - 3; 

Sin importar el orden en que los valores sean agregados, siempre serán ordenados en base al valor del INDEX.

Y punto a recordar, si buscamos un INDEX que no existe, este tipo de Collection devuelven un NO DATA FOUND.

Aquí el ejemplo completo:

DECLARE
--
TYPE estructura_t IS TABLE OF DATE --TIPO DATO A ALMACENAR
INDEX BY VARCHAR2(255); --TIPO DATO POR EL QUE SE ACCEDE (INDEX)
estructura estructura_t;
--
  l_idx         varchar2(30);
  IDX_NO_EXISTE NUMBER := '45';
BEGI
   --Llenado de estructura
  estructura('MIERCOLES') := SYSDATE - 10;
  estructura('LUNES') := SYSDATE;
  estructura('MARTES') := SYSDATE - 3;
  --Recorrerlos de Forma lineal
  l_idx := estructura.FIRST;
  LOOP
    EXIT WHEN l_idx IS NULL;
    dbms_output.put_line('[' || l_idx || '] : [' ||estructura(l_idx) || ']');
    l_idx := estructura.NEXT(l_idx);
  END LOOP;
  --No encontrado
  BEGIN
    dbms_output.put_line('[' ||estructura(IDX_NO_EXISTE) || ']');
  EXCEPTION
    WHEN NO_DATA_FOUND THEN
      dbms_output.put_line('INDEX NO ENCONTRADO: [' || IDX_NO_EXISTE || ']');
  END;
END;

Resultado:

EDAD EXACTA EN AÑOS, MESES Y DÍAS – ORACLE PLSQL

Hoy tengo en mente volver a retomar el blog, que lleva ya, mucho tiempo abandonado. Así que empezaré con una entrada de algo que puede resultar muy útil.

En oportunidades por requerimientos de negocios en nuestros aplicativos siempre es necesario conocer la edad exacta de una persona a partir de su fecha de nacimiento, en valores de años, meses y días.

Para esto podemos hacer uso de las funciones de fecha que Oracle posee. Basándonos en la función months_between que devuelve los meses entre dos fechas como un número entero y de ser el caso con su parte fraccional.

Considerando esto, los años serían la parte entera del resultado de dividir los meses para 12. La cantidad de meses sería igual al residuo entero de la división anterior. Y los días… bueno considerando que el resultado de la resta de dos fechas (date) en Oracle siempre será dada en días, si sumamos el número entero de meses a la fecha de nacimiento y la restamos a la fecha de cálculo obtendremos un valor numérico que representa los días.

A continuación un ejemplo mucho más claro en código PLSQL:

declare
f_nacimiento date; --fecha de nacimiento de la persona
f_calculo date; --fecha a la cual deseamos saber su edad
--var respuesta:
anios number;
meses number;
dias number;
--
solo_meses number;
begin
--datos iniciales
f_nacimiento := to_date('1989/06/03', 'yyyy/mm/dd');
f_calculo := to_date('2016/07/29', 'yyyy/mm/dd');

--todo a meses
solo_meses := months_between(f_calculo, f_nacimiento);
--
anios := trunc(solo_meses / 12);
meses := trunc(mod(solo_meses, 12));
dias := f_calculo - add_months(f_nacimiento, trunc(solo_meses));
--
dbms_output.put_line('Usted tiene : ' || anios || ' año(s) con ' ||
meses || ' mes(es) y ' || dias || ' dia(s)');
end;</pre>
<pre>

Y su resultado luego de la ejecución en un test:

resultado
Saludos,

JSON DESDE VIRTUOSO + SPARQL + AJAX

La comunicación con un TripleStore desde un aplicativo externo, en su mayoría web, suele ser un inconveniente en algunos casos. Esto por la variada forma de responder y el no existir un estándar para la comunicación.

El presente caso se muestra como extraer información desde un servidor Virtuoso (EndPoint) mediante una petición HTTP, y esperando el resultado en formato JSON, el cual es muy sencillo manejar desde JavaScript.

Virtuoso en su EndPoint (http://mi_servidor:8890/sparql) permite la realización de consultas tanto de forma directa como mediante peticiones HTTP. Pudiendo ser estas un GET (consultas pequeñas) o un POST(consultas mayores a 19000 bytes). Y una de sus principales ventajas es que podemos especificar el formato en que deseamos la respuesta, pudiendo soportar formatos como XML, RDF, JSON y muchos más.

A continuación se muestra una consulta sparql y el resultado de la misma. Este mismo resultado será extraído desde un ambiente web mediante una consulta HTTP realizada por AJAX mediante el framework JQuery.

consulta_sparql
Los archivos utilizados para la demostración son los siguientes:

estructura
Dónde:

peticionHTTP.php: Forma la dirección HTTP la cual se solicitará a Virtuoso.

procesoJS.js: Contiene la consulta SPARQL y la llamada mediante Ajax.

Index.html: Inicia el proceso de la consulta.

Para la realización de la petición HTTP a virtuoso la URL que se construye utiliza los parámetros que se detallan en la imagen. Para este caso estos son los básicos y necesarios.

parametros

Como se puede apreciar, se valida la información de la petición y respuesta recibida por parte del servidor en donde se observa el formato de respuesta.

tipo_respuesta

peticion_console

Y finalmente el resultado se puede visualizar en nuestra página.

resultado_json

Los archivos utilizados los pueden descargar del widget de la página o de este link.

Información adicional la pueden encontrar en el siguiente enlace: http://virtuoso.openlinksw.com/dataspace/doc/dav/wiki/Main/VOSSparqlProtocol

Saludos.

Pasar JSON desde PHP(MySql) a JavaScript

El trabajo con estructuras JSON para el intercambio de datos entre cliente y servidor es una tarea relativamente sencilla y potente que permite agilizar el desarrollo. En este caso si necesitamos enviar datos desde un servidor que utiliza PHP y recupera datos de una base MySql bastará con tener un archivo .php similar a este:

$sql = "SELECT ID, POBLACION, NUMVISITAS FROM VISITAS_CENTROS";

$resulset = mysql_query($sql, $_SESSION["idBD"])

$arr = array();
while ($obj = mysql_fetch_object($resulset)) {
	$arr[] = array('ID' => $obj->ID,
				   'P' => utf8_encode($obj->POBLACION),
				   'NV' => $obj->NUMVISITAS,
		);
}
echo '' . json_encode($arr) . '';

El tema de la conexión con MySql puede ser consultado acá.

Haciendo uso de la instrucción  mysql_fetch_object recorreremos cada unos de los resultados de la consulta y los introduciremos en un Array que será transaformado median la instrucción json_encode.

En nuestro cliente podemos llamar a este archivo mediante JQuery de la siguiente forma:

$.ajax({
        type: "POST",
        url:"getData.php",
        async: true,
        success: function(datos){
            var dataJson = eval(datos);
			
            for(var i in dataJson){
				alert(dataJson[i].ID + " _ " + dataJson[i].P + " _ " + dataJson[i].NV);
            }
			
        },
        error: function (obj, error, objError){
            //avisar que ocurrió un error
        }
});

Donde el mostrar la información será tan fácil como utilizar un for para el objeto Json. Utilizando la sintaxis dataJson[i].PROPIEDAD para acceder a la información.

Sencillo pero muy útil.

Saludos.

Expresiones Regulares – Java

El trabajo con expresiones regulares en java es relativamente sencillo y útil. A continuación un ejemplo de como reemplazar varios espacios en blanco por uno solo.

Primero, crear un compilado de la expresión regular mediante la clase Pattern, especificando que se buscará un conjunto de espacios de 1 ó más.

Pattern patron = Pattern.compile("[ ]+");

Creamos un objeto Matcher que permitirá establecer las coincidencias dentro de la cadena basados en el compilado anterior.

Matcher encaja = patron.matcher("x     000000000    estado    buenos    malos    rrrr");

Ejecutamos la operación de reemplazo para todas las cadenas que coincidan con nuestro patrón.

String resultado = encaja.replaceAll(" ");

Lo que obtendremos será de una cadena inicial:

x     000000000    estado    buenos    malos    rrrr

algo como

x 000000000 estado buenos malos rrrr

Saludos.

ResultSet closed – mysql – java

Nuevamente me encuentro con esta situación, así que mejor la coloco como un post en el blog para tenerla luego como referencia y haber si a alguien más le sirve.
Cuando se está iterando un ResultSet en java como resultado de una consulta hacia MySql (jdbc) es muy común querer extraer más datos por cada iteración, es decir ejecutar una nueva consulta dentro del while que está iterando y recibir una excepción del tipo:

java.sql.SQLException: Operation not allowed after ResultSet closed

La misma que puede ser generada con un código parecido a este:

Statement st_A = conexion.createStatement();
ResultSet rs_A = st_A.executeQuery("cualquierConsulta");
while(rs_A.next()){
ResultSet rs_B = st_A.executeQuery("otraConsulta");
}

El origen es muy simple, cada vez que se realiza la ejecución de una sentencia en el ‘Statement’ todos los ‘ResultSet’ asociados a este son cerrados por lo que iterarlos ya no es posible (el programa anterior fallará luego de la primer iteración).

Una solución que encontré a esto es crear ‘Statement’ separados por cada uno de los ‘ResultSet’ de la siguiente forma:

Statement st_A = conexion.createStatement();
ResultSet rs_A = st_A.executeQuery("cualquierConsulta");
while(rs_A.next()){
Statement st_B = conexion.createStatement();
ResultSet rs_B = st_B.executeQuery("otraConsulta");
}

Saludos.

Publish Vocabulary using PURL and Apache

Un breve tutorial sobre el proceso de Instalar un Servidor PURL y utilizarlo para la publicación de vocabularios Utilizados en Web Semántica y Linked Data. 

Publish Vocabulary using PURL and Apache

Saludos.

PD: Como transcurra el tiempo iré perfeccionándolo, detallándolo y añadiendo nuevas características.

Iterar HashMap – JAVA

La estructuras del tipo HashMap permiten almacenar contenido relacionado de la forma LLAVE –> VALOR. Una estructura de este tipo es útil cuando existen referencias a valores de los cuales se desea saber su correspondencia con otro valor. Evitando el uso de las estructuras IF y SWITCH.

Aunque presenta  todas estas ventajas uno de sus inconvenientes, muchas de las veces, es el iterar sus elementos uno a uno. A continuación el proceso a seguir ::

Creamos un HashMap para almacenar una llave de tipo caracter y su valor entero.

HashMap<String, Integer> ht = new HashMap<String, Integer>();

Si poseemos elementos en ella podremos iterarlos uno a uno, haciendo uso de un FOREACH en base a Map.Entry para ello ::

for (Map.Entry<String, Integer> elemento : ht.entrySet()) {
     System.out.println(elemento.getKey() + " _ " + elemento.getValue());
}

Hay que recordar que el elemento a iterar deberá ser de el mismo tipo que el HashMap, en este caso <String, Integer>. Aquí un proyecto en NetBeans implementando esta utilidad.

Saludos.

Encadenamiento Hacia Delante (EHD)

El encadenamiento hacia delante aplicado a la lógica de predicados permite inferir conocimiento (o comprobarlo) mediante la utilización de varias reglas predefinidas. Aquí pueden encontrar un programa desarrollado completamente en JAVA bajo NetBeans.

El mismo se basa en un conjunto de hechos y reglas que son dados como entrada a partir de los cuales se realiza interacciones sucesivas hasta que no se pueda inferir más premisas.

Espero les resulte útil.

 

Saludos.

PD: El programa utiliza un Look&Feel de Substance, por tanto hay que importarlo primero, se encuentra en la misma carpeta del proyecto.

 

Encriptación MD5 – JAVA

Más de una vez se suele necesitar cifrar información sensible como contraseñas o códigos de aplicación. En esta ocasión realizaré la encriptación basada en MD5. Pero de forma recursiva 😉 De tal forma que tendremos la siguiente fórmula de encriptación:

MD5(MD5(MD5(PASSWORD) + MD5(SEMILLA)))

La que utiliza una semilla para garantizar más aún nuestros datos. Y como era de suponer JAVA posee una clase que nos permite aplicar MD5 a una cadena, la misma que es MessageDigest. Para ello:

Especificamos la Instancia del Algoritmo (también podemos hacerlo con SHA pero no es el caso)

MessageDigest md = MessageDigest.getInstance(«MD5»);

Indicamos los caracteres contenidos en la clave y su longitud.

md.update(clave.getBytes(«UTF-8»), 0, clave.length());

Debido a que la clase MessageDigest devuelve el valor como un vector de bytes, deberemos realizar el siguiente proceso para transformar bytes–>BigInteger–>String

byte[] bt = md.digest();

BigInteger bi = new BigInteger(1, bt);

String md5 = bi.toString(16);  //16 por hexadecimal.

Con este principio lo que se debe hacer es realizar las llamadas a un método en el orden correcto para conseguir nuestro objetivo del principio. Aquí pueden encontrar la implementación en un proyecto de NetBeans con una interfaz gráfica.
Saludos.

qmarqeva