FAQ JDBCConsultez toutes les FAQ

Nombre d'auteurs : 8, nombre de questions : 162, dernière mise à jour : 3 juin 2015  Ajouter une question

 

Cette FAQ a été réalisée à partir des questions fréquemment posées sur les forums de http://www.developpez.com et de l'expérience personnelle des auteurs.

Nous tenons à souligner que cette FAQ ne garantit en aucun cas que les informations qu'elle propose sont correctes. Les auteurs font leur maximum, mais l'erreur est humaine. Cette FAQ ne prétend pas non plus être complète. Si vous trouvez une erreur, ou que vous souhaitez nous aider en devenant rédacteur, lisez ceci.


SommaireLes types SQL et les types Java (12)
précédent sommaire suivant
 

Voici un tableau des correspondances entre les types SQL définis dans java.sql.Types, les méthodes de ResultSet et les types Java :

Type SQL Méthode ResultSet Type Java
ARRAY getArray java.sql.Array
BIGINT getLong long
BINARY getBytes byte[]
BIT getBoolean boolean
BLOB getBlob java.sql.Blob
CHAR getString java.lang.String
CLOB getClob java.sql.Clob
DATE getDate java.sql.Date
DECIMAL getBigDecimal java.math.BigDecimal
DINSTINCT getTypeDeBase typeDeBase
DOUBLE getDouble double
FLOAT getDouble double
INTEGER getInt int
JAVA_OBJECT (type)getObject type
LONGVARBINARY getBytes byte[]
LONGVARCHAR getString java.lang.String
NUMERIC getBigDecimal java.math.BigDecimal
OTHER getObject java.lang.Object
REAL getFloat float
REF getRef java.sql.Ref
SMALLINT getShort short
STRUCT (type)getObject type
TIME getTime java.sql.Time
TIMESTAMP getTimestamp java.sql.Timestamp
TINYINT getByte byte
VARBINARY getBytes byte[]
VARCHAR getString java.lang.String

On peut juste noter que les méthodes getObject et getString sont génériques et peuvent servir pour tous ces types.

Il ne faut pas oublier que ce tableau est simplifié, il existe d'autres types et correspondances. Pour plus d'informations, suivez les liens ci-dessous.

Mis à jour le 11 avril 2013 Ioan

Première méthode : passage par une java.util.Date Les classes Date, Time et Timestamp, du package java.sql, étendent toutes java.util.Date. Pour obtenir une instance de celles-ci, le plus simple est de passer justement par une java.util.Date. Par exemple :

Code java : Sélectionner tout
1
2
3
4
java.util.Date date = new java.util.Date(); 
java.sql.Date dateSQL = new java.sql.Date(date.getTime()); 
Time time = new Time(date.getTime()); 
Timestamp time = new Timestamp(date.getTime());
Vous pouvez aussi utiliser la méthode setTime pour modifier une de ces instances.

Seconde méthode : passage par la syntaxe d'échappement. Ses trois classes proposent une méthode statique valueOf(String s) qui renvoie une instance correspondante. La chaîne de caractères passée en paramètre doit respecter la syntaxe d'échappement. Par exemple :

Code java : Sélectionner tout
Date date = Date.valueOf("2004-10-20");
Pour connaître les différents formats regardez Qu'est-ce que la syntaxe d'échappement ? .

Mis à jour le 11 avril 2013 Ioan

Le type DISTINCT est un UDT (User Defined Type) défini par la norme SQL 3. Ce type est basé sur un type déjà existant. Par exemple :

Code sql : Sélectionner tout
CREATE TYPE TELEPHONE AS CHAR(10);
Dans cet exemple, on crée un nouveau type TELEPHONE. Celui-ci correspond à une chaîne de 10 caractères.

Attention : la syntaxe utilisée est celle de la norme SQL3, elle est peu utilisée en pratique.

La manipulation du type se fait grâce aux méthodes du type qu'il « étend ». En imaginant un ResultSet contenant une colonne Telephones contenant des données de type TELEPHONE :

Code java : Sélectionner tout
1
2
3
4
5
ResultSet resultset = ...;  
while(resultset.next()){ 
   String telephone = resultset.getString("Telephones"); 
   //... 
}
De la même manière, on utiliserait setString pour le passage d'un argument de type TELEPHONE.

Mis à jour le 11 avril 2013 Ioan

