martes, 30 de septiembre de 2014

Java Message Service: Topic vs Queue

Una cola de mensajes es un lugar común donde las aplicaciones pueden publicar y consumir mensajes. Existen 4 componentes principales en un sistema de mensajería:
  • el publicador,  es quien publica un Mensaje en una Cola
  • el consumidor, es quien consume Mensajes de una Cola
  • el mensaje, que tiene algún formato que tanto publicador como consumidor conocen.
  • la cola, es el lugar donde publicadores y consumidores se conectan y comunican a través de mensajes.

Una de las grandes ventajas que ofrece el uso de colas respecto a otras tecnologías, es que el publicador y el consumidor no tienen porque estar disponibles a la vez.

Existen dos tipos de colas en JMS(Java Message Service): Topic y Queue
  • En las colas tipo Queue, existen uno o varios publicadores, y un consumidor. Los publicadores van dejando sus mensajes en la cola, y son tomados en orden por el consumidor. Si el consumidor no está disponible, la cola va guardando los mensajes, de manera que el consumidor pueda retomar su procesamiento cuando vuelva a estar disponible.


  • En las colas tipo Topic,  siguen el modelo "publicador/subscriptor". Uno o varios consumidores se "suscriben" al Topic, y van recibiendo los mensajes que se publican. Cuando se desconectan dejan de recibir esos mensajes, y los pierden.



Conclusión

  • Las colas tipo Topic se utilizan cuando la información es "time sensitive", por ejemplo en las quotas de stocks...
  • También utilizaremos las colas Topic cuando la información se envía a una audiencia amplia.
  • En cambio utilizaremos colas de tipo Queue cuando se utilicen transacciones.


lunes, 29 de septiembre de 2014

Usando Ensembles para mejorar las predicciones

Si te has iniciado con BigML, ya conoces que trabaja con modelos basados en árboles de decisiones.

Estos árboles son usados para encontrar patrones en los datos con los que realizar las predicciones. A grandes rasgos, un proceso de predicción parte de una serie de datos históricos que sirven para entrenar un modelo (o árbol) en el que se visualizan los patrones y las relaciones entre los datos. Para hacer una predicción, los nuevos datos entran en la caja negra (el árbol) y el sistema predice el resultado en función de a qué rama del árbol pertenecen.

Los "ensembles" son también llamados Bosques de Decisión ( Decision Forests en ingles). Estos usan varios árboles para hacer una predicción, y son una herramienta muy potente que sirve para mejorarla.

El concepto que se esconde detrás de los ensembles es sencillo: En vez de entrenar con un único árbol de decisiones, se utilizan varios, cada uno de ellos con un subconjunto aleatorio de datos. Cada árbol hace su predicción, y gana la predicción en la que coinciden la mayoría de los árboles. Por ejemplo, en un ensemble de 10 árboles, si la predicción de 8 de ellos es que un cliente "sí se dará de baja" de un servicio (y los otros 2 predicen que no), la predicción final será que "sí se dará de baja".

Nos preguntamos: ¿por qué todo este lío?¿Por qué no entrenar un único árbol y punto? 

Existen diversos estudios que responden a estas preguntas desde un punto de vista académico, pero para poder entenderlo hacemos referencia a Charles Parker en un artículo del blog de BigML. Si quieres profundizar más en este concepto, visita el artículo original y sus enlaces.

Pensemos en predecir qué restaurantes son los que mejor calidad y servicio ofrecen. Una posibilidad es ir a todos los restaurantes, probarlos y darles una nota a cada uno. Pero no parece algo razonable. Lo que se suele hacer es preguntar a los amigos, revisar los menús, eliminar los que de forma evidente los que no nos gustan y comer en aquellos que pensamos que tienen bastante probabilidad de ser buenos.

Si llevamos esta analogía al campo del Machine Learning, un ensemble es como si un grupo de personas buscasen un buen restaurante en una misma zona y entre todos votasen cuál es el mejor.

Paso 1: Cómo usar ensembles con BigML


Pasemos a la parte práctica y veamos qué efecto tiene sobre la confianza de las predicciones. Usaremos el dataset que ya hemos trabajado en un artículo anterior.

