Java JDBC ignore setFetchSize?

Je suis en utilisant le code suivant

 st = connection.createStatement(
            ResultSet.CONCUR_READ_ONLY,
            ResultSet.FETCH_FORWARD,
            ResultSet.TYPE_FORWARD_ONLY
             );
 st.setFetchSize(1000);
 System.out.println("start query ");
 rs = st.executeQuery(queryString);
 System.out.println("done query");

La requête en retour beaucoup d' (800k) lignes et de prendre un temps important (~2m) entre l'impression de "query" et "fait de requête". Quand j'mettre manuellement une "limite de 10000" dans ma requête il n'y a pas de temps entre "démarrer" et "fait". Le traitement des résultats prend du temps donc je suppose que c'est globalement plus rapide si elle récupère 1k lignes à partir de la base de données, processus de ceux et quand il est à court de lignes qu'il peut obtenir de nouveaux en arrière-plan.

La ResultsSet.CONCUR_READ_ONLY etc où mon dernier deviner; suis-je raté quelque chose?

(c'est un serveur postgresql 8.3)

setFetchSize fonctionne réellement bien avec le driver PostgreSQL, il n'a tout simplement une chose très différente que vous vous attendez à faire. Voir ma réponse.
Voir aussi stackoverflow.com/a/47517489/32453

OriginalL'auteur kresjer | 2009-09-23

  1. 22

    Essayez d'activer l'auto-commit off:

    //make sure autocommit is off
connection.setAutoCommit(false);

 st = connection.createStatement();
 st.setFetchSize(1000);
 System.out.println("start query ");
 rs = st.executeQuery(queryString);
 System.out.println("done query");

    Référence

    Exactement. setFetchSize ne fonctionne pas en mode autoCommit, avec PostgresSQL pilote JDBC.
    Il est intéressant de noter que vous avez probablement besoin à son tour de validation automatique de retour avant la fermeture de la connexion, si vous êtes en utilisant le regroupement de connexion, et d'autres parties de l'application s'appuyer sur validation. Sinon, vous pourriez vous retrouver avec des données aléatoires de perte lorsqu'il n'est pas explicitement de commettre.
    Plus de détails sur cette JDBC PostgreSQL restriction peut être trouvé à l'adresse jdbc.postgresql.org/documentation/head/....
    FWIW autoCommit est sur "on" par défaut, alors assurez-vous de varier d'elle...voir aussi les autres commentaires.

    OriginalL'auteur dogbane

  2. 2

    Cela dépendra de votre pilote. À partir de la documentation:

    Donne le pilote JDBC une allusion à la
    nombre de lignes qui doivent être récupérés
    à partir de la base de données lorsque plusieurs lignes sont
    nécessaire. Le nombre de lignes spécifié
    affecte uniquement les ensembles de résultats créés à l'aide de
    la présente déclaration. Si la valeur spécifiée
    est égal à zéro, alors l'indicateur est ignoré. L'
    la valeur par défaut est zéro.

    Note qu'il est dit "un soupçon" - je prendrais cela pour dire qu'un pilote ne peut ignorer l'indication, si elle le veut vraiment... et il semble que c'est ce qui se passe.

    Ouais j'ai lu ça, mais ne pouvais pas croire que JDBC + postgreSQL serait ignorer que, c'est autour depuis des siècles.
    Son postgresql, donc vous devriez avoir accès à la source de la DB et les pilotes JDBC. Vous pouvez l'utiliser pour comprendre ce qui se passe réellement ...
    NB que postgres (si autocommit, donc taille de l'extraction est de travailler) réglage de la taille de l'extraction de 0 apparemment il cache "tout" par défaut (je suppose que c'est la façon dont ils interprètent "ignorant" un soupçon) avec oracle la valeur par défaut est 10, apparemment, docs.oracle.com/cd/A97335_02/apps.102/a83724/resltse5.htm

    OriginalL'auteur Jon Skeet

  3. 2

    Les deux requêtes de faire des choses totalement différentes.

    À l'aide de la LIMIT clause ne limite la taille de l'ensemble de résultats de 10000, tandis que le réglage de la taille de l'extraction n'est pas, il donne au contraire un indice pour le pilote de dire le nombre de lignes à récupérer à un moment lors d'une itération dans le jeu de résultats - qui comprend tous les 800k lignes.

    Donc, lorsque vous utilisez setFetchSize, la base de données crée le jeu de résultats complet, c'est pourquoi il est si long.

    Modifier pour plus de clarté:
    Réglage de la taille de l'extraction ne fait rien à moins que vous itérer sur le résultat (voir Jon commentaire), mais la création d'un beaucoup plus petit ensemble de résultats via une LIMITE de fait une grande différence.

    Mais il n'est pas itération dans le jeu de résultats. L'idée est que pendant, vous pouvez parcourir l'ensemble de résultats, idéalement, il devrait chercher de 1000 résultats sur le réseau, alors vous pouvez les traiter, et quand vous arrivez à la 1001st il va alors récupérer les 1000 prochaines etc.
    Bien sûr. La différence de vitesse est à cause de differenr tailles des ensembles de résultats, 10000 vs 800000.

    OriginalL'auteur Henning

  4. 2

    J'ai remarqué que votre utilisation de l'API est différent de ce qu'exprimée par Javadoc:

    Essayer de passer les paramètres dans cet ordre

      ResultSet.TYPE_FORWARD_ONLY,
  ResultSet.CONCUR_READ_ONLY,
  ResultSet.FETCH_FORWARD
    Ces 3 touches, avec réglage de conn.setAutoCommit(false) a fait l'affaire pour moi

    OriginalL'auteur Wishper