Un objet de type java.sql.Array ne contient pas à proprement parler de données. C'est une sorte de pointeur vers les données contenues dans le ARRAY SQL. Pour en récupérer les données, vous devez faire comme ceci :

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
Statement statement = ... ;  
String sql = "SELECT * FROM MaTable"; 
ResultSet resultset = statement.executeQuery(sql);  
while(resultset.next()){ 
   Array array = resultset.getArray("colonneArray"); 
   //array est un simple "pointeur" 
   Object tableau = array.getArray(); 
   //tableau est tableau Java 
   String[] donneesTableau = (String[])tableau; 
   //vous devez le caster dans le type de données contenues 
   for(int i=0; i<donneesTableau.length ; i++){ 
      System.out.println(donneesTableau[i]); 
   }  
}
Pour connaître le type SQL des données contenues dans le Array, vous pouvez utiliser les méthodes getBaseType() et getBaseTypeName(). La première méthode est la plus intéressante, puisqu'elle renvoie le type correspondant dans java.sql.Types.

Voici une autre méthode pour parcourir les données de l'Array, peut-être plus élégante et dans l'esprit JDBC, car elle utilise un ResultSet :

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
Statement statement = ... ;  
String sql = "SELECT * FROM MaTable"; 
ResultSet resultset = statement.executeQuery(sql);  
while(resultset.next()){ 
   Array array = resultset.getArray("colonneArray"); 
   //array est un simple "pointeur" 
   ResultSet tableau = array.getResultSet(); 
   //tableau est un ResultSet contenant les données de l'Array 
   while(tableau.next()){ 
      System.out.println(tableau.getString(1)); 
      //le ResultSet n'a qu'une colonne 
   } 
}
Quelle que soit la méthode que vous utilisez pour récupérer les données de l'Array, vous pouvez spécifier l'index et le nombre d'éléments à récupérer. Par exemple :

Code java : Sélectionner tout
1
2
3
4
Array array = resultset.getArray("colonneArray"); 
int index = 3;  
int longueur = 4;  
ResultSet tableau = array.getResultSet(index, longueur);

Mis à jour le 11 avril 2013 Ioan

Un LOB ou Large OBject est une catégorie de types SQL 3. Il en existe deux : les BLOB et les CLOB. Ces types permettent de stocker de grandes quantités de données dans une seule « cellule » d'une table.

BLOB

Un BLOB ou Binary Large OBject permet de stocker de grandes quantités de données sous forme binaire. On peut par exemple insérer dans une table des fichiers (images, musique, etc.).

CLOB

Un CLOB ou Character Large OBject permet de stocker de grandes quantités de données sous forme de caractères. On peut par exemple insérer dans une table des articles de journaux, des livres ou les pages d'un site internet.

JDBC a prévu pour la manipulation de ces deux types SQL les classes Clob et Blob du package java.sql. La plupart des manipulations de ces objets se font directement en utilisant des flux. Pour plus d'informations, suivez les liens ci-dessous.

Mis à jour le 11 avril 2013 Ioan

Pour mettre en évidence l'insertion d'un BLOB dans une base de données, nous allons prendre pour exemple l'insertion d'une image. Notre table ne contient que deux colonnes. La première sera le nom de l'image et la seconde l'image elle-même (le fichier).

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public static void insererImage(String nom, String chemin) { 
   File file = new File(chemin); 
   try{ 
      //lien vers la base de données 
      Connection connection = DriverManager.getConnection("url","user","password"); 
  
      //lien vers notre fichier image 
      FileInputStream stream = new FileInputStream(file); 
  
      //préparation de l'instruction SQL 
      String sql = "INSERT INTO TableImages VALUES (?, ?)"; 
      PreparedStatement statement = connection.prepareStatement(sql); 
  
      //insertion de l'image 
      statement.setString(1, nom); 
      statement.setBinaryStream(2, stream, (int)file.length()); 
      statement.executeUpdate(); 
  
    }catch(Exception e){ 
       //traitement des erreurs SQL, IO, etc. 
    }finally { 
       //fermeture de la connexion, du flux, etc. 
    } 
}
Pour un exemple plus complet, regardez Utilisation de JDBC pour la gestion d'images en base de données par Ricky81 .

Mis à jour le 11 avril 2013 Ioan

La lecture d'un BLOB est relativement simple. Pour commencer, on doit récupérer une instance de Blob, afin de récupérer un flux de lecture sur celui-ci. Finalement, il ne reste qu'à lire ce flux.

