Java admite muchas bases de datos y, para cada base de datos, debemos tener sus respectivos archivos jar para colocarlos en la ruta de compilación para continuar con la conectividad JDBC. Primero, debemos decidir qué base de datos estamos usando y, en consecuencia, debemos agregar los frascos. Para otras bases de datos como Progress, Cassandra, etc., también tenemos archivos jar y debemos incluirlos en la ruta de compilación. Hay diferentes tipos de uniones disponibles en MySQL y, según los requisitos, podemos enmarcar consultas.
Join es una combinación que brinda la posibilidad de conectar dos tablas que se fusionan entre sí de acuerdo con un campo que es común y crea una nueva tabla virtual.
- COMBINACIÓN NATURAL : es un tipo de combinación que recupera datos dentro de tablas específicas en un campo específico que coincide.
- UNIÓN IZQUIERDA NATURAL : En esta operación, ambas tablas se fusionan entre sí según campos comunes, pero se da prioridad a la primera tabla en la base de datos.
- UNIÓN DERECHA NATURAL : También es lo mismo que la combinación izquierda natural pero recupera los datos de la segunda tabla en la base de datos.
Tablas de MySQL que se utilizan en el código:
primera mesa
CREATE TABLE `studentsdetails` ( `id` int(6) unsigned NOT NULL, `Name` varchar(50) NOT NULL, `caste` varchar(10) NOT NULL, `NeetMarks` int(11) NOT NULL, `gender` varchar(10) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=latin1;
Segunda mesa
CREATE TABLE `studentspersonaldetails` ( `id` int(6) unsigned NOT NULL AUTO_INCREMENT, `Name` varchar(30) NOT NULL, `Address` varchar(30) NOT NULL, `email` varchar(50) DEFAULT NULL, `reg_date` timestamp NOT NULL DEFAULT current_timestamp() ON UPDATE current_timestamp(), PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8mb4;
En ambas tablas, «Nombre» es la columna común. La primera tabla especifica Género, NeetMarks, Casta, etc., mientras que la segunda tabla especifica la dirección, el correo electrónico, etc. Ahora solo es necesario crear una consulta SQL para unirse a la tabla, que es la siguiente:
SELECT * FROM " + "studentsdetails" + " NATURAL JOIN " + "studentspersonaldetails"
Ahora, a medida que se ejecuta esta consulta, recupera datos dentro de las tablas especificadas con un campo específico que coincide, coincidirá con los registros en ambas tablas dependiendo de la columna «Nombre», implementando el concepto de unión natural en juego. Ahora el programa depende de los datos presentes en ambas tablas y de los valores coincidentes de la columna «Nombre» en ambas tablas para obtener el resultado deseado.
Implementación: ahora ejecute el comando de consulta anterior con la ayuda del siguiente programa según Natural Join.
Java
// Java Program to Join Contents
// of More than One Table & Display in JDBC
// Step 1: Importing DB files
// Provides the API for accessing and processing
// data stored in a data source
import java.sql.*;
// Class for Joining of multiple tables
public class GFG {
// Main driver method
public static void main(String[] args)
{
// Display message
System.out.println(
"Joining 2 MySQL tables using Natural Join");
// DB 'Connection' object of Connection class
Connection con = null;
// Try block to check exceptions
try {
// Step 2: Load and register drivers
// Loading driver
// Jars(relevant) or mysql-connector-java-8.0.22
// in build path of project
Class.forName("com.mysql.cj.jdbc.Driver");
// Registering driver
// test is database name here
// serverTimezone=UTC, if not provided we will
// have java.sql.SQLException
// Credentials here are root/""
// i.e. username is root
// password is ""
// Step 3: Establishing a connection
con = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/test?serverTimezone=UTC",
"root", "");
// Try block to check java exceptions
try {
// Step 4: Write a statement
// Join
Statement st = con.createStatement();
// Combining two tables in query using
// NATURAL JOIN studentsdetails columns :
// Name,caste,NeetMarks,gender
// studentspersonaldetails columns :
// Name,Address,email
// In both tables, connecting columns are
// Name Name is taken Here res will have the
// data from
// both studentsdetails and
// studentspersonaldetails whenever "Name"
// in both tables are matched join
ResultSet res = st.executeQuery(
"SELECT *FROM "
+ "studentsdetails"
+ " NATURAL JOIN "
+ "studentspersonaldetails");
// Step 5: Execute the query
System.out.println(" StuName"
+ " Gender"
+ " Caste "
+ "Neet Marks"
+ " Email");
// Step 6: Process the statements
// Iterate the resultset and retrieve the
// required fields
while (res.next()) {
String name = res.getString("Name");
String gender = res.getString("gender");
String caste = res.getString("caste");
String neetMarks
= res.getString("NeetMarks");
String email = res.getString("email");
// Beautification of output
System.out.format(
"%10s%10s%10s%10s%20s\n", name,
gender, caste, neetMarks, email);
}
// Step 7: Close the connection
con.close();
}
// Catch bloack to handle DB exceptions
catch (SQLException s) {
// If there is error in SQL query, this
// exception occurs
System.out.println(
"SQL statement is not executed!");
}
// Catch bloack to handle generic java
// exceptions
}
catch (Exception e) {
// General exception apart from SQLException are
// caught here
e.printStackTrace();
}
}
}
Producción :
De manera similar, también podemos usar el resto de las otras uniones en la consulta SQL. Join y Natural join solo hacen que las columnas coincidan en ambas tablas y muestren datos de ambas tablas. Según los requisitos, para
- Unión izquierda natural : La prioridad va a la primera mesa.
- Unión derecha natural : La prioridad va a la segunda mesa.
Para diferentes servidores, se utilizan diferentes archivos jar.
para sql
Paso 1: Cargue la clase de controlador
jar a utilizar: sqljdbc4.jar
Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
Paso 2: Cree una conexión para la cual la string de conexión «HOSP_SQL1.company.com» sea definida por el usuario. Del mismo modo, podemos usar nombre de usuario, contraseña, la base de datos se puede usar como se muestra
Connection conn = DriverManager.getConnection(“jdbc:sqlserver://HOSP_SQL1.company.com;user=name;password=abcdefg;database=Test”);
para oráculo
Paso 1: Cargue la clase de controlador
jar a utilizar: ojdbc14.jar
Class.forName("oracle.jdbc.driver.OracleDriver");
Paso 2: cree un objeto de conexión seguido del nombre de usuario y la contraseña
Connection con=DriverManager.getConnection( "jdbc:oracle:thin:@localhost:1521:xe","system","oracle");
Publicación traducida automáticamente
Artículo escrito por priyarajtt y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA