FAQ JDBCConsultez toutes les FAQ

1
2
3
4
5
6
7
8
9
10
11
Statement createStatement(int resultSetType, 
                          int resultSetConcurrency, 
                          int resultSetHoldability) 
PreparedStatement prepareStatement(String sql, 
                                   int resultSetType, 
                                   int resultSetConcurrency, 
                                   int resultSetHoldability) 
CallableStatement prepareCall(String sql, 
                              int resultSetType, 
                              int resultSetConcurrency, 
                              int resultSetHoldability)

1
2
3
4
5
6
CREATE TABLE MaTable ( 
   id INTEGER PRIMARY KEY, 
   nom VARCHAR(50), 
   prix DECIMAL, 
   date DATE 
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Statement statement = connection.createStatement( 
ResultSet.TYPE_FORWARD_ONLY, 
ResultSet.CONCUR_READ_ONLY); 
String sql = "SELECT * FROM MaTable"; 
ResultSet resultat = statement.executeQuery(sql); 
while(resultat.next()){ 
int id = resultat.getInt(1); 
String nom = resultat.getString(2); 
double prix = resultat.getDouble(3); 
java.sql.Date date = resultat.getDate(4); 
int row = resultat.getRow(); 
System.out.println("Données contenues dans la ligne "+row); 
System.out.println("id : "+id+" nom : "+nom+ 
" prix : "+prix+" date : "+date); 
}

1
2
3
4
int id = resultat.getInt("id"); 
String nom = resultat.getString("nom"); 
double prix = resultat.getDouble("prix"); 
java.sql.Date date = resultat.getDate("date");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Statement statement = connection.createStatement( 
ResultSet.TYPE_SCROLL_SENSITIVE, 
ResultSet.CONCUR_READ_ONLY); 
String sql = "SELECT * FROM MaTable"; 
ResultSet resultat = statement.executeQuery(sql); 
resultat.first(); 
//on récupère le "prix" de la première ligne 
double d1 = resultat.getDouble("prix"); 
//un traitement quelconque 
resultat.fisrt(); 
//on vérifie que le prix n'a pas changé durant le traitement 
resultat.refreshRow(); 
double d2 = resultat.getDouble("prix"); 
if(d1!=d2){ 
   //le prix a changé 
}

1
2
3
4
5
6
7
8
9
Statement statement = connection.createStatement( 
ResultSet.TYPE_FORWARD_ONLY, 
ResultSet.CONCUR_READ_ONLY); 
String sql = "SELECT * FROM MaTable"; 
ResultSet resultat = statement.executeQuery(sql); 
while(resultat.next()){ 
double prix = resultat.getDouble(3); 
String text = (resultat.wasNull())?"pas de prix spécifié(NULL)":String.valueOf(prix); 
System.out.println(" prix : "+txt);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Connection connection = DriverManager.getConnection(url,user,password); 
Statement statement = connection.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE 
,ResultSet.CONCUR_READ_ONLY); 
ResultSet resultat = statement.executeQuery("SELECT * FROM MaTable"); 
System.out.println(resultat.isbeforeFirst()); 
//true 
resultat.next(); 
//on se retrouve ici sur la première ligne 
  
//traitement de la première ligne ... 
while(resultat.next()){ 
  //traitement des autres lignes 
} 
resultat.first(); 
//on a replacé ici le curseur sur la première ligne 
resultset.afterlast(); 
//on a replacé le curseur après la dernière ligne 
while(resultat.previous()){ 
  // on parcourt ici le ResultSet de la dernière à la première ligne 
} 
//etc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
Connection connection = DriverManager.getConnection(url,user,password); 
Statement statement = connection.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE 
,ResultSet.CONCUR_READ_ONLY); 
ResultSet resultat = statement.executeQuery("SELECT * FROM MaTable"); 
resultat.next(); 
//on se trouve ici sur la première ligne 
resultat.absolute(40); 
//on se trouve ici sur la 40e ligne 
resultat.absolute(1); 
//on se trouve sur la première ligne == resultat.first() 
resultat.absolute(-1); 
//on se trouve sur la dernière ligne == resultat.last() 
resultat.absolute(-2); 
//on se trouve sur l'avant-dernière ligne == resultat.last()+reusultat.previous() 
resultat.first(); 
//on revient sur la première ligne 
resultat.relative(1); 
//on se trouve sur la deuxième ligne == resultat.next(); 
resultat.relative(50); 
//on se trouve sur la 52e ligne 
resultat.relative(-1); 
//on se trouve sur la 51e ligne == resultat.previous()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public void afficherInfosCurseur(ResultSet resultat) throws SQLException{ 
String curseur = "row = "+resultat.getRow(); 
if(resultat.isBeforeFirst()){ 
  curseur += "(avant la première ligne)"; 
} 
if(resultat.isAfterLast()){ 
  curseur += "(après la dernière ligne)"; 
} 
if(resultat.isFirst()){ 
  curseur += "(première ligne)"; 
} 
if(resultat.isLast()){ 
  curseur += "(dernière ligne)"; 
} 
System.out.println(curseur); 
}

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
Statement statement = connection.createStatement( 
ResultSet.TYPE_SCROLL_INSENSITIVE, 
ResultSet.CONCUR_READ_ONLY); 
String sql = "SELECT * FROM Annuaire"; 
ResultSet resultat = statement.executeQuery(sql); 
afficherInfosCurseur(resultat); 
//on parcourt le ResultSet de la première à la dernière ligne 
while(resultat.next()){ 
afficherInfosCurseur(resultat); 
} 
afficherInfosCurseur(resultat); 
//on parcourt le ResultSet de la dernière à la première ligne 
while(resultat.previous()){ 
afficherInfosCurseur(resultat); 
} 
afficherInfosCurseur(resultat); 
//quelques mouvements absolus 
resultat.absolute(-1); 
afficherInfosCurseur(resultat); 
resultat.absolute(1); 
afficherInfosCurseur(resultat); 
//quelques mouvements relatifs 
resultat.relative(5); 
afficherInfosCurseur(resultat); 
resultat.relative(-3); 
afficherInfosCurseur(resultat); 
resultat.relative(-3); 
afficherInfosCurseur(resultat);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
row = 0(avant la première ligne) 
row = 1(première ligne) 
row = 2 
//... 
row = 7 
row = 8(dernière ligne) 
row = 0(après la dernière ligne) 
row = 8(dernière ligne) 
row = 7 
//... 
row = 2 
row = 1(première ligne) 
row = 0(avant la première ligne) 
row = 8(dernière ligne) 
row = 1(première ligne) 
row = 6 
row = 3 
row = 0(avant la première ligne)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Connection connection = ...; 
//création d'une instruction renvoyant des résultats 
  
