MYSQL via une ligne de commande DOS

Les bases de données MySql sont accessibles pas divers moyens. Il existe une très bonne interface d'administration développée en PHP: 'PHPMyAdmin'. Mais parfois, les limitations imposées par de tels outils, peuvent pousser à retourner vers une administration plus archaïque. C'est le cas, par exemple, lorsque l'on souhaite charger de gros fichiers de 'dump' sql de manière fiable.

En fait, la manière la plus fiable de travailler sur une base de données MySql, est d'utiliser la console MySql. Apres avoir lancé le service du serveur MySql 'mysqld-nt.exe', celle-ci est accessible en lançant l'exécutable 'mysql.exe'. Ces deux exécutables se trouvent dans le répertoire 'bin' de l'installation de MySql.

La suite présente les principales commandes à employer pour travailler avec MYSQL via une ligne de commande DOS.

• Connection

Si le serveur est déjà démarré ( .../mysql/bin/mysqld-nt.exe )

- En local:
Dans le répertoire .../mysql/bin  lance mysql.exe  via: 'mysql –u nom_utilisateur  –p mot_de_passe'  ( -p password si besoin )  
Tu obtiens: 'Mysql > '

- Sur un autre serveur:
Dans le répertoire …mysqlbin  lance mysql.exe  via: 'mysql –h 158.67.144.67 –u root  –p password'  ( -p password si besoin )

• Opérations d'administration

Pour modifier le mot de passe d'un compte:
set password for root@localhost=password('mot_de_passe');

Pour effacer les comptes anonymes (pour raisons de sécurité):
Mysql > use mysql;
Mysql > delete from user where User='';
Mysql > delete from db where User='';

Créer un compte pour effectuer des opérations courantes:
Mysql > grant create, create temporary tables, delete, execute, index, insert,
Mysql > lock tables, select, show databases, update
Mysql > on *.*
Mysql > to username@server identified by 'password';

Pour créer un compte utilisateur sur une base de données:
Mysql > create user nom_user@host_name identified by 'password';
Mysql > grant all on nom_database.* to nom_user;

• Les lignes de commandes

Rq: ne pas oublier le ';' à la fin de chaque ligne

Pour obtenir de l'aide:
Mysql > help;

Pour sortir
Mysql >  Quit

Pour lister les databases
Mysql > show databases ;

Pour choisir une database
Mysql > use nom_database

Pour lister les tables de cette BD
Mysql > show tables ;

Pour voir une decription d'une table:
mysql> desc nom_table;

Pour executer un script sql via un fichier
Mysql >  source  nom_du_fichier ;

Pour créer une sauvegarde de la base (dump ou backup), directement depuis la fenêtre de commande DOS:
mysqldump -u root -proot nom_de_base > nom_de_fichier.sql

Pour créer une database
mysql> drop database if exists menagerie;
mysql> CREATE DATABASE menagerie;

Pour créer une table - utilisez une requête CREATE TABLE pour spécifier la structure de votre table :
Exemple
Mysql > CREATE TABLE animal (nom VARCHAR(20), maitre VARCHAR(20),
Mysql > espece VARCHAR(20), sexe CHAR(1), naissance DATE, mort DATE);

Pour voir la description de la table
mysql> DESCRIBE animal;

Pour modifier une table:
mysql> ALTER TABLE animal ADD couleur varchar(15);
ou
mysql> ALTER TABLE animal MODIFY colonne_a TEXT;

Pour lister les droits des utilisateurs pour une base:
mysql> use mysql;
mysql> select * from schema_privileges;

 

Référence:
- Mysql tutorial by Sams publishing

Auteur: Euan MATEO

Log4j: Logging pour Java

Log4J est une API JAVA (bibliothèque logicielle) qui permet de créer et de stocker des messages, pendant l'exécution du code. Cet outil très apprécié des developpeurs JAVA, offre la possibilité de paramétrer finement l'émission des messages. Ainsi, Log4j  permet de choisir la sortie du flot des messages (console, fichier texte..), mais également le niveau d'information donné (info, warn, debug..).

L'archive jar de la bibliothèque Log4J est téléchargeable ICI.

Pour pouvoir être utilisée, la bibliothèque associée à Log4j doit être placée dans le classpath du projet JAVA développé. C'est à dire, soit dans le répertoire 'lib' du projet, soit dans le répertoire 'lib' du serveur (si exécution sur un serveur).

