Newsgroup: it.comp.java
Titolo: Problema con HSQLDB

Ciao a tutti,
ho un problema con l'utilizzo di HSQLDB in modalità standalone.
Fino a qualche settimana fa usavo per la mia applicazione una sola
connessione al db ed andava tutto bene.
Adesso utilizzo una strato di persistenza (OJB) che utilizza più connessioni
gestite in un pool.
Mi succede che a volte mi da errore dicendo che il db è in uso da un altro
processo. (Ovviamente non ho altri processi che accedono al db)
Ho provato con una piccola classe di prova e ho notato che se apro n
connessioni non ci sono problemi, ma se apro e chiudo anche solo 15
connessioni da vari thread mi da questo errore.
Pensavo fosse dovuto al fatto che se arrivo a 0 connessioni attive in qulche
modo il db si chiude e quindi non posso riaprirlo subito ma questo errore lo
da anche se ho varie connessioni ancora aperte.
Spero che qualcuno sappia darmi qualche consiglio. Sarebbe antipatico
costringere chi ha una sola postazione di lavoro ad usare il db in modalità
client-server.
Grazie a tutti.
Paolo.

 errore lo da anche se ho varie connessioni ancora aperte.
Ciao
dalla documentazione di hsqldb sembra che sia proprio così. Ti riporto il 
pezzo:
"In-process databases are closed also when the last connection to the 
database is explicitly closed via JDBC".
(per tutto il documento vedi 
http://hsqldb.sourceforge.net/doc/hsqlGuide.html
)
A questo punto potresti prendere due scelte: una più elegante e una più 
semplice :)
Quella elegante: "wrappare" il driver jdbc di hsqlb con una classe identica 
che però tiene traccia delle connessioni aperte e impedisce che l'ultima 
venga chiusa (vedi pattern "decorator")
Quella semplice: tieni sempre una connessione in più aperta, e la chiudi 
solo alla chiusura del programma (e non sarebbe nemmeno necessario perché 
dovrebbe venir fatto cmq automaticamente).
Cosa sceglierei io? Beh la semplicità a volte è una bella cosa... ;-)
ciao :)
pole
-- 
Note: Some input words use a deprecated author.
Note: Read with -deprecation to understand.
http://web.tiscali.it/meridies

Grazie per il link, ma avevo giŕ provato a tenere una connessione aperta.
Posto un piccolo programma di prova in cui ho definito due metodi statici e
synchronized per aprire e chiudere le connessioni cosě posso tenere traccia
del numero di connessioni aperte.
Eseguendolo (prende un parametro intero per il numero di ripetizioni) apre
una connessione che non chiude piů e poi lancia n volte 2 thread che per 10
volte aprono una connessione fanno una select e poi chiudono la connessione.
L'ultima volta che l'ho lanciato mi ha dato errore con un conteggio delle
connessioni aperte pari a 157.
import java.util.*;
import java.sql.*;
public class prova {
 static int max=0;
        static int connessioni=0;
        static int maxconnessioni=0;
 synchronized static int getMax() {return max++;}
        synchronized static Connection connetti()  {
            try {
                Connection c =
DriverManager.getConnection("jdbc:hsqldb:pippo","sa","");
                connessioni++;
                if (maxconnessioni<connessioni)
{maxconnessioni=connessioni;}
                System.out.println("Aperta:"+connessioni);
                return c;
            }
            catch (Exception e) {
                System.out.println(e.getMessage()+" connessioni:
"+connessioni);
                return null;
            }
        }
        synchronized static void disconnetti(Connection c)  {
            try {
                connessioni--;
                c.close();
                System.out.println("Chiusa:"+connessioni);
            }
            catch (Exception e) {
                System.out.println(e.getMessage()+" connessioni:
"+connessioni);
            }
        }
        public static void main(String[] args) {
            int ripetizioni = Integer.parseInt(args[0]);
  try{
                    Class.forName("org.hsqldb.jdbcDriver");
                }
                catch(Exception ex) {
                }
                Runtime.getRuntime().addShutdownHook(new Thread() {public
void run() {System.out.println("MAX CONN:"+maxconnessioni);}});
  connetti();
  for (int x=0;x<ripetizioni;x++) {
   new Leggi().start();
   new Conta().start();
  }
 }
 static class Leggi extends Thread {
  public void run() {
   for (int x=0;x<10;x++) {
    try {
    Connection c = connetti();
    Statement s = c.createStatement();
    s.executeQuery("select * from SYSTEM_TABLES");
    s.close();
    disconnetti(c);
    }
    catch (Exception e) {e.printStackTrace();}
                                Thread.yield();
   }
  }
 }
 static  class Conta extends Thread {
  public void run() {
   for (int x=0;x<10;x++) {
    try {
    Connection c = connetti();
    Statement s = c.createStatement();
    s.execute("select count(*) from SYSTEM_TABLES");
    s.close();
    disconnetti(c);
    }
    catch (Exception e) {e.printStackTrace();}
                                Thread.yield();
   }
  }
 }
}