Eu tenho um banco de dados H2 com URL "jdbc:h2:test". Eu crio uma tabela usando CREATE TABLE PERSON (ID INT PRIMARY KEY, FIRSTNAME VARCHAR(64), LASTNAME VARCHAR(64));. Em seguida, seleciono tudo dessa tabela (vazia) usando SELECT * FROM PERSON. Por enquanto, tudo bem.

No entanto, se eu alterar o URL para "jdbc:h2:mem:test", a única diferença é que o banco de dados agora está apenas na memória, isso me dá uma org.h2.jdbc.JdbcSQLException: Table "PERSON" not found; SQL statement: SELECT * FROM PERSON [42102-154]. Provavelmente estou perdendo algo simples aqui, mas qualquer ajuda seria apreciada.

DB_CLOSE_DELAY=-1

O hbm2ddl fecha a conexão depois de criar a tabela; portanto, a h2 a descarta.

Se você tiver seu URL de conexão configurado assim

jdbc:h2:mem:test

o conteúdo do banco de dados é perdido no momento em que a última conexão é fechada.

Se você deseja manter seu conteúdo, precisa configurar o URL como este

jdbc:h2:mem:test;DB_CLOSE_DELAY=-1

Se fizer isso, a h2 manterá seu conteúdo enquanto a vm permanecer.

Observe o ponto-e-vírgula ( ;) em vez de dois-pontos ( :).

Consulte a seção Bancos de dados na memória da página Recursos . Citar:

Por padrão, fechar a última conexão com um banco de dados fecha o banco de dados. Para um banco de dados na memória, isso significa que o conteúdo é perdido. Para manter o banco de dados aberto, adicione ;DB_CLOSE_DELAY=-1ao URL do banco de dados. Para manter o conteúdo de um banco de dados na memória enquanto a máquina virtual estiver ativa, use jdbc:h2:mem:test;DB_CLOSE_DELAY=-1.

Eu sei que esse não foi o seu caso, mas tive o mesmo problema, porque o H2 estava criando as tabelas com nomes MAIÚSCULAS e, então, fazia distinção entre maiúsculas e minúsculas, mesmo que em todos os scripts (inclusive nos de criação) eu usasse letras minúsculas.

Resolvido adicionando ;DATABASE_TO_UPPER=falseao URL de conexão.

Difícil de dizer. Eu criei um programa para testar isso:

package com.gigaspaces.compass;

import org.testng.annotations.Test;

import java.sql.*;

public class H2Test {
@Test
public void testDatabaseNoMem() throws SQLException {
    testDatabase("jdbc:h2:test");
}
@Test
public void testDatabaseMem() throws SQLException {
    testDatabase("jdbc:h2:mem:test");
}

private void testDatabase(String url) throws SQLException {
    Connection connection= DriverManager.getConnection(url);
    Statement s=connection.createStatement();
    try {
    s.execute("DROP TABLE PERSON");
    } catch(SQLException sqle) {
        System.out.println("Table not found, not dropping");
    }
    s.execute("CREATE TABLE PERSON (ID INT PRIMARY KEY, FIRSTNAME VARCHAR(64), LASTNAME VARCHAR(64))");
    PreparedStatement ps=connection.prepareStatement("select * from PERSON");
    ResultSet r=ps.executeQuery();
    if(r.next()) {
        System.out.println("data?");
    }
    r.close();
    ps.close();
    s.close();
    connection.close();
}
}

O teste foi concluído, sem falhas e sem saída inesperada. Qual versão do h2 você está executando?

O banco de dados na memória H2 armazena dados na memória dentro da JVM. Quando a JVM sai, esses dados são perdidos.

Eu suspeito que o que você está fazendo é semelhante às duas classes Java abaixo. Uma dessas classes cria uma tabela e a outra tenta inserir nela:

import java.sql.*;

