gif animé ordinateur

lundi 29 août 2011

Bonne rentrée à toutes et à tous

Je souhaites à chacune et à chacun une bonne rentrée 2011.
J'espère vous à avez passé de bonnes vacances.
Place donc à une nouvelle année, j'espère, pleine de bonne choses, une année pour améliorer la qualité et la fréquentation de ce blog.

mercredi 13 avril 2011

Performance et Tuning Oracle

Voici ce que dit le site oracle sur le tuning

Performance tuning is the one area in which the Oracle DBA probably spends most of his or her time. If you’re a DBA helping developers to tune their SQL, you can improve performance by suggesting more efficient queries or table- and index-organization schemes. If you’re a production DBA, you’ll be dealing with user perceptions of a slow database, batch jobs taking longer and longer to complete, and so on. Performance tuning focuses primarily on writing efficient SQL, allocating appropriate computing resources, and analyzing wait events and contention in the system. Some Links for your kind reference.

Oracle Tuning References

Donc, pour résumer, écrire de belles requêtes ou des bouts de PL/SQL c'est bien, mais en écrire des rapides et des moins couteux, c'est encore mieux.
Je dirai même plus, une requête ou PL/SQL lent, c'est tout simplement bon à jeter à la corbeille de votre PC.

Il existe plusieurs moyens de rendre vos requêtes ou PL/SQL performants, le premier d'entre eux, est d'ordre d'architecture du schéma de la base de données elle même, disposer d'un schéma qui garantie la non redondance des accès aux tables, qui économise les ressources et les accès disque, c'est par ça qu'il faut commencer. Ensuite, il faut jouer sur les index dans les tables tout en sachant que trop d'index tue l'index. Une des solutions c'est d'embarquer dynamiquement les script de création de l'index quand on a besoin, et de le supprimer aussitôt qu'en on a fini.
Sachez aussi que Oracle ne prend pas spécialement en considération la création instantanée de vos index (c'est un peu la même histoire que le java garbage collector), des fois, il faut l'appeller manuellement. La commande pour lancer la prise en compte de vos index, sous Oracle est connu sous le nom du calcul des statistiques sur une table et la commande est de ce genre :
dbms_stats.gather_table_stats(schema_name,table_name,estimate_percent=>8,cascade=>true);

Sachez que la création d'un index sur un champ pour lequel on teste le cas NULL, fait perdre tout ces avantage à cet index. C'est le cas de la clause WHERE champ_name IS NULL (OR IS NOT NULL).

Sachez aussi qu'indexer un champ sur lequel il y a une fonction vous fait perdre tous les avantages de l'index. et cela se traduit par un parcours complet de la table au lieu de scander l'index et s'arrêter là. Exemple un index sur field_name est inutile si dans la clause WHERE  TRIM(field_name)='TOTO'.

Un bouton magique sur ToadOracle vous permet de visualiser le plan d’exécution de votre requête, le but c'est d'éviter au minimum les FULL ACCESS sur les tables et de minimiser les lectures disque.

 Je vous recommande vivement ce tutoriel  pour plus détails.

vendredi 8 avril 2011

Linux fête son 20ème anniversaire

La révolution open source continue, le Système d’exploitations libre  Linux  fête ce 06 avril 2011 son 20ème anniversaire.

Alors, ça mérite bien une belle bougie, n'est ce pas ?

vendredi 25 mars 2011

Programmation Oracle PL/SQL



Voici ce que dit le site ORACLE sur ce language :  PL/SQL is an imperative 3GL that was designed specifically for the seamless processing of SQL commands. It provides specific syntax for this purpose and supports exactly the same datatypes as SQL. Server-side PL/SQL is stored and compiled in Oracle Database and runs within the Oracle executable. It automatically inherits the robustness, security, and portability of Oracle Database.

PL/SQL, vous l'avez compris, est un langage propriétaire (Not open source). Mais le maîtriser c'est s'assurer d'avoir de belles perspectives d'emploi devant soi. C'est donc un langage à prendre au sérieux.


PL/SQL pour "procedural langagePL/SQL est un langage structuré en blocs, constitués d'un ensemble d'instructions.

Un bloc PL/SQL peut être "externe", on dit alors qu'il est anonyme, ou alors stocké dans la base de données sous forme de procédure, fonction ou trigger.

Un bloc PL/SQL est intégralement envoyé au moteur PL/SQL, qui traite chaque instruction PL/SQL et sous-traite les instructions purement SQL au moteur SQL, afin de réduire le trafic réseau.
Chaque bloc PL/SQL peut être constitué de 3 sections :

  • Une section facultative de déclaration et initialisation de types, variables et constantes
  • Une section obligatoire contenant les instructions d'exécution
  • Une section facultative de gestion des erreurs
[DECLARE
… déclarations et initialisation]
BEGIN
… instructions exécutables
[EXCEPTION
… interception des erreurs]
END;
Un bloc PL/SQL minimum peut être représenté de la façon suivante :

BEGIN
   Null ;
END ;

Le mot clé BEGIN détermine le début de la section des instructions exécutables
Le mot clé END; indique la fin de la section des instructions exécutables
Une seule instruction figure dans ce bloc : Null; qui ne génère aucune action
Ce bloc PL/SQL ne fait donc absolument rien !
La section déclarative (facultative) d'un bloc débute par le mot clé DECLARE
Elle contient toutes les déclarations des variables qui seront utilisées localement par la section exécutable, ainsi que leur éventuelle initialisation.

DECLARE
   LC$Chaine                      VARCHAR2(15) := 'Salut Monde' ;
BEGIN
   DBMS_OUTPUT.PUT_LINE( LC$Chaine ) ;
END ;

DBMS_OUTPUT.PUT_LINE : est l’équivalent en java de System.out.println

Une variable LC$Chaine est déclarée de type VARCHAR2(15) et initialisée avec la valeur 'Salut Monde' ;
Dans la section exécutable, cette variable est transmise à la fonction DBMS_OUTPUT() pour être affichée à l'écran

Cette section ne peut pas contenir d'instructions exécutables. Toutefois, il est possible de définir dans cette section des procédures ou des fonctions contenant une section exécutable.

La section de gestion des erreurs (facultative) débute par le mot clé EXCEPTION
Elle contient le code exécutable mis en place pour la gestion des erreurs
Lorsqu'une erreur intervient dans l'exécution, le programme est stoppé et le code erreur est transmis à cette section.

Toute variable doit avoir été déclarée avant de pouvoir être utilisée dans la section exécutable.
DECLARE
   LC$Chaine                      VARCHAR2(15) := 'Hello World' ;
BEGIN
   DBMS_OUTPUT.PUT_LINE( LC$Chaine ) ;
EXCEPTION
   When OTHERS then
         Null ;
END ;
Les erreurs doivent être interceptées avec le mot clé WHEN suivi du code erreur ciblé. Ici, le code OTHERS qui définit toutes les erreurs non interceptées individuellement par les clauses WHEN précédentes.
Cette section peut elle-même contenir d'autres blocs PL/SQL.

Après ce bref aperçu sur le PL/SQL, je vous envoie vers sur ce  tutorial.
Je vous le recommande vivement.

jeudi 27 janvier 2011

les threads en java

Pour illustrer les threads en java, imaginons  une application boursière avec plusieurs fonctionnalités et préoccupation. Une d’elles, par exemple, se charge de fournir le prix de la dernière action, la seconde effectue les vérifications et lance les warnings si le prix des actions, tandis que la troisième fournie l’historiques des opérations boursière pour la company XYZ.
Dans un environnement mono thread, ces actions s’exécutent l’une suivi de la suivante dans l’ordre. L’action suivante ne peut s’exécuter qu’une fois la première est achevée. Si par exemple l’analyse de l’historique des données de la company XYW prend ½ heure, les warnings sur les prix des actions ne sont levées qu’une ½ plus tard, et le donneur d’ordre de validation d’achat, de vente ou d’acquisition d’actions ne reçoit l’ordre qu’une fois tous ces process terminés. Je vous laisse imaginer ce que cela peut induire en perte de réactivité et de temps de réponse.
Alors, pour remédier à la situation, on a tout simplement imaginé le monde mutithread. Ainsi, l’application d’analyse de l’historique des données de la company XYZ, tourne en arrière plan dans son propre thread, en simultané avec l’application qui lance les warnings sur les prix des actions sur un autre thread. Nous voila donc entrain de travailler dans un environnement bi-thread.
Mais alors, Un thread, c’est quoi exactement ?
En java, Thread signifie deux choses :
-          Une instance de la classe java.lang.Thread
-          Un autre thread d’exécution

Une instance de Thread, c’est juste un …Object, comme tout autre Object en Java, il a des variables et des méthodes et vit et meurt dans le Heap. Mais un thread  (avec T en minuscule) d’exécution c’est un process individuel ( a lightweight process) qui a son propre appel de la Stack.
En java, il y un thread par appel de la Stack, ou pour le dire autrement un appel de la Stack par thread. Bien que vous ne créiez aucun thread dans vos programme, il y’en a un à chaque exécution.
La méthode java main()  qui se lance et exécute votre programme, lance son propre thread, appelé d’ailleurs main thread. Et quand vous regardez dans la stack traces de l’exécution du programme, vous constatez que la méthode main est le point d’enter dans la stack, et au fur et à mesure qu’on crée d’autre thread, les stack trace s’ajoute l’une derrière l’autre.

Vous pouvez trouvez ça confus, de parler programmes se lançant en parallèle les uns avec les autres dans un OS qui tourne souvent avec un seul CPU. On effet les JVM actuellement sur les OS du marché, se compte comme des mini OS qui ordonnance chacun ses taches selon le type de system en question (MAC, Windows, LINUX …etc.).

Ne faites donc pas l’erreur de concevoir vos applications en fonction de la JVM installée sur votre OS. Les JVM n’ordonnancent pas les thread de la même manière.
En java, les thread se lancent comme des instances de la classe Thread (avec T majuscule). Dans cette classe, des méthodes de gestion de la vie d’un thread sont disponibles, notamment, pour créer, lancer et mettre en pause le thread en cours de création :
- start()
- yield()
- sleep()
- run()

L’exécution est effectue dans la méthode run().
Pensez au thread comme l’agent qui va exécuter votre job (programme). If the work to do is the job, the one doing the work (actually executing the job code) is the thread. And the job always starts from a run() method.

Voici un bout de code pour illustrer ça :

Public void run() {
// your job codes goes here
}

Vous pouvez définir et instancier des threads, de deux façons :
-          en étendant (extends) la classe java.lang.Thread
-          en implémentant (impements)  l’interface Runnable
Dans la vraie vie, vous allez plus implémenter l’interface Runnable qu’étendre la classe java.lang.Thread (T en majuscule).
Etendre la classe Thread est portant très facile à mettre en œuvre par le code, mais cette option n’est pas toujours conforme aux normes de programmation Orientée Object (OO).
En effet le cas où étendre la classe Thread a des sens, est lorsque vous avez plusieurs comportements de votre même thread. Mais heureusement, dans la vraie vie, un job, c’est un thread, et dans ce cas, il est plus commode d’écrire vos thread en les faisant implémenter de l’interface Runnable, qui laisse le libre choix à vos classes d’étendre d’autres classes.
(Une classe ne peut étendre qu’une autre classe, tandis qu’elle peut implémenter autant d’interface qu’elle veut).

Voici un exemple :
Class MyThread extends Thread {
public void run(){
     System.out.println(“ ici est executer mon thread “) ;
}
}

La limite de cette architecture, en plus de son faible respect du concepts de l’OO, et que votre classe ne peut plus étendre aucune autre classe, et ce n’est pas le meilleur pour hériter des comportement d’autres thread.

Dites vous que vous pouvez overloader le méthode run(), mais celle-ci sera ignorée par la classe Thread, sauf si vous la faite appeler vous même.

Class MyThread extends Thread {
public void run(){
     System.out.println(“ ici est executé mon thread “) ;
}
public void run(String s){
     System.out.println(“ string in run is “+s) ;
}
}

La classe Thread ne s’attend et n’appelle que la méthode run() sans arguments, et va exécuter pour vous celle-ci dans une stack à part une fois le thread lancé.

Maintenant, voyons, comment implémenter l’interface Runnable

Class MyRunnable implements Runnable {
public void run(){
     System.out.println(“ important job is runnig in runnable “) ;
}
}

Pour instancier un thread :
Si vous étendez la classe Thread, il vous suffit d’écrire :

MyThread t = new MuThread() ;

En revanche, si vous implémenter l’interface Runnable :
MyRunnable r = new MyRunnable() ;//instantiate your Runnable
Thread t = new Thread(r);//pass your runnable to Thread

Si vous créez votre Thread sans lui passer en argument votre Runnable, la classe Thread appel sa propre méthode run(), c’est ce que vous faite lorsque vous étendez la classe Thread, contrairement à lorsque vous implémenter l’interface Runnable où vous devrez indiquer à votre new thread, la méthode run() à appeler à la place de la sienne.
On peut passer un single Runnable à autant de multiples Thread :

Public class TestThreads{
Public static void main(String[] args){
MyRunnable r = new MyRunnable();
Thread foo = new Thread(r);
Thread bar= new Thread(r);
Thread bat = new Thread(r);

}
}

Passer le même argument à différent Threads, revient à exécuter plusieurs fois le même job.

En plus du constructeur new Thread() sans argument ou avec Runnable comme argument, des overload de celle-ci existent, notamment :
-          Tread(Runnable r, String name)
-          Thread(String name)

Une fois l’object Thread est crée, et que sa cible est connu (l’argument Runnable ), allons y lancer notre thread (lancer à new stack), grâce à la méthode start() :

class FooRunnable impements Runnable {
public void run(){
For(int x=; x<6, x++){
System.out.println(“runnable running”);
}
}
}


Public class TestThreads{
Public static void main(String[] args){
FooRunnable r = new FooRunnable ();
Thread t = new Thread(r);
t.start();

}
}

Voici comment on lance notre thread.
Bonne lecture.

La suite de cet article sera bientôt publiée.