• abilitare le DML parallele :Alter session enable parallel DML;
• Aggiungere l’hint alla query : INSERT /*+ PARALLEL(a, 4) */  INTO mytable a ....

Prima di tutto eseguo la procedure da sqlplus e vedo che funziona tutto alla perfezione ma non appena viene inserita all’interno dello scheduler, la procedura va a buon fine ma senza alcun parallelismo e quindi senza alcuna riduzione dei tempi rispetto a quella originale.
Cerco il problema su google e scopro che facendo l’upgrade alla versione 10.2.0.5 di Oracle, si ha la possibilità di eseguire DML parallele anche ll’interno di “Transazioni autonome” e quindi anche all’interno dello scheduler.
Eseguo l’upgrade e riprovo ma senza successo. Facendo altri test, capisco che il problema è dato dal fatto che chiamo la procedura tramite Execute immediate.

Per riassumere : se uno procedura invocata dallo scheduler chiama un’altra procedura tramite il comando Execute Immediate, le query/dml parallele all’interno di quest’ultima procedura non verranno eseguite in parallelo. Se invece si chiamasse direttamente la procedura senza l’uso del comando execute immediate, tutto funzionerebbe come ci si aspetta.

Con il primo statement comprimiamo la sottopartizione e ricreiamo eventuali indici globali, col secondo ricreiamo eventuali indici locali.

La prima cosa che faccio è andare ad installare alcuni plugin , ma quando faccio click su next per confermare l’installazione non accade niente!

Dopo una veloce ricerca sui forum di Eclipse trovo la soluzione : creare un piccolo script per lanciare eclipse:

#!/bin/sh
export GDK_NATIVE_WINDOWS=1
/app/eclipse-3.5/eclipse


Sembra che sia un errore ricorrente anche su ubuntu 9.10.

L’installazione è andata bene e a mio avviso è stata anche più rapida rispetto a quella di Fedora 11.

Aggiungo i repository Rpm Fusion , installo gli ultimi driver nvidia e riavvio.

Mi accorgo subito che il desktop risulta lento in alcune operazioni semplicissime come l’apertura del menu principale (Alt + F1) o di “Run Command” (Alt + F2). Dopo aver fatto alcune ricerche in google e aver provato varie configurazioni di  xorg.conf, l’unica soluzione valida è stata quella di fare un downgrade di xorg-x11-server-Xorg e xorg-x11-server-common alla versione 1.7.1.3 che potete trovare qui.

Per il resto funziona tutto bene e tutte le periferiche sono state riconosciute senze problemi o interventi manuali.

Help -> Install New Software

Come sito di aggiornamento selezionare Galileo, andare sotto la sezione Collaboration e spuntare Subversive SVN Team Provider (incubation), quindi cliccare next, accettare la licenza e fare Finish

Help -> Install New Software

Questa volta dobbiamo aggiungere il sito di aggiornamento , quindi scriviamo http://www.polarion.org/projects/subversive/download/eclipse/2.0/update-site/ nella edit in alto “Work with” , clicchiamo su add e inseriamo una descrizione

Sotto Subversive SVN Connectors, spuntare SVNKit 1.3.0 Implementation (optional), fare Next e poi Finish

Mi sembra strano che questo plugin non sia ancora integrato in Eclipse in quanto la maggior parte,o comunque una grande fetta,  degli utenti di questo IDE utilizza subversion.

Se però dovesse capitarvi che anche la combinazione Ctrl-Alt-Del non riavvii la macchina allora potrete ricorrere alla seguente combinazione per evitare il tasto reset : tenere premuti Alt(destro) e SysRq e digitare R E I S U B

Ecco l’azione associata ad ogni lettera :

R : mette la tastiera in modalità XLATE

E : invia SIGTERM a tutti i processi tranne init

I : invia SIGKILL a tutti i processi tranne init

S : sincronizza tutti i filesystem montati

U : rimonta tutti i filesystem in sola lettura

B : riavvio immediato del sistema senza smontare i dischi

Perchè questa procedura funzioni bisogna assicurarsi che /proc/sys/kernel/sysrq contenga 1

1.
for x in *.trc
do
rm $x
done

2.
find . -name  '*.txt' -print0 | xargs -0 rm

3.
find . -name  '*.txt' -exec rm {} \; -print

4.
find . -name  '*.txt' -delete (presente dalla versione 4.2 di find)

Mostrerò come utilizzarle e includerò qualche esempio di impieghi particolari.

Innanzitutto creiamo il tipo

Create or replace type t_varchar2_table as table of varchar2(4000);

Operazioni base :

