Java Database Connectivity también se conoce como JDBC y es una interfaz de programación de aplicaciones en Java que se utiliza para establecer la conectividad entre una aplicación Java y una base de datos. Los comandos JDBC se pueden usar para realizar operaciones SQL desde la aplicación Java. Demostración de la ejecución de múltiples comandos SQL en una base de datos simultáneamente usando los comandos addBatch() y executeBatch() de JDBC.
El comando addBatch() se usa para poner en cola las sentencias SQL y el comando executeBatch() se usa para ejecutar todas las sentencias SQL en cola a la vez. Para utilizar instrucciones SQL en la aplicación Java, es necesario importar el paquete «java.sql» al principio de la aplicación Java. La aplicación Java se conecta a la base de datos utilizando el método getConnection() de la clase DriverManager. El método getConnection() toma tres parámetros URL, nombre de usuario y contraseña.
Objetivo: Demuestra dos ejemplos de los cuales uno usa la interfaz de declaraciones y el otro usa la interfaz de declaraciones preparadas . PreparedStatement funciona mejor que la interfaz de declaración. La interfaz de declaraciones se puede usar para ejecutar consultas SQL estáticas, mientras que la interfaz PreparedStatement se usa para ejecutar consultas SQL dinámicas varias veces.
Ejemplo 1: uso de la interfaz de declaración
En este ejemplo, se importan las clases e interfaces del paquete java.sql. La interfaz de declaración se utiliza para ejecutar las declaraciones sql. La declaración SQL de creación de tablas junto con la declaración SQL de inserción de registros se agregan al lote mediante el comando addBatch(). Cuando todas las declaraciones se procesan por lotes, se ejecuta el comando executeBatch(), que ejecuta todas las consultas por lotes simultáneamente. Las declaraciones sql pueden arrojar excepciones SQL que deben manejarse en un bloque try catch para evitar la terminación abrupta del programa. Después de que se crea la tabla y se insertan los registros, para ver los datos en la tabla, se ejecuta la consulta de selección. El resultado obtenido al ejecutar la consulta de selección se almacena en el cursor ResultSet. El cursor se itera utilizando el método next() y los registros se muestran en la pantalla.
Implementación: Uso de la interfaz estándar
Java
// Step 1: Create a database
// SQL database imported
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
public class BatchCommand {
// Main driver method
public static void main(String args[])
{
// Try block to check if exception occurs
try {
// Step 2: Loading driver class
// Using forName()
Class.forName("oracle.jdbc.OracleDriver");
// Step 3: Create connection object
Connection con = DriverManager.getConnection(
"jdbc:oracle:thin:@localhost:1521:xe",
"username", "password");
Statement s = con.createStatement();
// Step 4: Create a statement / create table
String sql1
= "CREATE TABLE STUDENT(STUDENTID VARCHAR2(10) PRIMARY KEY,NAME VARCHAR2(20),DEPARTMENT VARCHAR2(10))";
// Step 5: Process a query
// Insert records in the table
String sql2
= "INSERT INTO STUDENT VALUES('S101','JEAN','CSE')";
String sql3
= "INSERT INTO STUDENT VALUES('S102','ANA','CSE')";
String sql4
= "INSERT INTO STUDENT VALUES('S103','ROBERT','ECE')";
String sql5
= "INSERT INTO STUDENT VALUES('S104','ALEX','IT')";
String sql6
= "INSERT INTO STUDENT VALUES('S105','DIANA','IT')";
s.addBatch(sql1);
s.addBatch(sql2);
s.addBatch(sql3);
s.addBatch(sql4);
s.addBatch(sql5);
s.addBatch(sql6);
// Step 6: Process the results
// execute the sql statements
s.executeBatch();
ResultSet rs
= s.executeQuery("Select * from Student");
// Print commands
System.out.println(
"StudentID\tName\t\tDepartment");
System.out.println(
"-------------------------------------------------------");
// Condition to check pointer pointing
while (rs.next()) {
System.out.println(rs.getString(1) + "\t\t"
+ rs.getString(2)
+ "\t\t"
+ rs.getString(3));
}
// Step 7: Close the connection
con.commit();
con.close();
}
// Catch block to handle exceptions
catch (Exception e) {
// Print line number if exception occurred
System.out.println(e);
}
}
}
Comandos SQL sobre la base de datos usando el método addBatch() con la participación de executeBatch()
Java
// Step 1: Importing database
// SQL database imported
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
public class BatchCommand {
// Main driver method
public static void main(String args[])
{
// Try block to handle if exception occurs
try {
// Step 2: loading driver class
Class.forName("oracle.jdbc.OracleDriver");
// Step 3: create connection object
Connection con = DriverManager.getConnection(
"jdbc:oracle:thin:@localhost:1521:xe",
"username", "password");
Statement s = con.createStatement();
// Step 4: Create a statement
// Create table
String sql1
= "CREATE TABLE STUDENT(STUDENTID VARCHAR2(10) PRIMARY KEY,NAME VARCHAR2(20),DEPARTMENT VARCHAR2(10))";
// Step 5: Execute a query
// Insert records in the table
String sql2
= "INSERT INTO STUDENT VALUES('S101','JEAN','CSE')";
String sql3
= "INSERT INTO STUDENT VALUES('S102','ANA','CSE')";
String sql4
= "INSERT INTO STUDENT VALUES('S103','ROBERT','ECE')";
String sql5
= "INSERT INTO STUDENT VALUES('S104','ALEX','IT')";
String sql6
= "INSERT INTO STUDENT VALUES('S105','DIANA','IT')";
s.addBatch(sql1);
s.addBatch(sql2);
s.addBatch(sql3);
s.addBatch(sql4);
s.addBatch(sql5);
s.addBatch(sql6);
// Step 6: Process the statements
// Create an int[] to hold returned values
s.executeBatch();
ResultSet rs
= s.executeQuery("Select * from Student");
// Print statements
System.out.println(
"StudentID\tName\t\tDepartment");
System.out.println(
"-------------------------------------------------------");
// Condition check for pointer pointing which
// record
while (rs.next()) {
System.out.println(rs.getString(1) + "\t\t"
+ rs.getString(2)
+ "\t\t"
+ rs.getString(3));
}
// Step 7: Close the connection
con.commit();
con.close();
}
// Catch block to handle exception
catch (Exception e) {
// Print line number where exception occurred
System.out.println(e);
}
}
}
Producción
Ejemplo 2:En este ejemplo, se importan las clases e interfaces del paquete java.sql. La interfaz PreparedStatement se utiliza para ejecutar las sentencias SQL. La tabla es la instrucción SQL de creación junto con la instrucción SQL de inserción de registros que se agregan al lote mediante el comando addBatch(). Cuando todas las declaraciones se procesan por lotes, se ejecuta el comando executeBatch(), que ejecuta todas las consultas por lotes simultáneamente. Las declaraciones sql pueden arrojar excepciones SQL que deben manejarse en un bloque try-catch para evitar la terminación abrupta del programa. Después de que se crea la tabla y se insertan los registros, para ver los datos en la tabla, se ejecuta la consulta de selección. El resultado obtenido al ejecutar la consulta de selección se almacena en el cursor ResultSet. El cursor se itera utilizando el método next() y los registros se muestran en la pantalla. A diferencia del ejemplo anterior, toma entrada dinámica del usuario. Por lo tanto, el uso de PreparedStatement tiene beneficios de rendimiento.
Implementación de código
Java
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.*;
public class AddBatchCommand {
public static void main(String args[])
{
Scanner scan = new Scanner(System.in);
try {
// loading driver class
Class.forName("oracle.jdbc.OracleDriver");
// create connection object
Connection con = DriverManager.getConnection(
"jdbc:oracle:thin:@localhost:1521:xe",
"username", "password");
// create the table
String sql1
= "CREATE TABLE STUDENTS(STUDENTID VARCHAR2(10) PRIMARY KEY,NAME VARCHAR2(20),DEPARTMENT VARCHAR2(10))";
PreparedStatement ps
= con.prepareStatement(sql1);
ps.execute(sql1);
// inserting records
String sql
= "Insert into Students values(?,?,?)";
PreparedStatement ps1
= con.prepareStatement(sql);
for (int i = 0; i < 3; i++) {
System.out.println("Enter Student ID");
String id = scan.nextLine();
System.out.println("Enter Student Name");
String name = scan.nextLine();
System.out.println("Enter the Department");
String dept = scan.nextLine();
ps1.setString(1, id);
ps1.setString(2, name);
ps1.setString(3, dept);
// adding to batch
ps1.addBatch();
}
// executing the batch
ps1.executeBatch();
// viewing the table
ResultSet rs
= ps.executeQuery("Select * from Students");
System.out.println(
"StudentID\tName\t\tDepartment");
System.out.println(
"-------------------------------------------------------");
while (rs.next()) {
System.out.println(rs.getString(1) + "\t\t"
+ rs.getString(2)
+ "\t\t"
+ rs.getString(3));
}
con.commit();
con.close();
}
catch (Exception e) {
System.out.println(e);
}
}
}
Salida: ilustrando múltiples comandos SQL en una base de datos simultáneamente:
Publicación traducida automáticamente
Artículo escrito por Shreyasi_Chakraborty y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA