HSQLDB - Guía rápida

HyperSQL Database (HSQLDB) es un moderno administrador de bases de datos relacionales que se ajusta estrechamente al estándar SQL: 2011 y las especificaciones JDBC 4. Es compatible con todas las funciones principales y RDBMS. HSQLDB se utiliza para el desarrollo, la prueba y la implementación de aplicaciones de bases de datos.

La característica principal y única de HSQLDB es el cumplimiento de estándares. Puede proporcionar acceso a la base de datos dentro del proceso de aplicación del usuario, dentro de un servidor de aplicaciones o como un proceso de servidor independiente.

Características de HSQLDB

• HSQLDB utiliza una estructura en memoria para operaciones rápidas contra el servidor de base de datos. Utiliza la persistencia del disco según la flexibilidad del usuario, con una recuperación de fallos confiable.

• HSQLDB también es adecuado para inteligencia empresarial, ETL y otras aplicaciones que procesan grandes conjuntos de datos.

• HSQLDB tiene una amplia gama de opciones de implementación empresarial, como transacciones XA, fuentes de datos de agrupación de conexiones y autenticación remota.

• HSQLDB está escrito en el lenguaje de programación Java y se ejecuta en una máquina virtual Java (JVM). Es compatible con la interfaz JDBC para el acceso a la base de datos.

Componentes de HSQLDB

Hay tres componentes diferentes en el paquete jar de HSQLDB.

• Motor HyperSQL RDBMS (HSQLDB)

• Controlador HyperSQL JDBC

• Database Manager (herramienta de acceso a la base de datos GUI, con versiones Swing y AWT)

HyperSQL RDBMS y JDBC Driver proporcionan la funcionalidad principal. Los administradores de bases de datos son herramientas de acceso a bases de datos de propósito general que se pueden utilizar con cualquier motor de base de datos que tenga un controlador JDBC.

Un jar adicional llamado sqltool.jar contiene la herramienta Sql, que es una herramienta de acceso a la base de datos de línea de comandos. Este es un comando de propósito general. Línea herramienta de acceso a la base de datos que también se puede utilizar con otros motores de base de datos.

HSQLDB es un sistema de gestión de bases de datos relacionales implementado en Java puro. Puede incrustar fácilmente esta base de datos en su aplicación utilizando JDBC. O puede utilizar las operaciones por separado.

Prerrequisitos

Siga las instalaciones de software de requisitos previos para HSQLDB.

Verificar la instalación de Java

Dado que HSQLDB es un sistema de administración de bases de datos relacionales implementado en Java puro, debe instalar el software JDK (Java Development Kit) antes de instalar HSQLDB. Si ya tiene la instalación de JDK en su sistema, pruebe el siguiente comando para verificar la versión de Java.

java –version

Si JDK se instaló correctamente en su sistema, obtendrá 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 no tiene JDK instalado en su sistema, visite el siguiente enlace para instalar JDK.

Instalación de HSQLDB

Los siguientes son los pasos para instalar HSQLDB.

Step 1 − Download HSQLDB bundle

Descargue la última versión de la base de datos HSQLDB desde el siguiente enlace https://sourceforge.net/projects/hsqldb/files/. Una vez que haga clic en el enlace, obtendrá la siguiente captura de pantalla.

Haga clic en HSQLDB y la descarga comenzará inmediatamente. Finalmente, obtendrá el archivo zip llamadohsqldb-2.3.4.zip.

Step 2 − Extract the HSQLDB zip file

Extraiga el archivo zip y colóquelo en el C:\directorio. Después de la extracción, obtendrá una estructura de archivo como se muestra en la siguiente captura de pantalla.

Step 3 − Create a default database

No hay una base de datos predeterminada para HSQLDB, por lo tanto, debe crear una base de datos para HSQLDB. Creemos un archivo de propiedades llamadoserver.properties que define una nueva base de datos llamada demodb. Eche un vistazo a las siguientes propiedades del servidor de base de datos.

server.database.0 = file:hsqldb/demodb
server.dbname.0 = testdb

Coloque este archivo server.properties en el directorio de inicio de HSQLDB que es C:\hsqldb- 2.3.4\hsqldb\.

Ahora ejecute el siguiente comando en el símbolo del sistema.

\>cd C:\hsqldb-2.3.4\hsqldb
hsqldb>java -classpath lib/hsqldb.jar org.hsqldb.server.Server

Después de la ejecución del comando anterior, recibirá el estado del servidor como se muestra en la siguiente captura de pantalla.

Más tarde, podrá encontrar la siguiente estructura de carpetas del directorio hsqldb en el directorio de inicio de HSQLDB que es C:\hsqldb-2.3.4\hsqldb. Esos archivos son el archivo temporal, el archivo lck, el archivo de registro, el archivo de propiedades y el archivo de secuencia de comandos de la base de datos demodb creada por el servidor de base de datos HSQLDB.

Step 4 − Start the database server

Una vez que haya terminado de crear una base de datos, debe iniciar la base de datos utilizando el siguiente comando.

\>cd C:\hsqldb-2.3.4\hsqldb
hsqldb>java -classpath lib/hsqldb.jar org.hsqldb.server.Server --database.0
file:hsqldb/demodb --dbname.0 testdb

Después de la ejecución del comando anterior, obtiene el siguiente estado.

Ahora, puede abrir la pantalla de inicio de la base de datos que está runManagerSwing.bat desde C:\hsqldb-2.3.4\hsqldb\binubicación. Este archivo bat abrirá el archivo GUI para la base de datos HSQLDB. Antes de eso, le pedirá la configuración de la base de datos a través de un cuadro de diálogo. Eche un vistazo a la siguiente captura de pantalla. En este cuadro de diálogo, ingrese el Nombre de configuración, URL como se muestra arriba y haga clic en Aceptar.

Obtendrá la pantalla GUI de la base de datos HSQLDB como se muestra en la siguiente captura de pantalla.

En el capítulo de instalación, discutimos cómo conectar la base de datos manualmente. En este capítulo, discutiremos cómo conectar la base de datos mediante programación (usando programación Java).

Eche un vistazo al siguiente programa, que iniciará el servidor y creará una conexión entre la aplicación Java y la base de datos.

Ejemplo

import java.sql.Connection;
import java.sql.DriverManager;

public class ConnectDatabase {
   public static void main(String[] args) {
      Connection con = null;
      
      try {
         //Registering the HSQLDB JDBC driver
         Class.forName("org.hsqldb.jdbc.JDBCDriver");
         //Creating the connection with HSQLDB
         con = DriverManager.getConnection("jdbc:hsqldb:hsql://localhost/testdb", "SA", "");
         if (con!= null){
            System.out.println("Connection created successfully");
            
         }else{
            System.out.println("Problem with creating connection");
         }
      
      }  catch (Exception e) {
         e.printStackTrace(System.out);
      }
   }
}

Guarde este código en ConnectDatabase.javaarchivo. Deberá iniciar la base de datos con el siguiente comando.

\>cd C:\hsqldb-2.3.4\hsqldb
hsqldb>java -classpath lib/hsqldb.jar org.hsqldb.server.Server --database.0
file:hsqldb/demodb --dbname.0 testdb

Puede utilizar el siguiente comando para compilar y ejecutar el código.

\>javac ConnectDatabase.java
\>java ConnectDatabase

Después de la ejecución del comando anterior, recibirá el siguiente resultado:

Connection created successfully

Este capítulo explica los diferentes tipos de datos de HSQLDB. El servidor HSQLDB ofrece seis categorías de tipos de datos.

Tipos de datos numéricos exactos

Tipo de datos	Desde	A
Empezando	-9,223,372,036,854,775,808	9.223.372.036.854.775.807
En t	-2,147,483,648	2,147,483,647
pequeño	-32,768	32,767
diminuto	0	255
poco	0	1
decimal	-10 ^ 38 +1	10 ^ 38 -1
numérico	-10 ^ 38 +1	10 ^ 38 -1
dinero	-922,337,203,685,477.5808	+922,337,203,685,477.5807
poco dinero	-214,748.3648	+214,748.3647

Tipos de datos numéricos aproximados

Tipo de datos	Desde	A
flotador	-1,79E + 308	1,79E + 308
real	-3,40E + 38	3.40E + 38

Tipos de datos de fecha y hora

Tipo de datos	Desde	A
fecha y hora	1 de enero de 1753	31 de diciembre de 9999
pequeña fecha y hora	1 de enero de 1900	6 de junio de 2079
fecha	Almacena una fecha como el 30 de junio de 1991
hora	Almacena una hora del día como las 12:30 p.m.

Note - Aquí, la fecha y hora tiene una precisión de 3,33 milisegundos, mientras que la fecha pequeña tiene una precisión de 1 minuto.

Tipos de datos de cadenas de caracteres

Tipo de datos	Descripción
carbonizarse	Longitud máxima de 8.000 caracteres (caracteres no Unicode de longitud fija)
varchar	Máximo de 8.000 caracteres (datos no Unicode de longitud variable)
varchar (máximo)	Longitud máxima de 231 caracteres, datos no Unicode de longitud variable (solo SQL Server 2005)
texto	Datos no Unicode de longitud variable con una longitud máxima de 2,147,483,647 caracteres

Tipos de datos de cadenas de caracteres Unicode