Le comportement de Log4J est précisé dans un fichier de configuration. Deux formats sont disponibles, 'log4j.properties' contient des couples clef/valeur, ou 'log4j.xml' au format xml. Le format xml est préférable car il permet un contrôle plus fin du paramétrage, dont par exemple l'usage de filtres.

Le fichier de configuration de Log4j permet d'indiquer des 'appenders', des 'loggers', et des 'layouts'.

Un 'appender' est le moyen utilisé pour afficher les messages. Autrement dit, un 'appender' est une sortie. Les 'appenders' courants sont la console (ex: la console du serveur Tomcat), ou un fichier texte. Mais, on peut également rediriger les messages vers une base de données. Ainsi, si on veut utiliser la console pour afficher les messages émis par Log4j, la classe 'org.apache.log4j.ConsoleAppender' sera utilisée. Si on souhaite que les messages soient redirigés vers un fichier texte, on pourra se servir de la classe 'org.apache.log4j.RollingFileAppender'. Techniquement, 'appender' est l'interface 'org.apache.log4j.Appender'. Les classes qui définissent les appenders (console, file..) implémentent toutes l'interface 'Appender'.

Le 'logger' est l'objet qui effectue la journalisation. Le niveau minimum des messages émis est défini par le logger. Il peut être: all, no, debug, info, warn, error, fatal. L'appel pour créer un nouveau log se fait par l'usage de la classe 'Logger':

import org.apache.log4j.Logger;

public class uneClasse {

private Logger log = Logger.getLogger(uneClasse.class);

log.info("+ Test de logging +");

}

Le 'layout' définit la présentation utilisée par log4j pour l'écriture des messages. Il existe des layouts prédéfinis comme 'org.apache.log4j.SimpleLayout', ou configurables 'org.apache.log4j.PatternLayout'.

Exemple de fichier de configuration 'log4j.xml' complet:

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE log4j:configuration SYSTEM "log4j.dtd" >
    <log4j:configuration xmlns:log4j='http://jakarta.apache.org/log4j/'>
      <appender name="console" class="org.apache.log4j.ConsoleAppender">
        <layout class="org.apache.log4j.SimpleLayout"></layout>
      </appender>
      <appender name="fichier" class="org.apache.log4j.RollingFileAppender">
        <param name="maxFileSize" value="100KB"/>
        <param name="File" value="../webapps/monProjet/log.txt"/>
        <param name="threshold" value="warn"/>
        <layout class="org.apache.log4j.PatternLayout">
          <param name="ConversionPattern" value="%d{ABSOLUTE} %5p %c{1}: message => %m%n" />
        </layout>
      </appender>
      <root>
        <priority value="debug"/>
        <appender-ref ref="console"/>
        <appender-ref ref="fichier"/>
      </root>
    </log4j:configuration>                          

L'exemple va créer une sortie sur la console avec un niveau 'debug', et une sortie dans un fichier du répertoire du projet, avec un niveau 'warn'.

Quelques remarques concernant l'exemple ci-dessus:

• Le fichier 'log4j.xml' doit être placé dans le ClassPath de l'application, 'WEB-INF/classes' par exemple
• Le chemin vers le fichier de log peut être défini de manière relative. La racine du chemin est alors le répertoire d'exécution du serveur (si exécution sur un serveur). Le répertoire 'bin' pour un serveur tomcat.
  
• Le logger racine est contenu par la balise 'root'
• Le niveau de journalisation de log4j peut être défini de manière globale pour tous les appenders associés à un logger. C'est le rôle de la balise <priority> qui est incluse dans la balise <root>
• Le niveau de journalisation peut aussi être redéfini au niveau de chaque appender, avec le paramètre 'threshold' de la balise <param>
• Les conventions pour créer un PatternLayout sont visibles dans la doc de l'API: PatternLayout
  

Vos commentaires sont bienvenus !

Références:

• Tutoriel Log4j sur Developpez.com: http://beuss.developpez.com/tutoriels/java/jakarta/log4j/
• Cours sur Log4j par Labo-Sun: http://www.labo-sun.com/resource-FR-articles-612-0-java-g...
• Tutoriel Log4J avec exemples Tomcat, par Laliluna: http://www.laliluna.de/log4j-tutorial.html
• Encore un bon tutoriel Log4j: http://www.vipan.com/htdocs/log4jhelp.html

