25/10/13 Tutorial
www.h2database.com/html/tutorial.html#fulltext 1/18
Traduzir
Pesquisar:
Início
de Download
Cheat Sheet
Documentação
Quickstart
Instalação
Tutorial
Características
Desempenho
Avançado
Referência
SQL Gramática
Funções
Tipos de dados
Javadoc
PDF (1 MB)
Suporte
FAQ
Erro Analyzer
Google Group (em Inglês)
Google Group (japonês)
Google Group (chinês)
Apêndice
História e Roteiro
Licença
Envergadura
links
JaQu
MVStore
Tutorial
Iniciar e utilizar o H2 Console
especiais H2 Console Sintaxe
Configurações do Console H2
Conectando-se a um banco de dados usando JDBC
Criando novos bancos de dados
usando o Servidor
Usando Hibernate
Usando TopLink e Glassfish
Usando EclipseLink
Usando Apache ActiveMQ
Usando H2 no NetBeans
Usando H2 com jOOQ
Usando bancos de dados na Web Aplicações
Android
CSV (Comma Separated Values) Suporte
para atualização, backup e restauração de
ferramentas de linha de comando
A ferramenta Shell
Usando OpenOffice Base de
Java Web Start / JNLP
Usando um pool de conexão
de texto completo Pesquisa
Variáveis definidas pelo usuário
data e hora
usando Spring
OSGi
Java Gestão Extension (JMX )
Iniciar e utilizar o H2 Console
A aplicação H2 Console permite que você acesse um banco de dados usando um navegador. Isso
pode ser um banco de dados H2, ou outro banco de dados que suporta a API JDBC.
Esta é uma aplicação cliente / servidor, portanto, um servidor e um cliente (um navegador) são
necessários para executá-lo.
Dependendo da sua plataforma e ambiente, existem várias maneiras de iniciar o H2 Console:
OS Começar
Windows Clique no botão [Iniciar], [Todos os programas], [H2] e [H2 Console (Command Line)]
Um ícone será adicionado à bandeja do sistema: Se você não obter a janela eo ícone da
bandeja do sistema, então talvez Java não está instalado corretamente (neste caso, tente
outra maneira de iniciar o aplicativo). Uma janela do navegador deve abrir e apontar para a
página de login na
http://localhost:8082 .
Windows Abra um navegador de arquivos, navegue até h2/bin E clique duas vezes em h2.bat .
Aparece uma janela de console. Se houver um problema, você vai ver uma mensagem de
erro nesta janela. Uma janela do navegador será aberta e apontar para a página de login
(URL: http://localhost:8082 ).
Qualquer Dê um duplo clique sobre o h2*.jar arquivo. Isso só funciona se o .jar sufixo está
associada com Java.
▲
25/10/13 Tutorial
www.h2database.com/html/tutorial.html#fulltext 2/18
associada com Java.
Qualquer Abra uma janela do console, navegue até o diretório h2/bin E digite:
java -jar h2*.jar
Firewall
Se você iniciar o servidor, você pode receber um aviso de segurança do firewall (se tiver instalado um).
Se você não quer que outros computadores na rede para acessar o aplicativo em sua máquina, você
pode deixar o firewall bloquear essas ligações. A conexão da máquina local ainda funcionará. Só se
você quiser outros computadores para acessar o banco de dados no computador, você precisa permitir
conexões remotas no firewall.
Tem sido relatado que, ao usar o Kaspersky 7.0 com firewall, o Console de H2 é muito lento ao ligar
sobre o endereço IP. A solução é conectar usando 'localhost'.
Um pequeno firewall já está embutido no servidor: outros computadores podem se conectar ao servidor
por padrão. Para mudar isso, vá em "Preferências" e selecione "Permitir conexões de outros
computadores".
Teste Java
Para descobrir qual versão do Java está instalado, abra um prompt de comando e digite:
java -version
Se você receber uma mensagem de erro, você pode precisar adicionar o diretório binário Java para a
variável de ambiente do caminho.
Mensagem de erro 'Porta pode estar em uso "
Você só pode iniciar uma instância do H2 Console, caso contrário você vai receber a seguinte
mensagem de erro: "O servidor Web não pôde ser iniciado Possível causa:. Outro servidor já está em
execução ...". É possível iniciar vários aplicativos de console no mesmo computador (usando portas
diferentes), mas isso geralmente não é necessário que o console suporta múltiplas conexões
simultâneas.
Usando outro Porto
Se a porta padrão do Console H2 já está em uso por outro aplicativo, em seguida, uma porta diferente
precisa ser configurado. As configurações são armazenadas em um arquivo de propriedades. Para
mais detalhes, consulte Configurações do Console H2 . A entrada é relevante webPort .
Se nenhuma porta for especificada para os servidores PG TCP e, cada serviço vai tentar ouvir em sua
porta padrão. Se a porta padrão já está em uso, uma porta aleatória é usado.
Conectando-se ao servidor usando um navegador
Se o servidor foi iniciado com sucesso, você pode conectá-lo usando um navegador web. Javascript
precisa estar habilitado. Se você iniciou o servidor no mesmo computador como o navegador, abra a
URL http://localhost:8082 . Se você deseja conectar-se a aplicação de outro computador, você
precisará fornecer o endereço IP do servidor, por exemplo: http://192.168.0.2:8082 . Se você ativou o
SSL no lado do servidor, a URL deve começar com https:// .
Múltiplas sessões concorrentes
Várias sessões do navegador simultâneos são suportados. Enquanto que os objetos de banco de
dados residem no servidor, a quantidade de trabalho concomitante é limitada pela memória disponível
para o aplicativo de servidor.
Login
Na página de login, você precisa fornecer informações de conexão para se conectar a um banco de
dados. Defina a classe do driver JDBC do seu banco de dados, JDBC URL, nome de usuário e senha.
Se você estiver pronto, clique em [Connect].
Você pode salvar e reutilizar as configurações salvas anteriormente. As configurações são
armazenadas em um arquivo de propriedades (veja Configurações do Console H2 ).
Mensagens de erro
25/10/13 Tutorial
www.h2database.com/html/tutorial.html#fulltext 3/18
Mensagens de erro
Mensagens de erro no são mostrados em vermelho. Você pode exibir / ocultar o rastreamento de pilha
de exceção, clicando na mensagem.
Adicionando drivers de banco de dados
Para registrar drivers JDBC adicionais (MySQL, PostgreSQL, HSQLDB, ...), adicione os nomes de
arquivo jar para as variáveis de ambiente H2DRIVERS ou CLASSPATH . Exemplo (Windows): para
adicionar o driver JDBC HSQLDB C:\Programs\hsqldb\lib\hsqldb.jar , Defina a variável de ambiente
H2DRIVERS a C:\Programs\hsqldb\lib\hsqldb.jar .
Vários drivers pode ser definido; entradas precisam ser separados por ; (Windows) ou : (Outros
sistemas operacionais). Espaços nos nomes de caminho são suportados. As configurações não deve
ser citado.
Utilizando a consola de H2
A aplicação H2 Console tem três painéis principais: a barra de ferramentas no topo, a árvore à
esquerda, eo painel de consulta / resultado à direita. Os objetos de banco de dados (por exemplo,
tabelas) estão listados na esquerda. Digite um comando SQL no painel de consulta e clique em [Run].
O resultado aparece logo abaixo do comando.
Inserindo nomes de tabela e os nomes das colunas
Para inserir nomes de tabelas e colunas para o script, clique no item na árvore. Se você clicar em uma
mesa, enquanto a consulta está vazia, então SELECT * FROM ... é adicionado. Ao digitar uma
consulta, a tabela que foi usada é expandido na árvore. Por exemplo, se você digitar SELECT * FROM
TEST T WHERE T. então o teste de mesa é expandido.
Desligar e parar a aplicação
Para sair do banco de dados, clique em [Desligar] no painel de barra de ferramentas. No entanto, o
servidor ainda está em execução e pronto para aceitar novas sessões.
Para parar o servidor, clique direito sobre o ícone da bandeja do sistema e selecione [Sair]. Se você
não tem o ícone na bandeja do sistema, navegue até [Preferências] e clique em [Shutdown], pressione
[Ctrl] + [C] no console onde o servidor foi iniciado (Windows), ou fechar a janela do console.
Sintaxe especial H2 Console
O Console H2 suporta alguns comandos embutidos. Aqueles que são interpretadas dentro do H2
Console, então eles trabalham com qualquer banco de dados. Comandos built-in precisa estar no
início de uma declaração (antes de quaisquer observações), caso contrário eles não são analisados
corretamente. Em caso de dúvida, adicione ; antes do comando.
Command (s) Descrição
@autocommit_true;
@autocommit_false;
Ativar ou desativar autocommit.
@cancel; Cancelar a instrução atualmente em execução.
@columns null null TEST;
@index_info null null TEST;
@tables;
@tables null null TEST;
Chame o correspondente DatabaseMetaData.get método.
Padrões são sensíveis caso (geralmente identificadores são
maiúsculas). Para obter informações sobre os parâmetros,
consulte a documentação do Javadoc. Parâmetros em falta no
fim da linha são definidas como null. A lista completa dos
comandos de metadados é: @attributes,
@best_row_identifier, @catalogs, @columns,
@column_privileges, @cross_references, @exported_keys,
@imported_keys, @index_info, @primary_keys,
@procedures, @procedure_columns, @schemas,
@super_tables, @super_types, @tables, @table_privileges,
@table_types, @type_info, @udts, @version_columns
@edit select * from test; Use um conjunto de resultados atualizável.
@generated insert into test() values(); Mostrar o resultado de Statement.getGeneratedKeys() .
@history; Listar o histórico de comandos.
@info; Exibir o resultado de vários Connection e
DatabaseMetaData métodos.
25/10/13 Tutorial
www.h2database.com/html/tutorial.html#fulltext 4/18
@list select * from test; Mostrar o conjunto de resultados em formato de lista (cada
coluna em sua própria linha, com números de linha).
@loop 1000 select ?, ?/*rnd*/;
@loop 1000 @statement select ?;
Execute a instrução isso muitas vezes. Parâmetros ( ? ) São
definidas usando um loop de 0 até x - 1. Os valores aleatórios
são utilizados para cada ?/*rnd*/ . Um objeto Statement é
utilizado em vez de um PreparedStatement se @statement é
usado. Os conjuntos de resultados são lidos
até ResultSet.next() retornos false . Informação de tempo é
impresso.
@maxrows 20; Defina o número máximo de linhas para mostrar.
@memory; Mostra a memória utilizada e livre. Isso vai
chamar System.gc() .
@meta select 1; Liste o ResultSetMetaData após a execução da consulta.
@parameter_meta select ?; Ver o resultado da
PreparedStatement.getParameterMetaData() chamadas. A
declaração não é executado.
@prof_start;
call hash('SHA256', '', 1000000);
@prof_stop;
Iniciar / parar a ferramenta de profiling built-in. O top 3
rastreamentos de pilha da declaração (s) entre o início e
parada são listados (se houver 3).
@prof_start;
@sleep 10;
@prof_stop;
Latência para um número de segundos. Usado para o perfil de
uma consulta de longa duração ou a operação que está sendo
executado em outra sessão (mas no mesmo processo).
@transaction_isolation;
@transaction_isolation 2;
Mostrar (sem parâmetros) ou mudança (com parâmetros 1, 2,
4, 8), o nível de isolamento da transação.
Configurações do H2 Console
As configurações do Console H2 são armazenados em um arquivo de configuração chamado
.h2.server.properties em você diretório home do usuário. Para instalações do Windows, o diretório
home do usuário geralmente é C:\Documents and Settings\[username] ou C:\Users\[username] . O
arquivo de configuração contém as configurações do aplicativo e é criado automaticamente quando o
Console H2 é iniciado pela primeira vez. As definições suportadas são:
webAllowOthers : Permitir que outros computadores se conectem.
webPort : A porta do H2 Console
webSSL : Usar conexões criptografadas (HTTPS).
Além dessas configurações, as propriedades de a última ligação recentemente utilizadas são listadas
na forma <number>=<name>|<driver>|<url>|<user> usando o caractere de escape \ .
Exemplo: 1=Generic H2 (Embedded)|org.h2.Driver|jdbc\:h2\:~/test|sa
Conectando-se a um banco de dados usando JDBC
Para se conectar a um banco de dados, uma aplicação Java precisa primeiro carregar o driver de
banco de dados e, em seguida, obter uma conexão. Uma maneira simples de fazer isso é usando o
seguinte código:
import java.sql.*;
public class Test {
public static void main(String[] a)
throws Exception {
Class.forName("org.h2.Driver");
Connection conn = DriverManager.
getConnection("jdbc:h2:~/test", "sa", "");
// add application code here
conn.close();
}
}
Esse código primeiro carrega o driver ( Class.forName(...) ) E, em seguida, abre uma conexão (usando
DriverManager.getConnection() ). O nome do driver é "org.h2.Driver" . A URL do banco de dados
sempre precisa começar com jdbc:h2: para ser reconhecido por esta base de dados. O segundo
parâmetro na getConnection() chamada é o nome de usuário ( sa para o administrador do sistema,
25/10/13 Tutorial
www.h2database.com/html/tutorial.html#fulltext 5/18
parâmetro na getConnection() chamada é o nome de usuário ( sa para o administrador do sistema,
neste exemplo). O terceiro parâmetro é a senha. Neste banco de dados, nomes de usuário não são
case sensitive, mas as senhas são.
Criando novos bancos de dados
Por padrão, se o banco de dados especificado na URL ainda não existe, um novo banco de dados
(vazio) é criado automaticamente. O usuário que criou o banco de dados automaticamente se torna o
administrador do banco de dados.
Auto-criação de novo banco de dados pode ser desativado, consulte Abrir um banco de dados somente
se ele já existe .
Utilização do servidor
H2 atualmente suporta três servidores: um servidor web (para o H2 Console), um servidor TCP (para
conexões de cliente / servidor) e um servidor de PG (para clientes do PostgreSQL). Por favor, note que
apenas o servidor web suporta conexões navegador. Os servidores pode ser iniciado de maneiras
diferentes, uma está a utilizar o Server ferramenta. Iniciando o servidor não abrir um banco de dados -
bases de dados são abertos assim que um cliente se conecta.
Iniciando a Ferramenta Server a partir da linha de comando
Para iniciar o Server ferramenta de linha de comando com as configurações padrão, execute:
java -cp h2*.jar org.h2.tools.Server
Isso vai iniciar a ferramenta com as opções padrão. Para obter a lista de opções e valores padrão,
execute:
java -cp h2*.jar org.h2.tools.Server -?
Existem opções disponíveis para usar outras portas, e iniciar ou não iniciar partes.
Conectando-se ao servidor TCP
Para se conectar remotamente a um banco de dados usando o servidor TCP, use o seguinte motorista
e banco de dados URL:
Classe do driver JDBC: org.h2.Driver
URL do banco de dados: jdbc:h2:tcp://localhost/~/test
Para obter detalhes sobre a URL do banco de dados, ver também em recursos. Por favor, note que não
é possível conexão com um navegador da web para este URL. Você só pode conectar usando um
cliente H2 (sobre JDBC).
Iniciando o servidor TCP dentro de um aplicativo
Os servidores também pode ser iniciado e interrompido a partir de dentro de um aplicativo. Exemplo de
código:
import org.h2.tools.Server;
...
// start the TCP Server
Server server = Server.createTcpServer(args).start();
...
// stop the TCP Server
server.stop();
Parar um servidor TCP de outro processo
O servidor de TCP pode ser parado a partir de outro processo. Para parar o servidor a partir da linha de
comando, execute:
java org.h2.tools.Server -tcpShutdown tcp://localhost:9092
Para parar o servidor a partir de um aplicativo de usuário, use o seguinte código:
25/10/13 Tutorial
www.h2database.com/html/tutorial.html#fulltext 6/18
org.h2.tools.Server.shutdownTcpServer("tcp://localhost:9094");
Esta função só irá parar o servidor TCP. Se outro servidor foram iniciados no mesmo processo, eles
vão continuar a correr. Para evitar a recuperação, quando os bancos de dados são abertos na próxima
vez, todas as conexões com os bancos de dados devem ser fechados antes de chamar esse método.
Para parar um servidor remoto, conexões remotas deve estar habilitado no servidor. Desligar um
servidor TCP podem ser protegidas usando a opção -tcpPassword (A mesma senha deve ser utilizado
para iniciar e parar o servidor TCP).
Usando Hibernate
Este banco de dados suporta Hibernate versão 3.1 e mais recentes. Você pode usar o dialeto
HSQLDB, ou o dialeto nativo H2. Infelizmente, o dialeto H2 incluído em algumas versões antigas do
Hibernate foi buggy. Um patch para o Hibernate foi enviado e agora é aplicado. Você pode renomeá-lo
para H2Dialect.java e incluir esta como uma mancha em seu aplicativo, ou atualizar para uma versão
do Hibernate que isso seja corrigido.
Ao usar o Hibernate, tente usar o H2Dialect se possível. Quando se utiliza o H2Dialect , Tais como os
modos de compatibilidade MODE=MySQL não são suportados. Quando usar o modo essa
compatibilidade, use o dialeto do Hibernate para o banco de dados correspondente, em vez
do H2Dialect , Mas por favor note H2 não suporta todas as características de todos os bancos de
dados.
Usando TopLink e Glassfish
Para usar o H2 com Glassfish (ou Sun AS), defina a fonte de dados para Classname
org.h2.jdbcx.JdbcDataSource . Você pode definir isso no GUI em Application Server - Recursos -
JDBC - Pools de conexão, ou editando o arquivo sun-resources.xml : Pelo elemento jdbc-connection-
pool , Defina o atributo datasource-classname a org.h2.jdbcx.JdbcDataSource .
O banco de dados H2 é compatível com HSQLDB e PostgreSQL. Para tirar proveito dos recursos
específicos H2, use o H2Platform . O código de fonte de esta plataforma está incluído em H2
a src/tools/oracle/toplink/essentials/platform/database/DatabasePlatform.java.txt . Você terá que copiar
este arquivo para o seu aplicativo, e renomeá-lo para. Java. Para habilitá-lo, altere a seguinte
configuração no persistence.xml:
<property
name="toplink.target-database"
value="oracle.toplink.essentials.platform.database.H2Platform"/>
Em versões antigas do Glassfish, o nome da propriedade é toplink.platform.class.name .
Para usar o H2 no Glassfish, copie o h2 *. Jar para o diretório glassfish/glassfish/lib .
Usando EclipseLink
Para usar o H2 em EclipseLink, use a classe plataforma
org.eclipse.persistence.platform.database.H2Platform . Se essa plataforma não está disponível na sua
versão do EclipseLink, você pode usar o OraclePlatform vez, em muitos casos. Veja também
H2Platform .
Usando Apache ActiveMQ
Ao utilizar H2 como o banco de dados de back-end para Apache ActiveMQ, utilize o
TransactDatabaseLocker em vez do mecanismo de bloqueamento padrão. Caso contrário, o arquivo
de banco de dados irá crescer sem limites. O problema é que o mecanismo de travamento utiliza um
padrão uncommitted UPDATE transação, que mantém o log de transações de encolhimento (faz com
que o arquivo de banco de dados para crescer). Em vez de usar uma UPDATE declaração, o
TransactDatabaseLocker usa SELECT ... FOR UPDATE o que não é problemática. Para usá-lo,
mudar o elemento de configuração ApacheMQ <jdbcPersistenceAdapter> elemento, a propriedade
databaseLocker="org.apache.activemq.store.jdbc.adapter.TransactDatabaseLocker" . No entanto,
usando o modo de MVCC novamente conduzido o mesmo problema. Portanto, por favor não use o
modo MVCC neste caso. Outra solução (mais perigoso) é definir useDatabaseLock para false.
Usando H2 dentro do NetBeans
25/10/13 Tutorial
www.h2database.com/html/tutorial.html#fulltext 7/18
O projeto H2 Suporte de Banco de Dados para o NetBeans permite iniciar e parar o servidor de H2 a
partir do IDE.
Há um problema conhecido pelo uso da janela de execução do Netbeans SQL: antes de executar uma
consulta, outra consulta na forma SELECT COUNT(*) FROM <query> é executado. Isto é um
problema para consultas que modificam o estado, como o SELECT SEQ.NEXTVAL . Neste caso, dois
valores de sequência são atribuídos, em vez de apenas um.
Usando H2 com jOOQ
jOOQ adiciona uma camada fina em cima de JDBC, permitindo a construção de SQL de tipo seguro,
incluindo avançado SQL, procedimentos armazenados e tipos de dados avançados. jOOQ leva o seu
esquema de banco de dados como base para a geração de código. Se este é o seu exemplo de
esquema:
CREATE TABLE USER (ID INT, NAME VARCHAR(50));
em seguida, executar o gerador de código jOOQ na linha de comando usando o seguinte comando:
java -cp jooq.jar;jooq-meta.jar;jooq-codegen.jar;h2-1.3.158.jar;.
org.jooq.util.GenerationTool /codegen.xml
Onde ... codegen.xml está no classpath e contém informações
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<configuration xmlns="http://www.jooq.org/xsd/jooq-codegen-2.3.0.xsd">
<jdbc>
<driver>org.h2.Driver</driver>
<url>jdbc:h2:~/test</url>
<user>sa</user>
<password></password>
</jdbc>
<generator>
<name>org.jooq.util.DefaultGenerator</name>
<database>
<name>org.jooq.util.h2.H2Database</name>
<includes>.*</includes>
<excludes></excludes>
<inputSchema>PUBLIC</inputSchema>
</database>
<generate></generate>
<target>
<packageName>org.jooq.h2.generated</packageName>
<directory>./src</directory>
</target>
</generator>
</configuration>
Usando o código-fonte gerado, você pode consultar o banco de dados da seguinte forma:
Factory create = new H2Factory(connection);
Result<UserRecord> result =
create.selectFrom(USER)
.where(NAME.like("Johnny%"))
.orderBy(ID)
.fetch();
Veja mais detalhes sobre jOOQ Homepage e no Tutorial jOOQ
Usando bancos de dados em aplicações Web
Existem várias maneiras de acessar um banco de dados a partir de aplicativos web. Aqui estão alguns
exemplos, se você usar Tomcat ou JBoss.
Modo embutido
25/10/13 Tutorial
www.h2database.com/html/tutorial.html#fulltext 8/18
Modo embutido
O (atualmente) solução mais simples é usar o banco de dados no modo integrado, o que significa abrir
uma conexão em seu aplicativo quando ele começa (uma boa solução é usar um Listener Servlet, veja
abaixo), ou quando a sessão é iniciada. Um banco de dados pode ser acessado a partir de várias
sessões e aplicativos ao mesmo tempo, contanto que eles correm no mesmo processo. Containers
mais Servlet (por exemplo Tomcat) estão apenas usando um processo, de modo que este não é um
problema (a menos que você executar Tomcat no modo cluster). Tomcat usa vários segmentos e
vários carregadores de classe. Se vários aplicativos acessem o mesmo banco de dados, ao mesmo
tempo, você precisa colocar o jar do banco de dados no shared/lib ou server/lib diretório. É uma boa
idéia para abrir o banco de dados quando a aplicação web começa, e fechá-la quando a aplicação web
pára. Se usar várias aplicações, apenas uma (qualquer) deles precisa fazer isso. No aplicativo, uma
idéia é usar uma conexão por sessão, ou até mesmo uma conexão por pedido (ação). Essas
conexões devem ser fechadas após o uso, se possível (mas não é tão ruim se eles não ficam
fechadas).
Modo de servidor
O modo de servidor é semelhante, mas permite que você execute o servidor em outro processo.
Usando um Servlet Listener para iniciar e parar um banco de dados
Adicione o arquivo. Jar h2 * a sua aplicação web, e adicionar o seguinte trecho de seu arquivo web.xml
(entre a context-param e a filter seção):
<listener>
<listener-class>org.h2.server.web.DbStarter</listener-class>
</listener>
Para mais informações sobre como acessar o banco de dados, consulte o arquivo DbStarter.java . Por
padrão, essa ferramenta abre uma conexão incorporada usando o URL do banco de
dados jdbc:h2:~/test , Nome de usuário sa E senha sa . Se você quiser usar essa conexão dentro do
seu servlet, você pode acessar o seguinte:
Connection conn = getServletContext().getAttribute("connection");
DbStarter Também é possível iniciar o servidor TCP, no entanto, este é desativado por padrão. Para
ativá-lo, use o parâmetro db.tcpServer no arquivo web.xml . Aqui está a lista completa de opções.
Estas opções devem ser colocados entre o description tag eo listener / filter tags:
<context-param>
<param-name>db.url</param-name>
<param-value>jdbc:h2:~/test</param-value>
</context-param>
<context-param>
<param-name>db.user</param-name>
<param-value>sa</param-value>
</context-param>
<context-param>
<param-name>db.password</param-name>
<param-value>sa</param-value>
</context-param>
<context-param>
<param-name>db.tcpServer</param-name>
<param-value>-tcpAllowOthers</param-value>
</context-param>
Quando o aplicativo web é interrompido, a conexão do banco de dados será fechada automaticamente.
Se o servidor TCP é iniciado dentro do DbStarter , Que também irá ser interrompido automaticamente.
Usando o H2 Console Servlet
O H2 Console é um aplicativo independente e inclui seu próprio servidor web, mas pode ser usado
como um servlet bem. Para fazer isso, inclua o do h2*.jar Arquivo em seu aplicativo e adicione a
seguinte configuração para o seu web.xml :
<servlet>
25/10/13 Tutorial
www.h2database.com/html/tutorial.html#fulltext 9/18
<servlet>
<servlet-name>H2Console</servlet-name>
<servlet-class>org.h2.server.web.WebServlet</servlet-class>
<!--
<init-param>
<param-name>webAllowOthers</param-name>
<param-value></param-value>
</init-param>
<init-param>
<param-name>trace</param-name>
<param-value></param-value>
</init-param>
-->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>H2Console</servlet-name>
<url-pattern>/console/*</url-pattern>
</servlet-mapping>
Para mais detalhes, veja também src/tools/WEB-INF/web.xml .
Para criar um aplicativo web com apenas o Console H2, execute o seguinte comando:
build warConsole
Andróide
Você pode usar esse banco de dados em um dispositivo Android (usando o Dalvik VM) em vez de ou
além do SQLite. Até agora, apenas poucos testes e benchmarks foram executados, mas parece que o
desempenho é semelhante ao SQLite, exceto para abertura e fechamento de um banco de dados, que
ainda não é otimizada de H2 (H2 leva cerca de 0,2 segundo, e SQLite cerca de 0,02 segundos) . As
operações de leitura parece ser um pouco mais rápido do que SQLite, e as operações de gravação
parece ser mais lento. Até agora, apenas poucos testes foram executados, e tudo parece funcionar
como esperado. Pesquisa de texto completo ainda não foi testado, no entanto, a pesquisa de texto
completo nativa deve funcionar.
Razões para usar H2 em vez de SQLite são:
Unicode suporte completo, incluindo UPPER () e menor ().
Transmissão API para BLOB e CLOB dados.
Pesquisa de texto completo.
Múltiplas conexões.
Funções e gatilhos definidos pelo usuário.
Criptografia de arquivos de banco de dados.
Leitura e escrita de arquivos CSV (este recurso pode ser usado fora do banco de dados também).
A integridade referencial e restrições de verificação.
Melhor tipo de dados e suporte SQL.
Bases de dados em memória, de dados somente leitura, tabelas vinculadas.
Melhor compatibilidade com outros bancos de dados que simplifica portar aplicativos.
Possivelmente o melhor desempenho (até agora para operações de leitura).
Modo Server (acessando um banco de dados em uma máquina diferente sobre TCP / IP).
Atualmente, apenas a API JDBC é suportado (é planejado para suportar a API de banco de dados
Android em versões futuras). Tanto o arquivo jar H2 regular eo menor h2small-*.jar podem ser usados.
Para criar o arquivo jar menor, execute o comando ./build.sh jarSmall (Linux / Mac OS) ou build.bat
jarSmall (Windows).
Os arquivos de banco de dados precisam ser armazenados em um local que é acessível para a
aplicação. Exemplo:
String url = "jdbc:h2:/data/data/" +
"com.example.hello" +
"/data/hello" +
";FILE_LOCK=FS" +
";PAGE_SIZE=1024" +
25/10/13 Tutorial
www.h2database.com/html/tutorial.html#fulltext 10/18
";PAGE_SIZE=1024" +
";CACHE_SIZE=8192";
Class.forName("org.h2.Driver");
conn = DriverManager.getConnection(url);
...
Limitações: Usando um pool de conexão não é suportada atualmente, porque o requerido javax.sql.
classes não estão disponíveis no Android.
CSV (Comma Separated Values) Suporte
O suporte a arquivos CSV pode ser usado dentro do banco de dados utilizando as funções
CSVREAD e CSVWRITE , Ou pode ser usado fora da base de dados como uma ferramenta
independente.
Leitura de um arquivo CSV de dentro de um banco de dados
Um arquivo CSV pode ser lido utilizando a função CSVREAD . Exemplo:
SELECT * FROM CSVREAD('test.csv');
Por favor, note por motivo de desempenho, CSVREAD não deve ser utilizado dentro de uma junção.
Em vez disso, importar os dados em primeiro lugar (possivelmente em uma tabela temporária), criar os
índices necessários se necessário, e, em seguida, consultar esta tabela.
Importando dados de um arquivo CSV
A maneira mais rápida para carregar ou importar dados (algumas vezes chamado de "carga a granel»)
a partir de um arquivo CSV é combinar a criação da tabela com importação. Opcionalmente, os nomes
das colunas e tipos de dados pode ser definido ao criar a tabela. Outra opção é usar INSERT INTO ...
SELECT .
CREATE TABLE TEST AS SELECT * FROM CSVREAD('test.csv');
CREATE TABLE TEST(ID INT PRIMARY KEY, NAME VARCHAR(255))
AS SELECT * FROM CSVREAD('test.csv');
Escrevendo um arquivo CSV de dentro de um banco de dados
A função built-in CSVWRITE pode ser usado para criar um arquivo CSV a partir de uma consulta.
Exemplo:
CREATE TABLE TEST(ID INT, NAME VARCHAR);
INSERT INTO TEST VALUES(1, 'Hello'), (2, 'World');
CALL CSVWRITE('test.csv', 'SELECT * FROM TEST');
Escrevendo um arquivo CSV a partir de um aplicativo Java
O Csv ferramenta pode ser usada em uma aplicação Java, mesmo quando não se usa uma base de
dados de todo. Exemplo:
import java.sql.*;
import org.h2.tools.Csv;
import org.h2.tools.SimpleResultSet;
public class TestCsv {
public static void main(String[] args) throws Exception {
SimpleResultSet rs = new SimpleResultSet();
rs.addColumn("NAME", Types.VARCHAR, 255, 0);
rs.addColumn("EMAIL", Types.VARCHAR, 255, 0);
rs.addRow("Bob Meier", "[email protected]");
rs.addRow("John Jones", "[email protected]");
new Csv().write("data/test.csv", rs, null);
}
}
Leitura de um arquivo CSV a partir de um aplicativo Java
25/10/13 Tutorial
www.h2database.com/html/tutorial.html#fulltext 11/18
É possível ler um arquivo CSV sem abrir um banco de dados. Exemplo:
import java.sql.*;
import org.h2.tools.Csv;
public class TestCsv {
public static void main(String[] args) throws Exception {
ResultSet rs = new Csv().read("data/test.csv", null, null);
ResultSetMetaData meta = rs.getMetaData();
while (rs.next()) {
for (int i = 0; i < meta.getColumnCount(); i++) {
System.out.println(
meta.getColumnLabel(i + 1) + ": " +
rs.getString(i + 1));
}
System.out.println();
}
rs.close();
}
}
Atualização, backup e restauração
Atualização de banco de dados
A forma recomendada para atualizar a partir de uma versão do motor de banco de dados para a
próxima versão é a de criar um backup de banco de dados (na forma de um script SQL) usando o
motor antigo, e, em seguida, executar o script SQL usando o novo motor.
Backup utilizando a ferramenta Script
A maneira recomendada de fazer backup de um banco de dados é criar um arquivo de script SQL
comprimido. Isso resultará em uma leitura, e banco de dados versão de backup independente
pequeno, humano. Criando o script também irá verificar as somas de verificação do arquivo de banco
de dados. O Script ferramenta é executado da seguinte forma:
java org.h2.tools.Script -url jdbc:h2:~/test -user sa -script test.zip -options compression zip
Também é possível usar o comando SQL SCRIPT para criar o backup do banco de dados. Para mais
informações sobre as opções, consulte o comando SQL SCRIPT . O backup pode ser feito
remotamente, no entanto, o arquivo será criado no lado do servidor. O construído em servidor de FTP
pode ser usado para recuperar o arquivo do servidor.
Restaurar a partir de um script
Para restaurar um banco de dados a partir de um arquivo de script SQL, você pode usar o RunScript
ferramenta:
java org.h2.tools.RunScript -url jdbc:h2:~/test -user sa -script test.zip -options compression zip
Para mais informações sobre as opções, consulte o comando SQL RUNSCRIPT . A restauração pode
ser feito remotamente, no entanto, o arquivo precisa estar no lado do servidor. O construído em
servidor de FTP pode ser usado para copiar o arquivo para o servidor. Também é possível usar o
comando SQL RUNSCRIPT para executar um script SQL. Arquivos de script SQL pode conter
referências a outros arquivos de script, na forma de RUNSCRIPT comandos. No entanto, quando se
utiliza o modo de servidor, os arquivos de script referências precisam estar disponíveis no lado do
servidor.
Online Backup
O BACKUP Instrução SQL eo Backup ferramenta tanto para criar um arquivo zip com o arquivo de
banco de dados. No entanto, o conteúdo deste arquivo não é legível.
O backup resultante é transacional consistente, ou seja, a consistência e atomicidade regras se
aplicam.
BACKUP TO 'backup.zip'
25/10/13 Tutorial
www.h2database.com/html/tutorial.html#fulltext 12/18
BACKUP TO 'backup.zip'
O Backup ferramenta ( org.h2.tools.Backup ) Não pode ser usado para criar uma cópia de segurança
em linha, a base de dados não deve estar em uso durante a execução deste programa.
Criando um backup, copiando os arquivos de banco de dados enquanto o banco de dados está sendo
executado não é suportado, salvo se os sistemas de arquivos suportam a criação de snapshots. Com
outros sistemas de arquivos, não é possível garantir que os dados são copiados na ordem certa.
Ferramentas de Linha de Comando
Esta base de dados vem com uma série de ferramentas de linha de comando. Para obter mais
informações sobre a ferramenta, inicie-o com o parâmetro '-', por exemplo:
java -cp h2*.jar org.h2.tools.Backup -?
As ferramentas de linha de comando são:
Backup cria um backup de um banco de dados.
ChangeFileEncryption permite alterar a senha de criptografia de arquivos ou algoritmo de um
banco de dados.
Console inicia o navegador baseado H2 Console.
ConvertTraceFile converte um arquivo trace.db. uma aplicação Java e script SQL.
CreateCluster cria um cluster de um banco de dados independente.
DeleteDbFiles exclui todos os arquivos pertencentes a um banco de dados.
Recover ajuda a recuperar um banco de dados corrompido.
Restore restaura um backup de um banco de dados.
RunScript executa um script SQL contra um banco de dados.
Script permite a conversão de um banco de dados para um script SQL para backup ou migração.
Server é utilizado no modo de servidor para iniciar um servidor de H2.
Shell é uma ferramenta de banco de dados de linha de comando.
As ferramentas também pode ser chamado de um aplicativo chamando o principal ou outro método
público. Para mais detalhes, consulte a documentação do Javadoc.
A ferramenta de Shell
A ferramenta Shell é uma ferramenta de linha de comando interativo simples. Para iniciá-lo, digite:
java -cp h2*.jar org.h2.tools.Shell
Você será solicitado para uma URL do banco de dados, driver JDBC, nome de usuário e senha. A
configuração de conexão também pode ser definido como parâmetros de linha de comando. Depois de
conectar, você terá a lista de opções. Os comandos built-in não precisa terminar com um ponto e
vírgula, mas instruções SQL são executados somente se a linha termina com um ponto e vírgula ; .
Isto permite inserir instruções multi-linha:
sql> select * from test
...> where id = 0;
Por padrão, os resultados são impressos como uma tabela. Para obter resultados com muitos coluna,
considere usar o modo de lista:
sql> list
Result list mode is now on
sql> select * from test;
ID : 1
NAME: Hello
ID : 2
NAME: World
(2 rows, 0 ms)
Utilizando Base de OpenOffice
OpenOffice.org Base de dados de suporte ao acesso de banco de dados sobre a API JDBC. Para se
25/10/13 Tutorial
www.h2database.com/html/tutorial.html#fulltext 13/18
OpenOffice.org Base de dados de suporte ao acesso de banco de dados sobre a API JDBC. Para se
conectar a um banco de dados H2 usando Base de OpenOffice, primeiro você precisa adicionar o driver
JDBC para o OpenOffice. Os passos para se conectar a um banco de dados H2 são:
Comece OpenOffice Writer, vá para [Ferramentas], [Opções]
Certifique-se de ter selecionado um ambiente de execução Java no OpenOffice.org / Java
Clique [Caminho Classe ...], [Adicionar Arquivo ...]
Selecione o arquivo jar h2 (localização é com você, pode ser onde quer que você escolher)
Clique em [OK] (tanto quanto necessário), parar OpenOffice (incluindo a inicialização rápida)
Comece Base de OpenOffice
Conectar a um banco de dados existente, selecione [JDBC], [Next]
Exemplo de fonte de dados URL: jdbc:h2:~/test
Classe do driver JDBC: org.h2.Driver
Agora você pode acessar o banco de dados armazenados no diretório home do usuário atual.
Para usar o H2 em NeoOffice (OpenOffice sem X11):
Em NeoOffice, vá para [NeoOffice], [Preferências]
Procure a página em [NeoOffice], [Java]
Clique [Caminho Classe], [Adicionar Arquivo ...]
Selecione o arquivo jar h2 (localização é com você, pode ser onde quer que você escolher)
Clique em [OK] (tanto quanto necessário), reinicie o NeoOffice.
Agora, quando a criação de um novo banco de dados usando o "Assistente de Banco de Dados":
Clique em [File], [New], [banco de dados].
Selecione [Conectar ao banco de dados existente] e selecione [JDBC]. Clique ao lado.
Exemplo de fonte de dados URL: jdbc:h2:~/test
Classe do driver JDBC: org.h2.Driver
Outra solução para usar em H2 NeoOffice é:
Empacotar o frasco h2 dentro de um pacote de extensão
Instale-o como uma extensão de Java no NeoOffice
Isso pode ser feito por criá-lo usando o plugin do OpenOffice NetBeans. Veja também Desenvolvimento
Extensions .
Java Web Start / JNLP
Ao usar o Java Web Start / JNLP (Java Network Protocol lançamento), as tags de permissões devem
ser definidas no arquivo jnlp., Eo arquivo do aplicativo. Jar deve ser assinado. Caso contrário, ao tentar
escrever para o sistema de arquivos, a seguinte exceção
ocorrerá: java.security.AccessControlException : Acesso negado ( java.io.FilePermission ... read ).
Exemplos de marcas de permissão:
<security>
<all-permissions/>
</security>
Usando um pool de conexão
Para H2, abrindo uma conexão é rápida, se o banco de dados já está aberta. Ainda assim, usando um
pool de conexão melhora o desempenho se você abrir e fechar conexões muito. Um pool de conexão
simples é incluído no H2. Ele é baseado no Mini Pool Manager Conexão de Christian d'Heureuse. Há
outros, mais complexos, abertos pools de conexão de base disponíveis, por exemplo, o Apache
Commons DBCP . Para H2, é cerca de duas vezes mais rápido para obter uma conexão do pool de
conexão built-in do que para obter um usando DriverManager.getConnection() . O build-in pool de
conexão é usado como segue:
import java.sql.*;
import org.h2.jdbcx.JdbcConnectionPool;
public class Test {
public static void main(String[] args) throws Exception {
JdbcConnectionPool cp = JdbcConnectionPool.create(
25/10/13 Tutorial
www.h2database.com/html/tutorial.html#fulltext 14/18
JdbcConnectionPool cp = JdbcConnectionPool.create(
"jdbc:h2:~/test", "sa", "sa");
for (int i = 0; i < args.length; i++) {
Connection conn = cp.getConnection();
conn.createStatement().execute(args[i]);
conn.close();
}
cp.dispose();
}
}
Pesquisa de texto completo
H2 inclui duas implementações de busca de texto completo. Uma delas é usando Apache Lucene, eo
outro (a implementação nativa) armazena os dados do índice em tabelas especiais no banco de
dados.
Usando o Native texto completo Pesquisa
Para iniciar, ligue para:
CREATE ALIAS IF NOT EXISTS FT_INIT FOR "org.h2.fulltext.FullText.init";
CALL FT_INIT();
Você precisa inicializar em cada banco de dados em que você deseja usá-lo. Depois, você pode criar
um índice de texto completo de uma tabela usando:
CREATE TABLE TEST(ID INT PRIMARY KEY, NAME VARCHAR);
INSERT INTO TEST VALUES(1, 'Hello World');
CALL FT_CREATE_INDEX('PUBLIC', 'TEST', NULL);
PÚBLICO é o nome do esquema, teste é o nome da tabela. A lista de nomes de colunas (separados
por vírgula) é opcional, neste caso, todas as colunas são indexadas. O índice é atualizado em tempo
real. Para procurar o índice, use a seguinte consulta:
SELECT * FROM FT_SEARCH('Hello', 0, 0);
Isto irá produzir um conjunto de resultados de consulta que contém o necessário para recuperar os
dados:
QUERY: "PUBLIC"."TEST" WHERE "ID"=1
Para excluir um índice em uma tabela:
CALL FT_DROP_INDEX('PUBLIC', 'TEST');
Para obter os dados brutos, use FT_SEARCH_DATA('Hello', 0, 0); . O resultado contém as
colunas SCHEMA (O nome do esquema) TABLE (O nome da tabela), COLUMNS (Uma matriz de
nomes de colunas) e KEYS (Uma matriz de objetos). Para participar de uma tabela, use uma junção
como em: SELECT T.* FROM FT_SEARCH_DATA('Hello', 0, 0) FT, TEST T WHERE
FT.TABLE='TEST' AND T.ID=FT.KEYS[0];
Você também pode ligar para o índice de dentro de uma aplicação Java:
org.h2.fulltext.FullText.search(conn, text, limit, offset);
org.h2.fulltext.FullText.searchData(conn, text, limit, offset);
Usando o Lucene pesquisa de texto completo
Para usar a pesquisa de texto completo Lucene, você precisa da biblioteca Lucene no classpath.
Atualmente Apache Lucene versão 2.x é utilizado por padrão para H2 versão 1.2.x, e Lucene versão
3.x é usado por padrão para H2 versão 1.3.x. Como fazer isso depende da aplicação, se você usar o
Console de H2, você pode adicionar o arquivo jar Lucene para as variáveis de ambiente H2DRIVERS
ou CLASSPATH . Para iniciar a pesquisa de texto completo Lucene em um banco de dados, ligue
para:
25/10/13 Tutorial
www.h2database.com/html/tutorial.html#fulltext 15/18
CREATE ALIAS IF NOT EXISTS FTL_INIT FOR "org.h2.fulltext.FullTextLucene.init";
CALL FTL_INIT();
Você precisa inicializar em cada banco de dados em que você deseja usá-lo. Depois, você pode criar
um índice de texto completo de uma tabela usando:
CREATE TABLE TEST(ID INT PRIMARY KEY, NAME VARCHAR);
INSERT INTO TEST VALUES(1, 'Hello World');
CALL FTL_CREATE_INDEX('PUBLIC', 'TEST', NULL);
PÚBLICO é o nome do esquema, teste é o nome da tabela. A lista de nomes de colunas (separados
por vírgula) é opcional, neste caso, todas as colunas são indexadas. O índice é atualizado em tempo
real. Para procurar o índice, use a seguinte consulta:
SELECT * FROM FTL_SEARCH('Hello', 0, 0);
Isto irá produzir um conjunto de resultados de consulta que contém o necessário para recuperar os
dados:
QUERY: "PUBLIC"."TEST" WHERE "ID"=1
Para excluir um índice em uma tabela (ser avisado de que isso irá reindexar todos os índices de texto
completo para todo o banco de dados):
CALL FTL_DROP_INDEX('PUBLIC', 'TEST');
Para obter os dados brutos, use FTL_SEARCH_DATA('Hello', 0, 0); . O resultado contém as
colunas SCHEMA (O nome do esquema) TABLE (O nome da tabela), COLUMNS (Uma matriz de
nomes de colunas) e KEYS (Uma matriz de objetos). Para participar de uma tabela, use uma junção
como em: SELECT T.* FROM FTL_SEARCH_DATA('Hello', 0, 0) FT, TEST T WHERE
FT.TABLE='TEST' AND T.ID=FT.KEYS[0];
Você também pode ligar para o índice de dentro de uma aplicação Java:
org.h2.fulltext.FullTextLucene.search(conn, text, limit, offset);
org.h2.fulltext.FullTextLucene.searchData(conn, text, limit, offset);
A busca Lucene suporta a pesquisa de texto completo em apenas coluna específica. Os nomes das
colunas deve ser maiúscula (exceto se as colunas originais são o dobro citado). Para os nomes das
colunas que começam com um sublinhado (_), outro sublinhado precisa ser adicionado. Exemplo:
CREATE ALIAS IF NOT EXISTS FTL_INIT FOR "org.h2.fulltext.FullTextLucene.init";
CALL FTL_INIT();
DROP TABLE IF EXISTS TEST;
CREATE TABLE TEST(ID INT PRIMARY KEY, FIRST_NAME VARCHAR, LAST_NAME VARCHAR);
CALL FTL_CREATE_INDEX('PUBLIC', 'TEST', NULL);
INSERT INTO TEST VALUES(1, 'John', 'Wayne');
INSERT INTO TEST VALUES(2, 'Elton', 'John');
SELECT * FROM FTL_SEARCH_DATA('John', 0, 0);
SELECT * FROM FTL_SEARCH_DATA('LAST_NAME:John', 0, 0);
CALL FTL_DROP_ALL();
A implementação de busca Lucene texto completo não está sincronizada internamente. Se você
atualizar o banco de dados e consultar a pesquisa de texto completo ao mesmo tempo (diretamente
usando a API Java de H2 ou a própria Lucene), você precisa garantir que as operações são
devidamente sincronizados. Se este não é o caso, você pode ter exceções,
como org.apache.lucene.store.AlreadyClosedException: this IndexReader is closed .
Variáveis definidas pelo usuário
Este banco de dados suporta variáveis definidas pelo usuário. Variáveis começam com @ e pode ser
utilizado sempre que as expressões ou parâmetros são permitidos. Variáveis não são persistentes e
escopo de sessão, o que significa apenas visível a partir da sessão em que eles são definidos. O valor
geralmente é atribuído utilizando o comando SET:
25/10/13 Tutorial
www.h2database.com/html/tutorial.html#fulltext 16/18
SET @USER = 'Joe';
O valor também pode ser alterado usando o método set (). Isso é útil em consultas:
SET @TOTAL = NULL;
SELECT X, SET(@TOTAL, IFNULL(@TOTAL, 1.) * X) F FROM SYSTEM_RANGE(1, 50);
Variáveis que não são definidas para avaliar NULL . O tipo de uma variável definida pelo usuário de
dados é o tipo do valor que lhe é atribuído de dados, o que significa que não é necessário (ou possível)
para declarar nomes de variáveis antes de usá-los. Não há restrições sobre os valores atribuídos;
objetos grandes (LOB) são suportados também. Revertendo uma transação não afeta o valor de uma
variável definida pelo usuário.
Data e Hora
Valores de data, hora e timestamp apoiar a formatação ISO 8601, incluindo o fuso horário:
CALL TIMESTAMP '2008-01-01 12:00:00+01:00';
Se o fuso horário não está definido, o valor é analisado usando a configuração de fuso horário atual do
sistema. Data e hora a informação é armazenada em arquivos de banco de dados H2, sem
informações de fuso horário. Se o banco de dados é aberto usando um outro fuso horário do sistema, a
data eo horário será o mesmo. Isso significa que se você armazenar o valor '2000-01-01 00:00:00 'em
um fuso horário, em seguida, feche o banco de dados e abrir o banco de dados novamente em um fuso
horário diferente, você também irá receber '2000-01-01 dezembro : 00:00 '. Por favor, note que a
mudança do fuso horário após o motorista H2 é carregado não é suportado.
Usando Spring
Usando o servidor TCP
Use a seguinte configuração para iniciar e parar o servidor TCP H2 usando o Spring Framework:
<bean id = "org.h2.tools.Server"
class="org.h2.tools.Server"
factory-method="createTcpServer"
init-method="start"
destroy-method="stop">
<constructor-arg value="-tcp,-tcpAllowOthers,-tcpPort,8043" />
</bean>
O destroy-method irá ajudar a evitar exceções em hot-reafectação ou quando reiniciar o servidor.
Incompatibilidade Código de erro
Existe uma incompatibilidade com a mola JdbcTemplate e H2 versão 1.3.154 e mais recente, devido a
uma alteração no código de erro. Isso fará com que o JdbcTemplate para não detectar uma condição
de chave duplicada, e assim a DataIntegrityViolationException é lançada em vez de
DuplicateKeyException . Veja também a questão SPR-8235 . A solução é adicionar o seguinte
arquivo XML para a raiz do classpath:
<beans
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation=
"http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd"
>
<import resource="classpath:org/springframework/jdbc/support/sql-error-codes.xml"/>
<bean id = "H2" class="org.springframework.jdbc.support.SQLErrorCodes">
<property name="badSqlGrammarCodes">
<value>
42000,42001,42101,42102,42111,42112,42121,42122,42132
</value>
</property>
25/10/13 Tutorial
www.h2database.com/html/tutorial.html#fulltext 17/18
</property>
<property name="duplicateKeyCodes">
<value>23001,23505</value>
</property>
<property name="dataIntegrityViolationCodes">
<value>22003,22012,22025,23000</value>
</property>
<property name="dataAccessResourceFailureCodes">
<value>90046,90100,90117,90121,90126</value>
</property>
<property name="cannotAcquireLockCodes">
<value>50200</value>
</property>
</bean>
</beans>
OSGi
O frasco H2 padrão pode ser descartado como um pacote em um contêiner OSGi. H2 implementa o
Serviço JDBC definido no OSGi Serviço Platform Release 4 Versão 4.2 Especificação da empresa. O
H2 serviço Fábrica de fonte de dados é registrado com as seguintes
propriedades: OSGI_JDBC_DRIVER_CLASS=org.h2.Driver e OSGI_JDBC_DRIVER_NAME=H2 .
O OSGI_JDBC_DRIVER_VERSION propriedade reflete a versão do motorista como é.
As seguintes propriedades de configuração padrão são suportados: JDBC_USER,
JDBC_PASSWORD, JDBC_DESCRIPTION, JDBC_DATASOURCE_NAME,
JDBC_NETWORK_PROTOCOL, JDBC_URL, JDBC_SERVER_NAME, JDBC_PORT_NUMBER .
Qualquer outra propriedade padrão serão rejeitados. Propriedades não-padrão serão repassados para
H2 na URL de conexão.
Java Gestão Extension (JMX)
Gestão sobre JMX é suportado, mas não habilitado por padrão. Para habilitar JMX,
acrescente ;JMX=TRUE para o URL do banco quando se abre a base de dados. Várias ferramentas de
apoio JMX, uma dessas ferramentas é o jconsole . Ao abrir o jconsole , Conectar-se ao processo em
que o banco de dados estiver aberto (quando se utiliza o modo de servidor, é necessário conectar-se
ao processo de servidor). Então vá para o MBeans secção. Em org.h2 você vai encontrar uma entrada
por banco de dados. O nome do objeto de entrada é o nome abreviado de banco de dados, mais o
caminho (cada cólon é substituído por um caractere sublinhado).
Os seguintes atributos e operações são suportados:
CacheSize : O tamanho do cache em uso atualmente em KB.
CacheSizeMax (Leitura / escrita): o tamanho máximo do cache em KB.
Exclusive : Se este banco de dados é aberto no modo exclusivo ou não.
FileReadCount : O número de operações de leitura de arquivos desde o banco de dados foi aberto.
FileSize : O tamanho do arquivo em KB.
FileWriteCount : O número de operações de gravação de ficheiro uma vez que a base de dados foi
aberto.
FileWriteCountTotal : O número de operações de gravação de ficheiro uma vez que a base de
dados foi criada.
LogMode (Leitura / escrita): o modo de log de transações correntes. Ver SET LOG para mais
detalhes.
Mode : O modo de compatibilidade ( REGULAR se nenhum modo de compatibilidade é usado).
MultiThreaded : True se multi-threaded está habilitado.
Mvcc : True se MVCC é ativado.
ReadOnly : True se o banco de dados é somente leitura.
TraceLevel (Leitura / escrita): o nível de rastreamento de arquivos.
Version : A versão de base de dados em uso.
listSettings : Listar as configurações de banco de dados.
listSessions : Listar as sessões abertas, incluindo a instrução atualmente em execução (se
houver) e tabelas bloqueadas (se houver).
Para habilitar JMX, pode ser necessário para definir as propriedades do sistema
com.sun.management.jmxremote e com.sun.management.jmxremote.port conforme exigido pela
JVM.
25/10/13 Tutorial
www.h2database.com/html/tutorial.html#fulltext 18/18
JVM.
Top Related