Tipo de datos	Descripción
nchar	Longitud máxima de 4000 caracteres (Unicode de longitud fija)
nvarchar	Longitud máxima de 4000 caracteres (Unicode de longitud variable)
nvarchar (máximo)	Longitud máxima de 231 caracteres (solo SQL Server 2005), (longitud variable Unicode)
ntext	Longitud máxima de 1.073.741.823 caracteres (Unicode de longitud variable)

Tipos de datos binarios

Tipo de datos	Descripción
binario	Longitud máxima de 8.000 bytes (datos binarios de longitud fija)
varbinary	Longitud máxima de 8.000 bytes (datos binarios de longitud variable)
varbinary (máx.)	Longitud máxima de 231 bytes (solo SQL Server 2005), (datos binarios de longitud variable)
imagen	Longitud máxima de 2,147,483,647 bytes (datos binarios de longitud variable)

Tipos de datos varios

Tipo de datos	Descripción
sql_variant	Almacena valores de varios tipos de datos compatibles con SQL Server, excepto texto, ntext y marca de tiempo
marca de tiempo	Almacena un número único en toda la base de datos que se actualiza cada vez que se actualiza una fila
identificador único	Almacena un identificador único global (GUID)
xml	Almacena datos XML. Puede almacenar instancias xml en una columna o variable (solo SQL Server 2005)
cursor	Referencia a un objeto cursor
mesa	Almacena un conjunto de resultados para su posterior procesamiento.

Los requisitos obligatorios básicos para crear una tabla son el nombre de la tabla, los nombres de los campos y los tipos de datos de esos campos. Opcionalmente, también puede proporcionar las restricciones clave a la tabla.

Sintaxis

Eche un vistazo a la siguiente sintaxis.

CREATE TABLE table_name (column_name column_type);

Ejemplo

Creemos una tabla llamada tutorials_tbl con los nombres de campo como id, title, author y submit_date. Eche un vistazo a la siguiente consulta.

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

Después de la ejecución de la consulta anterior, recibirá el siguiente resultado:

(0) rows effected

HSQLDB - Programa JDBC

A continuación se muestra el programa JDBC que se utiliza para crear una tabla denominada tutorials_tbl en la base de datos HSQLDB. Guarde el programa enCreateTable.java archivo.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

public class CreateTable {
   
   public static void main(String[] args) {
      
      Connection con = null;
      Statement stmt = null;
      int result = 0;
      
      try {
         Class.forName("org.hsqldb.jdbc.JDBCDriver");
         con = DriverManager.getConnection("jdbc:hsqldb:hsql://localhost/testdb", "SA", "");
         stmt = con.createStatement();
         
         result = stmt.executeUpdate("CREATE TABLE tutorials_tbl (
            id INT NOT NULL, title VARCHAR(50) NOT NULL,
            author VARCHAR(20) NOT NULL, submission_date DATE,
            PRIMARY KEY (id));
         ");
			
      }  catch (Exception e) {
         e.printStackTrace(System.out);
      }
      System.out.println("Table created successfully");
   }
}

Puede iniciar la base de datos usando el siguiente comando.

\>cd C:\hsqldb-2.3.4\hsqldb
hsqldb>java -classpath lib/hsqldb.jar org.hsqldb.server.Server --database.0
file:hsqldb/demodb --dbname.0 testdb

Compile y ejecute el programa anterior usando el siguiente comando.

\>javac CreateTable.java
\>java CreateTable

Después de la ejecución del comando anterior, recibirá el siguiente resultado:

Table created successfully

Es muy fácil eliminar una tabla HSQLDB existente. Sin embargo, debe tener mucho cuidado al eliminar cualquier tabla existente, ya que los datos perdidos no se recuperarán después de eliminar una tabla.

Sintaxis

A continuación se muestra una sintaxis SQL genérica para eliminar una tabla HSQLDB.

DROP TABLE table_name;

Ejemplo

Consideremos un ejemplo para eliminar una tabla llamada empleado del servidor HSQLDB. A continuación se muestra la consulta para eliminar una tabla llamada empleado.

DROP TABLE employee;

Después de la ejecución de la consulta anterior, recibirá el siguiente resultado:

(0) rows effected

HSQLDB - Programa JDBC

A continuación se muestra el programa JDBC utilizado para eliminar al empleado de la tabla del servidor HSQLDB.

Guarde el siguiente código en DropTable.java archivo.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

public class DropTable {
   public static void main(String[] args) {
      Connection con = null;
      Statement stmt = null;
      int result = 0;
      
      try {
         Class.forName("org.hsqldb.jdbc.JDBCDriver");
         con = DriverManager.getConnection("jdbc:hsqldb:hsql://localhost/testdb", "SA", "");
         stmt = con.createStatement();
         result = stmt.executeUpdate("DROP TABLE employee");
      }catch (Exception e) {
         e.printStackTrace(System.out);
      }
      
      System.out.println("Table dropped successfully");
   }
}

Puede iniciar la base de datos usando el siguiente comando.

\>cd C:\hsqldb-2.3.4\hsqldb
hsqldb>java -classpath lib/hsqldb.jar org.hsqldb.server.Server --database.0
file:hsqldb/demodb --dbname.0 testdb

Compile y ejecute el programa anterior usando el siguiente comando.

\>javac DropTable.java
\>java DropTable

Después de la ejecución del comando anterior, recibirá el siguiente resultado:

Table dropped successfully

Puede lograr Insertar instrucción de consulta en HSQLDB utilizando el comando INSERT INTO. Debe proporcionar los datos definidos por el usuario siguiendo el orden de los campos de columna de la tabla.

Sintaxis

A continuación se muestra la sintaxis genérica para INSERT una consulta.

INSERT INTO table_name (field1, field2,...fieldN)
VALUES (value1, value2,...valueN );

Para insertar datos de tipo cadena en una tabla, deberá utilizar comillas simples o dobles para proporcionar un valor de cadena en la declaración de consulta de inserción.

Ejemplo

Consideremos un ejemplo que inserta un registro en una tabla llamada tutorials_tbl con los valores id = 100, title = Learn PHP, Author = John Poul, y la fecha de envío es la fecha actual.

A continuación se muestra la consulta para el ejemplo dado.

INSERT INTO tutorials_tbl VALUES (100,'Learn PHP', 'John Poul', NOW());

Después de la ejecución de la consulta anterior, recibirá el siguiente resultado:

1 row effected

HSQLDB - Programa JDBC

Aquí está el programa JDBC para insertar el registro en la tabla con los valores dados, id = 100, title = Learn PHP, Author = John Poul, y la fecha de envío es la fecha actual. Eche un vistazo al programa dado. Guarde el código en elInserQuery.java archivo.

import java.sql.Connection; 
import java.sql.DriverManager; 
import java.sql.Statement;  

