Spesso capita di avere più database che contengono copie delle biasi di dati, immaginiamo ad esempio nell’ambito di una applicazione il database ti sviluppo, test e quello di produzione oppure lo stesso db di clienti differenti.

Potremmo arrivare ad un punto in cui questi database sono disallineati per campi o tabelle presenti su uno e non sugli altri. Se non si è tenuta traccia di tutti i cambiamenti apportati si può avere la necessità di utilizzare una query per estrarre un riassunto di tutte le colonne delle varie tabelle e confrontare il risultato ottenuto sui diversi schemi.

Ecco la query:

select
   table_name,
   column_name,
   data_type,
   NVL(data_length, 0) data_length,
   NVL(data_precision, 0) data_precision,
   NVL(data_scale, 0) data_scale,
   nullable
from
   sys.all_tab_cols
where
   owner='OWNER_NAME'
order by
   table_name,
   column_name

Sarà sufficiente sostituire a OWNER_NAME il possessore dello schema per ottenere l’elenco di tutti i campi del database con le informazioni relative.

Analogamente ai campi possiamo visualizzare anche gli indici con:

select index_name, table_name, column_position, column_name
from
   sys.all_ind_columns
where
   table_owner='OWNER_NAME' and
order by
   table_name,
   column_position,
   column_name

Infine possiamo avere la lista dei constraint con:

select
   table_name,
   constraint_type,
   constraint_name
from
   sys.all_constraints c
where
   owner = 'OWNER_NAME' and
   constraint_type in ('P', 'R')
order by
   table_name,
   constraint_name

il campo constraint_type può assumere i valori riportati in tabella:

Parto con il ricordare, per chi non lo sapesse, che cos’è un lock:

quando bisogna usare in modo esclusivo una risorsa (tabelle, record, ecc…) è necessario attivare un meccanismo, il lock appunto, che consenta ad un utente (o più in generale ad un processo) di essere l’unico in grado di utilizzare l’oggetto.

Il lock può avere diverse granularità ovvero diversi gradi di precisione, può essere ad esempio su un singolo record o su una intera tabella e può essere con diversi gradi di visibilità (lettura, scrittura, lettura e scrittura).

Quando si ottiene un lock su una risorsa è necessario rilasciarlo una volta che si è terminato di utilizzare l’oggetto. Se il lock non viene rilasciato la risorsa risulta bloccata. Da qui nasce la necessità di individuare i lock presenti e di poterli sbloccare manualmente (attenzione a quello che fate!!).

Vediamo come è possibile attraverso una semplice query individuare i lock presenti in un database Oracle:

SELECT s1.username || '@' || s1.machine
    || ' ( SID=' || s1.sid || ' ) is blocking '
    || s2.username || '@' || s2.machine || ' ( SID=' || s2.sid
    || ' ) on object ' || obj.object_name
    AS Blocking_Status
FROM v$lock l1, v$session s1, v$lock l2, v$session s2, dba_objects obj
WHERE s1.sid=l1.sid and s2.sid=l2.sid
    AND l1.BLOCK=1 and l2.request > 0
    AND l1.id1 = l2.id1
    AND l2.id2 = l2.id2
    AND obj.object_id = s2.row_wait_obj#;

Così facendo otterremo qualcosa di simile:

Blocking_Status
--------------------------------------------------------------------------
UTENTE1@Macchina1 ( SID=109 ) is blocking UTENTE2@Macchina2 ( SID=137 )
on object TABELLA1

Il risultato ci dice che l’UTENTE1 sulla Macchina 1 sta loccando l’oggetto TABELLA1 che è stata richiesta anche dall’UTENTE2 sulla Macchina2.

Se volessimo analizzare con più esattezza quali record sono loccati potremmo farlo con:

select * from TABELLA1 where rowid=(
	select
	dbms_rowid.rowid_create
      ( 1, ROW_WAIT_OBJ#, ROW_WAIT_FILE#, ROW_WAIT_BLOCK#, ROW_WAIT_ROW# )
	from v$session s, dba_objects do
	where sid=numero_sid
	and s.ROW_WAIT_OBJ# = do.OBJECT_ID
);

Sostituendo ovviamente numero_sid con il sid dell’UTENTE2 che abbiamo ottenuto dalla query precedente.

Infine se volessimo eliminare il lock trovato potremmo costruirci una query con il seguente comado:

SELECT 'ALTER SYSTEM KILL SESSION ''' || SID || ',' || SERIAL# || ''';'
AS Kill_Query
FROM V$SESSION
WHERE
    sid in (SELECT s1.sid
             FROM v$lock l1, v$session s1, v$lock l2, v$session s2
             WHERE s1.sid=l1.sid and s2.sid=l2.sid
             AND l1.BLOCK=1 and l2.request > 0
             AND l1.id1 = l2.id1
             AND l2.id2 = l2.id2
            )

Otterremo come risultato una query del genere:

Kill_Query
---------------------------------------------
ALTER SYSTEM KILL SESSION '109,58435';

Se il lock è generato da una applicazione non è usualmente normale che non venga rilasciato dopo un tot di tempo per cui fate attenzione a rimuoverlo manualmente.

La SUN ha deciso di puntare pesantemente su JavaFx, il progetto, ancora in fase di beta, sembra essere molto promettente.
JavaFX permette tramite appositi plug-in di realizzare “Rich Internet Applications” ovvero delle applicazioni accessibili anche via browser molto avanzate; lo scopo è di dare il via al web 3.0, ovvero il nuovo stato dell’arte per designer, sviluppatori e grafici in ambito web.
Questa tecnologia permette (o per meglio dire permetterà una volta a regime) di immergere i contenuti in una nuova dimensione rendendo l’aspetto delle pagine e delle applicazioni tridimensionale.
Lo scopo di questo articolo non è quello di elencare le caratteristiche di JavaFX ma di dare agli sviluppatori e agli smanettoni le informazioni essenziali per poter incominciare a scrivere la prima applicazione.

Vediamo passo dopo passo cosa fare:

• Scarichiamo e installiamo l’ultima versione dell’SDK di Java.
• Se non è già presenti aggiungiamo la variabile di ambiente JAVA_HOME che punta alla directory dove abbiamo installato il JDK di Java e aggiungiamo JAVA_HOME/bin al PATH di sistema.
• Scarichiamo l’SDK di JavaFx che altro non è che una estensione di quello Java. E’ presente solo per le piattaforme Windows e Mac ma gli utenti Linux possono tranquillamente utilizzare la versione Mac (testato su Ubuntu Hardy). Consiglio anche per gli utenti Windows di scaricare l’archivio compresso in modo tale che avremo il controllo su tutte le operazioni che andremo a fare.
• Aggiungiamo la variabile di ambiente JAVAFX_HOME che punta alla directory dove abbiamo installato l’SDK di JavaFxe aggiungiamo JAVAFX_HOME/bin al PATH di sistema

Ora siamo pronti per scrivere la nostra prima applicazione ovvere un bell Hello World!!

import javafx.scene.*;
import javafx.scene.paint.*;
import javafx.scene.geometry.*;
import javafx.scene.text.*;
import javafx.scene.effect.*;
import javafx.ext.swing.*;

SwingFrame {
 var phrase:String
 title: "Hello, Goodbye"
 height: 200
 width: 200
 visible: true
 content:
   BorderPanel {
     center:
       Canvas {
         content:
           Text {
             x: 95
             y: 105
             content: bind phrase
             font: Font {
               name: "Serif"
               size: 50
               style: FontStyle.BOLD
             }
             fill: Color.YELLOW
             horizontalAlignment: HorizontalAlignment.CENTER
             effect: DropShadow {
               offsetX: 2   offsetY: -2   radius: 6
               color: Color.BLACK
             }
           }
       }
     bottom:
       FlowPanel {
         content: [
           Button {
             text: "1"
             action:
               function():Void {
                 phrase = "Hello";
               }
           },
           Button {
             text: "2"
             action:
               function():Void {
                 phrase = "World";
               }
           },
           Button {
             text: "3"
             action:
               function():Void {
                 phrase = "!!";
               }
           }
         ]
       }
   }
}

Dopo aver salvato il file come test.fx non ci resta che compilare il nostro codice sorgente con il comando

javafxc Test.fx

Il compilatore accetta anche il parametro -d con il quale possiamo specificare la directory di destinazione del bytecode. Dopo la compilazione verranno creati i vari file .class necessari per l’esecuzione.
Infine eseguiamo con il comando

javafx Test

Se tutto è andato a buon fine dovrebbe apparire una finestrella con tre tasti, premendo i quali potremo comporre la scritta Hello World!!