Visualizza il contenuto del database in memoria H2 o HSQLDB

90

C'è un modo per sfogliare il contenuto di un database in memoria H2 o HSQLDB per la visualizzazione? Ad esempio, durante una sessione di debug con Hibernate per controllare quando viene eseguito il flush; o per assicurarsi che lo script che istanzia il DB dia il risultato atteso.

Esiste un addon o una libreria che puoi incorporare con il tuo codice per consentirlo?

Per favore, menziona di quale stai parlando (H2 o HSQLDB) nel caso tu abbia una risposta specifica per uno di loro.

hsqldb  h2  in-memory-database 
— jplandrain
fonte
Questo risponde alla tua domanda? Ispeziona in memoria hsqldb durante il debug
— rogerdpack

Risposte:

59

È possibile eseguire il server Web H2 all'interno dell'applicazione che accederà allo stesso database in memoria. È inoltre possibile accedere a H2 in esecuzione in modalità server utilizzando qualsiasi client JDBC generico come SquirrelSQL .

AGGIORNARE:

Server webServer = Server.createWebServer("-web,-webAllowOthers,true,-webPort,8082").start();
Server server = Server.createTcpServer("-tcp,-tcpAllowOthers,true,-tcpPort,9092").start();

Ora puoi connetterti al tuo database tramite jdbc:h2:mem:foo_dbURL all'interno dello stesso processo o navigare nel foo_dbdatabase usando localhost:8082. Ricorda di chiudere entrambi i server. Vedi anche: Il database H2 in modalità memoria non è accessibile dalla console .

Puoi anche usare Spring:

<bean id="h2Server" class="org.h2.tools.Server" factory-method="createTcpServer" init-method="start" destroy-method="stop" depends-on="h2WebServer">
    <constructor-arg value="-tcp,-tcpAllowOthers,true,-tcpPort,9092"/>
</bean>
<bean id="h2WebServer" class="org.h2.tools.Server" factory-method="createWebServer" init-method="start" destroy-method="stop">
    <constructor-arg value="-web,-webAllowOthers,true,-webPort,8082"/>
</bean>

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close" depends-on="h2Server">
    <property name="driverClass" value="org.h2.Driver"/>
    <property name="jdbcUrl" value="jdbc:h2:mem:foo_db"/>
</bean>

A proposito, dovresti dipendere solo dalle affermazioni e non dalla sbirciatina manuale del contenuto del database. Usalo solo per la risoluzione dei problemi.

NB se utilizzi il framework di test Spring non vedrai le modifiche apportate da una transazione in esecuzione e questa transazione verrà annullata immediatamente dopo il test.

— Tomasz Nurkiewicz
fonte
2
Ho ricevuto un errore indicante che "true" non è un'opzione non valida. -WebAllowOthers era usato per prendere il parametro? Con l'ultimo codice H2, non accetta alcun parametro. Guarda il metodo "principale" qui: h2database.com/javadoc/org/h2/tools/Server.html
— hshib
1
Come menzionato da hman, l'ultima versione non accetta il parametro "true" quindi rimuovilo semplicemente:<constructor-arg value="-web,-webAllowOthers,-webPort,8082"/>
— Mike R
2
Le nuove versioni seguono la convenzione degli argomenti separati di Server.createTcpServer("-tcpPort" ,"9092", "-tcpAllowOthers") Server.createWebServer("-webPort", "8082", "-tcpAllowOthers")
— Jor
8
In Java puro, devi rimuovere il parametro "true" e separare i parametri in questo modo:Server.createWebServer("-web", "-webAllowOthers", "-webPort", "8082").start();
— xnopre
2
Con Spring Boot puoi semplicemente impostare "h2.console.enabled: true" e "h2.console.path: h2-console" nel tuo file application.properties.
— user2754985
33

Per H2, puoi avviare un server web all'interno del tuo codice durante una sessione di debug se hai un oggetto di connessione al database. Puoi aggiungere questa riga al tuo codice o come "espressione di controllo" (dinamicamente):

org.h2.tools.Server.startWebServer(conn);

Lo strumento server avvierà localmente un browser web che ti permetterà di accedere al database.

