Wyświetl zawartość bazy danych w pamięci H2 lub HSQLDB

Czy istnieje sposób przeglądania zawartości bazy danych w pamięci H2 lub HSQLDB do przeglądania? Na przykład, podczas sesji debugowania z Hibernate, w celu sprawdzenia, kiedy czyszczenie jest wykonywane; lub aby upewnić się, że skrypt, który tworzy instancję bazy danych, daje oczekiwany wynik.

Czy istnieje dodatek lub biblioteka, które możesz osadzić w swoim kodzie, aby to umożliwić?

Proszę wspomnieć, o którym mówisz (H2 lub HSQLDB) na wypadek, gdybyś miał odpowiedź dotyczącą jednego z nich.

Możesz uruchomić serwer WWW H2 w swojej aplikacji, który będzie miał dostęp do tej samej bazy danych w pamięci. Możesz również uzyskać dostęp do H2 działającego w trybie serwera za pomocą dowolnego ogólnego klienta JDBC, takiego jak SquirrelSQL .

AKTUALIZACJA:

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

Teraz możesz połączyć się z bazą danych za pomocą jdbc:h2:mem:foo_dbadresu URL w ramach tego samego procesu lub przeglądać foo_dbbazę danych za pomocą localhost:8082. Pamiętaj, aby zamknąć oba serwery. Zobacz też: Baza danych H2 w trybie pamięci nie jest dostępna z konsoli .

Możesz także użyć 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>

BTW, powinieneś polegać tylko na asercjach, a nie na ręcznym przeglądaniu zawartości bazy danych. Używaj tego tylko do rozwiązywania problemów.

Uwaga: jeśli korzystasz z Spring Test Framework, nie zobaczysz zmian wprowadzonych przez uruchomioną transakcję i ta transakcja zostanie wycofana natychmiast po teście.

W przypadku H2 możesz uruchomić serwer WWW w swoim kodzie podczas sesji debugowania, jeśli masz obiekt połączenia z bazą danych. Możesz dodać tę linię do swojego kodu lub jako „wyrażenie obserwujące” (dynamicznie):

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

Narzędzie serwerowe uruchomi lokalnie przeglądarkę internetową, która umożliwia dostęp do bazy danych.

W H2 działa u mnie:

Koduję, uruchamiając serwer jak:

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

To uruchamia serwer na localhostporcie 9092.

Następnie w kodzie nawiąż połączenie z bazą danych pod następującym adresem URL JDBC:

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

Podczas debugowania jako klient do wglądu w bazę danych używam tej dostarczonej przez H2, która jest wystarczająco dobra, aby ją uruchomić, wystarczy osobno uruchomić następującą główną java

org.h2.tools.Console

Spowoduje to uruchomienie serwera WWW z aplikacją na 8082, uruchomienie przeglądarki na localhost:8082

Następnie możesz wprowadzić poprzedni adres URL, aby zobaczyć DB

Dzięki HSQLDB masz kilka wbudowanych opcji.

Istnieją dwa menedżery baz danych GUI i interfejs wiersza poleceń do bazy danych. Zajęcia dla nich to:

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

Możesz uruchomić jedną z powyższych z aplikacji i uzyskać dostęp do baz danych w pamięci.

Przykład z JBoss jest podany tutaj:

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

Możesz także uruchomić serwer ze swoją aplikacją, kierując ją do bazy danych w pamięci.

org.hsqldb.Server

Możesz udostępnić go jako funkcję JMX, uruchamianą przez 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);
    }
}

Kontekst XML:

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

Oto kontroler Play 2 do inicjalizacji H2 TCP i serwerów WWW:

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 <[email protected]>
 */
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");
        }
    }
}

W przypadku HSQLDB działało dla mnie:

DatabaseManager.threadedDBM();

To spowodowało wyświetlenie GUI z moimi tabelami i danymi, gdy wskazałem je na bazę danych o odpowiedniej nazwie.

Jest to w zasadzie odpowiednik nowego tworzenia a DatabaseManager(odmiana bez Swing), która monituje o szczegóły połączenia i jest ustawiona na --noexit)

Wypróbowałem także wersję Swing, ale miała tylko a main, i nie byłem pewien argumentów do przekazania. Jeśli ktoś wie, napisz tutaj.

Tylko dlatego, że godzinami szukałem właściwej nazwy bazy danych: Nazwa bazy danych to nazwa twojego źródła danych. Spróbuj więc użyć adresu URL jdbc: hsqldb: mem: dataSource, jeśli masz fasolę źródła danych z id = dataSource. Jeśli to nie zadziała, wypróbuj testdb, który jest domyślny.

Mam problem ze zdalnym połączeniem H2 w wersji 1.4.190 z inMemory (a także w pliku) z Connection is broken: "unexpected status 16843008"do momentu, gdy nie staram się downgrade do 1.3.176. Zobacz Grails uzyskując dostęp do serwera H2 TCP zawiesza się

Jest to bardziej komentarz do poprzedniego posta Thomasa Muellera niż odpowiedź, ale nie ma na to wystarczającej reputacji. Innym sposobem uzyskania połączenia, jeśli używasz szablonu Spring JDBC, jest użycie:

jdbcTemplate.getDataSource().getConnection();

Tak więc w trybie debugowania, jeśli dodasz do widoku „Wyrażenia” w Eclipse, otworzy się przeglądarka pokazująca konsolę H2:

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

Widok wyrażeń Eclipse

Konsola H2

Nie wiem, dlaczego działa dobrze na twoich maszynach, ale musiałem poświęcić dzień, aby to działało.

Serwer współpracuje z Intellij Idea U za pośrednictwem adresu url „jdbc: h2: tcp: // localhost: 9092 / ~ / default”.

„localhost: 8082” w przeglądarce działa również dobrze.

Dodałem to do pliku 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>

A co z wygodnym przeglądaniem (a także edytowaniem) treści przez ODBC i MS-Access, Excel? Wersje oprogramowania:

• Wersja H2: 1.4.196
• Wersja sterownika ODBC dla systemu Windows 10 Postgres: psqlodbc_09_03_0210
• Klient Win7 ODBC: win7_psqlodbc_09_00_0101-x64.msi

Serwer H2:

/*
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());

    }
}   

Konfiguracja źródła danych ODBC w Windows10, z której może korzystać każdy klient ODBC: W polu Databse należy użyć nazwy podanej w parametrze „-key”.