Dans l'exemple ci-dessous, on lit une image dans une base de données afin de l'écrire sur le disque. L'utilisation de ImageIO permet de facilement récupérer le contenu du Blob sous forme de BufferedImage.

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public static void extraireImage(String nom, String chemin) { 
   String destination = chemin + System.getProperty("file.separator") 
                         + nom + ".jpg"; 
   File file = new File(destination); 
   try{ 
      //lien vers la base de données 
      Connection connection = DriverManager.getConnection("url","user","password"); 
  
      //préparation de l'instruction SQL 
      String sql = "SELECT * FROM TableImages WHERE nom = ? "; 
      PreparedStatement statement = connection.prepareStatement(sql); 
  
      //récupération de l'image (BLOB) 
      statement.setString(1, nom); 
      ResultSet resultat = statement.executeQuery(); 
      resultat.first(); 
      Blob blob = resultat.getBlob("images"); 
  
      //lecture du blob et écriture sur le disque 
      BufferedImage image = ImageIO.read(blob.getBinaryStream()); 
      FileOutputStream stream = new FileOutputStream(file); 
      ImageIO.write(image,"jpg",stream);   
  
    }catch(Exception e){ 
       //traitement des erreurs SQL, IO, etc. 
    }finally { 
       //fermeture de la connexion, du flux, etc. 
    } 
}
Pour un exemple plus complet, regardez Utilisation de JDBC pour la gestion d'images en base de données par Ricky81 .

Mis à jour le 11 avril 2013 Ioan

L'insertion d'un CLOB dans une base de données se fait grâce à un flux de caractères. Voici un exemple qui lit le contenu d'un fichier et le stocke sous forme de CLOB :

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public static void insererTexte(String nomFichier){ 
   File file = new File(nomFichier); 
   BufferedReader fileReader = null; 
   String texte = ""; 
   StringReader stringReader = null; 
   Connection connection = null; 
   PreparedStatement statement = null; 
   try{ 
      //lectute du contenu du fichier à insérer 
      fileReader = new BufferedReader(new FileReader(file)); 
      String ligne = null; 
      while((ligne = fileReader.readLine()) != null){ 
         texte += ligne+"\n"; 
      } 
  
      //préparation de la connexion 
      connection = DriverManager.getConnection("url","login","pass"); 
      String sql = "INSERT INTO ClobTable (nom,article) VALUES (?, ?)"; 
      statement = connection.prepareStatement(sql); 
  
      //on met en place les paramètres du statement 
      statement.setString(1,file.getName()); 
      stringReader = new StringReader(texte); 
      statement.setCharacterStream(2,stringReader,texte.length()); 
  
      //exécution de l'instruction 
      statement.executeUpdate(); 
  
   }catch(Exception e){ 
      e.printStackTrace(); 
   }finally{ 
      try{fileReader.close();}catch(Exception e){} 
      try{stringReader.close();}catch(Exception e){} 
      try{statement.close();}catch(Exception e){} 
      try{connection.close();}catch(Exception e){} 
   } 
}

Mis à jour le 11 avril 2013 Ioan

L'interface Clob du package java.sql permet de récupérer un flux de caractères sous forme de Reader. Voici un exemple qui récupère le texte contenu dans un CLOB et l'affiche sur la sortie standard :

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public static void lectureTexte(String nomArticle){ 
   BufferedReader clobReader = null; 
   Connection connection = null; 
   PreparedStatement statement = null; 
   ResultSet resultset = null; 
   try{ 
      //préparation de la connexion 
      connection = DriverManager.getConnection("url","login","pass"); 
      String sql = "SELECT article FROM ClobTable WHERE nom = ?"; 
      statement = connection.prepareStatement(sql); 
  
      //on met en place les paramètres du statement 
      statement.setString(1,nomArticle); 
  
      //exécution de la requête 
      resultset = statement.executeQuery(); 
  
      //récupération et lecture du clob 
      if(resultset.next()){ 
         Clob clob = resultset.getClob("article"); 
         clobReader = new BufferedReader(clob.getCharacterStream()); 
         String ligne = null; 
         while((ligne = clobReader.readLine()) != null){ 
            System.out.println(ligne); 
         } 
      }else{ 
         System.out.println("Article "+nomArticle+" introuvable"); 
      } 
   }catch(Exception e){ 
      e.printStackTrace(); 
   }finally{ 
      try{clobReader.close();}catch(Exception e){} 
      try{resultset.close();}catch(Exception e){} 
      try{statement.close();}catch(Exception e){} 
      try{connection.close();}catch(Exception e){} 
   } 
}