Auteur: Euan MATEO

Notes à propos d'ANT

ANT est un utilitaire JAVA qui permet d'effectuer un certain nombre de tâches relatives à des projets JAVA:
- Compiler des classes JAVA
- Créer des archives jar, war, zip..
- manipuler des fichiers, dossiers (création, suppression..)
- ..

ANT se lance avec la commande 'ant' sous DOS (Windows), ex:
'ant nom_de_cible'

L'exéction d'ANT dépend d'un fichier de configuration xml, 'build.xml'.
Après avoir installé ANT (cf note sur l'installation de Ant), il faut donc créer et renseigner le fichier 'build.xml'.

L'élément racine est 'project'. Il rassemble un ensemble de tâches à effectuer, les 'target'. Il peut être accompagné des attributs:
- name: pour donner un nom au projet ANT
- basedir: pour renseigner le point de départ des chemins du projet
- default: pour préciser un élément cible (target) par défaut, qui sera utlisé si aucun élément cible n'est précisé.

L'élément 'property' permet de déclarer des variables qui seront utilisées dans le projet. Ses attributs usuels sont:
- name: nom de la variable
- value: valeur de la variable

'target' contient les tâches (Tasks) à effectuer. C'est le coeur des opérations ANT. Ses principaux attributs sont:
- name: le nom de la cible
- depends: précise si cette tâche dépend d'une autre tâche qui doit déjà être effectuée
- conditions: if, unless

Les 'Tasks' sont des tâches réalisables par ANT: compilation, manipulation de fichier ou répertoire, création d'archive..
Une liste des tâches et de leurs attributs est disponible dans la document d'ANT: manuel > 'Overview of Ant Tasks'
Quelques tâches courantes:
- delete: effacer un fichier ou un répertoire
- mkdir: créer un répertoire
- javac: compiler (voir la doc pour les options)
- jar: créer une archive au format jar
- war: créer une archive war (Web ARchive)
- java: exécuter du code JAVA ou un JAR, avec la machine virtuelle JAVA

Pour spécifier des librairies à l'aide de 'classpath', il existe principalement deux manières de faire:
- par éléments 'nested', ex:
<javac ...>
<classpath>
<pathelement location="..."/>
<pathelement path=""/>
<fileset dir="lib">
<include name=""**/*.jar"/>
</fileset>
</classpath>
</javac>
- par réference, ex:
<!-- On définit la ressource -->
<path id="ressources.lib">
<pathelement location='...'/>
<pathelement path=""/>
</path>
<!-- on appelle la référence pour lancer une tâche -->
<target ... >
<javac ... classpathref="ressources.lib">
</target>
ou
<target ... >
<javac ... >
<classpath refid="ressources.lib"/>
</javac>
</target>



Exemple complet de fichier 'build.xml':
<?xml version="1.0" encoding="iso-8859-1"?>

<project name="strutsStart" basedir="." default="compile">
<!-- Chemin du serveur (Tomcat) et du jre, pour la définition du classpath -->
<property name="tomcat.dir" value="C:/tomcat4.1"/>
<property name="tomcat.lib.dir" value="${tomcat.dir}/common/lib"/>
<property name="jdk.dir" value="C:/j2sdk1.4.2_17"/> 
<property name="jdk.lib.dir" value="${jdk.dir}/jre/lib"/>

<!-- chemins des répertoires de l'application -->
<property name="webinf.dir" value="WEB-INF"/>
<property name="src.dir" value="${webinf.dir}/sources"/>
<property name="classes.dir" value="${webinf.dir}/classes"/>

<!-- Classpath avec référence pour la compilation (javac) -->
<path id="classpath">
<pathelement location="${tomcat.lib.dir}/servlet.jar"/>
<pathelement location="${jdk.lib.dir}/rt.jar"/>
<fileset dir="${webinf.dir}/lib"/>
</path>

<!-- Tâche d'initialisation: création du répertoire contenant les classes -->
<target name="prepare">
<mkdir dir="${classes.dir}"/>
</target>

<!-- Tâche de compilation des sources -->
<target name="compile" depends="prepare">
<javac srcdir="${src.dir}" destdir="${classes.dir}" classpathref="classpath"/>
</target>
</project>


Référence:
- "Using Ant" dans le manuel apache-ant

Auteur: Euan MATEO