Base de datos H2 - Guía rápida

H2 es una base de datos Java ligera de código abierto. Puede integrarse en aplicaciones Java o ejecutarse en modo cliente-servidor. Básicamente, la base de datos H2 se puede configurar para que se ejecute como una base de datos inmemory, lo que significa que los datos no persistirán en el disco. Debido a la base de datos incorporada, no se utiliza para el desarrollo de producción, sino que se utiliza principalmente para desarrollo y pruebas.

Esta base de datos se puede utilizar en modo integrado o en modo servidor. Las siguientes son las características principales de la base de datos H2:

  • API JDBC de código abierto extremadamente rápido
  • Disponible en modo integrado y de servidor; bases de datos en memoria
  • Aplicación de consola basada en navegador
  • Tamaño reducido: aproximadamente 1,5 MB de tamaño de archivo jar

Características de la base de datos H2

Las principales características de H2 Database son las siguientes:

  • Es un motor de base de datos extremadamente rápido.

  • H2 es de código abierto y está escrito en Java.

  • Es compatible con la API estándar de SQL y JDBC. También puede usar el controlador ODBC de PostgreSQL.

  • Tiene modo integrado y servidor.

  • Soportes H2 clustering y multi-version concurrency.

  • Tiene fuertes características de seguridad.

Características adicionales

A continuación se muestran algunas características adicionales de H2 Database:

  • H2 es una base de datos y tablas basada en disco o en memoria, soporte de base de datos de solo lectura, tablas temporales.

  • H2 proporciona soporte para transacciones (lectura confirmada), múltiples conexiones de confirmación en 2 fases, bloqueo a nivel de tabla.

  • H2 es un optimizador basado en costos, que utiliza un algoritmo genético para consultas complejas, sin administración.

  • H2 contiene soporte de conjunto de resultados desplazable y actualizable, conjunto de resultados grande, clasificación de resultados externos, las funciones pueden devolver un conjunto de resultados.

  • H2 admite bases de datos cifradas (AES), cifrado de contraseña SHA-256, funciones de cifrado y SSL.

Componentes en la base de datos H2

Para utilizar la base de datos H2, debe tener los siguientes componentes:

  • Un navegador web
  • Un servidor de consola H2

Esta es una aplicación cliente / servidor, por lo que tanto el servidor como el cliente (un navegador) son necesarios para ejecutarla.

H2 es una base de datos escrita en Java. Podemos incrustar fácilmente esta base de datos en nuestra aplicación utilizando JDBC. Podemos ejecutar esto en muchas plataformas diferentes o en cualquier versión de Java Runtime Environment. Sin embargo, antes de instalar la base de datos, debe haber Java instalado en el sistema.

Verificar la instalación de Java

Si JDK está instalado en el sistema, pruebe el siguiente comando para verificar la versión de Java.

java –version

Si JDk se instaló correctamente en el sistema, obtendremos el siguiente resultado.

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)

Si JDK no está instalado en el sistema, visite el siguiente enlace para instalar JDK .

Instalar base de datos H2

Podemos ejecutar esta base de datos en muchas plataformas diferentes. En este capítulo, aprenderemos sobre la instalación de la base de datos H2 en Windows.

Los siguientes son los pasos para instalar H2 Database en el sistema operativo Windows.

Paso 1: descargue el archivo de instalación H2

Descargue la última versión de H2 Database desde el enlace proporcionado. En este enlace, obtendrá la última versión de la base de datos H2 en dos tipos. Uno es el tipo de Windows Installer (es decir, un archivo .exe) y el segundo es un archivo zip independiente de la plataforma para otros sistemas operativos.

Haga clic en el instalador de Windows para descargar la base de datos H2 compatible con Windows después de descargar el archivo .exe. En este caso, estamos usando H2 Database con la versión 1.4.192.

Paso 2: Instale la base de datos H2

Después de descargar, obtenemos el archivo instalador H2 de Windows (es decir, h2-setup-aaaa-mm-dd.exe) en el directorio de Descargas. Para iniciar el proceso de instalación de H2 Database, haga doble clic en el archivo de instalación.

La siguiente pantalla es el primer paso del proceso de instalación. Proporcione una ruta donde queremos instalar el servidor de base de datos H2 como se muestra en la siguiente captura de pantalla.

Como se ve en la captura de pantalla anterior, por defecto tomará C:\ProgramFiles (x86)\H2como carpeta de destino. Haga clic en siguiente para continuar con el siguiente paso. Aparece la siguiente pantalla.

En la captura de pantalla anterior, haga clic en el botón Instalar para iniciar el proceso de instalación. Después de la instalación, obtenemos la siguiente captura de pantalla.

Haga clic en Finalizar para completar el proceso de instalación.

Paso 3: verificar la instalación de la base de datos H2

Después de la instalación, verifiquemos la instalación de la base de datos en el sistema. Haga clic en Windows → escriba H2 Console → Haga clic en el icono de la consola H2. Conectarse a la URLhttp://localhost:8082. En el momento de la conexión, la base de datos H2 solicitará el registro de la base de datos como se muestra en la siguiente captura de pantalla.

Complete todos los detalles en el cuadro de diálogo anterior, como Configuración guardada, Nombre de configuración, Clase de controlador, URL de JDBC, Nombre de usuario y Contraseña. En la URL de JDBC, especifique la ubicación de la base de datos y el nombre de la base de datos. El nombre de usuario y la contraseña son los campos para el nombre de usuario y la contraseña de la base de datos. Haga clic en Conectar.

Aparecerá la página de bienvenida de la base de datos como se muestra en la siguiente captura de pantalla.

El comando Seleccionar se utiliza para obtener datos de registro de una tabla o de varias tablas. Si diseñamos una consulta de selección, devuelve datos en forma de tabla de resultados llamadaresult sets.

Sintaxis

La sintaxis básica de la instrucción SELECT es la siguiente:

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 obtener todos los campos disponibles, utilice la siguiente sintaxis.

SELECT * FROM table_name;

Ejemplo

Considere la tabla CLIENTE que tiene los siguientes 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 obtener la tabla de clientes junto con los datos proporcionados, ejecute las siguientes 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);

El siguiente comando es un ejemplo, que buscaría los campos ID, Nombre y Salario de los clientes disponibles en la tabla CLIENTE.

SELECT ID, NAME, SALARY FROM CUSTOMERS;

El comando anterior produce el siguiente 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 | 
+----+----------+----------+

Utilice la siguiente consulta para obtener todos los campos de la tabla CLIENTES.

SQL> SELECT * FROM CUSTOMERS;

La consulta anterior produce el siguiente 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 | 
+----+----------+-----+-----------+----------+

La instrucción SQL INSERT se usa para agregar nuevas filas de datos a una tabla en la base de datos.

Sintaxis

A continuación se muestra la sintaxis básica de la instrucción INSERT INTO.

INSERT INTO tableName 
{ [ ( columnName [,...] ) ] 
{ VALUES 
{ ( { DEFAULT | expression } [,...] ) } [,...] | [ DIRECT ] [ SORTED ] select } } | 
{ SET { columnName = { DEFAULT | expression } } [,...] }

Usando esta instrucción INSERT, podemos insertar un nuevo registro o nuevas filas en una tabla. Cuando se usa la cláusula DIRECT, los resultados se ven afectados directamente por la tabla de destino sin ningún paso intermedio. Sin embargo, al agregar valores para todas las columnas de la tabla, asegúrese de que el orden de los valores esté en el mismo orden que las columnas de la tabla.

Ejemplo

Tomemos un ejemplo e intentemos insertar los siguientes registros dados en la tabla Cliente.

CARNÉ DE IDENTIDAD Nombre Años Habla a Salario
1 Ramesh 32 Ahmedabad 2000
2 Khilan 25 Delhi 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 10000

Podemos obtener todos los registros dados en la tabla de clientes ejecutando los siguientes 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);

La consulta UPDATE se utiliza para actualizar o modificar los registros existentes en una tabla. Podemos usar la cláusula WHERE con la consulta UPDATE para actualizar las filas seleccionadas, de lo contrario todas las filas se verían afectadas.

Sintaxis

A continuación se muestra la sintaxis básica de la consulta UPDATE.

UPDATE tableName [ [ AS ] newTableAlias ] SET 
{ { columnName = { DEFAULT | expression } } [,...] } | 
{ ( columnName [,...] ) = ( select ) } 
[ WHERE expression ] [ ORDER BY order [,...] ] [ LIMIT expression ]

En esta sintaxis UPDATE, podemos combinar más de una condición usando cláusulas AND u OR.

Ejemplo

Considere que la tabla CLIENTE tiene los siguientes 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 | 
+----+----------+-----+-----------+----------+

Si desea obtener la tabla de clientes junto con los datos proporcionados, ejecute las siguientes 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);

El siguiente comando es un ejemplo, que actualizaría ADDRESS para un cliente cuyo ID es 6 -

UPDATE CUSTOMERS SET ADDRESS = 'Pune' WHERE ID = 6;

Ahora, la tabla CUSTOMERS tendría los siguientes registros. Podemos comprobar los registros de la tabla de clientes ejecutando la siguiente consulta.

SELECT * FROM CUSTOMERS;

La consulta anterior produce el siguiente 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 los valores de las columnas ADDRESS y SALARY en la tabla CUSTOMERS, no necesitamos usar la cláusula WHERE. La consulta ACTUALIZAR sería la siguiente:

UPDATE CUSTOMERS SET ADDRESS = 'Pune', SALARY = 1000.00;

Ahora, la tabla CUSTOMERS tendría los siguientes registros. Podemos comprobar los registros de la tabla de clientes ejecutando la siguiente consulta.

SELECT * FROM CUSTOMERS;

La consulta anterior produce el siguiente 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 | 
+----+----------+-----+---------+---------+

La consulta SQL DELETE se utiliza para eliminar los registros existentes de una tabla. Podemos usar la cláusula WHERE con la consulta DELETE para eliminar los registros seleccionados; de lo contrario, se eliminarán todos los registros.

Sintaxis

A continuación se muestra la sintaxis de consulta genérica del comando de eliminación.

DELETE [ TOP term ] FROM tableName [ WHERE expression ] [ LIMIT term ]

La sintaxis anterior elimina las filas de una tabla. Si se especifica TOP o LIMIT, como máximo se elimina el número especificado de filas (sin límite si es nulo o menor que cero).

Ejemplo

Considere que la tabla CLIENTE tiene los siguientes 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 | 
+----+----------+-----+-----------+----------+

El siguiente comando eliminará los detalles del cliente, cuyo ID es 6.

DELETE FROM CUSTOMERS WHERE ID = 6;

Después de ejecutar el comando anterior, verifique la tabla de Clientes ejecutando el siguiente comando.

SELECT * FROM CUSTOMERS;

El comando anterior produce la siguiente salida:

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

Si queremos BORRAR todos los registros de la tabla CUSTOMERS, no usamos la cláusula WHERE. La consulta DELETE sería la siguiente.

DELETE FROM CUSTOMER;

Después de ejecutar el comando anterior, no habrá registros disponibles en la tabla Cliente.

BACKUP es el comando que se utiliza para guardar la copia de seguridad de la base de datos en un archivo .zip separado. Los objetos no están bloqueados y, cuando se realiza una copia de seguridad, también se copia el registro de transacciones. Se requieren derechos de administrador para ejecutar este comando.

Sintaxis

A continuación se muestra la sintaxis genérica del comando Copia de seguridad.

BACKUP TO fileNameString;

Ejemplo

En este ejemplo, tomemos una copia de seguridad de la base de datos actual en backup.ziparchivo. Utilice el siguiente comando para lo mismo.

BACKUP TO 'backup.zip';

Al ejecutar el comando anterior, obtendrá el archivo backup.zip en su sistema de archivos local.

CALL es un comando SQL que pertenece al servidor de base de datos H2. Este comando se usa para calcular una expresión simple. Devuelve el resultado de la expresión dada en un campo de una sola columna. Cuando devuelve una matriz de resultados, cada elemento de la matriz se muestra como un valor de columna.

Sintaxis

A continuación se muestra la sintaxis genérica del comando CALL.

CALL expression;

Podemos usar la expresión aritmética en esta sintaxis.

Ejemplo

Tomemos un ejemplo y ejecutemos una expresión aritmética (15 * 25) usando el comando de llamada.

CALL 15*25;

El comando anterior produce la siguiente salida.

375
375

El comando EXPLAIN muestra el plan de ejecución de una declaración. Cuando ejecutamos una declaración usando el comando EXPLAIN ANALYZE, el plan de consulta incluirá el recuento real de escaneo de filas para cada tabla.

Sintaxis

A continuación se muestra la sintaxis genérica del comando EXPLAIN.

EXPLAIN { [ PLAN FOR ] | ANALYZE } { select | insert | update | delete | merge}

Junto con esta sintaxis podemos usar seleccionar, insertar, eliminar y fusionar.

Ejemplo

Este ejemplo explica los detalles del plan de consulta del cliente con ID 1.

EXPLAIN SELECT * FROM CUSTOMER WHERE ID = 1;

El comando anterior produce la siguiente salida:

El comando MERGE se usa para actualizar las filas existentes e insertar nuevas filas en una tabla. La columna de la clave principal juega un papel importante al usar este comando; se usa para encontrar la fila.

Sintaxis

A continuación se muestra la sintaxis genérica del comando MERGE.

MERGE INTO tableName [ ( columnName [,...] ) ] 
[ KEY ( columnName [,...] ) ] 
{ VALUES { ( { DEFAULT | expression } [,...] ) } [,...] | select }