public class InsertQuery {
   public static void main(String[] args) { 
      Connection con = null; 
      Statement stmt = null; 
      int result = 0; 
      try { 
         Class.forName("org.hsqldb.jdbc.JDBCDriver"); 
         con = DriverManager.getConnection( 
            "jdbc:hsqldb:hsql://localhost/testdb", "SA", ""); 
         stmt = con.createStatement(); 
         result = stmt.executeUpdate("INSERT INTO tutorials_tbl 
            VALUES (100,'Learn PHP', 'John Poul', NOW())"); 
         con.commit(); 
      }catch (Exception e) { 
         e.printStackTrace(System.out); 
      } 
      System.out.println(result+" rows effected"); 
      System.out.println("Rows inserted successfully"); 
   } 
}

Puede iniciar la base de datos usando el siguiente comando.

\>cd C:\hsqldb-2.3.4\hsqldb 
hsqldb>java -classpath lib/hsqldb.jar org.hsqldb.server.Server --database.0 
file:hsqldb/demodb --dbname.0 testdb

Compile y ejecute el programa anterior usando el siguiente comando.

\>javac InsertQuery.java 
\>java InsertQuery

Después de la ejecución del comando anterior, recibirá el siguiente resultado:

1 rows effected 
Rows inserted successfully

Intente insertar los siguientes registros en el tutorials_tbl tabla usando el INSERT INTO mando.

Carné de identidad	Título	Autor	Día de entrega
101	Aprender C	Yaswanth	Ahora()
102	Aprenda MySQL	Abdul S	Ahora()
103	Aprende Excell	Bavya kanna	Ahora()
104	Aprenda JDB	Ajith kumar	Ahora()
105	Aprende Junit	Sathya Murthi	Ahora()

El comando SELECT se utiliza para obtener los datos del registro de la base de datos HSQLDB. Aquí, debe mencionar la lista de campos obligatorios en la declaración Seleccionar.

Sintaxis

Aquí está la sintaxis genérica para la consulta de selección.

SELECT field1, field2,...fieldN table_name1, table_name2...
[WHERE Clause]
[OFFSET M ][LIMIT N]

• Puede buscar uno o más campos en un solo comando SELECT.

• Puede especificar asterisco (*) en lugar de campos. En este caso, SELECT devolverá todos los campos.

• Puede especificar cualquier condición utilizando la cláusula WHERE.

• Puede especificar un desplazamiento usando OFFSET desde donde SELECT comenzará a devolver registros. Por defecto, la compensación es cero.

• Puede limitar el número de devoluciones utilizando el atributo LIMIT.

Ejemplo

A continuación, se muestra un ejemplo que obtiene los campos de identificación, título y autor de todos los registros de tutorials_tblmesa. Podemos lograr esto usando la instrucción SELECT. A continuación se muestra la consulta del ejemplo.

SELECT id, title, author FROM tutorials_tbl

Después de la ejecución de la consulta anterior, recibirá el siguiente resultado.

+------+----------------+-----------------+
|  id  |      title     |    author       |
+------+----------------+-----------------+
| 100  |     Learn PHP  |    John Poul    |
| 101  |     Learn C    |    Yaswanth     |
| 102  |   Learn MySQL  |     Abdul S     |
| 103  |   Learn Excell |   Bavya kanna   |
| 104  |   Learn JDB    |    Ajith kumar  |
| 105  |   Learn Junit  |   Sathya Murthi |
+------+----------------+-----------------+

HSQLDB - Programa JDBC

Aquí está el programa JDBC que obtendrá los campos de identificación, título y autor de todos los registros de tutorials_tblmesa. Guarde el siguiente código en elSelectQuery.java archivo.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class SelectQuery {
   
   public static void main(String[] args) {
      Connection con = null;
      Statement stmt = null;
      ResultSet result = null;
      
      try {
         Class.forName("org.hsqldb.jdbc.JDBCDriver");
         con = DriverManager.getConnection(
            "jdbc:hsqldb:hsql://localhost/testdb", "SA", "");
         stmt = con.createStatement();
         result = stmt.executeQuery(
            "SELECT id, title, author FROM tutorials_tbl");
         
         while(result.next()){
            System.out.println(result.getInt("id")+" | "+
               result.getString("title")+" | "+
               result.getString("author"));
         }
      } catch (Exception e) {
         e.printStackTrace(System.out);
      }
   }
}

Puede iniciar la base de datos usando el siguiente comando.

\>cd C:\hsqldb-2.3.4\hsqldb
hsqldb>java -classpath lib/hsqldb.jar org.hsqldb.server.Server --database.0
file:hsqldb/demodb --dbname.0 testdb

Compile y ejecute el código anterior usando el siguiente comando.

\>javac SelectQuery.java
\>java SelectQuery

Después de la ejecución del comando anterior, recibirá el siguiente resultado:

100 | Learn PHP | John Poul
101 | Learn C | Yaswanth
102 | Learn MySQL | Abdul S
103 | Learn Excell | Bavya Kanna
104 | Learn JDB | Ajith kumar
105 | Learn Junit | Sathya Murthi

Generalmente, usamos el comando SELECT para obtener datos de la tabla HSQLDB. Podemos usar la cláusula condicional WHERE para filtrar los datos resultantes. Usando DONDE podemos especificar los criterios de selección para seleccionar los registros requeridos de una tabla.

Sintaxis

A continuación se muestra la sintaxis de la cláusula WHERE del comando SELECT para obtener datos de la tabla HSQLDB.

SELECT field1, field2,...fieldN table_name1, table_name2...
[WHERE condition1 [AND [OR]] condition2.....

• Puede usar una o más tablas separadas por comas para incluir varias condiciones usando una cláusula WHERE, pero la cláusula WHERE es una parte opcional del comando SELECT.

• Puede especificar cualquier condición utilizando la cláusula WHERE.

• Puede especificar más de una condición mediante los operadores AND u OR.

• También se puede usar una cláusula WHERE junto con el comando DELETE o UPDATE SQL para especificar una condición.

Podemos filtrar los datos del registro utilizando condiciones. Estamos usando diferentes operadores en la cláusula condicional WHERE. Aquí está la lista de operadores, que se puede usar con la cláusula WHERE.

Operador	Descripción	Ejemplo
=	Comprueba si los valores de dos operandos son iguales o no, en caso afirmativo, la condición se cumple.	(A = B) no es cierto
! =	Comprueba si los valores de dos operandos son iguales o no, si los valores no son iguales, la condición se vuelve verdadera.	(A! = B) es cierto
>	Comprueba si el valor del operando izquierdo es mayor que el valor del operando derecho; en caso afirmativo, la condición se cumple.	(A> B) no es cierto
<	Comprueba si el valor del operando izquierdo es menor que el valor del operando derecho, si es así, la condición se convierte en verdadera.	(A <B) es cierto
> =	Comprueba si el valor del operando izquierdo es mayor o igual que el valor del operando derecho; si es así, la condición se convierte en verdadera.	(A> = B) no es cierto
<=	Comprueba si el valor del operando izquierdo es menor o igual que el valor del operando derecho; si es así, la condición se cumple.	(A <= B) es cierto

Ejemplo

A continuación, se muestra un ejemplo que recupera los detalles como la identificación, el título y el autor del libro titulado "Aprender C". Es posible usando la cláusula WHERE en el comando SELECT. A continuación se muestra la consulta para el mismo.

SELECT id, title, author FROM tutorials_tbl WHERE title = 'Learn C';

Después de la ejecución de la consulta anterior, recibirá el siguiente resultado.

+------+----------------+-----------------+
| id   |      title     |    author       |
+------+----------------+-----------------+
| 101  |      Learn C   |   Yaswanth      |
+------+----------------+-----------------+

HSQLDB - Programa JDBC

Aquí está el programa JDBC que recupera los datos de registro de la tabla tutorials_tbl con el título Learn C. Guarde el siguiente código enWhereClause.java.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class WhereClause {
   
   public static void main(String[] args) {
      Connection con = null;
      Statement stmt = null;
      ResultSet result = null;
      try {
         Class.forName("org.hsqldb.jdbc.JDBCDriver");
         con = DriverManager.getConnection(
            "jdbc:hsqldb:hsql://localhost/testdb", "SA", "");
         stmt = con.createStatement();
         result = stmt.executeQuery(
            "SELECT id, title, author FROM tutorials_tbl
            WHERE title = 'Learn C'");
         
         while(result.next()){
            System.out.println(result.getInt("id")+" |
               "+result.getString("title")+" |
               "+result.getString("author"));
         }
      } catch (Exception e) {
         e.printStackTrace(System.out);
      }
   }

}

Puede iniciar la base de datos usando el siguiente comando.

\>cd C:\hsqldb-2.3.4\hsqldb
hsqldb>java -classpath lib/hsqldb.jar org.hsqldb.server.Server --database.0
file:hsqldb/demodb --dbname.0 testdb

Compile y ejecute el código anterior usando el siguiente comando.

\>javac WhereClause.java
\>java WhereClause

Después de la ejecución del comando anterior, recibirá el siguiente resultado.

101 | Learn C | Yaswanth

Siempre que desee modificar los valores de una tabla, puede utilizar el comando ACTUALIZAR. Esto modificará cualquier valor de campo de cualquier tabla HSQLDB.

Sintaxis

Aquí está la sintaxis genérica del comando UPDATE.

UPDATE table_name SET field1 = new-value1, field2 = new-value2 [WHERE Clause]

• Puede actualizar uno o más campos por completo.
• Puede especificar cualquier condición utilizando la cláusula WHERE.
• Puede actualizar valores en una sola tabla a la vez.

Ejemplo

Consideremos un ejemplo que actualiza el título del tutorial de "Aprender C" a "C y estructuras de datos" con una identificación "101". A continuación se muestra la consulta para la actualización.

UPDATE tutorials_tbl SET title = 'C and Data Structures' WHERE id = 101;

Después de la ejecución de la consulta anterior, recibirá el siguiente resultado.

(1) Rows effected

HSQLDB - Programa JDBC

Aquí está el programa JDBC que actualizará el título de un tutorial de Learn C a C and Data Structures tener una identificación 101. Guarde el siguiente programa en elUpdateQuery.java archivo.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

public class UpdateQuery {
   
   public static void main(String[] args) {
      Connection con = null;
      Statement stmt = null;
      int result = 0;
      
      try {
         Class.forName("org.hsqldb.jdbc.JDBCDriver");
         con = DriverManager.getConnection(
            "jdbc:hsqldb:hsql://localhost/testdb", "SA", "");
         stmt = con.createStatement();
         result = stmt.executeUpdate(
            "UPDATE tutorials_tbl SET title = 'C and Data Structures' WHERE id = 101");
      } catch (Exception e) {
         e.printStackTrace(System.out);
      }
      System.out.println(result+" Rows effected");
   }
}

Puede iniciar la base de datos usando el siguiente comando.

\>cd C:\hsqldb-2.3.4\hsqldb
hsqldb>java -classpath lib/hsqldb.jar org.hsqldb.server.Server --database.0
file:hsqldb/demodb --dbname.0 testdb

Compile y ejecute el programa anterior usando el siguiente comando.

\>javac UpdateQuery.java
\>java UpdateQuery

Después de la ejecución del comando anterior, recibirá el siguiente resultado:

1 Rows effected

Siempre que desee eliminar un registro de cualquier tabla HSQLDB, puede usar el comando DELETE FROM.

Sintaxis

Aquí está la sintaxis genérica del comando DELETE para eliminar datos de una tabla HSQLDB.

DELETE FROM table_name [WHERE Clause]

• Si no se especifica la cláusula WHERE, todos los registros se eliminarán de la tabla MySQL dada.

• Puede especificar cualquier condición utilizando la cláusula WHERE.

• Puede eliminar registros en una sola tabla a la vez.

Ejemplo

Consideremos un ejemplo que elimina los datos de registro de la tabla llamada tutorials_tbl tener identificación 105. A continuación se muestra la consulta que implementa el ejemplo dado.

DELETE FROM tutorials_tbl WHERE id = 105;

Después de la ejecución de la consulta anterior, recibirá el siguiente resultado:

(1) rows effected

HSQLDB - Programa JDBC

Aquí está el programa JDBC que implementa el ejemplo dado. Guarde el siguiente programa enDeleteQuery.java.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

public class DeleteQuery {
   
   public static void main(String[] args) {
      Connection con = null;
      Statement stmt = null;
      int result = 0;
      
      try {
         Class.forName("org.hsqldb.jdbc.JDBCDriver");
         con = DriverManager.getConnection(
            "jdbc:hsqldb:hsql://localhost/testdb", "SA", "");
         stmt = con.createStatement();
         result = stmt.executeUpdate(
            "DELETE FROM tutorials_tbl   WHERE id=105");
      } catch (Exception e) {
      
         e.printStackTrace(System.out);
      }
      System.out.println(result+" Rows effected");
   }
}

Puede iniciar la base de datos usando el siguiente comando.

\>cd C:\hsqldb-2.3.4\hsqldb
hsqldb>java -classpath lib/hsqldb.jar org.hsqldb.server.Server --database.0
file:hsqldb/demodb --dbname.0 testdb

Compile y ejecute el programa anterior usando el siguiente comando.

\>javac DeleteQuery.java
\>java DeleteQuery

Después de la ejecución del comando anterior, recibirá el siguiente resultado:

1 Rows effected

Hay una cláusula WHERE en la estructura RDBMS. Puede usar la cláusula WHERE con un signo igual a (=) donde queremos hacer una coincidencia exacta. Pero puede haber un requisito donde queramos filtrar todos los resultados donde el nombre del autor debe contener "john". Esto se puede manejar usando la cláusula SQL LIKE junto con la cláusula WHERE.

Si se usa la cláusula SQL LIKE junto con% caracteres, entonces funcionará como un metacarácter (*) en UNIX mientras enumera todos los archivos o directorios en el símbolo del sistema.

Sintaxis

A continuación se muestra la sintaxis SQL genérica de la cláusula LIKE.

SELECT field1, field2,...fieldN table_name1, table_name2...
WHERE field1 LIKE condition1 [AND [OR]] filed2 = 'somevalue'

• Puede especificar cualquier condición utilizando la cláusula WHERE.

• Puede utilizar la cláusula LIKE junto con la cláusula WHERE.

• Puede utilizar la cláusula LIKE en lugar del signo igual.

• Cuando se usa la cláusula LIKE junto con el signo%, funcionará como una búsqueda de metacaracteres.

• Puede especificar más de una condición mediante los operadores AND u OR.

• Se puede utilizar una cláusula WHERE ... LIKE junto con el comando DELETE o UPDATE SQL para especificar una condición.

Ejemplo

Consideremos un ejemplo que recupera la lista de datos de tutoriales donde el nombre del autor comienza con John. A continuación se muestra la consulta HSQLDB para el ejemplo dado.

SELECT * from tutorials_tbl WHERE author LIKE 'John%';

Después de la ejecución de la consulta anterior, recibirá el siguiente resultado.

+-----+----------------+-----------+-----------------+
|  id |      title     |   author  | submission_date |
+-----+----------------+-----------+-----------------+
| 100 |    Learn PHP   | John Poul | 2016-06-20      |
+-----+----------------+-----------+-----------------+

HSQLDB - Programa JDBC

A continuación se muestra el programa JDBC que recupera la lista de datos de tutoriales donde el nombre del autor comienza con John. Guarde el código enLikeClause.java.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class LikeClause {
   
   public static void main(String[] args) {
      Connection con = null;
      Statement stmt = null;
      ResultSet result = null;
      
      try {
         Class.forName("org.hsqldb.jdbc.JDBCDriver");
         con = DriverManager.getConnection(
            "jdbc:hsqldb:hsql://localhost/testdb", "SA", "");
         stmt = con.createStatement();
         result = stmt.executeQuery(
            "SELECT * from tutorials_tbl WHERE author LIKE 'John%';");
         
         while(result.next()){
            System.out.println(result.getInt("id")+" |
               "+result.getString("title")+" |
               "+result.getString("author")+" |
               "+result.getDate("submission_date"));
         }
      } catch (Exception e) {
         e.printStackTrace(System.out);
      }
   }
}

Puede iniciar la base de datos usando el siguiente comando.

\>cd C:\hsqldb-2.3.4\hsqldb
hsqldb>java -classpath lib/hsqldb.jar org.hsqldb.server.Server --database.0
file:hsqldb/demodb --dbname.0 testdb

Compile y ejecute el código anterior usando el siguiente comando.

\>javac LikeClause.java
\>java LikeClause

Después de la ejecución del siguiente comando, recibirá el siguiente resultado.

100 | Learn PHP | John Poul | 2016-06-20

El comando SQL SELECT obtiene datos de la tabla HSQLDB siempre que existe un requisito que sigue un orden particular al recuperar y mostrar registros. En ese caso, podemos usar elORDER BY cláusula.

Sintaxis

Aquí está la sintaxis del comando SELECT junto con la cláusula ORDER BY para ordenar los datos de HSQLDB.

SELECT field1, field2,...fieldN table_name1, table_name2...
ORDER BY field1, [field2...] [ASC [DESC]]

• Puede ordenar el resultado devuelto en cualquier campo siempre que ese campo esté en la lista.

• Puede ordenar el resultado en más de un campo.

• Puede utilizar la palabra clave ASC o DESC para obtener el resultado en orden ascendente o descendente. De forma predeterminada, está en orden ascendente.

• Puede utilizar la cláusula WHERE ... LIKE de la forma habitual para poner una condición.

Ejemplo

Consideremos un ejemplo que obtiene y ordena los registros de tutorials_tbltabla ordenando el nombre del autor en orden ascendente. A continuación se muestra la consulta para el mismo.

SELECT id, title, author from tutorials_tbl ORDER BY author ASC;

Después de la ejecución de la consulta anterior, recibirá el siguiente resultado.

+------+----------------+-----------------+
| id   |     title      |     author      |
+------+----------------+-----------------+
| 102  |  Learn MySQL   |     Abdul S     | 
| 104  |  Learn JDB     |    Ajith kumar  |
| 103  |  Learn Excell  |    Bavya kanna  |
| 100  |  Learn PHP     |    John Poul    |
| 105  |  Learn Junit   |   Sathya Murthi |
| 101  |  Learn C       |    Yaswanth     |
+------+----------------+-----------------+

HSQLDB - Programa JDBC

Aquí está el programa JDBC que busca y ordena los registros de tutorials_tbltabla ordenando el nombre del autor en orden ascendente. Guarde el siguiente programa enOrderBy.java.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class OrderBy {
   
   public static void main(String[] args) {
      Connection con = null;
      Statement stmt = null;
      ResultSet result = null;
      
      try {
         Class.forName("org.hsqldb.jdbc.JDBCDriver");
         con = DriverManager.getConnection(
            "jdbc:hsqldb:hsql://localhost/testdb", "SA", "");
         stmt = con.createStatement();
         result = stmt.executeQuery(
            "SELECT id, title, author from tutorials_tbl
            ORDER BY author ASC");
         
         while(result.next()){
            System.out.println(result.getInt("id")+" |
            "+result.getString("title")+" |
            "+result.getString("author"));
         }
      } catch (Exception e) {
         e.printStackTrace(System.out);
      }
   }
}

Puede iniciar la base de datos usando el siguiente comando.

\>cd C:\hsqldb-2.3.4\hsqldb
hsqldb>java -classpath lib/hsqldb.jar org.hsqldb.server.Server --database.0
file:hsqldb/demodb --dbname.0 testdb

Compile y ejecute el programa anterior usando el siguiente comando.

\>javac OrderBy.java
\>java OrderBy

Después de la ejecución del comando anterior, recibirá el siguiente resultado.

102 | Learn MySQL           | Abdul S
104 | Learn JDB             | Ajith kumar
103 | Learn Excell          | Bavya Kanna
100 | Learn PHP             | John Poul
105 | Learn Junit           | Sathya Murthi
101 | C and Data Structures | Yaswanth

Siempre que sea necesario recuperar datos de varias tablas mediante una sola consulta, puede utilizar JOINS desde RDBMS. Puede utilizar varias tablas en su única consulta SQL. El acto de unirse en HSQLDB se refiere a romper dos o más tablas en una sola tabla.

Considere las siguientes tablas de Clientes y Pedidos.

Customer:
+----+----------+-----+-----------+----------+
| 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 |
+----+----------+-----+-----------+----------+
Orders:
+-----+---------------------+-------------+--------+
|OID  |         DATE        | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |      3      |  3000  |
| 100 | 2009-10-08 00:00:00 |      3      |  1500  |
| 101 | 2009-11-20 00:00:00 |      2      |  1560  |
| 103 | 2008-05-20 00:00:00 |      4      |  2060  |
+-----+---------------------+-------------+--------+

Ahora, intentemos recuperar los datos de los clientes y el monto del pedido que realizó el cliente respectivo. Esto significa que estamos recuperando los datos de registro tanto de clientes como de la tabla de pedidos. Podemos lograr esto usando el concepto JOINS en HSQLDB. A continuación se muestra la consulta JOIN para el mismo.

SELECT ID, NAME, AGE, AMOUNT FROM CUSTOMERS, ORDERS WHERE CUSTOMERS.ID =
ORDERS.CUSTOMER_ID;

Después de la ejecución de la consulta anterior, recibirá el siguiente resultado.

+----+----------+-----+--------+
| ID |   NAME   | AGE | AMOUNT |
+----+----------+-----+--------+
|  3 | kaushik  |  23 |  3000  |
|  3 | kaushik  |  23 |  1500  |
|  2 | Khilan   |  25 |  1560  |
|  4 | Chaitali |  25 |  2060  |
+----+----------+-----+--------+

Tipos de JOIN

Hay diferentes tipos de combinaciones disponibles en HSQLDB.

• INNER JOIN - Devuelve las filas cuando hay una coincidencia en ambas tablas.

• LEFT JOIN - Devuelve todas las filas de la tabla de la izquierda, incluso si no hay coincidencias en la tabla de la derecha.

• RIGHT JOIN - Devuelve todas las filas de la tabla de la derecha, incluso si no hay coincidencias en la tabla de la izquierda.

• FULL JOIN - Devuelve las filas cuando hay una coincidencia en una de las tablas.

• SELF JOIN - Se utiliza para unir una tabla consigo misma como si fueran dos tablas, cambiando temporalmente el nombre de al menos una tabla en la declaración SQL.

Unir internamente

La combinación más utilizada e importante es la INNER JOIN. También se conoce como EQUIJOIN.

INNER JOIN crea una nueva tabla de resultados combinando los valores de columna de dos tablas (table1 y table2) según el predicado de unión. La consulta compara cada fila de table1 con cada fila de table2 para encontrar todos los pares de filas que satisfacen el predicado de unión. Cuando se satisface el predicado de unión, los valores de columna para cada par coincidente de filas A y B se combinan en una fila de resultados.

Sintaxis

La sintaxis básica de INNER JOIN es la siguiente.

SELECT table1.column1, table2.column2...
FROM table1
INNER JOIN table2
ON table1.common_field = table2.common_field;

Ejemplo

Considere las siguientes dos tablas, una titulada como tabla CLIENTES y otra titulada como tabla PEDIDOS de la siguiente manera:

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

+-----+---------------------+-------------+--------+
| OID |         DATE        | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |      3      | 3000   |
| 100 | 2009-10-08 00:00:00 |      3      | 1500   |
| 101 | 2009-11-20 00:00:00 |      2      | 1560   |
| 103 | 2008-05-20 00:00:00 |      4      | 2060   |
+-----+---------------------+-------------+--------+

Ahora, unamos estas dos tablas usando la consulta INNER JOIN de la siguiente manera:

SELECT ID, NAME, AMOUNT, DATE FROM CUSTOMERS
INNER JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

Después de la ejecución de la consulta anterior, recibirá el siguiente resultado.

+----+----------+--------+---------------------+
| ID |   NAME   | AMOUNT |         DATE        |
+----+----------+--------+---------------------+
| 3  |  kaushik |  3000  | 2009-10-08 00:00:00 |
| 3  |  kaushik |  1500  | 2009-10-08 00:00:00 |
| 2  |  Khilan  |  1560  | 2009-11-20 00:00:00 |
| 4  | Chaitali |  2060  | 2008-05-20 00:00:00 |
+----+----------+--------+---------------------+

Unión a la izquierda

HSQLDB LEFT JOIN devuelve todas las filas de la tabla izquierda, incluso si no hay coincidencias en la tabla derecha. Esto significa que si la cláusula ON coincide con 0 (cero) registros en la tabla de la derecha, la combinación seguirá devolviendo una fila en el resultado, pero con NULL en cada columna de la tabla de la derecha.

Esto significa que una combinación izquierda devuelve todos los valores de la tabla izquierda, más los valores coincidentes de la tabla derecha o NULL en caso de que no haya un predicado de combinación coincidente.

Sintaxis

La sintaxis básica de LEFT JOIN es la siguiente:

SELECT table1.column1, table2.column2...
FROM table1
LEFT JOIN table2
ON table1.common_field = table2.common_field;

Aquí, la condición dada podría ser cualquier expresión dada según su requisito.

Ejemplo

Considere las siguientes dos tablas, una titulada como tabla CLIENTES y otra titulada como tabla PEDIDOS de la siguiente manera:

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

+-----+---------------------+-------------+--------+
| OID |        DATE         | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |     3       | 3000   |
| 100 | 2009-10-08 00:00:00 |     3       | 1500   |
| 101 | 2009-11-20 00:00:00 |     2       | 1560   |
| 103 | 2008-05-20 00:00:00 |     4       | 2060   |
+-----+---------------------+-------------+--------+

Ahora, unamos estas dos tablas usando la consulta LEFT JOIN de la siguiente manera:

SELECT ID, NAME, AMOUNT, DATE FROM CUSTOMERS
LEFT JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

Después de la ejecución de la consulta anterior, recibirá el siguiente resultado:

+----+----------+--------+---------------------+
| ID |   NAME   | AMOUNT |         DATE        |
+----+----------+--------+---------------------+
|  1 |  Ramesh  |  NULL  |        NULL         |
|  2 |  Khilan  |  1560  | 2009-11-20 00:00:00 |
|  3 |  kaushik |  3000  | 2009-10-08 00:00:00 |
|  3 |  kaushik |  1500  | 2009-10-08 00:00:00 |
|  4 | Chaitali |  2060  | 2008-05-20 00:00:00 |
|  5 |  Hardik  |  NULL  |        NULL         |
|  6 |  Komal   |  NULL  |        NULL         |
|  7 |  Muffy   |  NULL  |        NULL         |
+----+----------+--------+---------------------+

Unión derecha

HSQLDB RIGHT JOIN devuelve todas las filas de la tabla derecha, incluso si no hay coincidencias en la tabla izquierda. Esto significa que si la cláusula ON coincide con 0 (cero) registros en la tabla de la izquierda, la combinación seguirá devolviendo una fila en el resultado, pero con NULL en cada columna de la tabla de la izquierda.

Esto significa que una combinación derecha devuelve todos los valores de la tabla derecha, más los valores coincidentes de la tabla izquierda o NULL en caso de que no haya un predicado de combinación coincidente.

Sintaxis

La sintaxis básica de RIGHT JOIN es como sigue -

SELECT table1.column1, table2.column2...
FROM table1
RIGHT JOIN table2
ON table1.common_field = table2.common_field;

Ejemplo

Considere las siguientes dos tablas, una titulada como tabla CLIENTES y otra titulada como tabla PEDIDOS de la siguiente manera:

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

+-----+---------------------+-------------+--------+
| OID |       DATE          | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |      3      |  3000  |
| 100 | 2009-10-08 00:00:00 |      3      |  1500  |
| 101 | 2009-11-20 00:00:00 |      2      |  1560  |
| 103 | 2008-05-20 00:00:00 |      4      |  2060  |
+-----+---------------------+-------------+--------+

Ahora, unamos estas dos tablas usando la consulta RIGHT JOIN de la siguiente manera:

SELECT ID, NAME, AMOUNT, DATE FROM CUSTOMERS
RIGHT JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

Después de la ejecución de la consulta anterior, recibirá el siguiente resultado.

+------+----------+--------+---------------------+
|  ID  |   NAME   | AMOUNT |        DATE         |
+------+----------+--------+---------------------+
|  3   |  kaushik |  3000  | 2009-10-08 00:00:00 |
|  3   |  kaushik |  1500  | 2009-10-08 00:00:00 |
|  2   |  Khilan  |  1560  | 2009-11-20 00:00:00 |
|  4   | Chaitali |  2060  | 2008-05-20 00:00:00 |
+------+----------+--------+---------------------+

Unión completa

HSQLDB FULL JOIN combina los resultados de las combinaciones externas izquierda y derecha.

La tabla unida contendrá todos los registros de ambas tablas y completará NULL para las coincidencias que faltan en cada lado.

Sintaxis

La sintaxis básica de FULL JOIN es la siguiente:

SELECT table1.column1, table2.column2...
FROM table1
FULL JOIN table2
ON table1.common_field = table2.common_field;

Aquí, la condición dada podría ser cualquier expresión dada según su requisito.

Ejemplo

Considere las siguientes dos tablas, una titulada como tabla CLIENTES y otra titulada como tabla PEDIDOS de la siguiente manera:

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

+-----+---------------------+-------------+--------+
| OID |         DATE        | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |    3        | 3000   |
| 100 | 2009-10-08 00:00:00 |    3        | 1500   |
| 101 | 2009-11-20 00:00:00 |    2        | 1560   |
| 103 | 2008-05-20 00:00:00 |    4        | 2060   |
+-----+---------------------+-------------+--------+

Ahora, unamos estas dos tablas usando la consulta FULL JOIN de la siguiente manera:

SELECT ID, NAME, AMOUNT, DATE FROM CUSTOMERS
FULL JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

Después de la ejecución de la consulta anterior, recibirá el siguiente resultado.

+------+----------+--------+---------------------+
|  ID  |    NAME  | AMOUNT |        DATE         |
+------+----------+--------+---------------------+
|   1  |  Ramesh  |  NULL  |        NULL         |
|   2  |  Khilan  |  1560  | 2009-11-20 00:00:00 |
|   3  |  kaushik |  3000  | 2009-10-08 00:00:00 |
|   3  |  kaushik |  1500  | 2009-10-08 00:00:00 |
|   4  | Chaitali |  2060  | 2008-05-20 00:00:00 |
|   5  |  Hardik  |  NULL  |        NULL         |
|   6  |   Komal  |  NULL  |        NULL         |
|   7  |   Muffy  |  NULL  |        NULL         |
|   3  |  kaushik |  3000  | 2009-10-08 00:00:00 |
|   3  |  kaushik |  1500  | 2009-10-08 00:00:00 |
|   2  |  Khilan  |  1560  | 2009-11-20 00:00:00 |
|   4  | Chaitali |  2060  | 2008-05-20 00:00:00 |
+------+----------+--------+---------------------+

Auto unión

SQL SELF JOIN se utiliza para unir una tabla consigo misma como si fueran dos tablas, cambiando temporalmente el nombre de al menos una tabla en la declaración SQL.

Sintaxis

La sintaxis básica de SELF JOIN es la siguiente:

SELECT a.column_name, b.column_name...
FROM table1 a, table1 b
WHERE a.common_field = b.common_field;

Aquí, la cláusula WHERE podría ser cualquier expresión dada según su requisito.

Ejemplo

Considere las siguientes dos tablas, una titulada como tabla CLIENTES y otra titulada como tabla PEDIDOS de la siguiente manera:

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

Ahora, unámonos a esta tabla usando la consulta SELF JOIN de la siguiente manera:

SELECT a.ID, b.NAME, a.SALARY FROM CUSTOMERS a, CUSTOMERS b
WHERE a.SALARY > b.SALARY;

Después de la ejecución de la consulta anterior, recibirá el siguiente resultado:

+----+----------+---------+
| ID |   NAME   | SALARY  |
+----+----------+---------+
| 2  |  Ramesh  | 1500.00 |
| 2  |  kaushik | 1500.00 |
| 1  | Chaitali | 2000.00 |
| 2  | Chaitali | 1500.00 |
| 3  | Chaitali | 2000.00 |
| 6  | Chaitali | 4500.00 |
| 1  |  Hardik  | 2000.00 |
| 2  |  Hardik  | 1500.00 |
| 3  |  Hardik  | 2000.00 |
| 4  |  Hardik  | 6500.00 |
| 6  |  Hardik  | 4500.00 |
| 1  |  Komal   | 2000.00 |
| 2  |  Komal   | 1500.00 |
| 3  |  Komal   | 2000.00 |
| 1  |  Muffy   | 2000.00 |
| 2  |  Muffy   | 1500.00 |
| 3  |  Muffy   | 2000.00 |
| 4  |  Muffy   | 6500.00 |
| 5  |  Muffy   | 8500.00 |
| 6  |  Muffy   | 4500.00 |
+----+----------+---------+

SQL NULL es un término que se utiliza para representar un valor perdido. Un valor NULO en una tabla es un valor en un campo que parece estar en blanco. Siempre que intentamos dar una condición, que compara el valor del campo o columna con NULL, no funciona correctamente.

Podemos manejar los valores NULL usando las tres cosas.

• IS NULL - El operador devuelve verdadero si el valor de la columna es NULL.

• IS NOT NULL - El operador devuelve verdadero si el valor de la columna NO es NULO.

• <=> - El operador compara valores, que (a diferencia del operador =) es verdadero incluso para dos valores NULL.

Para buscar columnas que sean NULL o NOT NULL, use IS NULL o IS NOT NULL respectivamente.

Ejemplo

Consideremos un ejemplo donde hay una mesa. tcount_tblque contiene dos columnas, autor y tutorial_count. Podemos proporcionar valores NULL al tutorial_count que indica que el autor no publicó ni un tutorial. Por lo tanto, el valor de tutorial_count para ese autor respectivo es NULL.

Ejecute las siguientes consultas.

create table tcount_tbl(author varchar(40) NOT NULL, tutorial_count INT);
INSERT INTO tcount_tbl values ('Abdul S', 20);
INSERT INTO tcount_tbl values ('Ajith kumar', 5);
INSERT INTO tcount_tbl values ('Jen', NULL);
INSERT INTO tcount_tbl values ('Bavya kanna', 8);
INSERT INTO tcount_tbl values ('mahran', NULL);
INSERT INTO tcount_tbl values ('John Poul', 10);
INSERT INTO tcount_tbl values ('Sathya Murthi', 6);

Utilice el siguiente comando para mostrar todos los registros del tcount_tbl mesa.

select * from tcount_tbl;

Después de la ejecución del comando anterior, recibirá el siguiente resultado.

+-----------------+----------------+
|     author      | tutorial_count |
+-----------------+----------------+
|      Abdul S    |      20        |
|    Ajith kumar  |      5         |
|        Jen      |     NULL       |
|    Bavya kanna  |      8         |
|       mahran    |     NULL       |
|     John Poul   |      10        |
|   Sathya Murthi |      6         |
+-----------------+----------------+

Para encontrar los registros donde la columna tutorial_count ES NULL, a continuación se muestra la consulta.

SELECT * FROM tcount_tbl WHERE tutorial_count IS NULL;

Después de la ejecución de la consulta, recibirá el siguiente resultado.

+-----------------+----------------+
|     author      | tutorial_count |
+-----------------+----------------+
|       Jen       |     NULL       |
|      mahran     |     NULL       |
+-----------------+----------------+

Para encontrar los registros donde la columna tutorial_count NO ES NULA, la siguiente es la consulta.

SELECT * FROM tcount_tbl WHERE tutorial_count IS NOT NULL;

Después de la ejecución de la consulta, recibirá el siguiente resultado.

+-----------------+----------------+
|      author     | tutorial_count |
+-----------------+----------------+
|      Abdul S    |      20        |
|     Ajith kumar |       5        |
|     Bavya kanna |       8        |
|     John Poul   |      10        |
|   Sathya Murthi |       6        |
+-----------------+----------------+

HSQLDB - Programa JDBC

Aquí está el programa JDBC que recupera los registros por separado de la tabla tcount_tbl donde tutorial_ count es NULL y tutorial_count NO es NULL. Guarde el siguiente programa enNullValues.java.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class NullValues {
   public static void main(String[] args) {
      Connection con = null;
      Statement stmt_is_null = null;
      Statement stmt_is_not_null = null;
      ResultSet result = null;
      try {
         Class.forName("org.hsqldb.jdbc.JDBCDriver");
         con = DriverManager.getConnection(
            "jdbc:hsqldb:hsql://localhost/testdb", "SA", "");
         stmt_is_null = con.createStatement();
         stmt_is_not_null = con.createStatement();
         result = stmt_is_null.executeQuery(
            "SELECT * FROM tcount_tbl WHERE tutorial_count IS NULL;");
         System.out.println("Records where the tutorial_count is NULL");
         
         while(result.next()){
            System.out.println(result.getString("author")+" |
            "+result.getInt("tutorial_count"));
         }
         result = stmt_is_not_null.executeQuery(
            "SELECT * FROM tcount_tbl WHERE tutorial_count IS NOT NULL;");
         System.out.println("Records where the tutorial_count is NOT NULL");
         
         while(result.next()){
            System.out.println(result.getString("author")+" |
            "+result.getInt("tutorial_count"));
         }
      } catch (Exception e) {
         e.printStackTrace(System.out);
      }
   }
}

Compile y ejecute el programa anterior usando el siguiente comando.

\>javac NullValues.java
\>Java NullValues

Después de la ejecución del comando anterior, recibirá el siguiente resultado.

Records where the tutorial_count is NULL
Jen         | 0
mahran      | 0

Records where the tutorial_count is NOT NULL
Abdul S        | 20
Ajith kumar    | 5
Bavya kanna    | 8
John Poul      | 10
Sathya Murthi  | 6

HSQLDB admite algunos símbolos especiales para la operación de coincidencia de patrones basada en expresiones regulares y el operador REGEXP.

A continuación se muestra la tabla de patrones, que se puede utilizar junto con el operador REGEXP.

Patrón	Qué coincide el patrón
^	Principio de la cadena
PS	Final de la cadena
.	Cualquier personaje
[...]	Cualquier carácter listado entre corchetes
[^ ...]	Cualquier carácter que no figure entre corchetes
p1 | p2 | p3	Alternancia; coincide con cualquiera de los patrones p1, p2 o p3
*	Cero o más instancias del elemento anterior
+	Una o más instancias del elemento anterior
{norte}	n instancias del elemento anterior
{Minnesota}	m hasta n instancias del elemento anterior

Ejemplo

Probemos diferentes consultas de ejemplo para cumplir con nuestros requisitos. Eche un vistazo a las siguientes consultas dadas.

Pruebe esta consulta para encontrar todos los autores cuyo nombre comience con '^ A'.

SELECT author FROM tcount_tbl WHERE REGEXP_MATCHES(author,'^A.*');

Después de la ejecución de la consulta anterior, recibirá el siguiente resultado.

+-----------------+
|     author      |
+-----------------+
|     Abdul S     |
|    Ajith kumar  |
+-----------------+

Pruebe esta consulta para encontrar todos los autores cuyo nombre termine con 'ul $'.

SELECT author FROM tcount_tbl WHERE REGEXP_MATCHES(author,'.*ul$');

Después de la ejecución de la consulta anterior, recibirá el siguiente resultado.

+-----------------+
|     author      |
+-----------------+
|    John Poul    |
+-----------------+

Pruebe esta consulta para encontrar todos los autores cuyo nombre contenga 'th'.

SELECT author FROM tcount_tbl WHERE REGEXP_MATCHES(author,'.*th.*');

Después de la ejecución de la consulta anterior, recibirá el siguiente resultado.

+-----------------+
|     author      |
+-----------------+
|    Ajith kumar  | 
|     Abdul S     |
+-----------------+

Pruebe esta consulta para encontrar todos los autores cuyo nombre comience con vocal (a, e, i, o, u).

SELECT author FROM tcount_tbl WHERE REGEXP_MATCHES(author,'^[AEIOU].*');

Después de la ejecución de la consulta anterior, recibirá el siguiente resultado.

+-----------------+
|     author      |
+-----------------+
|     Abdul S     |
|    Ajith kumar  |
+-----------------+

UN Transactiones un grupo secuencial de operaciones de manipulación de bases de datos, que se realiza y se considera como una sola unidad de trabajo. En otras palabras, cuando todas las operaciones se ejecuten con éxito, solo entonces se completará toda la transacción. Si alguna operación dentro de la transacción falla, toda la transacción fallará.

Propiedades de las transacciones

Básicamente, la transacción admite 4 propiedades estándar. Pueden denominarse propiedades ACID.

Atomicity - Todas las operaciones en las transacciones se ejecutan con éxito; de lo contrario, la transacción se aborta en el punto de falla y las operaciones anteriores se revierten a su posición anterior.

Consistency - La base de datos cambia de estado correctamente tras una transacción confirmada con éxito.

Isolation - Permite que la transacción opere de forma independiente y transparente entre sí.

Durability - El resultado o efecto de una transacción comprometida persiste en caso de falla del sistema.

Confirmar, deshacer y guardar punto

Estas palabras clave se utilizan principalmente para transacciones HSQLDB.

Commit- Siempre la transacción exitosa debe completarse ejecutando el comando COMMIT.

Rollback - Si ocurre una falla en la transacción, entonces se debe ejecutar el comando ROLLBACK para devolver cada tabla referenciada en la transacción a su estado anterior.

Savepoint - Crea un punto dentro del grupo de transacciones en el que retroceder.

Ejemplo

El siguiente ejemplo explica el concepto de transacciones junto con la confirmación, la reversión y el punto de guardado. Consideremos la tabla Clientes con las columnas id, nombre, edad, dirección y salario.

Carné de identidad	Nombre	Años	Habla a	Salario
1	Ramesh	32	Ahmedabad	2000,00
2	Karun	25	Delhi	1500,00
3	Kaushik	23	Kota	2000,00
4	Chaitanya	25	Mumbai	6500,00
5	Harish	27	Bhopal	8500,00
6	Kamesh	22	MP	1500,00
7	Murali	24	Indore	10000,00

Utilice los siguientes comandos para crear la tabla de clientes según las líneas de los datos anteriores.

CREATE TABLE Customer (id INT NOT NULL, name VARCHAR(100) NOT NULL, age INT NOT
NULL, address VARCHAR(20), Salary INT, PRIMARY KEY (id));
Insert into Customer values (1, "Ramesh", 32, "Ahmedabad", 2000);
Insert into Customer values (2, "Karun", 25, "Delhi", 1500);
Insert into Customer values (3, "Kaushik", 23, "Kota", 2000);
Insert into Customer values (4, "Chaitanya", 25, "Mumbai", 6500);
Insert into Customer values (5, "Harish", 27, "Bhopal", 8500);
Insert into Customer values (6, "Kamesh", 22, "MP", 1500);
Insert into Customer values (7, "Murali", 24, "Indore", 10000);

Ejemplo de COMMIT

La siguiente consulta elimina filas de la tabla que tienen edad = 25 y usa el comando COMMIT para aplicar esos cambios en la base de datos.

DELETE FROM CUSTOMERS WHERE AGE = 25;
COMMIT;

Después de la ejecución de la consulta anterior, recibirá el siguiente resultado.

2 rows effected

Después de la ejecución exitosa del comando anterior, verifique los registros de la tabla de clientes ejecutando el comando dado a continuación.

Select * from Customer;

Después de la ejecución de la consulta anterior, recibirá el siguiente resultado.

+----+----------+-----+-----------+----------+
| ID |   NAME   | AGE |   ADDRESS |  SALARY  |
+----+----------+-----+-----------+----------+
| 1  |  Ramesh  |  32 | Ahmedabad |   2000   |
| 3  |  kaushik |  23 |   Kota    |   2000   |
| 5  |  Harish  |  27 |   Bhopal  |   8500   |
| 6  |  Kamesh  |  22 |    MP     |   4500   |
| 7  |  Murali  |  24 |   Indore  |   10000  |
+----+----------+-----+-----------+----------+

Ejemplo de reversión

Consideremos la misma tabla de clientes como entrada.

Carné de identidad	Nombre	Años	Habla a	Salario
1	Ramesh	32	Ahmedabad	2000,00
2	Karun	25	Delhi	1500,00
3	Kaushik	23	Kota	2000,00
4	Chaitanya	25	Mumbai	6500,00
5	Harish	27	Bhopal	8500,00
6	Kamesh	22	MP	1500,00
7	Murali	24	Indore	10000,00

Aquí está la consulta de ejemplo que explica acerca de la funcionalidad de Retroceso eliminando registros de la tabla que tienen edad = 25 y luego ROLLBACK los cambios en la base de datos.

DELETE FROM CUSTOMERS WHERE AGE = 25;
ROLLBACK;

Después de la ejecución exitosa de las dos consultas anteriores, puede ver los datos del registro en la tabla Cliente usando el siguiente comando.

Select * from Customer;

Después de la ejecución del comando anterior, recibirá el siguiente resultado.

+----+----------+-----+-----------+----------+
| ID |   NAME   | AGE |   ADDRESS |  SALARY  |
+----+----------+-----+-----------+----------+
|  1 |  Ramesh  |  32 | Ahmedabad |   2000   |
|  2 |  Karun   |  25 |   Delhi   |   1500   |
|  3 |  Kaushik |  23 |   Kota    |   2000   |
|  4 | Chaitanya|  25 |   Mumbai  |   6500   |
|  5 |  Harish  |  27 |   Bhopal  |   8500   |
|  6 |  Kamesh  |  22 |     MP    |   4500   |
|  7 |  Murali  |  24 |    Indore |   10000  |
+----+----------+-----+-----------+----------+

La consulta de eliminación elimina los datos de registro de los clientes cuya edad = 25. El comando Revertir, revierte esos cambios en la tabla Cliente.

Ejemplo de Savepoint

Savepoint es un punto en una transacción en el que puede revertir la transacción hasta cierto punto sin revertir toda la transacción.

Consideremos la misma tabla de clientes como entrada.

Carné de identidad	Nombre	Años	Habla a	Salario
1	Ramesh	32	Ahmedabad	2000,00
2	Karun	25	Delhi	1500,00
3	Kaushik	23	Kota	2000,00
4	Chaitanya	25	Mumbai	6500,00
5	Harish	27	Bhopal	8500,00
6	Kamesh	22	MP	1500,00
7	Murali	24	Indore	10000,00

Consideremos en este ejemplo que planea eliminar los tres registros diferentes de la tabla Clientes. Desea crear un punto de guardado antes de cada eliminación, de modo que pueda volver a cualquier punto de guardado en cualquier momento para devolver los datos apropiados a su estado original.

Aquí está la serie de operaciones.

SAVEPOINT SP1;
DELETE FROM CUSTOMERS WHERE ID = 1;
SAVEPOINT SP2;
DELETE FROM CUSTOMERS WHERE ID = 2;
SAVEPOINT SP3;
DELETE FROM CUSTOMERS WHERE ID = 3;

Ahora, ha creado tres puntos de guardado y ha eliminado tres registros. En esta situación, si desea revertir los registros que tienen Id 2 y 3, utilice el siguiente comando Revertir.

ROLLBACK TO SP2;

Observe que solo se llevó a cabo la primera eliminación desde que revertió al SP2. Utilice la siguiente consulta para mostrar todos los registros de los clientes.

Select * from Customer;

Después de la ejecución de la consulta anterior, recibirá el siguiente resultado.

+----+----------+-----+-----------+----------+
| ID |   NAME   | AGE |   ADDRESS |  SALARY  |
+----+----------+-----+-----------+----------+
|  2 |   Karun  |  25 |  Delhi    |   1500   |
|  3 |  Kaushik |  23 |  Kota     |   2000   |
|  4 | Chaitanya|  25 |  Mumbai   |   6500   |
|  5 |  Harish  |  27 |  Bhopal   |   8500   |
|  6 |  Kamesh  |  22 |  MP       |   4500   |
|  7 |  Murali  |  24 |  Indore   |  10000   |
+----+----------+-----+-----------+----------+

Liberar Savepoint

Podemos liberar el punto de guardado usando el comando RELEASE. A continuación se muestra la sintaxis genérica.

RELEASE SAVEPOINT SAVEPOINT_NAME;

Siempre que sea necesario cambiar el nombre de una tabla o un campo, cambiar el orden de los campos, cambiar el tipo de datos de los campos o cualquier estructura de la tabla, puede lograr lo mismo usando el comando ALTER.

Ejemplo

Consideremos un ejemplo que explica el comando ALTER utilizando diferentes escenarios.

Utilice la siguiente consulta para crear una tabla llamada testalter_tbl con los campos ' id y name.

//below given query is to create a table testalter_tbl table.
create table testalter_tbl(id INT, name VARCHAR(10));

//below given query is to verify the table structure testalter_tbl.
Select * From INFORMATION_SCHEMA.SYSTEM_COLUMNS as C Where C.TABLE_SCHEM =
   'PUBLIC' AND C.TABLE_NAME = 'TESTALTER_TBL';

Después de la ejecución de la consulta anterior, recibirá el siguiente resultado.

+------------+-------------+------------+-----------+-----------+------------+
|TABLE_SCHEM |  TABLE_NAME | COLUMN_NAME| DATA_TYPE | TYPE_NAME | COLUMN_SIZE|
+------------+-------------+------------+-----------+-----------+------------+
|   PUBLIC   |TESTALTER_TBL|     ID     |     4     |   INTEGER |     4      |
|   PUBLIC   |TESTALTER_TBL|    NAME    |     12    |   VARCHAR |     10     |
+------------+-------------+------------+-----------+-----------+------------+

Quitar o agregar una columna

Siempre que desee DROP una columna existente de la tabla HSQLDB, puede usar la cláusula DROP junto con el comando ALTER.

Utilice la siguiente consulta para quitar una columna (name) de la tabla testalter_tbl.

ALTER TABLE testalter_tbl DROP name;

Después de la ejecución exitosa de la consulta anterior, puede saber si el campo de nombre se elimina de la tabla testalter_tbl usando el siguiente comando.

Select * From INFORMATION_SCHEMA.SYSTEM_COLUMNS as C Where C.TABLE_SCHEM =
   'PUBLIC' AND C.TABLE_NAME = 'TESTALTER_TBL';

Después de la ejecución del comando anterior, recibirá el siguiente resultado.

+------------+-------------+------------+-----------+-----------+------------+
|TABLE_SCHEM |  TABLE_NAME | COLUMN_NAME| DATA_TYPE | TYPE_NAME | COLUMN_SIZE|
+------------+-------------+------------+-----------+-----------+------------+
|  PUBLIC    |TESTALTER_TBL|      ID    |      4    |   INTEGER |     4      |
+------------+-------------+------------+-----------+-----------+------------+

Siempre que desee agregar cualquier columna a la tabla HSQLDB, puede usar la cláusula ADD junto con el comando ALTER.

Use la siguiente consulta para agregar una columna llamada NAME a la mesa testalter_tbl.

ALTER TABLE testalter_tbl ADD name VARCHAR(10);

Después de la ejecución exitosa de la consulta anterior, puede saber si el campo de nombre se agrega a la tabla testalter_tbl usando el siguiente comando.

Select * From INFORMATION_SCHEMA.SYSTEM_COLUMNS as C Where C.TABLE_SCHEM =
   'PUBLIC' AND C.TABLE_NAME = 'TESTALTER_TBL';

Después de la ejecución de la consulta anterior, recibirá el siguiente resultado.

+------------+-------------+------------+-----------+-----------+------------+
|TABLE_SCHEM |  TABLE_NAME | COLUMN_NAME| DATA_TYPE | TYPE_NAME | COLUMN_SIZE|
+------------+-------------+------------+-----------+-----------+------------+
|  PUBLIC    |TESTALTER_TBL|      ID    |     4     |   INTEGER |     4      |
|  PUBLIC    |TESTALTER_TBL|     NAME   |     12    |   VARCHAR |     10     |
+------------+-------------+------------+-----------+-----------+------------+

Cambiar la definición o el nombre de una columna

Siempre que exista el requisito de cambiar la definición de columna, utilice el MODIFY o CHANGE cláusula junto con la ALTER mando.

Consideremos un ejemplo que explicará cómo utilizar la cláusula CHANGE. La mesatestalter_tblcontiene dos campos, id y nombre, con tipos de datos int y varchar respectivamente. Ahora intentemos cambiar el tipo de datos de id de INT a BIGINT. A continuación se muestra la consulta para realizar el cambio.

ALTER TABLE testalter_tbl CHANGE id id BIGINT;

Después de la ejecución exitosa de la consulta anterior, la estructura de la tabla se puede verificar usando el siguiente comando.

Select * From INFORMATION_SCHEMA.SYSTEM_COLUMNS as C Where C.TABLE_SCHEM =
   'PUBLIC' AND C.TABLE_NAME = 'TESTALTER_TBL';

Después de la ejecución del comando anterior, recibirá el siguiente resultado.

+------------+-------------+------------+-----------+-----------+------------+
|TABLE_SCHEM |  TABLE_NAME | COLUMN_NAME| DATA_TYPE | TYPE_NAME | COLUMN_SIZE|
+------------+-------------+------------+-----------+-----------+------------+
|  PUBLIC    |TESTALTER_TBL|      ID    |     4     |   BIGINT  |     4      |
|  PUBLIC    |TESTALTER_TBL|     NAME   |     12    |   VARCHAR |     10     |
+------------+-------------+------------+-----------+-----------+------------+

Ahora intentemos aumentar el tamaño de una columna NAME de 10 a 20 en el testalter_tblmesa. A continuación se muestra la consulta para lograr esto usando la cláusula MODIFY junto con el comando ALTER.

ALTER TABLE testalter_tbl MODIFY name VARCHAR(20);

Después de la ejecución exitosa de la consulta anterior, la estructura de la tabla se puede verificar usando el siguiente comando.

Select * From INFORMATION_SCHEMA.SYSTEM_COLUMNS as C Where C.TABLE_SCHEM =
   'PUBLIC' AND C.TABLE_NAME = 'TESTALTER_TBL';

Después de la ejecución del comando anterior, recibirá el siguiente resultado.

+------------+-------------+------------+-----------+-----------+------------+
|TABLE_SCHEM |  TABLE_NAME | COLUMN_NAME| DATA_TYPE | TYPE_NAME | COLUMN_SIZE|
+------------+-------------+------------+-----------+-----------+------------+
|  PUBLIC    |TESTALTER_TBL|    ID      |      4    |    BIGINT |     4      |
|  PUBLIC    |TESTALTER_TBL|    NAME    |     12    |   VARCHAR |    20      |
+------------+-------------+------------+-----------+-----------+------------+

UN database indexes una estructura de datos que mejora la velocidad de las operaciones en una tabla. Los índices se pueden crear utilizando una o más columnas, lo que proporciona la base tanto para búsquedas aleatorias rápidas como para ordenar eficazmente el acceso a los registros.

Al crear un índice, se debe considerar cuáles son las columnas que se utilizarán para realizar consultas SQL y crear uno o más índices en esas columnas.

Prácticamente, los índices también son tipos de tablas, que mantienen la clave principal o el campo de índice y un puntero a cada registro en la tabla real.

Los usuarios no pueden ver los índices. Solo se utilizan para acelerar las consultas y el motor de búsqueda de bases de datos los utilizará para localizar registros rápidamente.

Las instrucciones INSERT y UPDATE toman más tiempo en tablas que tienen índices, mientras que las instrucciones SELECT se ejecutan más rápido en esas tablas. El motivo es que, al insertar o actualizar, la base de datos también debe insertar o actualizar los valores del índice.

Índice simple y único

Puede crear un índice único en una tabla. UNunique indexsignifica que dos filas no pueden tener el mismo valor de índice. A continuación se muestra la sintaxis para crear un índice en una tabla.

CREATE UNIQUE INDEX index_name
ON table_name (column1, column2,...);

Puede utilizar una o más columnas para crear un índice. Por ejemplo, cree un índice en tutorials_tbl usando tutorial_author.

CREATE UNIQUE INDEX AUTHOR_INDEX
ON tutorials_tbl (tutorial_author)

Puede crear un índice simple en una tabla. Simplemente omita la palabra clave UNIQUE de la consulta para crear un índice simple. UNsimple index permite valores duplicados en una tabla.

Si desea indexar los valores en una columna en orden descendente, puede agregar la palabra reservada DESC después del nombre de la columna.

CREATE UNIQUE INDEX AUTHOR_INDEX
ON tutorials_tbl (tutorial_author DESC)

ALTER Comando para agregar y soltar ÍNDICE

Hay cuatro tipos de declaraciones para agregar índices a una tabla:

• ALTER TABLE tbl_name ADD PRIMARY KEY (column_list) - Esta declaración agrega una CLAVE PRIMARIA, lo que significa que los valores indexados deben ser únicos y no pueden ser NULL.

• ALTER TABLE tbl_name ADD UNIQUE index_name (column_list) - Esta declaración crea un índice para el cual los valores deben ser únicos (con la excepción de los valores NULL, que pueden aparecer varias veces).

• ALTER TABLE tbl_name ADD INDEX index_name (column_list) - Esto agrega un índice ordinario en el que cualquier valor puede aparecer más de una vez.

• ALTER TABLE tbl_name ADD FULLTEXT index_name (column_list) - Esto crea un índice FULLTEXT especial que se utiliza para fines de búsqueda de texto.

A continuación se muestra la consulta para agregar índice en una tabla existente.

ALTER TABLE testalter_tbl ADD INDEX (c);

Puede eliminar cualquier ÍNDICE utilizando la cláusula DROP junto con el comando ALTER. A continuación se muestra la consulta para eliminar el índice creado anteriormente.

ALTER TABLE testalter_tbl DROP INDEX (c);

Visualización de información de ÍNDICE

Puede utilizar el comando SHOW INDEX para enumerar todos los índices asociados con una tabla. La salida de formato vertical (especificada por \ G) a menudo es útil con esta declaración, para evitar líneas largas envolventes.

A continuación se muestra la sintaxis genérica para mostrar la información del índice sobre una tabla.

SHOW INDEX FROM table_name\G