Create or replace procedure pr_base_test AS
--inizializzo la lista con zero elementi
x_Varchar2_Table t_varchar2_table := t_varchar2_table();
n_Step NUMBER;
BEGIN
--mettiamo 10 elementi nella lista
FOR n_Step IN 1..10 LOOP
x_Varchar2_Table.EXTEND;
x_Varchar2_Table(x_Varchar2_Table.LAST) := 'Row '||n_Step;
END LOOP;
--visualizzo quanti elementi ho nella lista
Dbms_Output.put_Line('Count = '||x_Varchar2_Table.COUNT);
--visualizzo ogni elemento in lista
FOR n_Step IN x_Varchar2_Table.FIRST..x_Varchar2_Table.LAST LOOP
Dbms_Output.put_Line(x_Varchar2_Table(n_Step);
END LOOP;
--controllo se un elemento è presente nella lista
IF 'Row 7' MEMBER OF x_Varchar2_Table THEN
Dbms_output.put_Line('OK');
END IF;
--Controllo se la lista è univoca, ovvero non ho duplicati
IF x_Varchar2_Table IS A SET THEN
Dbms_output.put_Line('IS A SET);
END IF;
--svuoto la lista
x_Varchar2_Table.DELETE;
END;
/

A partire da Oracle 10g sono presenti una serie di operatori multiset che permettono operazioni sulle liste. Eccone una lista con accanto l’equivalente operatore SQL :

Per riempire una lista con dei valori provenienti da una query è semplicissimo :

declare
x_table_list t_varchar2_table := t_varchar2_table();
begin
select table_name BULK COLLECT INTO x_table_list
from user_tables
where table_name like 'A%';
--la lista ora contiene l'elenco delle tabelle che iniziano con A
end;

Naturalmente non bisogna abusare dell’uso delle liste in quanto consumano parecchia memoria. Gli utilizzi principali che ho riscontrato sono :

• creo una lista di dati che poi andrò ad utilizzare parecchie volte : è inutile fare la join con la medesima tabella (magari di grandi dimensioni) molte volte quando è possibile caricare in memoria la lista di ID di cui necessito e unitilizzarla n volte.
• sono molto utili per trasferire dati da una procedura all’altra : ad esempio, se ho un package che mi gestisce gli utenti e all’interno di questo una procedure che mi restituisce la lista degli utenti è inutile implementare tale logica in un altro package. Quindi il package che avrà bisogno dell’elenco degli utenti invocherà tale procedura e ne utilizzerà la lista ottenuta.
• Ottimizzazione di insert/update/delete di tante righe grazie all’operatore FORALL

Ecco alcuni esempi :

Esempio 1

declare
x_table_list t_varchar2_table := t_varchar2_table();
n_count Number;
begin
select table_name bulk collect into x_table_list
from user_tables
where table_name like 'A%';
--use the list as a table
select count(*) into n_count
from user_tab_columns a, TABLE(x_table_list) b
where a.table_name = b.column_value;
dbms_output.put_line(n_count);
end;

Esempio 2

create table temp
as select * from user_tables
where 1 = 2;

declare
type t_user_tables is table of user_tables%ROWTYPE;
x_user_tables t_user_tables := t_user_tables();
n Number;
begin
select * bulk collect into x_user_tables
from user_tables;
FORALL n IN x_user_tables.FIRST..x_user_tables.LAST
Insert into temp values x_user_tables(n);
COMMIT;
End;

E se invece avessi bisogno di utilizzare una collezione all’interno di una query dinamica ?? In questo caso è obbligatorio utilizzare collezioni basate su tipi creati all’interno dello schema tramite il comando Create Type. Nell’esempio utlizzerò il tipo t_varchar2_table creato all’inizio del post.


create or replace PACKAGE pk_Test AS
PROCEDURE pr_Load;
PROCEDURE pr_ExecuteQuery;

FUNCTION fn_List RETURN T_Varchar2_Table;

END  pk_Test;

create or replace PACKAGE BODY pk_Test AS
kx_List T_Varchar2_Table := T_Varchar2_Table();

PROCEDURE pr_Load IS
BEGIN
SELECT Table_Name BULK COLLECT INTO kx_List
FROM User_Tables
WHERE Table_Name LIKE ‘A%’;

END pr_Test;

PROCEDURE pr_ExecuteQuery IS
v_Sql VARCHAR2(1000);
n_Count NUMBER;
BEGIN
v_Sql := ‘SELECT COUNT(*)
FROM User_Tables
WHERE Table_Name IN (
SELECT Column_Value FROM
TABLE ( pk_Test.fn_List )
)’;

EXECUTE IMMEDIATE v_Sql INTO n_Count;
Dbms_Output.put_line(n_Count);
END pr_ExecuteQuery;

FUNCTION fn_List RETURN T_Varchar2_Table IS
BEGIN
Return kx_List;
END fn_List;

END pk_Test;

Nella procedura pr_Load non faccio altro che caricare in una collezione tutte le tabelle che iniziano con A.

Nella procedura pr_ExecuteQuery  eseguo una query dinamica tramite il comando Execute Immediate  utilizzando la lista appena caricata che mi viene restituita dalla funzione fn_List.