— Thomas Mueller
fonte
5
Commento per coloro che utilizzano Spring Data: è possibile ottenere la connessione da ApplicationContext in questo modo: ((DataSource) context.getBean ("dataSource")). GetConnection ()
— Odysseus
questo è ottimo anche in un JUnit TestWatcher @Rule
— weberjn
3
Funziona anche se lo lanci con "assessExpression" in intelliJ durante il debug. (blocca il resto degli orologi finché non viene fermato)
— Borjab
Ho cablato automaticamente l' DataSourceistanza nel mio caso di test e ho aggiunto un metodo con body org.h2.tools.Server.startWebServer(dataSource.getConnection());. Ora valutando quel metodo si apre il browser. Nota che questo fa sospendere l'esecuzione fino alla disconnessione (icona in alto a sinistra nel browser)!
— Tom
9

In H2, ciò che funziona per me è:

Codice, avviando il server in questo modo:

server = Server.createTcpServer().start();

Ciò avvia il server sulla localhostporta 9092.

Quindi, nel codice, stabilire una connessione DB sul seguente URL JDBC:

jdbc:h2:tcp://localhost:9092/mem:test;DB_CLOSE_DELAY=-1;MODE=MySQL

Durante il debug, come client per ispezionare il DB utilizzo quello fornito da H2, che è abbastanza buono, per avviarlo è sufficiente avviare separatamente il seguente java main

org.h2.tools.Console

Questo avvierà un server web con un'app su 8082, avvierà un browser su localhost:8082

Quindi puoi inserire l'URL precedente per vedere il DB

— dsantaolalla
fonte
4

Con HSQLDB, hai diverse opzioni integrate.

Ci sono due gestori di database GUI e un'interfaccia a riga di comando per il database. Le classi per questi sono:

org.hsqldb.util.DatabaseManager
org.hsqldb.util.DatabaseManagerSwing
org.hsqldb.cmdline.SqlTool

È possibile avviare uno dei precedenti dalla propria applicazione e accedere ai database in memoria.

Di seguito viene fornito un esempio con JBoss:

http://docs.jboss.org/jbpm/v3.2/userguide/html/ch07s03.html

Puoi anche avviare un server con la tua applicazione, puntandolo a un database in memoria.

org.hsqldb.Server
— fredt
fonte
Secondo i documenti, puoi usare un "manager" con qualsiasi connessione JDBC, quindi questo funzionerebbe anche per H2 :) hsqldb.org/doc/2.0/util-guide/dbm-chapt.html
— rogerdpack
3

Puoi esporlo come una funzionalità JMX, avviabile tramite JConsole:

@ManagedResource
@Named
public class DbManager {

    @ManagedOperation(description = "Start HSQL DatabaseManagerSwing.")
    public void dbManager() {
        String[] args = {"--url", "jdbc:hsqldb:mem:embeddedDataSource", "--noexit"};
        DatabaseManagerSwing.main(args);
    }
}

Contesto XML:

<context:component-scan base-package="your.package.root" scoped-proxy="targetClass"/>
<context:annotation-config />
<context:mbean-server />
<context:mbean-export />
— sibidiba
fonte
3

Questo è un controller Play 2 per inizializzare i server H2 TCP e Web:

package controllers;

import org.h2.tools.Server;
import play.mvc.Controller;
import play.mvc.Result;

import java.sql.SQLException;

/**
 * Play 2 controller to initialize H2 TCP Server and H2 Web Console Server.
 *
 * Once it's initialized, you can connect with a JDBC client with
 * the URL `jdbc:h2:tcp://127.0.1.1:9092/mem:DBNAME`,
 * or can be accessed with the web console at `http://localhost:8082`,
 * and the URL JDBC `jdbc:h2:mem:DBNAME`.
 *
 * @author Mariano Ruiz <mrsarm@gmail.com>
 */
public class H2ServerController extends Controller {

    private static Server h2Server = null;
    private static Server h2WebServer = null;

    public static synchronized Result debugH2() throws SQLException {
        if (h2Server == null) {
            h2Server = Server.createTcpServer("-tcp", "-tcpAllowOthers", "-tcpPort", "9092");
            h2Server.start();
            h2WebServer = Server.createWebServer("-web","-webAllowOthers","-webPort","8082");
            h2WebServer.start();
            return ok("H2 TCP/Web servers initialized");
        } else {
            return ok("H2 TCP/Web servers already initialized");
        }
    }
}
— Mariano Ruiz
fonte
3

Per HSQLDB, quanto segue ha funzionato per me:

DatabaseManager.threadedDBM();

E questo ha fatto apparire la GUI con le mie tabelle ei miei dati una volta che l'ho puntato al database in-mem denominato a destra.

È fondamentalmente l'equivalente di una nuova versione DatabaseManager(la varietà non Swing), che richiede i dettagli della connessione ed è impostata su --noexit)

Ho anche provato la versione Swing, ma aveva solo un main, e non ero sicuro degli argomenti da passare. Se qualcuno lo sa, per favore pubblica qui.

