JDBC de la Pagination

Il n'existe pas de moyen efficace de le faire simplement à l'aide de JDBC. Vous devez formuler la limite à n lignes et commencer à partir de la i-ème élément de clauses directement à SQL pour qu'il soit efficace. Selon la base de données cela peut être assez facile (voir MySQL LIMITE-mot-clé), sur d'autres bases de données comme Oracle, il peut être un peu plus délicat (implique une sous-requête et à l'aide de rownum pseudo colonne).

Voir ce JDBC Pagination Tutoriel:
http://java.avdiel.com/Tutorials/JDBCPaging.html

Avertissement: Cet article de blog sur SQL pagination & JDBC la pagination est posté par moi.

Mépris Hibernate pagination, nous pouvons utiliser SQL pagination /JDBC pagination

SQL pagination

Il existe deux approches de base:

1. d'exploitation sur fragmentaire ensemble de résultats (Nouvelle Requête pour Chaque Page)
2. d'exploitation sur l'ensemble de résultats complet

La façon de le faire est spécifique SQL

Pour MySQL /beaucoup d'autres SQLs il peut être fait avec limit et offset

Postgresql: http://microjet.ath.cx/WebWiki/ResultPaginationWithPostgresql.html

Dans Oracle, il utilise la même forme que pour gérer les "Top-requête N" par exemple, qui sont les 5 plus haut salarié, qui est optimisé

select *   from ( select a.*, rownum rnum

from ( YOUR_QUERY_GOES_HERE -- including the order by ) a

where rownum <= MAX_ROWS )

where rnum >= MIN_ROWS

Voici une explication détaillée sur la LIGNE-NUM

Similaire à ce Thread

JDBC Pagination

La question vient à l'esprit est: lorsque j'exécute SQL, comment est le résultat chargé? Immédiatement ou sur demande? même chose que ce fil

Nous avons d'abord besoin de comprendre certaines bases de JDBC, comme à partir d'Oracle

Par javadoc: déclaration.execute()

execute: Returns true if the first object that the query returns is a ResultSet object. Use this method if the query could return one or more ResultSet objects. Retrieve the ResultSet objects returned from the query by repeatedly calling Statement.getResutSet.

Nous avons accès à des données dans le jeu de résultat par l'intermédiaire d'un curseur. Remarque ce curseur est différent de celui de la DB, alors que c'est un pointeur initialement positionné avant la première ligne de données.

Les données récupérer sur demande. alors que quand vous ne l'execute() de l'extraction pour la première fois.

Ensuite, le nombre de données est chargé? Il est configurable.
On peut utiliser l'API java setFetchSize() la méthode sur ResultSet pour contrôler combien de lignes sont extraites à partir de DB une fois par le pilote, comment taille les blocs qu'il récupère à la fois.

Par exemple, supposons le résultat total est de 1000. Si la taille de l'extraction est de 100, l'extraction de la 1ère ligne de charge de 100 lignes de la DB et 2 au 100e rang sera chargé à partir de la mémoire locale.à la requête de la 101st ligne 100 lignes seront charger en mémoire.

De JavaDoc

Gives the JDBC driver a hint as to the number of rows that should be fetched from the database when more rows are needed for ResultSet objects genrated by this Statement. If the value specified is zero, then the hint is ignored. The default value is zero.

Note le mot "astuce" - il peut être remplacer par un pilote de mise en œuvre spécifiques.

C'est aussi ce que la "Limite de Lignes à 100" dans client SQL developer basé sur.

De remplir l'ensemble de la solution pour faire défiler les résultats, il faut considérer le jeu de résultats Types et ScrollableCursor de l'API de

On peut trouver un exemple de mise en œuvre de ce post dans oracle

qui est du livre Oracle Toplink Guide du Développeur
Exemple 112 Pilote JDBC Taille de l'Extraction

ReadAllQuery query = new ReadAllQuery();

query.setReferenceClass(Employee.class);

query.setSelectionCriteria(new ExpressionBuilder.get("id").greaterThan(100));

//Set the JDBC fetch size

query.setFetchSize(50);

//Configure the query to return results as a ScrollableCursor

query.useScrollableCursor();

//Execute the query

ScrollableCursor cursor = (ScrollableCursor) session.executeQuery(query);

//Iterate over the results

while (cursor.hasNext()) {

System.out.println(cursor.next().toString());

}

cursor.close();

.....................

Après tout, les questions ébullition à

Qui est la meilleure façon de faire de la pagination?

Note SQL devrait être de l'ORDRE par faire sens dans le SQL approche,

Sinon, il est possible de montrer que certaines lignes de nouveau dans la page suivante.

Ci-dessous quelques points de Postgresql documentation sur Pilote JDBC et d'autres réponses

Tout d'abord, l'original de la requête besoin d'avoir une clause ORDER BY pour faire de la pagination de la solution de travail raisonnable. Sinon, il serait parfaitement valable pour Oracle de retourner la même 500 lignes de la première page, la deuxième page, et la n-ième page

La différence majeure est pour le pilote JDBC, il est nécessaire pour maintenir la connexion lors de l'extraction. Cela peut ne pas être approprié dans les apatrides application web, par exemple.

Pour SQL façon

la syntaxe SQL est spécifique et ne peut pas être faciles à entretenir.
Pour JDBC façon

• La connexion au serveur doit être à l'aide de la V3 protocole. C'est
  la valeur par défaut (et n'est pris en charge par le serveur de versions 7.4 et
  plus tard.
• La Connexion ne doit pas être en mode autocommit. Le backend
  ferme les curseurs à la fin de la transaction, donc en mode autocommit, le
  backend sera fermé le curseur avant que quelque chose peut être récupérée
  à partir d'elle.
• La Déclaration doit être créé avec un ResultSet type de
  Jeu de résultats.TYPE_FORWARD_ONLY. C'est la valeur par défaut, donc pas de code
  besoin d'être réécrit pour tirer parti de cette situation, mais cela signifie aussi
  que vous ne pouvez pas faire défiler vers l'arrière ou autrement sauter partout dans la
  ResultSet.
• La requête doit être une instruction unique, et non plusieurs
  les déclarations s'enchaînent avec des points-virgules.

Quelques lectures complémentaires

Ce post est sur le réglage des performances optiques de l'extraction du

C'est le lien à un hibernate solution pour la pagination des résultats:
HQL - identificateur de ligne pour la pagination

Je comprendre implicitement que vous ne voulez pas de la connexion JDBC à avoir un seul gigantesque jeu de résultats qui vous garder ouvert pour un temps très long et naviguer lorsque requis.

L'approche habituelle consiste à ajouter le code SQL nécessaire pour obtenir uniquement un sous-ensemble de la demande complète, qui, malheureusement, est différente de la base de données de la base de données, et fera de votre SQL spécifiques au fournisseur. Si je me souviens bien, la LIMITE est utilisé par MySQL. Demandez pour la gamme appropriée pour chaque requête.

Je crois aussi que Hibernate contient une fonctionnalité qui vous permet de le faire pour les requêtes HQL, mais je suis pas familier avec elle.

Oracle prend en charge la norme ROW_NUMBER() de la fenêtre de fonction depuis 8i donc vous pouvez l'utiliser. Vous pouvez faire une requête paramétrée de sorte que vous suffit de définir le début et la fin de la ligne. E. g.

SELECT * 
   FROM ( SELECT *, ROW_NUMBER() ORDER BY (sort key) AS rowNumber FROM <your table name> ) AS data
WHERE 
   rowNumber>=:start AND
   rowNumber<:end

(Si vous n'êtes pas en utilisant des paramètres nommés, remplacer :démarrer/:fin avec le paramètre de position de l'espace réservé '?')

Voir SÉLECTIONNEZ SQL, Fonctions de la Fenêtre sur wikipédia.
L'article répertorie également les autres DBs qui prennent en charge la fonction ROW_NUMBER() standard de la fonction de fenêtrage.

D'entrée:

1. Informations de commande exemple (A2 ou D3) (A/D dans l'ordre croissant/décroissant) + colonne
2. Informations de commande exemple (A2 ou D3) (A/D dans l'ordre croissant/décroissant) + colonne
3. Valeur de filtre
4. début de la ligne
5. début de la ligne
6. nombre maximum de lignes

Résultat:

• Valeurs sélectionnées
• Page sélectionnée
• Indice de la ligne dans cet ordre
• Compterez données disponibles. (Enregistrer une deuxième requête)

Avantage de la Requête pour:

• somme des colonnes disponibles avec ce filtre
• seulement le transfert de la page sélectionnée à partir de db
• correctement ordonnées sans le sql dynamique

Inconvénient:

• Oracle Dependend

  sélectionnez x.* à partir de (
  sélectionnez c.pk_field,c.numeric_a, c.char_b, c.char_c
  ROW_NUMBER( ) over(ORDER BY
  décoder(?,'A1',to_char(c.numeric_a,'FM00000000'),'A2',c.char_b,'A3',c.char_c,'A') de l'asc ,
  décoder(?,'D1',to_char(c.numeric_a,'FM00000000'),'D2',c.char_b,'D3',c.char_c,'A') desc,
  c.pk_field asc
  
  ) En tant QUE "idx",
  COUNT (*) OVER (ORDER BY 1) "cnt" from myTable c
  où c.botte de foin=?
  ) x où x."idx" entre la plus grande(nvl(?,1),1) et nvl(?,1)-1+?

La suite des codes java qui fonctionne bien:

package paginationSample;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
/**
*
* @ Nwaeze Emmanuel (FUNAI, 2016)
*/
public class PaginationSample extends javax.swing.JFrame {  
public void getRows() {
Connection con2;
Statement stmt2;
ResultSet rs2;
int j=0;
String sz="";
try {
//Load MS accces driver class
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); 
String url = "jdbc:odbc:Driver={Microsoft Access Driver (*.mdb, 
*.accdb)};DBQ=" + "C:\\Database2.mdb"; 
try{
con2 = DriverManager.getConnection(url, "user", "");
System.out.println("Connection Succesfull");
try{
stmt2=con2.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, 
ResultSet.CONCUR_UPDATABLE );
String sql="";
if (txtpage.getText().trim().equals("") || 
txtpagesize.getText().trim().equals("")){
}else{
int pagesize=Integer.parseInt(txtpagesize.getText());   
int page=Integer.parseInt(txtpage.getText());
sql="SELECT * FROM FSRegistration100L WHERE SN >= " +  
(pagesize*page-pagesize+1) + " AND " + "SN <= " + (pagesize*page);
rs2=stmt2.executeQuery(sql);
if (rs2.wasNull()){
}else{
while ( rs2.next()){
sz=sz + rs2.getString("RegNo") + "\n";
j++;  
}
txta.setText(sz);
txta.append(" Total rows =" + Integer.toString(j));
} 
}
stmt2.close();
con2.close();
}
catch (NullPointerException s){
System.err.println("Got an exception166! ");
System.out.println(s.getMessage());
} 
} catch (SQLException e1) {
System.err.println("Got an exception1! ");
System.err.println(e1.getMessage());
}
} catch (ClassNotFoundException e2) {
System.err.println("Got an exception2! ");
System.err.println(e2.getMessage());
} 
}
private void jButton1ActionPerformed(java.awt.event.ActionEvent 
evt)     {                                         
//TODO add your handling code here:
getRows();
}                                        
//Variables declaration - do not modify                     
private javax.swing.JButton jButton1;
private javax.swing.JLabel jLabel1;
private javax.swing.JLabel jLabel2;
private javax.swing.JScrollPane jScrollPane1;
private javax.swing.JTextArea txta;
private javax.swing.JTextField txtpage;
private javax.swing.JTextField txtpagesize;
//End of variables declaration