En la sintaxis anterior, la cláusula KEY se usa para especificar el nombre de la columna de clave primaria. Junto con la cláusula VALUES, podemos usar valores primitivos para insertar o podemos recuperar y almacenar valores de otra tabla en esta tabla usando el comando select.

Ejemplo

En este ejemplo, intentemos agregar un nuevo registro a la tabla Clientes. A continuación se muestran los detalles del nuevo registro en la tabla.

Nombre de columna Valor
CARNÉ DE IDENTIDAD 8
NOMBRE Lokesh
AÑOS 32
HABLA A Hyderabad
SALARIO 2500

Usando la siguiente consulta, insertemos el registro dado en la consulta de la base de datos H2.

MERGE INTO CUSTOMER KEY (ID) VALUES (8, 'Lokesh', 32, 'Hyderabad', 2500);

La consulta anterior produce el siguiente resultado.

Update count: 1

Verifiquemos los registros de la tabla Customer ejecutando la siguiente consulta.

SELECT * FROM CUSTOMER;

La consulta anterior produce el siguiente resultado.

CARNÉ DE IDENTIDAD Nombre Años Habla a Salario
1 Ramesh 32 Ahmedabad 2000
2 Khilan 25 Delhi 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 10000
8 Lokesh 32 Hyderabad 2500

Ahora intentemos actualizar el registro usando el Mergemando. A continuación se muestran los detalles del registro que se actualizará.

Nombre de columna Valor
CARNÉ DE IDENTIDAD 8
NOMBRE Loki
AÑOS 32
HABLA A Hyderabad
SALARIO 3000

Utilice la siguiente consulta para insertar el registro dado en la consulta de la base de datos H2.

MERGE INTO CUSTOMER KEY (ID) VALUES (8, 'Loki', 32, 'Hyderabad', 3000);

La consulta anterior produce el siguiente resultado.

Update count: 1

Verifiquemos los registros de la tabla Customer ejecutando la siguiente consulta.

SELECT * FROM CUSTOMER;

La consulta anterior produce el siguiente resultado:

CARNÉ DE IDENTIDAD Nombre Años Habla a Salario
1 Ramesh 32 Ahmedabad 2000
2 Khilan 25 Delhi 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 10000
8 Loki 32 Hyderabad 3000

MOSTRAR es un comando que se utiliza para mostrar la lista de esquemas, tablas o columnas de la tabla.

Sintaxis

A continuación se muestra la sintaxis genérica del comando SHOW.

SHOW { SCHEMAS | TABLES [ FROM schemaName ] | 
COLUMNS FROM tableName [ FROM schemaName ] }

Ejemplo

El siguiente comando se puede utilizar para obtener la lista de tablas en la base de datos actual.

SHOW TABLES;

El comando anterior produce la siguiente salida.

NOMBRE DE LA TABLA TABLE_SCHEMA
CLIENTE PÚBLICO
EMP PÚBLICO

CREAR es un comando SQL genérico que se utiliza para crear tablas, esquemas, secuencias, vistas y usuarios en el servidor de base de datos H2.

Crear mesa

Crear tabla es un comando que se utiliza para crear una tabla definida por el usuario en la base de datos actual.

Sintaxis

A continuación se muestra la sintaxis genérica del comando Crear tabla.

CREATE [ CACHED | MEMORY ] [ TEMP | [ GLOBAL | LOCAL ] TEMPORARY ] 
TABLE [ IF NOT EXISTS ] name 
[ ( { columnDefinition | constraint } [,...] ) ] 
[ ENGINE tableEngineName [ WITH tableEngineParamName [,...] ] ] 
[ NOT PERSISTENT ] [ TRANSACTIONAL ] 
[ AS select ]

Al usar la sintaxis genérica del comando Crear tabla, podemos crear diferentes tipos de tablas, como tablas en caché, tablas de memoria y tablas temporales. A continuación se muestra la lista para describir diferentes cláusulas de la sintaxis dada.

  • CACHED- Las tablas en caché son el tipo predeterminado para tablas regulares. Esto significa que el número de filas no está limitado por la memoria principal.

  • MEMORY- Las tablas de memoria son el tipo predeterminado para tablas temporales. Esto significa que las tablas de memoria no deben ser demasiado grandes y los datos del índice se guardan en la memoria principal.

  • TEMPORARY- Las tablas temporales se eliminan al cerrar o abrir una base de datos. Básicamente, las tablas temporales son de dos tipos:

    • Tipo GLOBAL - Accesible por todas las conexiones.

    • Tipo LOCAL: accesible mediante la conexión actual.

    El tipo predeterminado para tablas temporales es el tipo global. Los índices de tablas temporales se guardan en la memoria principal, a menos que la tabla temporal se cree usando CREATE CACHED TABLE.

  • ENGINE - La opción ENGINE solo es necesaria cuando se utilizan implementaciones de tablas personalizadas.

  • NOT PERSISTENT - Es un modificador para mantener los datos completos de la tabla en la memoria y todas las filas se pierden cuando se cierra la base de datos.

  • TRANSACTIONAL - Es una palabra clave que confirma una transacción abierta y este comando solo admite tablas temporales.