public class CreateTable {
    public static void main(String[] args) throws Exception {
        DriverManager.registerDriver(new org.h2.Driver());
        Connection c = DriverManager.getConnection("jdbc:h2:mem:test");
        PreparedStatement stmt = c.prepareStatement("CREATE TABLE PERSON (ID INT PRIMARY KEY, FIRSTNAME VARCHAR(64), LASTNAME VARCHAR(64))");
        stmt.execute();
        stmt.close();
        c.close();
    }
}

e

import java.sql.*;

public class InsertIntoTable {
    public static void main(String[] args) throws Exception {
        DriverManager.registerDriver(new org.h2.Driver());
        Connection c = DriverManager.getConnection("jdbc:h2:mem:test");
        PreparedStatement stmt = c.prepareStatement("INSERT INTO PERSON (ID, FIRSTNAME, LASTNAME) VALUES (1, 'John', 'Doe')");
        stmt.execute();
        stmt.close();
        c.close();
    }
}

Quando executei essas classes uma após a outra, obtive a seguinte saída:

C: \ Usuários \ Lucas \ coisas> Java CreateTable

C: \ Users \ Luke \ stuff> java InsertIntoTable
Exceção no encadeamento "main" org.h2.jdbc.JdbcSQLException: Tabela "PERSON" não encontrada; Instrução SQL:
INSERIR NA PESSOA (ID, PRIMEIRO NOME, SOBRENOME) VALORES (1, 'João', 'Corça') [42102-154]
        em org.h2.message.DbException.getJdbcSQLException (DbException.java:327)
        em org.h2.message.DbException.get (DbException.java:167)
        em org.h2.message.DbException.get (DbException.java:144)
        ...

Assim que o primeiro javaprocesso termina, a tabela criada por CreateTablenão existe mais. Portanto, quando a classe InsertIntoTable aparecer, não haverá tabela para inserir.

Quando alterei as cadeias de conexão para jdbc:h2:test, descobri que não havia esse erro. Também descobri que um arquivo test.h2.dbhavia aparecido. Foi aqui que H2 colocou a tabela e, como ela foi armazenada em disco, a tabela ainda estava lá para a classe InsertIntoTable encontrar.

Eu tentei adicionar

jdbc:h2:mem:test;DB_CLOSE_DELAY=-1

No entanto, isso não ajudou. No site H2 , descobri o seguinte, o que de fato poderia ajudar em alguns casos.

Por padrão, fechar a última conexão com um banco de dados fecha o banco de dados. Para um banco de dados na memória, isso significa que o conteúdo é perdido. Para manter o banco de dados aberto, adicione; DB_CLOSE_DELAY = -1 ao URL do banco de dados. Para manter o conteúdo de um banco de dados na memória enquanto a máquina virtual estiver ativa, use jdbc: h2: mem: test; DB_CLOSE_DELAY = -1.

No entanto , meu problema era que apenas o esquema deveria ser diferente do padrão. Tão instado de usar

JDBC URL: jdbc:h2:mem:test

Eu tive que usar:

JDBC URL: jdbc:h2:mem:testdb

Então as mesas estavam visíveis

Eu tive o mesmo problema e alterei minha configuração em application-test.properties para isso:

#Test Properties
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.url=jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.hibernate.ddl-auto=create-drop

E minhas dependências:

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>

    <!-- https://mvnrepository.com/artifact/com.h2database/h2 -->
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <version>1.4.198</version>
        <scope>test</scope>
    </dependency>

E as anotações usadas na classe de teste:

@RunWith(SpringRunner.class)
@DataJpaTest
@ActiveProfiles("test")
public class CommentServicesIntegrationTests {
...
}

Eu estava tentando buscar metadados da tabela, mas tive o seguinte erro:

Usando:

String JDBC_URL = "jdbc:h2:mem:test;DB_CLOSE_DELAY=-1";

DatabaseMetaData metaData = connection.getMetaData();
...
metaData.getColumns(...);

retornou um ResultSet vazio.

Mas, usando o seguinte URL, ele funcionou corretamente:

String JDBC_URL = "jdbc:h2:mem:test;DB_CLOSE_DELAY=-1;DATABASE_TO_UPPER=false";

Havia uma necessidade de especificar: DATABASE_TO_UPPER = false

Ao abrir o console h2, a URL JDBC deve corresponder à especificada nas propriedades:

spring.datasource.driverClassName=org.h2.Driver
spring.datasource.url=jdbc:h2:mem:testdb

spring.jpa.hibernate.ddl-auto=create
spring.jpa.show-sql=true

spring.h2.console.enabled=true

O que parece óbvio, mas passei horas descobrindo isso.

Resolvido criando uma nova pasta src / test / resources + insira o arquivo application.properties, especificando explicitamente para criar um dbase de teste:

spring.jpa.generate-ddl=true
spring.jpa.hibernate.ddl-auto=create

Eu vim para este post porque tinha o mesmo erro.

No meu caso, as evoluções do banco de dados não foram executadas; portanto, a tabela não estava lá.

Meu problema era que a estrutura de pastas dos scripts de evolução estava errada.

from: https://www.playframework.com/documentation/2.0/Evolutions

O Play acompanha as evoluções do banco de dados usando vários scripts de evolução. Esses scripts são escritos em SQL antigo simples e devem estar localizados no diretório conf / evolutions / {database name} do seu aplicativo. Se as evoluções se aplicarem ao seu banco de dados padrão, esse caminho será conf / evolutions / default.

Eu tinha uma pasta chamada conf / evolutions.default criada pelo eclipse. O problema desapareceu depois que eu corrigi a estrutura da pasta para conf / evolutions / default

<bean id="benchmarkDataSource"
    class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="org.h2.Driver" />
    <property name="url" value="jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1" />
    <property name="username" value="sa" />
    <property name="password" value="" />
</bean>

Teve exatamente o mesmo problema, tentei todas as opções acima, mas sem sucesso. A causa mais engraçada do erro foi que a JVM foi iniciada muito rapidamente, antes da criação da tabela DB (usando um arquivo data.sql em src.main.resources). Então, eu coloquei um timer Thread.sleep (1000) para aguardar apenas um segundo antes de chamar "select * from person". Trabalhando perfeitamente agora.

application.properties:

spring.h2.console.enabled=true
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=

data.sql:

create table person
(
id integer not null,
name varchar(255) not null,
location varchar(255),
birth_date timestamp,
primary key(id)
);

insert into person values (
10001, 'Tofu', 'home', sysdate()
);

PersonJdbcDAO.java:

    public List<Person> findAllPersons(){
    return jdbcTemplate.query("select * from person", 
        new BeanPropertyRowMapper<Person>(Person.class));
}

classe principal:

Thread.sleep(1000);
logger.info("All users -> {}", dao.findAllPersons());

Eu o encontrei funcionando depois de adicionar a dependência do Spring Data JPA na versão de inicialização 2.2.2 do Spring.

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>

Adicione a configuração do H2 DB no application.yml -

spring:
  datasource:
    driverClassName: org.h2.Driver
    initialization-mode: always
    username: sa
    password: ''
    url: jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE
  h2:
    console:
      enabled: true
      path: /h2
  jpa:
    database-platform: org.hibernate.dialect.H2Dialect
    hibernate:
      ddl-auto: none

Encontrei a solução adicionando esta configuração:

spring.jpa.database-platform=org.hibernate.dialect.H2Dialect

A configuração completa (com simple spring.datasource.url):

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=sa
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.jpa.hibernate.ddl-auto=create-drop

Estou trabalhando com a versão h2 1.4.200 e o Spring-Boot 2.2.6.

Time.sleep (1000);

Isso é trabalho para mim. Apenas para tentar, se o seu PC estiver lento, você poderá aumentar o tempo de duração do encadeamento para que o DB funcione bem e a JVM possa obter nossa tabela.