Tras abrir el dataset, la forma más sencilla de crear un ensemble es hacer clic en 1-CLICK ENSEMBLE, situado en el menú desplegable de la nube con un rayo:



Esta operación tarda unos segundos, luego aparecerán los 10 modelos (en dos páginas de 5 cada una) con algunas pinceladas sobre la distribución de datos y la distribución que se predice. Si haces clic en un modelo, podrás ver su árbol de decisiones y trabajar sobre él.



Paso 2: Predicciones con ensembles


Cuando hagamos una predicción, la instancia o instancias pasarán por los 10 modelos y se tomará como correcta aquella predicción que democráticamente digan los 10 modelos. Si queremos evitar resultados ambiguos cuando 5 modelos predicen TRUE y los otros 5 predicen FALSE, tendremos que usar un número impar de modelos. En nuestro caso hemos hecho una predicción individual en la que 8 modelos han predicho TRUE y 2 FALSE . Por tanto la predicción final es TRUE.




Ahora toca analizar y ver en qué medida mejora este ensemble los resultados del modelo individual del artículo anterior. Una forma de hacerlo es pasar el dataset del 20% por una Batch Prediction, exportar el resultado a Excel y ver en qué medida ha acertado las predicciones (predicciones correctas/total predicciones).

Si queremos ahorrarnos ese trabajo, podemos usar las propias herramienta que proporciona BigML: evaluaciones y comparación de evaluaciones. Según nuestros cálculos, la precisión del modelo individual es del 92,90%, mientras que el ensemble de 10 modelos aumenta al 95,50%, o sea un 3,6% más.

Conclusión


El uso avanzado de los ensembles puede aumentar considerablemente esta cifra. Mira en CONFIGURE ENSEMBLE al visualizar un dataset y verás ver las posibilidades que nos ofrecen.

Fuenteclevertask

domingo, 28 de septiembre de 2014

Tutorial de BigML, un ejemplo práctico para conocer Machine Learning

Para trabajar con Machine Learning en BigML, solo tienes que aplicar 3 pasos:
  1. Crear un dataset (Recopilación de un conjunto de datos históricos de valor).
  2. Crear un modelo con los datos (Entrenar un algoritmo).
  3. Realizar las predicciones (Ejecutar el algoritmo).
Suena complicado, pues verás que fácil es.

Ejemplo práctico 


Vamos a ver un ejemplo práctico de cómo explotar los datos que tenemos en la empresa para tomar decisiones, en este caso evitar que un cliente se dé de baja de nuestros servicios.
Imaginemos una empresa ficticia que ofrece servicios de telefonía. El objetivo que pretende nuestra empresa es mantener los clientes, por lo tanto, la pregunta es: ¿un cliente seleccionado se va a dar de baja en los siguientes X meses?. Las posibles respuestas son dos: sí o no. (será nuestra predicción).

Paso 1: Crear un dataset


Una de las tareas más importantes en el proceso de predicción es la selección y preparación de los datos para entrenar al sistema. Muchas veces pensamos que teniendo más datos, mejores serán las predicciones. Pero en la realidad no funciona así, se necesitan datos de calidad y bien estructurados. Si los datos que hemos seleccionados no son de calidad lo que estamos haciendo es introducir ruido en el sistema produciendo predicciones de poco valor o nulas. Aunque durante el proceso de entrenamiento del algoritmo el propio sistema puede detectar y descartar datos que considera superfluos, es importante hacer una labor de selección de datos que tengan sentido para responder la pregunta que nos estamos haciendo.

En nuestra empresa ficticia, vamos a representar cada cliente con algunos datos clave de su cuenta, por ejemplo, su antigüedad y el número de llamadas que ha realizado. La pieza mínima de información que usamos para definir el perfil de los clientes se llama característica (feature en inglés). El conjunto de clientes, junto con sus características, forman una dataset (un fichero CSV) que es el que utilizaremos para realizar las predicciones.


Características del dataset