Solo perché ho cercato per ore il nome del database corretto: il nome del database è il nome dell'origine dati. Quindi prova con l'URL jdbc: hsqldb: mem: dataSource se hai un bean di origine dati con id = dataSource. Se questo non funziona, prova testdb che è l'impostazione predefinita.

— knownasilya
fonte
3
org.hsqldb.util.DatabaseManagerSwing.main (new String [] {"--url", URL, "--user", USERNAME, "--password", PASSWORD});
— Petro Semeniuk,
Ecco una spiegazione dei parametri: stackoverflow.com/a/3076005/32453
— rogerdpack
1

Questo è più un commento al precedente post di Thomas Mueller piuttosto che una risposta, ma non ho abbastanza reputazione per questo. Un altro modo per ottenere la connessione se sei Spring JDBC Template è usare quanto segue:

jdbcTemplate.getDataSource().getConnection();

Quindi in modalità debug se aggiungi alla vista "Espressioni" in Eclipse si aprirà il browser mostrandoti la Console H2:

org.h2.tools.Server.startWebServer(jdbcTemplate.getDataSource().getConnection());

Visualizzazione delle espressioni di Eclipse

Console H2

— Jacqueline Rodriguez
fonte
0

Non so perché funziona bene sulle tue macchine, ma ho dovuto passare una giornata per farlo funzionare.

Il server funziona con Intellij Idea U tramite l'URL "jdbc: h2: tcp: // localhost: 9092 / ~ / default".

"localhost: 8082" nel browser funziona anche bene.

L'ho aggiunto in mvc-dispatcher-servlet.xml

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close" depends-on="h2Server">
    <property name="driverClassName" value="org.h2.Driver"/>
    <property name="url" value="jdbc:h2:tcp://localhost:9092/~/default"/>
    <property name="username" value="sa"/>
    <property name="password" value=""/>
</bean>

<bean id="h2Server" class="org.h2.tools.Server" factory-method="createTcpServer" init-method="start" destroy-method="stop" depends-on="h2WebServer">
    <constructor-arg>
        <array>
            <value>-tcp</value>
            <value>-tcpAllowOthers</value>
            <value>-tcpPort</value>
            <value>9092</value>
        </array>
    </constructor-arg>
</bean>

<bean id="h2WebServer" class="org.h2.tools.Server" factory-method="createWebServer" init-method="start" destroy-method="stop">
    <constructor-arg>
        <array>
            <value>-web</value>
            <value>-webAllowOthers</value>
            <value>-webPort</value>
            <value>8082</value>
        </array>
    </constructor-arg>
</bean>
— Eugene Kortov
fonte
0

Che ne dici di visualizzare comodamente (e anche modificare) il contenuto su ODBC e MS-Access, Excel? Versioni software:

  • Versione H2: 1.4.196
  • Win 10 Postgres ODBC Driver Version: psqlodbc_09_03_0210
  • Per il client ODBC Win7: win7_psqlodbc_09_00_0101-x64.msi

H2 Server:

/*
For JDBC Clients to connect:
jdbc:h2:tcp://localhost:9092/trader;CIPHER=AES;IFEXISTS=TRUE;MVCC=true;LOCK_TIMEOUT=60000;CACHE_SIZE=131072;CACHE_TYPE=TQ
*/
public class DBStarter {
    public static final String BASEDIR = "/C:/Trader/db/";
    public static final String DB_URL = BASEDIR + "trader;CIPHER=AES;IFEXISTS=TRUE;MVCC=true;LOCK_TIMEOUT=10000;CACHE_SIZE=131072;CACHE_TYPE=TQ";

  static void startServer() throws SQLException {
        Server tcpServer = Server.createTcpServer(
                "-tcpPort", "9092",
                "-tcpAllowOthers",
                "-ifExists",
//                "-trace",
                "-baseDir", BASEDIR
        );
        tcpServer.start();
        System.out.println("H2 JDBC Server started:  " + tcpServer.getStatus());

        Server pgServer = Server.createPgServer(
                "-pgPort", "10022",
                "-pgAllowOthers",
                "-key", "traderdb", DB_URL
        );
        pgServer.start();
        System.out.println("H2 ODBC PGServer started: " + pgServer.getStatus());

    }
}

Configurazione dell'origine dati ODBC di Windows10 che può essere utilizzata da qualsiasi client ODBC: Nel campo Databse deve essere utilizzato il nome fornito nel parametro "-key". Configurazione ODBC

— YDZOGODOQ
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.