Ejemplo

En este ejemplo, creemos una tabla llamada tutorials_tbl usando los siguientes datos dados.

No Señor Nombre de columna Tipo de datos
1 CARNÉ DE IDENTIDAD En t
2 Título Varchar (50)
3 Autor Varchar (20)
4 Día de entrega Fecha

La siguiente consulta se utiliza para crear una tabla. tutorials_tbl junto con los datos de columna dados.

CREATE TABLE tutorials_tbl ( 
   id INT NOT NULL, 
   title VARCHAR(50) NOT NULL, 
   author VARCHAR(20) NOT NULL, 
   submission_date DATE 
);

La consulta anterior produce el siguiente resultado.

(0) rows effected

Crear esquema

Crear esquema es un comando que se usa para crear un esquema dependiente del usuario bajo una autorización particular (bajo el usuario registrado actualmente).

Sintaxis

A continuación se muestra la sintaxis genérica del comando Crear esquema.

CREATE SCHEMA [ IF NOT EXISTS ] name [ AUTHORIZATION ownerUserName ]

En la sintaxis genérica anterior, AUTORIZACIÓN es una palabra clave utilizada para proporcionar el nombre de usuario respectivo. Este comando es opcional, lo que significa que si no proporcionamos el nombre de usuario, considerará al usuario actual. El usuario que ejecuta el comando debe tener derechos de administrador, así como el propietario.

Este comando confirma una transacción abierta en esta conexión.

Ejemplo

En este ejemplo, creemos un esquema llamado test_schema bajo el usuario de SA, usando el siguiente comando.

CREATE SCHEMA test_schema AUTHORIZATION sa;

El comando anterior produce la siguiente salida.

(0) rows effected

Crear secuencia

La secuencia es un concepto que se utiliza para generar un número siguiendo una secuencia para id o cualquier valor de columna aleatorio.

Sintaxis

A continuación se muestra la sintaxis genérica del comando de creación de secuencia.

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 sintaxis genérica se utiliza para crear una secuencia. El tipo de datos de una secuencia esBIGINT. En esta secuencia, los valores nunca se reutilizan, incluso cuando la transacción se restituye.

Ejemplo

En este ejemplo, creemos una secuencia llamada SEQ_ID, utilizando la siguiente consulta.

CREATE SEQUENCE SEQ_ID;

La consulta anterior produce el siguiente resultado.

(0) rows effected

ALTER es un comando que se usa para cambiar la estructura de la tabla agregando diferentes cláusulas al altermando. Según el escenario, necesitamos agregar la cláusula respectiva al comando alter. En este capítulo, discutiremos varios escenarios de alter command.

Modificar tabla Agregar

Alter Table Add es un comando que se utiliza para agregar una nueva columna a una tabla junto con el tipo de datos correspondiente. Este comando confirma la transacción en esta conexión.

Sintaxis

A continuación se muestra la sintaxis genérica del comando Alter Table Add.

ALTER TABLE [ IF EXISTS ] tableName ADD [ COLUMN ] 
{ [ IF NOT EXISTS ] columnDefinition [ { BEFORE | AFTER } columnName ] 
   | ( { columnDefinition } [,...] ) }

Ejemplo

En este ejemplo, agregaremos una nueva columna start_date a la mesa tutorials_tbl. El tipo de datos para fecha_inicio es Fecha. A continuación se muestra la consulta para agregar una nueva columna.

ALTER TABLE tutorials_tbl ADD start_date DATE;

La consulta anterior produce el siguiente resultado.

(6) rows effected

Modificar tabla Agregar restricción

Alterar tabla agregar restricción es un comando que se usa para agregar diferentes restricciones a la tabla, como clave primaria, clave externa, no nula, etc.

Los índices necesarios se crean automáticamente si aún no existen. No es posible deshabilitar la comprobación de restricciones únicas. Este comando confirma una transacción abierta en esta conexión.

Sintaxis

A continuación se muestra la sintaxis genérica del comando Alterar tabla para agregar restricción.

ALTER TABLE [ IF EXISTS ] tableName ADD constraint [ CHECK | NOCHECK ]

Ejemplo

En este ejemplo, agreguemos una restricción de clave primaria (tutorials_tbl_pk) a la identificación de la columna de la tabla tutorials_tbl, utilizando la siguiente consulta.