Para predecir las bajas de un servicio de telefonía podríamos dividir las características en 4 grupos:
  1. Características del cliente: datos básicos del usuario (por ejemplo edad, sexo, ciudad de residencia).
  2. Características de soporte: son datos sobre la interacción del usuario con el servicio de atención al usuario (número de llamadas, cuestiones planteadas, valoración de su satisfacción).
  3. Características de uso: uso que hace el cliente del sistema (número de interacciones con el servicio, planes contratados, gasto mensual).
  4. Características adicionales o de contexto: otro tipo de información útil para la predicción (por ejemplo, antigüedad del cliente).
Usaremos un fichero que se encuentra a nuestra disposición en BigML para predecir las bajas de clientes en una empresa ficticia de telefonía. Al ser un ejemplo, las características no se ajustan exactamente a las que desearíamos, pero nos sirve para ilustrar el proceso de predicción.

El fichero que usaremos es un CSV tiene información de 3.333 abonados y tiene este aspecto:


Cada fila corresponde a un cliente, con sus características y en la última columna se indica si ese cliente se dio de baja o no (columna "churn"). El fichero original lo hemos dividido en dos.Una parte con el 80% de los datos para crear un modelo (entrenar el sistema). El otro 20% restante para verificar si el modelo hace buenas predicciones.

Si no tienes cuenta en BigML , create una (es gratis). En el panel de control (Dashboard), pulsa en el icono de la carpeta y selecciona el fichero con el 80% de los datos en tu ordenador o simplemente arrástralo desde el escritorio al espacio de trabajo (drag&drop).


Una vez subido, el fichero aparecerá en la lista de Sources:


Pulsando en el nombre del fichero que has subido, podrás ver una muestra de los datos (hasta 25 instancias). Observa que las filas se han convertido en columnas y las columnas en filas:
Como puedes observar, BigML ha detectado el tipo de dato de cada característica. En este caso sólo tenemos datos de texto y datos numéricos, representados por ABC y 123 respectivamente.

Una vez subidos los datos, procedemos a crear un Dataset, es decir, transformar el CSV en un formato que BigML puede entender y tratar. De esta forma podremos realizar un análisis previo de los datos.

Con un clic en el icono de la nube representado con un rayo creamos el Dataset en "1-CLICK DATASET":

Aparecerá la siguiente ventana:

Una vez que tenemos el dataset podemos hacer un pre-análisis de los datos. En la parte derecha, podemos visualizar los histogramas, que sirven para analizar la variación y distribución de cada característica. (Pasa el ratón por delante de las figuras para ver sus propiedades). Es interesante fijarnos en la última fila, que BigML ha marcado con una diana para indicar que es el campo objetivo, es decir, el campo que utilizaremos para predecir (automáticamente se asigna como objetivo la última columna del fichero, pero se puede cambiar):


También hay que destacar que la primera fila State, que tiene una admiración con la leyenda This field is not preferred. El sistema ha detectado que este campo no es significativo para hacer predicciones de bajas, ya que tal y como se ve en el histograma, es un dato que se puede considerar aleatorio. Es un dato que pensábamos que podría ser interesante para hacer la predicción, pero BigML lo descarta por no aportar valor y porque puede introducir ruido en las predicciones (aunque podríamos usarlo si consideramos que BigML se ha equivocado en su valoración).

¿Interesante hasta ahora no? pues espera a ver lo que viene.

Paso 2: Crear un modelo de datos


Tras crear el Dataset, procedemos a crear y entrenar el modelo. En este paso BigML va a detectar los patrones de comportamiento que llevan a los clientes a darse de baja. En la vista de Dataset hacemos clic de nuevo en el icono de la nube representado con el rayo y pulsamos esta vez en "1-CLICK MODEL":


Aparecerá una ventana con el árbol de patrones:


¿Qué es un árbol de patrones? pues este representa un modelo en el que cada nodo está asociado con una pregunta a un valor de una característica, con un número de posibles respuestas representadas por las ramas, en el que las hojas se asocian a los valores de salida. La respuesta a la primera pregunta está en el nodo superior. Según se baja por los nodos del árbol se van respondiendo a más preguntas. El valor del último nodo nos da la predicción del modelo. Cada nodo lleva asociada una confianza en porcentaje.