//pouvant être mis à jour 
Statement statement = connection.createStatement( 
ResultSet.TYPE_SCROLL_SENSITIVE, 
ResultSet.CONCUR_UPDATABLE); 
//on sélectionne tous les tuples de la table Annuaire 
String sql = "SELECT * FROM Annuaire"; 
ResultSet resultat = statement.executeQuery(sql); 
// on se place sur le premier tuple récupéré 
resultat.first(); 
//on récupère la valeur de la colonne "nom" 
String nom1 = resultat.getString("nom"); 
//on met à jour la valeur de la colonne "nom" 
resultat.updateString("nom", "nouveauNom"); 
//on met à jour la valeur dans la table 
resultat.updateRow(); 
String nom2 = resultat.getString("nom"); 
System.out.println("Ancien nom = "+nom1+ 
"Nouveau nom = "+nom2);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Connection connection = ...; 
Statement statement = connection.createStatement( 
ResultSet.TYPE_SCROLL_SENSITIVE, 
ResultSet.CONCUR_UPDATABLE); 
String sql = "SELECT * FROM Annuaire"; 
ResultSet resultat = statement.executeQuery(sql); 
// on se place sur la ligne à insérer 
resultat.moveToInsertRow(); 
//on renseigne les différents champs 
resultat.updateInt("id",456); 
resultat.updateString("nom","nouveauNom"); 
resultat.updateString("prenom","nouveauPrenom"); 
//on insère effectivement la nouvelle ligne 
resultat.insertRow();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static int countItem(Connection contact, String query) throws SQLException { 
  Statement stmt = contact.createStatement(    	    	     
    ResultSet.TYPE_SCROLL_INSENSITIVE, 
    ResultSet.CONCUR_READ_ONLY); 
  
  ResultSet resultset = stmt.executeQuery(query); 
  int nbItem = 0; 
  
  if (resultset!=null) { 
    resultset.last(); 
    nbItem = resultset.getRow(); 
    resultset.beforeFirst(); 
  } 
  return nbItem; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Connection connection = null; 
Statement statement = null; 
ResultSet resultat = null; 
try{ 
   //initialisation des trois éléments 
   //divers traitements sur la base de données 
} 
catch(Exception){ 
   //gestion des différents types d'erreurs pouvant survenir 
} 
finally{ 
   try{if(resultat!=null){resultat.close();}}catch(Exception e){} 
   try{if(statement!=null){statement.close();}}catch(Exception e){} 
   try{if(connection!=null){connection.close();}}catch(Exception e){} 
}

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
public void afficherCaracteristiques(ResultSet resultat)throws SQLException{ 
int type = resultat.getType(); 
//ou à partir du Statement 
  
//int type = resultat.getStatement().getResultSetType(); 
int concurrency = resultat.getConcurrency(); 
//ou à partir du Statement 
  
//int concurrency = resultat.getStatement().getResultSetConcurrency(); 
int holdability = resultat.getStatement().getResultSetHoldability(); 
String sType = ""; 
String sConcurrency = ""; 
String sHoldability = ""; 
switch(type){ 
    case ResultSet.TYPE_FORWARD_ONLY: 
        sType = "Type : FORWARD_ONLY"; 
        break; 
    case ResultSet.TYPE_SCROLL_INSENSITIVE: 
        sType = "Type : SCROLL_INSENSITIVE"; 
        break; 
    case ResultSet.TYPE_SCROLL_SENSITIVE: 
        sType = "Type : SCROLL_SENSITIVE"; 
        break; 
    default :  
        sType = "Type inconnu ??? Bug ???"; 
        break; 
} 
switch(concurrency){ 
    case ResultSet.CONCUR_READ_ONLY: 
        sConcurrency = "Concurrency : CONCUR_READ_ONLY"; 
        break; 
    case ResultSet.CONCUR_UPDATABLE: 
        sConcurrency = "Concurrency : CONCUR_UPDATABLE"; 
        break; 
    default :  
        sConcurrency = "Concurrency inconnue ??? Bug ???"; 
        break; 
} 
switch(holdability){ 
    case ResultSet.HOLD_CURSORS_OVER_COMMIT : 
        sHoldability = "Holdability : HOLD_CURSORS_OVER_COMMIT"; 
        break; 
    case ResultSet.CLOSE_CURSORS_AT_COMMIT: 
        sHoldability = "Holdability : CLOSE_CURSORS_AT_COMMIT"; 
        break; 
    default :  
        sHoldability = "Holdability inconnue ??? Bug ???"; 
        break; 
} 
System.out.println("Les caractéristiques de ce ResultSet sont : "); 
System.out.println(sType); 
System.out.println(sConcurrency); 
System.out.println(sHoldability); 
}

1
2
3
ResultSet resultat = ...; 
resultat.absolute(32); 
resultat.deleteRow();

1
2
3
4
5
6
7
8
9
10
11
Connection connection = ...; 
Statement statement = connection.createStatement( 
            ResultSet.TYPE_SCROLL_SENSITIVE, 
            ResultSet.CONCUR_UPDATABLE); 
String sql = "SELECT * FROM MaTable"; 
ResultSet resultat = statement.executeQuery(sql); 
while(resultat.next()){ 
   resultat.deleteRow(); 
   System.out.println("row  : "+resultat.getRow()); 
   System.out.println(" deleted : "+resultat.rowDeleted()); 
}

1
2
3
4
ResultSet resultat = ...; 
String nom = "nomDeLaColonne"; 
int index = resultat.findColumn(nom); 
System.out.println("La colonne "+nom+" a pour index "+index);