ALTER TABLE tutorials_tbl ADD CONSTRAINT tutorials_tbl_pk PRIMARYKEY(id);

La consulta anterior produce el siguiente resultado.

(6) row (s) effected

Modificar la restricción de cambio de nombre de la tabla

Este comando se usa para cambiar el nombre de la restricción de una tabla de relaciones en particular. Este comando confirma una transacción abierta en esta conexión.

Sintaxis

A continuación se muestra la sintaxis genérica del comando Modificar restricción de cambio de nombre de tabla.

ALTER TABLE [ IF EXISTS ] tableName RENAME oldConstraintName TO newConstraintName

Mientras usa esta sintaxis, asegúrese de que el nombre de la restricción anterior exista con la columna respectiva.

Ejemplo

En este ejemplo, cambiaremos el nombre de restricción de clave principal de la tabla. tutorials_tbl desde tutorials_tbl_pk a tutorials_tbl_pk_constraint. A continuación se muestra la consulta para hacerlo.

ALTER TABLE tutorials_tbl RENAME CONSTRAINT 
tutorials_tbl_pk TO tutorials_tbl_pk_constraint;

La consulta anterior produce el siguiente resultado.

(1) row (s) effected

Alterar la tabla Alter la columna

Este comando se utiliza para cambiar la estructura y las propiedades de la columna de una tabla en particular. Cambiar las propiedades significa cambiar el tipo de datos de una columna, cambiar el nombre de una columna, cambiar el valor de identidad o cambiar la selectividad.

Sintaxis

A continuación se muestra la sintaxis genérica del comando Modificar tabla Modificar columna.

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

En la sintaxis anterior:

  • RESTART - el comando cambia el siguiente valor de una columna de incremento automático.

  • SELECTIVITY- El comando establece la selectividad (1-100) para una columna. Basándonos en el valor de selectividad, podemos visualizar el valor de la columna.

  • SET DEFAULT : Cambia el valor predeterminado de una columna.

  • SET NULL : Establece la columna para permitir NULL.

  • SET NOT NULL : Establece la columna para permitir NOT NULL.

Ejemplo

En este ejemplo, cambiaremos el nombre de la columna de la tabla. tutorials_tbl desde Title a Tutorial_Title utilizando la siguiente consulta.

ALTER TABLE tutorials_tbl ALTER COLUMN title RENAME TO tutorial_title;

La consulta anterior produce el siguiente resultado.

(0) row(s) effected

De manera similar, podemos realizar diferentes escenarios con el comando ALTER.

DROP es un comando tomado de la gramática SQL genérica. Este comando se utiliza para eliminar un componente de la base de datos y su estructura de la memoria. Hay diferentes escenarios con el comando Soltar que discutiremos en este capítulo.

Mesa plegable

Drop Table es un comando que elimina la tabla respectiva y su estructura.

Sintaxis

A continuación se muestra la sintaxis genérica del comando Soltar tabla.

DROP TABLE [ IF EXISTS ] tableName [,...] [ RESTRICT | CASCADE ]

El comando fallará si estamos usando RESTRICT y existe la tabla que tiene vistas dependientes. Todas las vistas dependientes se eliminan cuando utilizamos la palabra clave CASCADE.

Ejemplo

En este ejemplo, soltaremos una tabla llamada prueba usando la siguiente consulta.

DROP TABLE test;

La consulta anterior produce el siguiente resultado.

(6) row (s) effected

Eliminar esquema

Eliminar esquema es un comando que elimina un esquema respectivo del servidor de la base de datos. No funcionará con el esquema actual.

Sintaxis

DROP SCHEMA [ IF EXISTS ] schemaName

Ejemplo

En este ejemplo, soltaremos un esquema llamado test_schema utilizando la siguiente consulta.

DROP SCHEMA TEST_SCHEMA;

La consulta anterior produce el siguiente resultado.

(0) row(s) effected

Secuencia de caída

Drop Sequence es un comando que se utiliza para eliminar una secuencia de la estructura de la tabla.

Sintaxis

A continuación se muestra la sintaxis genérica del comando Drop Sequence.

DROP SEQUENCE [ IF EXISTS ] sequenceName

Este comando confirma una transacción abierta en esta conexión.

Ejemplo

En este ejemplo, soltaremos una secuencia llamada sequence_id. A continuación está el comando.

DROP SEQUENCE sequence_id;

El comando anterior produce la siguiente salida.

(0) row (s) effected

Drop View

Drop View es un comando que se utiliza para eliminar la vista existente. Todas las vistas dependientes también se descartan si se utiliza la cláusula CASCADE.

Sintaxis