Hasta este punto tenemos el modelo entrenado con datos históricos. El sistema ha detectado los patrones junto con la confianza de cada uno. Llego el momento de realizar las predicciones.

Paso 3: Realizar predicciones


Existen varias formas de realizar las predicciones. En este ejemplo usaremos una de las más sencillas. Se trata de una predicción individual, de un único cliente, con las características que nosotros definamos.

Para empezar, en la vista del modelo pulsa en el icono de la nube representado con el rayo y después en "PREDICT":


Automáticamente aparece una pantalla para poner un valor a cada una de las características:


Selecciona los valores que desees y pulsa en el botón verde inferior "Predict".

¿Qué valores has puesto?¿Qué predice el modelo para este abonado?

Una predicción "uno a uno" no es práctica para muchos escenarios y ejemplos. Para predicciones "masivas" podemos usar un fichero de entrada con los datos de todos los usuarios de los que queremos hacer predicciones. Esta se realiza desde la opción "BATCH PREDICTION" que habrás visto al pulsar la última vez en el icono de la nube representado con el rayo.

Esta opción, además de servir para hacer predicciones masivas, sirve para verificar si el modelo está funcionando correctamente.


Es hora de usarlo. Hay que subirlo, crear un Dataset y hacer predicciones "Batch Prediction".

¿Ya lo has hecho?

El modelo que hemos creado, ¿está haciendo predicciones fiables?¿Qué porcentaje de las predicciones ha acertado? Te adelantamos que este modelo se puede mejorar, pero eso lo explicaremos en el artículo "Ensembles".

Conclusiones 


Una herramienta como BigML puede facilitarnos el trabajo de realizar predicciones. Si queremos integrar una aplicación para darle un valor agregado sin programar nada, podriamos entrar en unos de sus planes de pago y utilizarla con un costo razonable.

Solamente te digo que de la misma manera que este ejemplo facilita la información de cómo predecir las bajas, ¿por qué no predecir cuál es el plan más adecuado para cada cliente? Los datos están ahí. Es hora de empezar a explotarlos para ayudar a la evolución de tu empresa. Ya no es necesario instalar infraestructuras dedicadas con grandes costes de implementación y gestión. ¿Te animas?

Fuenteclevertask

sábado, 27 de septiembre de 2014

Machine Learning fácil con Java

Hay una serie de librerías disponibles en Java para el Aprendizaje Automático (Machine Learning) que facilitan la construcción de aplicaciones inteligentes. Una de las opciones más conocidas y populares es Weka. Si requieres un tratamiento con grandes cantidades de datos (Big Data), la librería Java de Apache Mahout nos facilita el trabajo. Sin embargo, en ambos casos no puedes evitar "la diversión de crear lineas de código complejas, ejecutar servidores, instalación de múltiples paquetes, escribir Jobs de tipo MapReduce, etc." Además, necesitas preocuparte de seleccionar y parametrizar el mejor algoritmo de aprendizaje para los datos, así como encontrar una manera de activar e integrar el modelo generado dentro de tu aplicación.

Para aquellas personas que han trabajado poco con Machine Learning, o aquellos que no desean programar horas y horas de código, existe una solución. BigML nos ofrece una nueva alternativa que conecta cualquier aplicación java con la API REST de BigML.  Con esta librería, y tan sólo unas pocas lineas de código, puedes crear un modelo predictivo y generar pronósticos para cualquier dominio de negocios en la que se encuentra tu aplicación. Es aplicable a muchos ejemplos: desde encontrar el mejor precio para los nuevos productos, pasando por el pronóstico de ventas, la creación de recomendaciones, para el diagnóstico o detección de anomalías, entre muchas más.
Si quieres aprender Machine Learning con un ejemplo práctico, te recomiendo que sigas el siguiente artículo: Tutorial de BigML con un ejemplo práctico para conocer Machine Learning

viernes, 26 de septiembre de 2014

Cambiar el tema por defecto del Eclipse

Cambiar el tema por defecto de Eclipse

