Tutorial h2

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.

▲

http://translate.google.com/translate?u=http%3A%2F%2Fh2database.com

http://www.h2database.com/html/main.html

http://www.h2database.com/html/download.html

http://www.h2database.com/html/cheatSheet.html

http://www.h2database.com/html/quickstart.html

http://www.h2database.com/html/installation.html

http://www.h2database.com/html/tutorial.html

http://www.h2database.com/html/features.html

http://www.h2database.com/html/performance.html

http://www.h2database.com/html/advanced.html

http://www.h2database.com/html/grammar.html

http://www.h2database.com/html/functions.html

http://www.h2database.com/html/datatypes.html

http://www.h2database.com/javadoc/index.html

http://www.h2database.com/h2.pdf

http://www.h2database.com/html/faq.html

http://www.h2database.com/html/sourceError.html

http://groups.google.com/group/h2-database

http://groups.google.co.jp/group/h2-database-jp

http://groups.google.com/group/h2-cn

http://www.h2database.com/html/history.html

http://www.h2database.com/html/license.html

http://www.h2database.com/html/build.html

http://www.h2database.com/html/links.html

http://www.h2database.com/html/jaqu.html

http://www.h2database.com/html/mvstore.html

25/10/13 Tutorial


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


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


@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


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:

http://www.h2database.com/html/features.html#database_only_if_exists

25/10/13 Tutorial


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

http://opensource.atlassian.com/projects/hibernate/browse/HHH-3401

http://wiki.eclipse.org/EclipseLink/Development/Incubator/Extensions/H2Platform

25/10/13 Tutorial


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

http://kenai.com/projects/nbh2

http://www.jooq.org/

http://www.jooq.org/tutorial.php

25/10/13 Tutorial


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


<servlet>

<servlet-name>H2Console</servlet-name>

<servlet-class>org.h2.server.web.WebServlet</servlet-class>



<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


";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


É possível ler um arquivo CSV sem abrir um banco de dados. Exemplo:

import java.sql.*;

import org.h2.tools.Csv;

public class TestCsv {


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


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


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


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


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 {


JdbcConnectionPool cp = JdbcConnectionPool.create(

http://wiki.services.openoffice.org/wiki/Extensions_development_java

http://www.source-code.biz/snippets/java/8.htm

http://jakarta.apache.org/commons/dbcp/

25/10/13 Tutorial


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


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


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>

https://jira.springsource.org/browse/SPR-8235

25/10/13 Tutorial


</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


JVM.