Mis à jour le 11 avril 2013 Ioan

L'interface Clob du package java.sql permet de facilement faire une recherche dans le contenu d'un CLOB. Voici un exemple permettant de rechercher toutes les occurrences d'un mot dans une table contenant des « articles » :

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public static void rechercherTexte(String recherche){ 
   Connection connection = null; 
   Statement statement = null; 
   ResultSet resultset = null; 
   try{ 
      //préparation de la connexion 
      connection = DriverManager.getConnection("url","login","pass"); 
      statement = connection.createStatement(); 
  
      //exécution de la requête 
      String sql = "SELECT * FROM ClobTable"; 
      resultset = statement.executeQuery(sql); 
  
      //recherche dans les différents clob 
      while(resultset.next()){ 
         String nomArticle = resultset.getString("nom"); 
         System.out.println("Recherche de "+recherche+" dans "+nomArticle); 
         Clob clob = resultset.getClob("article"); 
         long indexe = 1;//Attention : le premier caractère est d'indexe 1 
         while((indexe = clob.position(recherche,indexe)) != -1){ 
            System.out.println("  mot trouvé en "+indexe); 
            indexe++; 
            //ne pas oublier d'incrémenter l'index 
         } 
      } 
   }catch(Exception e){ 
      e.printStackTrace(); 
   }finally{ 
      try{resultset.close();}catch(Exception e){} 
      try{statement.close();}catch(Exception e){} 
      try{connection.close();}catch(Exception e){} 
   } 
}

Mis à jour le 11 avril 2013 Ioan

Pour faire la relation entre un UDT (User Defined Type) et un objet Java, vous devrez tout d'abord créer une classe implémentant SQLData. Voici un exemple :

UDT PERSONNE :

Code sql : Sélectionner tout
1
2
3
4
5
6
CREATE TYPE PERSONNE 
  ( 
    NOM VARCHAR(40), 
    PRENOM VARCHAR(40), 
    AGE INTEGER 
 );
Objet Java Personne :

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class Personne implements SQLData{ 
   private String nom;  
   private String prenom; 
   private int age; 
   private String typeSql;  
  
   //Définition des constructeurs 
  
   //Définition des getters/setters 
  
   //Implémentation de SQLData 
    public String getSQLTypeName() { 
      return typeSql; 
    } 
    public void readSQL(SQLInput stream, String type) 
                        throws SQLException { 
      typeSql = type; 
      nom = stream.readString(); 
      prenom = stream.readString(); 
      age = stream.readInt(); 
   } 
  
    public void writeSQL(SQLOutput stream)  
     throws SQLException { 
      stream.writeString(nom); 
      stream.writeString(prenom); 
      stream.writeInt(age); 
   } 
}
Utilisation :

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Connection connection = ...;  
  
// mise en place du mapping 
Map map = con.getTypeMap(); 
map.put("Schema.PERSONNE", Class.forName("Personne"); 
  
// utilisation 
Statement statement = ...;  
String sql = "SELECT Personnes FROM Annuaire"; 
ResultSet resultset = statement.executeQuery(sql); 
while(resultset.next()){ 
   Personne personne = (Personne)resultset.getObject(1); 
   System.out.println("Nom = "+personne.getNom()); 
   System.out.println("Prenom = "+personne.getPrenom()); 
   System.out.println("Age  = "+personne.getAge()); 
}

Mis à jour le 11 avril 2013 Ioan

Il est nécessaire d'utiliser la méthode getColumnTypeName de l'interface ResultSetMetaData.

Code Java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
public static void afficheTypeColonne(ResultSet rs) { 
	String nomColonne = null; 
	String type = null; 
	ResultSetMetaData rsmd = rs.getMetaData (); 
	int nbCol = rsmd.getColumnCount (); 
	for (int i = 0; i < nbCol; i++) { 
		nomColonne = rsmd.getColumnLabel(i + 1); 
		type = rsmd.getColumnTypeName(i + 1); 
		System.out.println("Colonne: "+nomColonne+" de type: "+type); 
	} 
}

Mis à jour le 3 juin 2015 bahamouth Robin56

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2017 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

 
Responsables bénévoles de la rubrique Java : Mickael Baron - Robin56 -