A continuación se muestra la sintaxis genérica del comando Drop View.

DROP VIEW [ IF EXISTS ] viewName [ RESTRICT | CASCADE ]

Ejemplo

En este ejemplo, soltaremos una vista llamada sample_view utilizando la siguiente consulta.

DROP VIEW sample_view;

La consulta anterior produce el siguiente resultado.

(0) row (s) effected

TRUNCATE es un comando que se utiliza para eliminar los datos de la tabla. A diferencia de DELETE FROM sin la cláusula WHERE, este comando no se puede revertir. Este comando confirma una transacción abierta en esta conexión.

Sintaxis

A continuación se muestra la sintaxis genérica del comando truncate.

TRUNCATE TABLE tableName

Ejemplo

En este ejemplo, truncaremos una tabla llamada test utilizando la siguiente consulta.

TRUNCATE TABLE test;

La consulta anterior produce el siguiente resultado.

(6) row (s) effected

COMMIT es un comando de la gramática SQL que se usa para confirmar la transacción. Podemos confirmar la transacción específica o podemos confirmar la transacción actualmente ejecutada.

Sintaxis

Hay dos sintaxis diferentes para el comando COMMIT.

A continuación se muestra la sintaxis genérica del comando de confirmación para confirmar la transacción actual.

COMMIT [ WORK ]

A continuación se muestra la sintaxis genérica del comando de confirmación para confirmar la transacción específica.

COMMIT TRANSACTION transactionName

Ejemplo 1

En este ejemplo, confirmemos la transacción actual usando el siguiente comando.

COMMIT

El comando anterior produce la siguiente salida.

Committed successfully

Ejemplo 2

En este ejemplo, confirmaremos la transacción llamada tx_test usando el siguiente comando.

COMMIT TRANSACTION tx_test;

El comando anterior produce la siguiente salida.

Committed successfully

Grant es un comando que proviene de la gramática SQL que se usa para otorgar derechos a una tabla, a un usuario o a un rol. Se requieren derechos de administrador para ejecutar este comando. Este comando confirma una transacción abierta en esta conexión.

En este capítulo, discutiremos los diferentes escenarios del comando Grant.

Conceder derecho

Otorgar derechos es un comando para proporcionar derechos de administrador a una tabla, a un usuario o a un rol.

Sintaxis

A continuación se muestra la sintaxis genérica del comando Grant.

GRANT { SELECT | INSERT | UPDATE | DELETE | ALL } [,...] ON 
{ { SCHEMA schemaName } | { tableName [,...] } } 
TO { PUBLIC | userName | roleName }

Ejemplo

En este ejemplo, concederemos la tabla de prueba como de solo lectura mediante el siguiente comando.

GRANT SELECT ON TEST TO READONLY

El comando anterior produce la siguiente salida.

Grant successfully

Otorgar alterar cualquier esquema

Grant Alter Any Schema es un comando para otorgar derechos de modificación de esquema a un usuario respectivo.

Sintaxis

A continuación se muestra la sintaxis genérica del comando Grant Alter Any Schema.

GRANT ALTER ANY SCHEMA TO userName

Ejemplo

En este ejemplo, concederemos privilegios de alteración de un esquema a un usuario llamado test_user. Asegúrese de que exista test_user. A continuación se muestra la consulta para otorgar privilegios de modificación.

GRANT ALTER ANY SCHEMA TO test_user;

La consulta anterior produce el siguiente resultado.

Granted successfully to test_user

SAVEPOINT es un comando que se utiliza para guardar temporalmente la transacción. Es mejor mantener los puntos de guardado en su transacción, ya que es útil revertir la transacción al punto de guardado respectivo siempre que sea necesario.

Sintaxis

A continuación se muestra la sintaxis genérica del comando Savepoint.

SAVEPOINT savepointName

Ejemplo

En este ejemplo, crearemos un punto de guardado llamado Half_Done usando el siguiente comando.

SAVEPOINT Half_Done;

El comando anterior produce la siguiente salida.

Savepoint created

ROLLBACK es un comando de la gramática SQL que se usa para revertir la transacción a un punto de guardado oa la transacción anterior. Al usar este comando, podemos retroceder al punto de guardado específico o podemos retroceder a la transacción ejecutada anteriormente.

Sintaxis

Hay dos sintaxis diferentes para el comando ROLLABCK.

A continuación se muestra la sintaxis genérica del comando de reversión.

ROLLBACK [ TO SAVEPOINT savepointName ]

A continuación se muestra la sintaxis genérica del comando Rollback a la transacción específica.

ROLLBACK TRANSACTION transactionName

Ejemplo 1

En este ejemplo, revertiremos la transacción actual a un punto de guardado llamado sp1_test usando el siguiente comando.