¿Quién no se ha cansado del color blanco del Eclipse? Aunque el tema que tiene por defecto es cómodo y bonito a la hora de visualizar el código, no es para mi uno de los más atractivos para trabajar.  Existe un plugin proporcionado por la web de eclipsecolorthemes, que nos permite cambiar fácilmente el tema del Eclipse por alguno que nos proporcionan ellos.

Primero es necesario la instalación del Plugin. Para ello, desde Eclipse, ve al menú Help > Install new software. Se abre una ventana llamada Install. Presionamos en el botón Add y agregamos el name "eclipsecolorthemes" y el location "http://eclipse-color-theme.github.com/update". Le damos a OK y posteriormente instalamos el plugin usando el botón Next, o el botón Finish preferiblemente.

Tras hacer esto, ve al menú Window > Preferences > General > Appereance >Color Theme. Allí tendrás los temas disponibles y puedes elegir el que más te guste.


En particular, este tema es el que más me gusta:
http://eclipsecolorthemes.org/?view=theme&id=1

Para ello, te descargas el fichero .xml, y te diriges al menú Window > Preferences > General > Appereance >Color Theme. Presionamos sobre Import a theme… y le indicas la ruta y el fichero que acabas de descargar. Eso es todo!

jueves, 25 de septiembre de 2014

Personalizando el Eclipse y trabajar más cómodo

Desactivar el compilado automático y compilar todo manualmente

El IDE Eclipse tiene activado, por defecto, la opción de compilar automáticamente el proyecto cuando se abre o se salva un fichero modificado. Si tienes algún dispositivo lento (PC o Portatil), el compilar puede llevar varios segundos o minutos, haciendo que pierdas tiempo en el momento que estas más concentrado trabajando.

Mi primer consejo es desactivar esta opción, desmarcandola en el menú Project > Build Automatically.

Ahora para compilar el código, se encuentra la opción a través del menú Project > Build All. En caso de tener varios proyectos y quieras compilar uno en específico:  Project > Build Project.  Lo que normalmente hago, sin navegar por el menú, es usar la combinación de teclas del Build All:  CTRL+B .

Desactivar el spelling o corrección ortográfica

El IDE Eclipse trae un corrector ortográfico (spelling) para los comentarios y documentación. Este corrector viene por defecto en inglés. Podríamos descargar e instalar un diccionario en español, pero yo prefiero optar por desactivarlo por completo y quitarme las molestas líneas rojas que salen por todas partes. Para ello ir al menú Window > Preferences > General > Editor > Text Editors > Spelling  

Java lleva siempre punto y coma siempre al final

Cuantas veces no hemos tenido que desplazarnos al final de una linea para poner un simple punto y coma. ¿Es mejor que el Eclipse se encargue de colocarlos no? Pues muy fácil, ir al menú Window > Preferences > Java > Editor > Typing  y seleccionar semicolons en Automatically insert at correct position.

Insertar automáticamente el carácter escape en un String

