H2 Database - Guia rápido
H2 é um banco de dados Java leve de código aberto. Ele pode ser integrado em aplicativos Java ou executado no modo cliente-servidor. Principalmente, o banco de dados H2 pode ser configurado para ser executado como um banco de dados de memória, o que significa que os dados não persistirão no disco. Por causa do banco de dados incorporado, ele não é usado para desenvolvimento de produção, mas principalmente para desenvolvimento e teste.
Este banco de dados pode ser usado no modo integrado ou no modo servidor. A seguir estão os principais recursos do banco de dados H2 -
- Extremamente rápido, código aberto, API JDBC
- Disponível nos modos incorporado e servidor; bancos de dados na memória
- Aplicativo de console baseado em navegador
- Pegada pequena - tamanho de arquivo jar de aproximadamente 1,5 MB
Recursos do banco de dados H2
As principais características do banco de dados H2 são as seguintes -
É um mecanismo de banco de dados extremamente rápido.
H2 é open source e escrito em Java.
Suporta SQL padrão e API JDBC. Ele também pode usar o driver ODBC PostgreSQL.
Possui modo de servidor e incorporado.
Suportes H2 clustering e multi-version concurrency.
Possui fortes recursos de segurança.
Características adicionais
A seguir estão alguns recursos adicionais do banco de dados H2 -
H2 é um banco de dados e tabelas baseado em disco ou na memória, suporte de banco de dados somente leitura, tabelas temporárias.
H2 fornece suporte de transação (leitura confirmada), conexões múltiplas de confirmação de 2 fases, bloqueio de nível de tabela.
H2 é um otimizador baseado em custos, usando um algoritmo genético para consultas complexas, administração zero.
H2 contém suporte para conjunto de resultados rolável e atualizável, conjunto de resultados grande, classificação de resultado externo, funções podem retornar um conjunto de resultados.
H2 oferece suporte a banco de dados criptografado (AES), criptografia de senha SHA-256, funções de criptografia e SSL.
Componentes no banco de dados H2
Para usar o banco de dados H2, você precisa ter os seguintes componentes -
- Um navegador da web
- Um servidor de console H2
Este é um aplicativo cliente / servidor, portanto, tanto o servidor quanto o cliente (um navegador) são necessários para executá-lo.
H2 é um banco de dados escrito em Java. Podemos incorporar facilmente esse banco de dados ao nosso aplicativo usando JDBC. Podemos executá-lo em muitas plataformas diferentes ou em qualquer versão do Java Runtime Environment. Porém, antes de instalar o banco de dados, deve haver Java instalado no sistema.
Verifique a instalação do Java
Se o JDK estiver instalado no sistema, tente o seguinte comando para verificar a versão do Java.
java –version
Se o JDk for instalado com sucesso no sistema, obteremos a seguinte saída.
java version "1.8.0_91"
Java(TM) SE Runtime Environment (build 1.8.0_91-b14)
Java HotSpot(TM) 64-Bit Server VM (build 25.91-b14, mixed mode)
Se o JDK não estiver instalado no sistema, visite o seguinte link para Instalar o JDK .
Instale o banco de dados H2
Podemos executar esse banco de dados em muitas plataformas diferentes. Neste capítulo, aprenderemos sobre a instalação do banco de dados H2 no Windows.
A seguir estão as etapas para instalar o banco de dados H2 no sistema operacional Windows.
Etapa 1: Baixe o arquivo de configuração H2
Baixe a versão mais recente do banco de dados H2 no link fornecido. Neste link, você obterá a versão mais recente do banco de dados H2 em dois tipos. Um é do tipo Windows Installer (ou seja, arquivo .exe) e o segundo é um arquivo zip independente de plataforma para outros sistemas operacionais.
Clique no instalador do Windows para fazer download do banco de dados H2 compatível com o Windows após fazer download do arquivo .exe. Neste caso, estamos usando o banco de dados H2 com a versão 1.4.192.
Etapa 2: Instale o banco de dados H2
Após o download, obtemos o arquivo H2 do instalador do Windows (ou seja, h2-setup-yyyy-mm-dd.exe) no diretório Downloads. Para iniciar o processo de instalação do Banco de Dados H2, clique duas vezes no arquivo instalador.
A tela a seguir é a primeira etapa do processo de instalação. Forneça um caminho onde queremos instalar o servidor de banco de dados H2, conforme mostrado na captura de tela a seguir.
Como pode ser visto na imagem acima, por padrão, C:\ProgramFiles (x86)\H2como a pasta de destino. Clique em Avançar para prosseguir para a próxima etapa. A tela a seguir é exibida.
Na captura de tela acima, clique no botão Instalar para iniciar o processo de instalação. Após a instalação, obtemos a seguinte imagem.
Clique em Concluir para completar o processo de instalação.
Etapa 3: verificar a instalação do banco de dados H2
Após a instalação, vamos verificar a instalação do banco de dados no sistema. Clique em Windows → digite H2 Console → Clique no ícone do console H2. Conecte-se ao URLhttp://localhost:8082. No momento da conexão, o banco de dados H2 solicitará o registro do banco de dados conforme mostrado na imagem a seguir.
Preencha todos os detalhes na caixa de diálogo acima, como Configurações salvas, Nome das configurações, Classe do driver, URL JDBC, Nome do usuário e Senha. No URL JDBC, especifique se o banco de dados está localizado e o nome do banco de dados. Nome de usuário e senha são os campos para nome de usuário e senha do banco de dados. Clique em Conectar.
A página de boas-vindas do banco de dados é exibida conforme mostrado na captura de tela a seguir.
O comando Selecionar é usado para buscar dados de registro de uma tabela ou várias tabelas. Se projetarmos uma consulta selecionada, ela retornará dados na forma de uma tabela de resultados chamadaresult sets.
Sintaxe
A sintaxe básica da instrução SELECT é a seguinte -
SELECT [ TOP term ] [ DISTINCT | ALL ] selectExpression [,...]
FROM tableExpression [,...] [ WHERE expression ]
[ GROUP BY expression [,...] ] [ HAVING expression ]
[ { UNION [ ALL ] | MINUS | EXCEPT | INTERSECT } select ] [ ORDER BY order [,...] ]
[ [ LIMIT expression ] [ OFFSET expression ] [ SAMPLE_SIZE rowCountInt ] ]
[ FOR UPDATE ]
Para buscar todos os campos disponíveis, use a seguinte sintaxe.
SELECT * FROM table_name;
Exemplo
Considere a tabela CUSTOMER com os seguintes registros -
+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Para obter a tabela do cliente junto com os dados fornecidos, execute as seguintes consultas.
CREATE TABLE CUSTOMER (id number, name varchar(20), age number, address varchar(20),
salary number);
INSERT into CUSTOMER values (1, 'Ramesh', 32, 'Ahmedabad', 2000);
INSERT into CUSTOMER values (2, 'Khilan', 25, 'Delhi', 1500);
INSERT into CUSTOMER values (3, 'kaushik', 23, 'Kota', 2000);
INSERT into CUSTOMER values (4, 'Chaitali', 25, 'Mumbai', 6500);
INSERT into CUSTOMER values (5, 'Hardik', 27, 'Bhopal', 8500);
INSERT into CUSTOMER values (6, 'Komal', 22, 'MP', 4500);
INSERT into CUSTOMER values (7, 'Muffy', 24, 'Indore', 10000);
O comando a seguir é um exemplo, que buscaria os campos ID, Nome e Salário dos clientes disponíveis na tabela CUSTOMER.
SELECT ID, NAME, SALARY FROM CUSTOMERS;
O comando acima produz o seguinte resultado.
+----+----------+----------+
| ID | NAME | SALARY |
+----+----------+----------+
| 1 | Ramesh | 2000.00 |
| 2 | Khilan | 1500.00 |
| 3 | kaushik | 2000.00 |
| 4 | Chaitali | 6500.00 |
| 5 | Hardik | 8500.00 |
| 6 | Komal | 4500.00 |
| 7 | Muffy | 10000.00 |
+----+----------+----------+
Use a seguinte consulta para buscar todos os campos da tabela CUSTOMERS.
SQL> SELECT * FROM CUSTOMERS;
A consulta acima produz o seguinte resultado -
+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
A instrução SQL INSERT é usada para adicionar novas linhas de dados a uma tabela no banco de dados.
Sintaxe
A seguir está a sintaxe básica da instrução INSERT INTO.
INSERT INTO tableName
{ [ ( columnName [,...] ) ]
{ VALUES
{ ( { DEFAULT | expression } [,...] ) } [,...] | [ DIRECT ] [ SORTED ] select } } |
{ SET { columnName = { DEFAULT | expression } } [,...] }
Usando esta instrução INSERT, podemos inserir um novo registro ou novas linhas em uma tabela. Ao usar a cláusula DIRECT, os resultados são afetados diretamente para a tabela de destino sem qualquer etapa intermediária. No entanto, ao adicionar valores para todas as colunas da tabela, certifique-se de que a ordem dos valores esteja na mesma ordem das colunas da tabela.
Exemplo
Tomemos um exemplo e tentemos inserir os seguintes registros fornecidos na tabela Customer.
EU IRIA | Nome | Era | Endereço | Salário |
---|---|---|---|---|
1 | Ramesh | 32 | Ahmedabad | 2000 |
2 | Khilan | 25 | Délhi | 1500 |
3 | Kaushik | 23 | Kota | 2000 |
4 | Chaitail | 25 | Mumbai | 6500 |
5 | Hardik | 27 | Bhopal | 8500 |
6 | Komal | 22 | MP | 4500 |
7 | Muffy | 24 | Indore | 10.000 |
Podemos obter todos os registros fornecidos na tabela do cliente executando os seguintes comandos.
INSERT INTO CUSTOMER VALUES (1, 'Ramesh', 32, 'Ahmedabad', 2000);
INSERT INTO CUSTOMER VALUES (2, 'Khilan', 25, 'Delhi', 1500);
INSERT INTO CUSTOMER VALUES (3, 'kaushik', 23, 'Kota', 2000);
INSERT INTO CUSTOMER VALUES (4, 'Chaitali', 25, 'Mumbai', 6500);
INSERT INTO CUSTOMER VALUES (5, 'Hardik', 27, 'Bhopal', 8500);
INSERT INTO CUSTOMER VALUES (6, 'Komal', 22, 'MP', 4500);
INSERT INTO CUSTOMER VALUES (7, 'Muffy', 24, 'Indore', 10000);
A consulta UPDATE é usada para atualizar ou modificar os registros existentes em uma tabela. Podemos usar a cláusula WHERE com a consulta UPDATE para atualizar as linhas selecionadas, caso contrário, todas as linhas seriam afetadas.
Sintaxe
A seguir está a sintaxe básica da consulta UPDATE.
UPDATE tableName [ [ AS ] newTableAlias ] SET
{ { columnName = { DEFAULT | expression } } [,...] } |
{ ( columnName [,...] ) = ( select ) }
[ WHERE expression ] [ ORDER BY order [,...] ] [ LIMIT expression ]
Nesta sintaxe UPDATE, podemos combinar mais de uma condição usando as cláusulas AND ou OR.
Exemplo
Considere a tabela CUSTOMER com os seguintes registros.
+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Se você deseja obter a tabela do cliente junto com os dados fornecidos, execute as seguintes consultas.
CREATE TABLE CUSTOMER (id number, name varchar(20), age number, address varchar(20),
salary number);
INSERT into CUSTOMER values (1, 'Ramesh', 32, 'Ahmedabad', 2000);
INSERT into CUSTOMER values (2, 'Khilan', 25, 'Delhi', 1500);
INSERT into CUSTOMER values (3, 'kaushik', 23, 'Kota', 2000);
INSERT into CUSTOMER values (4, 'Chaitali', 25, 'Mumbai', 6500);
INSERT into CUSTOMER values (5, 'Hardik', 27, 'Bhopal', 8500);
INSERT into CUSTOMER values (6, 'Komal', 22, 'MP', 4500);
INSERT into CUSTOMER values (7, 'Muffy', 24, 'Indore', 10000);
O comando a seguir é um exemplo, que atualizaria ADDRESS para um cliente cujo ID é 6 -
UPDATE CUSTOMERS SET ADDRESS = 'Pune' WHERE ID = 6;
Agora, a tabela CUSTOMERS teria os seguintes registros. Podemos verificar os registros da tabela do cliente executando a seguinte consulta.
SELECT * FROM CUSTOMERS;
A consulta acima produz o seguinte resultado.
+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | Pune | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Para modificar todos os valores das colunas ADDRESS e SALARY na tabela CUSTOMERS, não precisamos usar a cláusula WHERE. A consulta UPDATE seria a seguinte -
UPDATE CUSTOMERS SET ADDRESS = 'Pune', SALARY = 1000.00;
Agora, a tabela CUSTOMERS teria os seguintes registros. Podemos verificar os registros da tabela do cliente executando a seguinte consulta.
SELECT * FROM CUSTOMERS;
A consulta acima produz o seguinte resultado -
+----+----------+-----+---------+---------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+---------+---------+
| 1 | Ramesh | 32 | Pune | 1000.00 |
| 2 | Khilan | 25 | Pune | 1000.00 |
| 3 | kaushik | 23 | Pune | 1000.00 |
| 4 | Chaitali | 25 | Pune | 1000.00 |
| 5 | Hardik | 27 | Pune | 1000.00 |
| 6 | Komal | 22 | Pune | 1000.00 |
| 7 | Muffy | 24 | Pune | 1000.00 |
+----+----------+-----+---------+---------+
A consulta SQL DELETE é usada para excluir os registros existentes de uma tabela. Podemos usar a cláusula WHERE com a consulta DELETE para excluir os registros selecionados, caso contrário, todos os registros serão excluídos.
Sintaxe
A seguir está a sintaxe de consulta genérica do comando delete.
DELETE [ TOP term ] FROM tableName [ WHERE expression ] [ LIMIT term ]
A sintaxe acima exclui as linhas de uma tabela. Se TOP ou LIMIT for especificado, no máximo o número especificado de linhas será excluído (sem limite se nulo ou menor que zero).
Exemplo
Considere a tabela CUSTOMER com os seguintes registros.
+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
O comando a seguir excluirá os detalhes do cliente, cujo ID é 6.
DELETE FROM CUSTOMERS WHERE ID = 6;
Após a execução do comando acima, verifique a tabela do Cliente executando o seguinte comando.
SELECT * FROM CUSTOMERS;
O comando acima produz a seguinte saída -
+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Se quisermos DELETE todos os registros da tabela CUSTOMERS, não usamos a cláusula WHERE. A consulta DELETE seria a seguinte.
DELETE FROM CUSTOMER;
Após executar o comando acima, nenhum registro ficará disponível na tabela Cliente.
BACKUP é o comando usado para fazer o backup do banco de dados em um arquivo .zip separado. Os objetos não são bloqueados e, quando é feito o backup, o log de transações também é copiado. São necessários direitos de administrador para executar este comando.
Sintaxe
A seguir está a sintaxe genérica do comando Backup.
BACKUP TO fileNameString;
Exemplo
Neste exemplo, vamos fazer um backup do banco de dados atual em backup.zipArquivo. Use o seguinte comando para o mesmo.
BACKUP TO 'backup.zip';
Ao executar o comando acima, você obterá o arquivo backup.zip em seu sistema de arquivos local.
CALL é um comando SQL que pertence ao servidor de banco de dados H2. Este comando é usado para calcular uma expressão simples. Ele retorna o resultado da expressão fornecida em um campo de coluna única. Quando ele retorna uma matriz de resultados, cada elemento da matriz é exibido como um valor de coluna.
Sintaxe
A seguir está a sintaxe genérica do comando CALL.
CALL expression;
Podemos usar a expressão aritmética nesta sintaxe.
Exemplo
Vamos dar um exemplo e executar uma expressão aritmética (15 * 25) usando o comando call.
CALL 15*25;
O comando acima produz a seguinte saída.
375 |
---|
375 |
O comando EXPLAIN exibe o plano de execução de uma instrução. Quando executamos uma instrução usando o comando EXPLAIN ANALYZE, o plano de consulta incluirá a contagem real de varredura de linha para cada tabela.
Sintaxe
A seguir está a sintaxe genérica do comando EXPLAIN.
EXPLAIN { [ PLAN FOR ] | ANALYZE } { select | insert | update | delete | merge}
Junto com essa sintaxe, podemos usar selecionar, inserir, excluir e mesclar.
Exemplo
Este exemplo explica os detalhes do plano de consulta do cliente com ID 1.
EXPLAIN SELECT * FROM CUSTOMER WHERE ID = 1;
O comando acima produz a seguinte saída -
O comando MERGE é usado para atualizar as linhas existentes e inserir novas linhas em uma tabela. A coluna da chave primária desempenha um papel importante ao usar este comando; ele é usado para encontrar a linha.
Sintaxe
A seguir está a sintaxe genérica do comando MERGE.
MERGE INTO tableName [ ( columnName [,...] ) ]
[ KEY ( columnName [,...] ) ]
{ VALUES { ( { DEFAULT | expression } [,...] ) } [,...] | select }
Na sintaxe acima, a cláusula KEY é usada para especificar o nome da coluna da chave primária. Junto com a cláusula VALUES, podemos usar valores primitivos para inserir ou podemos recuperar e armazenar outros valores de tabela nesta tabela usando o comando select.
Exemplo
Neste exemplo, vamos tentar adicionar um novo registro à tabela Clientes. A seguir estão os detalhes do novo registro na tabela.
Nome da coluna | Valor |
---|---|
EU IRIA | 8 |
NOME | Lokesh |
ERA | 32 |
ENDEREÇO | Hyderabad |
SALÁRIO | 2500 |
Usando a consulta a seguir, vamos inserir o registro fornecido na consulta de banco de dados H2.
MERGE INTO CUSTOMER KEY (ID) VALUES (8, 'Lokesh', 32, 'Hyderabad', 2500);
A consulta acima produz a seguinte saída.
Update count: 1
Vamos verificar os registros da tabela Cliente executando a seguinte consulta.
SELECT * FROM CUSTOMER;
A consulta acima produz a seguinte saída.
EU IRIA | Nome | Era | Endereço | Salário |
---|---|---|---|---|
1 | Ramesh | 32 | Ahmedabad | 2000 |
2 | Khilan | 25 | Délhi | 1500 |
3 | Kaushik | 23 | Kota | 2000 |
4 | Chaitali | 25 | Mumbai | 6500 |
5 | Hardik | 27 | Bhopal | 8500 |
6 | Komal | 22 | MP | 4500 |
7 | Muffy | 24 | Indore | 10.000 |
8 | Lokesh | 32 | Hyderabad | 2500 |
Agora vamos tentar atualizar o registro usando o Mergecomando. A seguir estão os detalhes do registro a ser atualizado.
Nome da coluna | Valor |
---|---|
EU IRIA | 8 |
NOME | Loki |
ERA | 32 |
ENDEREÇO | Hyderabad |
SALÁRIO | 3000 |
Use a seguinte consulta para inserir o registro fornecido na consulta de banco de dados H2.
MERGE INTO CUSTOMER KEY (ID) VALUES (8, 'Loki', 32, 'Hyderabad', 3000);
A consulta acima produz a seguinte saída.
Update count: 1
Vamos verificar os registros da tabela Cliente executando a seguinte consulta.
SELECT * FROM CUSTOMER;
A consulta acima produz a seguinte saída -
EU IRIA | Nome | Era | Endereço | Salário |
---|---|---|---|---|
1 | Ramesh | 32 | Ahmedabad | 2000 |
2 | Khilan | 25 | Délhi | 1500 |
3 | Kaushik | 23 | Kota | 2000 |
4 | Chaitali | 25 | Mumbai | 6500 |
5 | Hardik | 27 | Bhopal | 8500 |
6 | Komal | 22 | MP | 4500 |
7 | Muffy | 24 | Indore | 10.000 |
8 | Loki | 32 | Hyderabad | 3000 |
SHOW é um comando usado para exibir a lista de esquemas, tabelas ou colunas da tabela.
Sintaxe
A seguir está a sintaxe genérica do comando SHOW.
SHOW { SCHEMAS | TABLES [ FROM schemaName ] |
COLUMNS FROM tableName [ FROM schemaName ] }
Exemplo
O seguinte comando pode ser usado para obter a lista de tabelas no banco de dados atual.
SHOW TABLES;
O comando acima produz a seguinte saída.
NOME DA TABELA | TABLE_SCHEMA |
---|---|
CLIENTE | PÚBLICO |
EMP | PÚBLICO |
CREATE é um comando SQL genérico usado para criar tabelas, esquemas, sequências, visualizações e usuários no servidor de banco de dados H2.
Criar a tabela
Criar Tabela é um comando usado para criar uma tabela definida pelo usuário no banco de dados atual.
Sintaxe
A seguir está a sintaxe genérica para o comando Criar Tabela.
CREATE [ CACHED | MEMORY ] [ TEMP | [ GLOBAL | LOCAL ] TEMPORARY ]
TABLE [ IF NOT EXISTS ] name
[ ( { columnDefinition | constraint } [,...] ) ]
[ ENGINE tableEngineName [ WITH tableEngineParamName [,...] ] ]
[ NOT PERSISTENT ] [ TRANSACTIONAL ]
[ AS select ]
Usando a sintaxe genérica do comando Criar Tabela, podemos criar diferentes tipos de tabelas, como tabelas em cache, tabelas de memória e tabelas temporárias. A seguir está a lista para descrever as diferentes cláusulas da sintaxe fornecida.
CACHED- As tabelas em cache são o tipo padrão para tabelas regulares. Isso significa que o número de linhas não é limitado pela memória principal.
MEMORY- As tabelas de memória são o tipo padrão para tabelas temporárias. Isso significa que as tabelas de memória não devem ficar muito grandes e os dados do índice são mantidos na memória principal.
TEMPORARY- As tabelas temporárias são excluídas ao fechar ou abrir um banco de dados. Basicamente, as tabelas temporárias são de dois tipos -
Tipo GLOBAL - Acessível por todas as conexões.
Tipo LOCAL - Acessível pela conexão atual.
O tipo padrão para tabelas temporárias é o tipo global. Os índices de tabelas temporárias são mantidos na memória principal, a menos que a tabela temporária seja criada usando CREATE CACHED TABLE.
ENGINE - A opção ENGINE só é necessária quando implementações de tabelas personalizadas são usadas.
NOT PERSISTENT - É um modificador para manter os dados completos da tabela na memória e todas as linhas são perdidas quando o banco de dados é fechado.
TRANSACTIONAL - É uma palavra-chave que confirma uma transação aberta e este comando suporta apenas tabelas temporárias.
Exemplo
Neste exemplo, vamos criar uma tabela chamada tutorials_tbl usando os seguintes dados fornecidos.
Sr. Não | Nome da coluna | Tipo de dados |
---|---|---|
1 | EU IRIA | Int |
2 | Título | Varchar (50) |
3 | Autor | Varchar (20) |
4 | Data de submissão | Encontro |
A seguinte consulta é usada para criar uma tabela tutorials_tbl junto com os dados da coluna fornecidos.
CREATE TABLE tutorials_tbl (
id INT NOT NULL,
title VARCHAR(50) NOT NULL,
author VARCHAR(20) NOT NULL,
submission_date DATE
);
A consulta acima produz a seguinte saída.
(0) rows effected
Criar Esquema
Criar esquema é um comando usado para criar um esquema dependente do usuário sob uma autorização específica (sob o usuário atualmente registrado).
Sintaxe
A seguir está a sintaxe genérica do comando Criar Esquema.
CREATE SCHEMA [ IF NOT EXISTS ] name [ AUTHORIZATION ownerUserName ]
Na sintaxe genérica acima, AUTHORIZATION é uma palavra-chave usada para fornecer o respectivo nome de usuário. Este comando é opcional, o que significa que se não fornecermos o nome do usuário, ele considerará o usuário atual. O usuário que executa o comando deve ter direitos de administrador, assim como o proprietário.
Este comando confirma uma transação aberta nesta conexão.
Exemplo
Neste exemplo, vamos criar um esquema chamado test_schema sob o usuário SA, usando o seguinte comando.
CREATE SCHEMA test_schema AUTHORIZATION sa;
O comando acima produz a seguinte saída.
(0) rows effected
Criar sequência
Sequência é o conceito usado para gerar um número seguindo uma sequência para id ou quaisquer valores de coluna aleatórios.
Sintaxe
A seguir está a sintaxe genérica do comando criar sequência.
CREATE SEQUENCE [ IF NOT EXISTS ] newSequenceName [ START WITH long ]
[ INCREMENT BY long ]
[ MINVALUE long | NOMINVALUE | NO MINVALUE ]
[ MAXVALUE long | NOMAXVALUE | NO MAXVALUE ]
[ CYCLE long | NOCYCLE | NO CYCLE ]
[ CACHE long | NOCACHE | NO CACHE ]
Esta sintaxe genérica é usada para criar uma sequência. O tipo de dados de uma sequência éBIGINT. Nesta sequência, os valores nunca são reutilizados, mesmo quando a transação é revertida.
Exemplo
Neste exemplo, vamos criar uma sequência chamada SEQ_ID, usando a seguinte consulta.
CREATE SEQUENCE SEQ_ID;
A consulta acima produz a seguinte saída.
(0) rows effected
ALTER é um comando usado para alterar a estrutura da tabela, adicionando diferentes cláusulas ao altercomando. Com base no cenário, precisamos adicionar a respectiva cláusula ao comando alter. Neste capítulo, discutiremos vários cenários do comando alter.
Alterar Adicionar Tabela
Alterar Adicionar Tabela é um comando usado para adicionar uma nova coluna a uma tabela junto com o respectivo tipo de dados. Este comando confirma a transação nesta conexão.
Sintaxe
A seguir está a sintaxe genérica do comando Alterar Adicionar Tabela.
ALTER TABLE [ IF EXISTS ] tableName ADD [ COLUMN ]
{ [ IF NOT EXISTS ] columnDefinition [ { BEFORE | AFTER } columnName ]
| ( { columnDefinition } [,...] ) }
Exemplo
Neste exemplo, vamos adicionar uma nova coluna start_date para a mesa tutorials_tbl. O tipo de dados para start_date é Date. A seguir está a consulta para adicionar uma nova coluna.
ALTER TABLE tutorials_tbl ADD start_date DATE;
A consulta acima produz a seguinte saída.
(6) rows effected
Alterar Tabela Adicionar Restrição
Alter table add constraint é um comando usado para adicionar diferentes restrições à tabela, como chave primária, chave estrangeira, não nula, etc.
Os índices necessários são criados automaticamente se ainda não existirem. Não é possível desativar a verificação de restrição exclusiva. Este comando confirma uma transação aberta nesta conexão.
Sintaxe
A seguir está a sintaxe genérica do comando Alter table add constraint.
ALTER TABLE [ IF EXISTS ] tableName ADD constraint [ CHECK | NOCHECK ]
Exemplo
Neste exemplo, vamos adicionar uma restrição de chave primária (tutorials_tbl_pk) para o id da coluna da tabela tutorials_tbl, usando a seguinte consulta.
ALTER TABLE tutorials_tbl ADD CONSTRAINT tutorials_tbl_pk PRIMARYKEY(id);
A consulta acima produz a seguinte saída.
(6) row (s) effected
Alterar restrição de renomeação de tabela
Este comando é usado para renomear o nome da restrição de uma tabela de relação específica. Este comando confirma uma transação aberta nesta conexão.
Sintaxe
A seguir está a sintaxe genérica do comando Alterar restrição de renomeação de tabela.
ALTER TABLE [ IF EXISTS ] tableName RENAME oldConstraintName TO newConstraintName
Ao usar essa sintaxe, certifique-se de que o nome da restrição antiga deve existir com a coluna respectiva.
Exemplo
Neste exemplo, vamos mudar o nome da restrição de chave primária da tabela tutorials_tbl de tutorials_tbl_pk para tutorials_tbl_pk_constraint. A seguir está a consulta para fazer isso.
ALTER TABLE tutorials_tbl RENAME CONSTRAINT
tutorials_tbl_pk TO tutorials_tbl_pk_constraint;
A consulta acima produz a seguinte saída.
(1) row (s) effected
Alterar Tabela Alterar Coluna
Este comando é usado para alterar a estrutura e as propriedades da coluna de uma tabela específica. Alterar as propriedades significa alterar o tipo de dados de uma coluna, renomear uma coluna, alterar o valor de identidade ou alterar a seletividade.
Sintaxe
A seguir está a sintaxe genérica do comando Alterar Tabela Alterar Coluna.
ALTER TABLE [ IF EXISTS ] tableName ALTER COLUMN columnName
{ { dataType [ DEFAULT expression ] [ [ NOT ] NULL ] [ AUTO_INCREMENT | IDENTITY ] }
| { RENAME TO name }
| { RESTART WITH long }
| { SELECTIVITY int }
| { SET DEFAULT expression }
| { SET NULL }
| { SET NOT NULL } }
Na sintaxe acima -
RESTART - o comando muda o próximo valor de uma coluna de incremento automático.
SELECTIVITY- o comando define a seletividade (1-100) para uma coluna. Com base no valor de seletividade, podemos imaginar o valor da coluna.
SET DEFAULT - altera o valor padrão de uma coluna.
SET NULL - define a coluna para permitir NULL.
SET NOT NULL - define a coluna para permitir NOT NULL.
Exemplo
Neste exemplo, vamos renomear a coluna da tabela tutorials_tbl de Title para Tutorial_Title usando a seguinte consulta.
ALTER TABLE tutorials_tbl ALTER COLUMN title RENAME TO tutorial_title;
A consulta acima produz a seguinte saída.
(0) row(s) effected
De forma semelhante, podemos realizar diferentes cenários com o comando ALTER.
DROP é um comando retirado da gramática SQL genérica. Este comando é usado para excluir um componente do banco de dados e sua estrutura da memória. Existem diferentes cenários com o comando Soltar que discutiremos neste capítulo.
Drop Table
Eliminar tabela é um comando que exclui a respectiva tabela e sua estrutura.
Sintaxe
A seguir está a sintaxe genérica do comando Eliminar Tabela.
DROP TABLE [ IF EXISTS ] tableName [,...] [ RESTRICT | CASCADE ]
O comando falhará se estivermos usando RESTRICT e a tabela com visualizações dependentes existir. Todas as visualizações dependentes são eliminadas, quando estamos usando a palavra-chave CASCADE.
Exemplo
Neste exemplo, vamos eliminar uma tabela chamada test usando a seguinte consulta.
DROP TABLE test;
A consulta acima produz a seguinte saída.
(6) row (s) effected
Drop Schema
Eliminar esquema é um comando que descarta um esquema respectivo do servidor de banco de dados. Não funcionará com o esquema atual.
Sintaxe
DROP SCHEMA [ IF EXISTS ] schemaName
Exemplo
Neste exemplo, vamos eliminar um esquema chamado test_schema usando a seguinte consulta.
DROP SCHEMA TEST_SCHEMA;
A consulta acima produz a seguinte saída.
(0) row(s) effected
Sequência de queda
A sequência de descarte é um comando usado para eliminar uma sequência da estrutura da tabela.
Sintaxe
A seguir está a sintaxe genérica do comando Drop Sequence.
DROP SEQUENCE [ IF EXISTS ] sequenceName
Este comando confirma uma transação aberta nesta conexão.
Exemplo
Neste exemplo, vamos descartar uma sequência chamada sequence_id. A seguir está o comando.
DROP SEQUENCE sequence_id;
O comando acima produz a seguinte saída.
(0) row (s) effected
Drop View
Soltar visualização é um comando usado para eliminar a visualização existente. Todas as visualizações dependentes também são eliminadas se a cláusula CASCADE for usada.
Sintaxe
A seguir está a sintaxe genérica do comando Soltar Visualização.
DROP VIEW [ IF EXISTS ] viewName [ RESTRICT | CASCADE ]
Exemplo
Neste exemplo, vamos remover uma visão chamada sample_view usando a seguinte consulta.
DROP VIEW sample_view;
A consulta acima produz a seguinte saída.
(0) row (s) effected
TRUNCATE é um comando usado para excluir os dados da tabela. Ao contrário de DELETE FROM sem a cláusula WHERE, este comando não pode ser revertido. Este comando confirma uma transação aberta nesta conexão.
Sintaxe
A seguir está a sintaxe genérica do comando truncate.
TRUNCATE TABLE tableName
Exemplo
Neste exemplo, vamos truncar uma tabela chamada test usando a seguinte consulta.
TRUNCATE TABLE test;
A consulta acima produz a seguinte saída.
(6) row (s) effected
COMMIT é um comando da gramática SQL usado para confirmar a transação. Podemos confirmar a transação específica ou podemos confirmar a transação executada atualmente.
Sintaxe
Existem duas sintaxes diferentes para o comando COMMIT.
A seguir está a sintaxe genérica para o comando commit para confirmar a transação atual.
COMMIT [ WORK ]
A seguir está a sintaxe genérica para o comando commit para confirmar a transação específica.
COMMIT TRANSACTION transactionName
Exemplo 1
Neste exemplo, vamos confirmar a transação atual usando o seguinte comando.
COMMIT
O comando acima produz a seguinte saída.
Committed successfully
Exemplo 2
Neste exemplo, vamos confirmar a transação chamada tx_test usando o seguinte comando.
COMMIT TRANSACTION tx_test;
O comando acima produz a seguinte saída.
Committed successfully
Grant é um comando proveniente da gramática SQL usado para conceder os direitos a uma tabela, a um usuário ou a uma função. São necessários direitos de administrador para executar este comando. Este comando confirma uma transação aberta nesta conexão.
Neste capítulo, discutiremos os diferentes cenários do comando Grant.
Conceder direito
Conceder direito é um comando para fornecer direitos de administrador a uma tabela, a um usuário ou a uma função.
Sintaxe
A seguir está a sintaxe genérica do comando Grant.
GRANT { SELECT | INSERT | UPDATE | DELETE | ALL } [,...] ON
{ { SCHEMA schemaName } | { tableName [,...] } }
TO { PUBLIC | userName | roleName }
Exemplo
Neste exemplo, concederemos a tabela de teste como somente leitura usando o seguinte comando.
GRANT SELECT ON TEST TO READONLY
O comando acima produz a seguinte saída.
Grant successfully
Conceder alterar qualquer esquema
Grant Alter Any Schema é um comando para conceder direitos de alteração de esquema a um respectivo usuário.
Sintaxe
A seguir está a sintaxe genérica do comando Grant Alter Any Schema.
GRANT ALTER ANY SCHEMA TO userName
Exemplo
Neste exemplo, vamos conceder privilégios de alteração de um esquema a um usuário chamado test_user. Certifique-se de que test_user existe. A seguir está a consulta para conceder privilégios de alteração.
GRANT ALTER ANY SCHEMA TO test_user;
A consulta acima produz a seguinte saída.
Granted successfully to test_user
SAVEPOINT é um comando usado para salvar temporariamente a transação. É melhor manter os pontos de salvamento em sua transação, pois é útil reverter a transação para o respectivo ponto de salvamento sempre que necessário.
Sintaxe
A seguir está a sintaxe genérica do comando Savepoint.
SAVEPOINT savepointName
Exemplo
Neste exemplo, criaremos um Savepoint denominado Half_Done usando o seguinte comando.
SAVEPOINT Half_Done;
O comando acima produz a seguinte saída.
Savepoint created
ROLLBACK é um comando da gramática SQL usado para reverter a transação para um ponto de salvamento ou para a transação anterior. Usando este comando, podemos reverter para o ponto de salvamento específico ou reverter para a transação executada anteriormente.
Sintaxe
Existem duas sintaxes diferentes para o comando ROLLABCK.
A seguir está a sintaxe genérica para o comando rollback.
ROLLBACK [ TO SAVEPOINT savepointName ]
A seguir está a sintaxe genérica do comando Rollback para a transação específica.
ROLLBACK TRANSACTION transactionName
Exemplo 1
Neste exemplo, vamos reverter a transação atual para um ponto de salvamento chamado sp1_test usando o seguinte comando.
ROLLBACK sp1_test;
O comando acima produz a seguinte saída.
Rollback successfully
Exemplo 2
No exemplo a seguir, vamos reverter a transação completa chamada tx_test usando o comando fornecido.
ROLLBACK TRANSACTION tx_test;
O comando acima produz a seguinte saída.
Rollback successfully
H2 é um banco de dados JAVA. Podemos interagir com este banco de dados usando JDBC. Neste capítulo, veremos como criar uma conexão JDBC com o banco de dados H2 e as operações CRUD com o banco de dados H2.
Geralmente, existem cinco etapas para criar uma conexão JDBC.
Step 1 - Registrando o driver de banco de dados JDBC.
Class.forName ("org.h2.Driver");
Step 2 - Abrindo a conexão.
Connection conn = DriverManager.getConnection ("jdbc:h2:~/test", "sa","");
Step 3 - Criar uma declaração.
Statement st = conn.createStatement();
Step 4 - Executando uma declaração e recebendo o Resultset.
Stmt.executeUpdate("sql statement");
Step 5 - Fechando uma conexão.
conn.close();
Antes de prosseguirmos para criar um programa completo, precisamos adicionar h2-1.4.192.jar filepara CLASSPATH. Nós podemos pegar issojar da pasta C:\Program Files (x86)\H2\bin.
Criar a tabela
Neste exemplo, vamos escrever um programa para criar tabela. Considere uma mesa chamadaRegistration tendo os seguintes campos.
S.No | Nome da coluna | Tipo de dados | NÃO NULO | Chave primária |
---|---|---|---|---|
1 | EU IRIA | Número | sim | sim |
2 | Primeiro | Varchar (255) | Não | Não |
3 | Último | Varchar (255) | Não | Não |
4 | Era | Número | Não | Não |
A seguir está um programa de exemplo chamado H2jdbcCreateDemo.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class H2jdbcCreateDemo {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "org.h2.Driver";
static final String DB_URL = "jdbc:h2:~/test";
// Database credentials
static final String USER = "sa";
static final String PASS = "";
public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
try {
// STEP 1: Register JDBC driver
Class.forName(JDBC_DRIVER);
//STEP 2: Open a connection
System.out.println("Connecting to database...");
conn = DriverManager.getConnection(DB_URL,USER,PASS);
//STEP 3: Execute a query
System.out.println("Creating table in given database...");
stmt = conn.createStatement();
String sql = "CREATE TABLE REGISTRATION " +
"(id INTEGER not NULL, " +
" first VARCHAR(255), " +
" last VARCHAR(255), " +
" age INTEGER, " +
" PRIMARY KEY ( id ))";
stmt.executeUpdate(sql);
System.out.println("Created table in given database...");
// STEP 4: Clean-up environment
stmt.close();
conn.close();
} catch(SQLException se) {
//Handle errors for JDBC
se.printStackTrace();
} catch(Exception e) {
//Handle errors for Class.forName
e.printStackTrace();
} finally {
//finally block used to close resources
try{
if(stmt!=null) stmt.close();
} catch(SQLException se2) {
} // nothing we can do
try {
if(conn!=null) conn.close();
} catch(SQLException se){
se.printStackTrace();
} //end finally try
} //end try
System.out.println("Goodbye!");
}
}
Salve o programa acima em H2jdbcCreateDemo.java. Compile e execute o programa acima executando os seguintes comandos no prompt de comando.
\>javac H2jdbcCreateDemo.java
\>java H2jdbcCreateDemo
O comando acima produz a seguinte saída.
Connecting to database...
Creating table in given database...
Created table in given database...
Goodbye!
Após esta execução, podemos verificar a tabela criada usando a interface H2 SQL.
Inserir registros
Neste exemplo, vamos escrever um programa para inserir registros. Vamos inserir os seguintes registros na tabela Registro.
EU IRIA | Primeiro | Último | Era |
---|---|---|---|
100 | Zara | Todos | 18 |
101 | Mahnaz | Fatma | 25 |
102 | Zaid | Khan | 30 |
103 | Sumit | Mital | 28 |
A seguir está um programa de exemplo chamado H2jdbcInsertDemo.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class H2jdbcInsertDemo {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "org.h2.Driver";
static final String DB_URL = "jdbc:h2:~/test";
// Database credentials
static final String USER = "sa";
static final String PASS = "";
public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
try{
// STEP 1: Register JDBC driver
Class.forName(JDBC_DRIVER);
// STEP 2: Open a connection
System.out.println("Connecting to a selected database...");
conn = DriverManager.getConnection(DB_URL,USER,PASS);
System.out.println("Connected database successfully...");
// STEP 3: Execute a query
stmt = conn.createStatement();
String sql = "INSERT INTO Registration " + "VALUES (100, 'Zara', 'Ali', 18)";
stmt.executeUpdate(sql);
sql = "INSERT INTO Registration " + "VALUES (101, 'Mahnaz', 'Fatma', 25)";
stmt.executeUpdate(sql);
sql = "INSERT INTO Registration " + "VALUES (102, 'Zaid', 'Khan', 30)";
stmt.executeUpdate(sql);
sql = "INSERT INTO Registration " + "VALUES(103, 'Sumit', 'Mittal', 28)";
stmt.executeUpdate(sql);
System.out.println("Inserted records into the table...");
// STEP 4: Clean-up environment
stmt.close();
conn.close();
} catch(SQLException se) {
// Handle errors for JDBC
se.printStackTrace();
} catch(Exception e) {
// Handle errors for Class.forName
e.printStackTrace();
} finally {
// finally block used to close resources
try {
if(stmt!=null) stmt.close();
} catch(SQLException se2) {
} // nothing we can do
try {
if(conn!=null) conn.close();
} catch(SQLException se) {
se.printStackTrace();
} // end finally try
} // end try
System.out.println("Goodbye!");
}
}
Salve o programa acima em H2jdbcInsertDemo.java. Compile e execute o programa acima executando os seguintes comandos no prompt de comando.
\>javac H2jdbcInsertDemo.java
\>java H2jdbcInsertDemo
O comando acima produz a seguinte saída.
Connecting to a selected database...
Connected database successfully...
Inserted records into the table...
Goodbye!
Ler registro
Neste exemplo, vamos escrever um programa para ler registros. Vamos tentar ler todos os registros da tabelaRegistration.
A seguir está um programa de exemplo chamado H2jdbcRecordDemo.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class H2jdbcReadDemo {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "org.h2.Driver";
static final String DB_URL = "jdbc:h2:~/test";
// Database credentials
static final String USER = "sa";
static final String PASS = "";
public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
try {
// STEP 1: Register JDBC driver
Class.forName(JDBC_DRIVER);
// STEP 2: Open a connection
System.out.println("Connecting to database...");
conn = DriverManager.getConnection(DB_URL,USER,PASS);
// STEP 3: Execute a query
System.out.println("Connected database successfully...");
stmt = conn.createStatement();
String sql = "SELECT id, first, last, age FROM Registration";
ResultSet rs = stmt.executeQuery(sql);
// STEP 4: Extract data from result set
while(rs.next()) {
// Retrieve by column name
int id = rs.getInt("id");
int age = rs.getInt("age");
String first = rs.getString("first");
String last = rs.getString("last");
// Display values
System.out.print("ID: " + id);
System.out.print(", Age: " + age);
System.out.print(", First: " + first);
System.out.println(", Last: " + last);
}
// STEP 5: Clean-up environment
rs.close();
} catch(SQLException se) {
// Handle errors for JDBC
se.printStackTrace();
} catch(Exception e) {
// Handle errors for Class.forName
e.printStackTrace();
} finally {
// finally block used to close resources
try {
if(stmt!=null) stmt.close();
} catch(SQLException se2) {
} // nothing we can do
try {
if(conn!=null) conn.close();
} catch(SQLException se) {
se.printStackTrace();
} // end finally try
} // end try
System.out.println("Goodbye!");
}
}
Salve o programa acima em H2jdbcReadDemo.java. Compile e execute o programa acima executando os seguintes comandos no prompt de comando.
\>javac H2jdbcReadDemo.java
\>java H2jdbcReadDemo
O comando acima produz a seguinte saída.
Connecting to a selected database...
Connected database successfully...
ID: 100, Age: 18, First: Zara, Last: Ali
ID: 101, Age: 25, First: Mahnaz, Last: Fatma
ID: 102, Age: 30, First: Zaid, Last: Khan
ID: 103, Age: 28, First: Sumit, Last: Mittal
Goodbye!
Atualizar registros
Neste exemplo, vamos escrever um programa para atualizar os registros. Vamos tentar ler todos os registros da tabelaRegistration.
A seguir está um programa de exemplo chamado H2jdbcUpdateDemo.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class H2jdbcUpdateDemo {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "org.h2.Driver";
static final String DB_URL = "jdbc:h2:~/test";
// Database credentials
static final String USER = "sa";
static final String PASS = "";
public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
try {
// STEP 1: Register JDBC driver
Class.forName(JDBC_DRIVER);
// STEP 2: Open a connection
System.out.println("Connecting to a database...");
conn = DriverManager.getConnection(DB_URL,USER,PASS);
// STEP 3: Execute a query
System.out.println("Connected database successfully...");
stmt = conn.createStatement();
String sql = "UPDATE Registration " + "SET age = 30 WHERE id in (100, 101)";
stmt.executeUpdate(sql);
// Now you can extract all the records
// to see the updated records
sql = "SELECT id, first, last, age FROM Registration";
ResultSet rs = stmt.executeQuery(sql);
while(rs.next()){
// Retrieve by column name
int id = rs.getInt("id");
int age = rs.getInt("age");
String first = rs.getString("first");
String last = rs.getString("last");
// Display values
System.out.print("ID: " + id);
System.out.print(", Age: " + age);
System.out.print(", First: " + first);
System.out.println(", Last: " + last);
}
rs.close();
} catch(SQLException se) {
// Handle errors for JDBC
se.printStackTrace();
} catch(Exception e) {
// Handle errors for Class.forName
e.printStackTrace();
} finally {
// finally block used to close resources
try {
if(stmt!=null) stmt.close();
} catch(SQLException se2) {
} // nothing we can do
try {
if(conn!=null) conn.close();
} catch(SQLException se) {
se.printStackTrace();
} // end finally try
} // end try
System.out.println("Goodbye!");
}
}
Salve o programa acima em H2jdbcUpdateDemo.java. Compile e execute o programa acima executando os seguintes comandos no prompt de comando.
\>javac H2jdbcUpdateDemo.java
\>java H2jdbcUpdateDemo
O comando acima produz a seguinte saída.
Connecting to a selected database...
Connected database successfully...
ID: 100, Age: 30, First: Zara, Last: Ali
ID: 101, Age: 30, First: Mahnaz, Last: Fatma
ID: 102, Age: 30, First: Zaid, Last: Khan
ID: 103, Age: 28, First: Sumit, Last: Mittal
Goodbye!
Excluir registros
Neste exemplo, escreveremos um programa para excluir registros. Vamos tentar ler todos os registros da tabelaRegistration.
A seguir está um programa de exemplo chamado H2jdbcDeleteDemo.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class H2jdbcDeleteDemo {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "org.h2.Driver";
static final String DB_URL = "jdbc:h2:~/test";
// Database credentials
static final String USER = "sa";
static final String PASS = "";
public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
try {
// STEP 1: Register JDBC driver
Class.forName(JDBC_DRIVER);
// STEP 2: Open a connection
System.out.println("Connecting to database...");
conn = DriverManager.getConnection(DB_URL,USER,PASS);
// STEP 3: Execute a query
System.out.println("Creating table in given database...");
stmt = conn.createStatement();
String sql = "DELETE FROM Registration " + "WHERE id = 101";
stmt.executeUpdate(sql);
// Now you can extract all the records
// to see the remaining records
sql = "SELECT id, first, last, age FROM Registration";
ResultSet rs = stmt.executeQuery(sql);
while(rs.next()){
// Retrieve by column name
int id = rs.getInt("id");
int age = rs.getInt("age");
String first = rs.getString("first");
String last = rs.getString("last");
// Display values
System.out.print("ID: " + id);
System.out.print(", Age: " + age);
System.out.print(", First: " + first);
System.out.println(", Last: " + last);
}
rs.close();
} catch(SQLException se) {
// Handle errors for JDBC
se.printStackTrace();
} catch(Exception e) {
// Handle errors for Class.forName
e.printStackTrace();
} finally {
// finally block used to close resources
try {
if(stmt!=null) stmt.close();
} catch(SQLException se2) {
} // nothing we can do
try {
if(conn!=null) conn.close();
} catch(SQLException se) {
se.printStackTrace();
} // end finally try
} // end try
System.out.println("Goodbye!");
}
}
Salve o programa acima em H2jdbcDeleteDemo.java. Compile e execute o programa acima executando os seguintes comandos no prompt de comando.
\>javac H2jdbcDeleteDemo.java
\>java H2jdbcDeleteDemo
O comando acima produz a seguinte saída.
Connecting to a selected database...
Connected database successfully...
ID: 100, Age: 30, First: Zara, Last: Ali
ID: 102, Age: 30, First: Zaid, Last: Khan
ID: 103, Age: 28, First: Sumit, Last: Mittal
Goodbye!