ROLLBACK sp1_test;

El comando anterior produce la siguiente salida.

Rollback successfully

Ejemplo 2

En el siguiente ejemplo, revertiremos la transacción completa llamada tx_test usando el comando dado.

ROLLBACK TRANSACTION tx_test;

El comando anterior produce la siguiente salida.

Rollback successfully

H2 es una base de datos JAVA. Podemos interactuar con esta base de datos utilizando JDBC. En este capítulo, veremos cómo crear una conexión JDBC con la base de datos H2 y las operaciones CRUD con la base de datos H2.

Generalmente, hay cinco pasos para crear una conexión JDBC.

Step 1 - Registro del controlador de la base de datos JDBC.

Class.forName ("org.h2.Driver");

Step 2 - Abriendo la conexión.

Connection conn = DriverManager.getConnection ("jdbc:h2:~/test", "sa","");

Step 3 - Creando una declaración.

Statement st = conn.createStatement();

Step 4 - Ejecutar una declaración y recibir Resultset.

Stmt.executeUpdate("sql statement");

Step 5 - Cerrar una conexión.

conn.close();

Antes de continuar con la creación de un programa completo, debemos agregar h2-1.4.192.jar filea CLASSPATH. Podemos conseguir estojar de la carpeta C:\Program Files (x86)\H2\bin.

Crear mesa

En este ejemplo, escribiremos un programa para crear una tabla. Considere una tabla llamadaRegistration teniendo los siguientes campos.

S. No Nombre de columna Tipo de datos NO NULO Clave primaria
1 CARNÉ DE IDENTIDAD Número si si
2 primero Varchar (255) No No
3 Último Varchar (255) No No
4 Años Número No No

A continuación se muestra un programa de ejemplo llamado 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!");
   } 
}

Guarde el programa anterior en H2jdbcCreateDemo.java. Compile y ejecute el programa anterior ejecutando los siguientes comandos en el símbolo del sistema.

\>javac H2jdbcCreateDemo.java 
\>java H2jdbcCreateDemo

El comando anterior produce la siguiente salida.

Connecting to database... 
Creating table in given database... 
Created table in given database... 
Goodbye!

Después de esta ejecución, podemos verificar la tabla creada usando la interfaz H2 SQL.

Insertar registros

En este ejemplo, escribiremos un programa para insertar registros. Insertemos los siguientes registros en la tabla Registro.

CARNÉ DE IDENTIDAD primero Último Años
100 Zara Ali 18
101 Mahnaz Fatma 25
102 Zaid Kan 30
103 Sumit Mital 28

A continuación se muestra un programa de ejemplo llamado 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!"); 
   } 
}

Guarde el programa anterior en H2jdbcInsertDemo.java. Compile y ejecute el programa anterior ejecutando los siguientes comandos en el símbolo del sistema.

\>javac H2jdbcInsertDemo.java 
\>java H2jdbcInsertDemo

El comando anterior produce la siguiente salida.

Connecting to a selected database... 
Connected database successfully... 
Inserted records into the table... 
Goodbye!

Leer registro

En este ejemplo, escribiremos un programa para leer registros. Intentemos leer todos los registros de la tabla.Registration.

A continuación se muestra un programa de ejemplo llamado 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!"); 
   } 
}

Guarde el programa anterior en H2jdbcReadDemo.java. Compile y ejecute el programa anterior ejecutando los siguientes comandos en el símbolo del sistema.

\>javac H2jdbcReadDemo.java 
\>java H2jdbcReadDemo

El comando anterior produce la siguiente salida.

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!

Actualizar registros

En este ejemplo, escribiremos un programa para actualizar registros. Intentemos leer todos los registros de la tabla.Registration.

A continuación se muestra un programa de ejemplo llamado 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!"); 
   } 
}

Guarde el programa anterior en H2jdbcUpdateDemo.java. Compile y ejecute el programa anterior ejecutando los siguientes comandos en el símbolo del sistema.

\>javac H2jdbcUpdateDemo.java 
\>java H2jdbcUpdateDemo

El comando anterior produce la siguiente salida.

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!

Eliminar registros

En este ejemplo, escribiremos un programa para eliminar registros. Intentemos leer todos los registros de la tabla.Registration.

A continuación se muestra un programa de ejemplo llamado 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!"); 
   } 
}

Guarde el programa anterior en H2jdbcDeleteDemo.java. Compile y ejecute el programa anterior ejecutando los siguientes comandos en el símbolo del sistema.

\>javac H2jdbcDeleteDemo.java 
\>java H2jdbcDeleteDemo

El comando anterior produce la siguiente salida.

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!