Cuantas veces no he visto a los programadores introduciendo manualmente el carácter escape ( sí, la barra diagonal invertida "\" ) en un String. ¿Cuántas veces has realizado un copy & paste que contiene comillas y otros caracteres que necesitan utilizar la bendita barra invertida ( por ejemplo: las comillas en un código html)? 


Deja que el Eclipse se encargue de esto. Ve al menú Window > Preferences > Java > Editor > Typing  y seleccionar Escape Text when pasting into a string literal en In string literals.






jueves, 18 de septiembre de 2014

Recuperar un workspace en Eclipse

Alguna vez se te ha colgado el Eclipse en el arranque y no te carga el workspace?

Sigue los siguientes pasos para recuperar el workspace en Eclipse:

Eliminar todos los ficheros del siguiente directorio:
  $WORKSPACE/.metadata/.plugins/org.eclipse.ui.workbench

Eliminar los bloqueos:
  $WORKSPACE/.metadata/.lock

Realizar la limpieza en Eclipse:
  Eclipse -clean

Si alguna vez quieres compartir los lanzadores con otro workspace, estos son almacenados en el siguiente directorio:
  $WORKSPACE/.metadata/.plugins/org.eclipse.debug.core/.launches/

miércoles, 17 de septiembre de 2014

Cómo detectar bloqueos en Oracle

Uno de los errores comunes que ocurren en cualquier sistema informático es el bloqueo de tablas. Si has trabajado con Java y algún framework (PDA, Hibernate, iBatis ) seguramente te has encontrado con un error típico:

  • org.hibernate.exception.GenericJDBCException: Could not open connection
  • SQLException: Connections could not be acquired from the underlying database!
  • om.mchange.v2.async.ThreadPoolAsynchronousRunner$DeadlockDetector@4f8244b -- APPARENT DEADLOCK!!! Creating emergency threads for unassigned pending tasks!

Posiblemente haya ocurrido un Deadlock. Si tenemos acceso, con privilegios de administrador, a la base de datos podemos revisar los logs y detectar el error.

¿Qué es un Deadlock? 

Un Deadlock es cuando un mínimo de 2 usuarios se quedan esperando algún dato que está siendo bloqueado por alguna otra sesión. Si ésto sucede, los usuarios involucrados en el Deadlock deben esperar y no pueden continuar con el procesamiento.

En mi caso, hablaremos de detectar bloqueos en la base de datos de Oracle.

Detectar el bloqueo en Oracle

Cuando Oracle detecta que se produjo un Deadlock, lo que hace es parar la ejecución del procedimiento y mostrar el siguiente mensaje de error: ORA-00060: deadlock detected while waiting for resource. Cuando se produce un error como este, Oracle genera un archivo de trace en el directorio UDUMP con información acerca del error.

En Oracle hay una vista v$lock que indica los objetos que se encuentran en bloqueo, el identificador de usuario, sesion y el tipo de bloqueo. Si realizamos un join con la tabla dba_objects podemos obtener el nombre y tipo de los objetos bloqueados:

SELECT
  decode(L.TYPE,'TM','TABLE','TX','Record(s)') TYPE_LOCK,
  decode(L.REQUEST,0,'NO','YES') WAIT,
  S.OSUSER OSUSER_LOCKER,
  S.PROCESS PROCESS_LOCKER,
  S.USERNAME DBUSER_LOCKER,
  O.OBJECT_NAME OBJECT_NAME,
  O.OBJECT_TYPE OBJECT_TYPE,
  concat(' ',s.PROGRAM) PROGRAM,
  O.OWNER OWNER
FROM v$lock l,dba_objects o,v$session s
WHERE 
  l.ID1 = o.OBJECT_ID
  AND s.SID =l.SID
  AND l.TYPE in ('TM','TX');

Los dos tipos de bloqueos:
  • (TM) bloqueos de tablas
  • (TX) bloqueos a nivel de fila

Bloqueos de tablas

Los bloqueos a nivel de tabla son creados cuando se ejecuta una sentencia DML del tipo: update, insert, delete, select ..for update sobre la tabla entera.

Un ejemplo de sentencias DML:

DELETE from mitabla;

UPDATE mitabla SET campo1 = valor;

Bloqueos a nivel de fila

Los bloqueos a nivel de fila se crean cuando se ejecutan sentencias DML contra un conjunto de registros específicos. La siguiente consulta nos permite rápidamente saber que procesos están bloqueados. Si ademas hacemos un join con v$open_cursor podemos ver que consulta es la que se encuentra parada a la espera de que se produzca el desbloqueo para poder ejecutarse.

En la consulta siguiente podemos ver las sentencias paradas y el id de proceso que las esta bloqueando.

-- Esta query permite ver los objetos que estan esperando 
-- a que termine un bloqueo y la sentencia que quieren ejecutar. 
-- el id de proceso nos da la pista de quien esta bloqueando.

select /*+ ordered
no_merge(L_WAITER)
no_merge(L_LOCKER) use_hash(L_LOCKER)
no_merge(S_WAITER) use_hash(S_WAITER)
no_merge(S_LOCKER) use_hash(S_LOCKER)
use_nl(O)
use_nl(U)
*/
/* first the table-level locks (TM) and mixed TM/TX TX/TM */
S_LOCKER.OSUSER OS_LOCKER,
S_LOCKER.USERNAME LOCKER_SCHEMA,
S_LOCKER.PROCESS LOCKER_PID,
S_WAITER.OSUSER OS_WAITER,
S_WAITER.USERNAME WAITER_SCHEMA,
S_WAITER.PROCESS WAITER_PID,
'Table lock (TM): '||U.NAME||'.'||O.NAME||
' - Mode held: '||
decode(L_LOCKER.LMODE,
0, 'None', /* same as Monitor */
1, 'Null', /* N */
2, 'Row-S (SS)', /* L */
3, 'Row-X (SX)', /* R */
4, 'Share', /* S */
5, 'S/Row-X (SSX)', /* C */
6, 'Exclusive', /* X */
'???: '||to_char(L_LOCKER.LMODE))||
' / Mode requested: '||
decode(L_WAITER.REQUEST,
0, 'None', /* same as Monitor */
1, 'Null', /* N */
2, 'Row-S (SS)', /* L */
3, 'Row-X (SX)', /* R */
4, 'Share', /* S */
5, 'S/Row-X (SSX)', /* C */
6, 'Exclusive', /* X */
'???: '||to_char(L_WAITER.REQUEST))
SQL_TEXT_WAITER
from
V$LOCK L_WAITER,
V$LOCK L_LOCKER,
V$SESSION S_WAITER,
V$SESSION S_LOCKER,
sys.OBJ$ O,
sys.USER$ U
where S_WAITER.SID = L_WAITER.SID
and L_WAITER.TYPE IN ('TM')
and S_LOCKER.sid = L_LOCKER.sid
and L_LOCKER.ID1 = L_WAITER.ID1
and L_WAITER.REQUEST > 0
and L_LOCKER.LMODE > 0
and L_WAITER.ADDR != L_LOCKER.ADDR
and L_WAITER.ID1 = O.OBJ#
and U.USER# = O.OWNER#
union
select /*+ ordered
no_merge(L_WAITER)
no_merge(L_LOCKER) use_hash(L_LOCKER)
no_merge(S_WAITER) use_hash(S_WAITER)
no_merge(S_LOCKER) use_hash(S_LOCKER)
no_merge(L1_WAITER) use_hash(L1_WAITER)
no_merge(O) use_hash(O)
*/
/* now the (usual) row-locks TX */
S_LOCKER.OSUSER OS_LOCKER,
S_LOCKER.USERNAME LOCKER_SCHEMA,
S_LOCKER.PROCESS LOCK_PID,
S_WAITER.OSUSER OS_WAITER,
S_WAITER.USERNAME WAITER_SCHEMA,
S_WAITER.PROCESS WAITER_PID,
'TX: '||O.SQL_TEXT SQL_TEXT_WAITER
from
V$LOCK L_WAITER,
V$LOCK L_LOCKER,
V$SESSION S_WAITER,
V$SESSION S_LOCKER,
V$_LOCK L1_WAITER,
V$OPEN_CURSOR O
where S_WAITER.SID = L_WAITER.SID
and L_WAITER.TYPE IN ('TX')
and S_LOCKER.sid = L_LOCKER.sid
and L_LOCKER.ID1 = L_WAITER.ID1
and L_WAITER.REQUEST > 0
and L_LOCKER.LMODE > 0
and L_WAITER.ADDR != L_LOCKER.ADDR
and L1_WAITER.LADDR = L_WAITER.ADDR
and L1_WAITER.KADDR = L_WAITER.KADDR
and L1_WAITER.SADDR = O.SADDR
and O.HASH_VALUE = S_WAITER.SQL_HASH_VALUE

Ejemplo  

En este ejemplo tenemos la tabla SMT_TESTCASE bloqueada con una sentencia:
SELECT * FROM SMT_TESTCASE FOR UPDATE
(En esta sentencia no se ha realizado el commit), así que cualquier sentencia posterior que intente acceder a la tabla se queda en espera (En este caso se paran las dos sentencias DELETE FROM hasta que la tabla bloqueada ya no este en situación de bloqueo).

Usando la consulta de detección de bloqueos
Usando la consulta de filas bloqueadas
Esta última consulta es muy útil porque podemos anotar el "id del proceso bloqueante" y ejecutando la primera consulta con el id de proceso averiguar que objeto (SMT_TESTCASE) y que tipo se encuentra bloqueado (TABLE).

Se debe tener en cuenta que muchas situaciones de bloqueo se producen porque podemos tener el cliente (por ejemplo el Toad) sin activar la opción de “autocommit”.  Así, que al salir del cliente es cuando se nos indica que realicemos el “commit” o “rollback”.  Pero, si ejecutamos una sentencia DDL sin hacer un “commit”, a continuación podemos provocar una situación de bloqueo a otro proceso que intente actualizar la tabla o filas bloqueadas.

Fuentes de ayuda


martes, 16 de septiembre de 2014

El proceso de validación del Eclipse es muy lento.

Algunas veces se provoca una lentitud en el eclipse entre la compilación y la validación del código fuente. He detectado que ciertos plugins que se agregan al Eclipse, en mi caso versión Indigo, provocan que la validación tarde en exceso.

Al deshabilitar la validación de los elementos .xml, .js, .jsp, .json, .html, etc. Al realizar dicha acción, el Eclipse ha mejorado considerablemente su rendimiento y ha evitado que se quede congelado (freezing). Sé que mucho de vosotros necesitáis usar la validación, tal como yo la requiero. Por ello, espero que este tip pueda facilitarle la vida y ,sobre todo, les ayude a que el proceso de validación sea más rápido.

El problema que he encontrado es el siguiente: A veces el indexador JavaScript ejecuta la validación para todos los recursos en la carpeta del proyecto web, de ahora en adelante le llamamos WebRoot, de tu proyecto. Sobre la base de cómo se estructura el proyecto, es posible que deseen excluir carpetas diferentes y usando comodines como se requiere mejore el rendimiento del eclipse.

La solución pasa por evitar esta validación, para ello selecciona tu proyecto web dirígete a: Properties >  JavaScript > Include Path  y seleccionamos la ficha Source. Expandimos cualquier entrada (carpeta) y entonces seleccionamos "Excluded node" y hacemos click en "Edit". En la ventana que se abre (resulting dialog), realizamos click en "Add" en la sección de "Exclusion patterns" y escribimos en la caja de texto  "WebRoot/**" (posiblemente tengas que cambiar el nombre si tu carpeta o proyecto web "WebRoot" tiene un nombre diferente).

Propiedades del proyecto web 

lunes, 15 de septiembre de 2014

Mejorar tiempo de inicio del Eclipse

Algunas veces el IDE Eclipse, bajo la configuración por defecto, suele tardar un tiempo elevado en arrancar, esto se debe a diferentes factores como el sistema operativo que utilizamos, el hardware disponible, procesos en memoria, etc.

Os facilito una configuración para Eclipse que puede llegar a reducir un 50% el tiempo que necesita la herramienta para arrancar. En mi caso, ha mejorado de 15 segundos a 7 segundos. Solamente se necesita modificar el fichero eclipse.ini, normalmente ubicado en la carpeta donde se tenga instalado el IDE.

Recomiendo realizar una copia de seguridad del fichero.

Los parámetros que agregaremos después del parámetro vmars son los siguientes:
-Xverify:none
-XX:+UseParallelGC
-XX:PermSize=20M
-XX:MaxNewSize=32M
-XX:NewSize=32M


#########Fichero Eclipse.ini########
-startup
plugins/org.eclipse.equinox.launcher_1.0.101.R34x_v20081125.jar
--launcher.library
plugins/org.eclipse.equinox.launcher.gtk.linux.x86_1.0.101.R34x_v20080805
-showsplash
org.eclipse.platform
--launcher.XXMaxPermSize
256m
-vmargs
-Xverify:none
-XX:+UseParallelGC
-XX:PermSize=20M
-XX:MaxNewSize=32M
-XX:NewSize=32M
-Xms40m
-Xmx160m