Tipos de sentencias en JDBC

La interfaz de declaraciones se utiliza para crear declaraciones básicas de SQL en Java y proporciona métodos para ejecutar consultas con la base de datos. Hay diferentes tipos de declaraciones que se utilizan en JDBC de la siguiente manera:

• Crear declaración
• Declaración preparada
• Estado de cuenta exigible

1.  Crear una declaración: desde la interfaz de conexión, puede crear el objeto para esta interfaz. Por lo general, se usa para el acceso de propósito general a las bases de datos y es útil cuando se usan sentencias SQL estáticas en tiempo de ejecución.

Sintaxis:

Statement statement = connection.createStatement();

Implementación: una vez que se crea el objeto Declaración, hay tres formas de ejecutarlo.

• ejecución booleana (String SQL): si se recupera el objeto ResultSet, devuelve verdadero; de lo contrario, se devuelve falso. Se utiliza para ejecutar sentencias SQL DDL o para SQL dinámico.
• int executeUpdate(String SQL): Devuelve el número de filas que se ven afectadas por la ejecución de la declaración, se usa cuando necesita un número para las declaraciones INSERT, DELETE o UPDATE.
• ResultSet executeQuery(String SQL): Devuelve un objeto ResultSet. Se usa de manera similar a como SELECT se usa en SQL.

Ejemplo:

// Java Program illustrating Create Statement in JDBC
 
// Importing Database(SQL) classes
import java.sql.*;
 
// Class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Try block to check if any exceptions occur
        try {
 
            // Step 2: Loading and registering drivers
 
            // Loading driver using forName() method
            Class.forName("com.mysql.cj.jdbc.Driver");
 
            // Registering driver using DriverManager
            Connection con = DriverManager.getConnection(
                "jdbc:mysql:///world", "root", "12345");
 
            // Step 3: Create a statement
            Statement statement = con.createStatement();
            String sql = "select * from people";
 
            // Step 4: Execute the query
            ResultSet result = statement.executeQuery(sql);
 
            // Step 5: Process the results
 
            // Condition check using hasNext() method which
            // holds true till there is single element
            // remaining in List
            while (result.next()) {
 
                // Print name an age
                System.out.println(
                    "Name: " + result.getString("name"));
                System.out.println(
                    "Age:" + result.getString("age"));
            }
        }
 
        // Catching database exceptions if any
        catch (SQLException e) {
 
            // Print the exception
            System.out.println(e);
        }
 
        // Catching generic ClassNotFoundException if any
        catch (ClassNotFoundException e) {
 
            // Print and display the line number
            // where exception occurred
            e.printStackTrace();
        }
    }
}

Salida: el nombre y la edad son los que se muestran para las entradas aleatorias

2. La declaración preparada representa una declaración SQL recompilada, que se puede ejecutar muchas veces. Esto acepta consultas SQL parametrizadas. En esto, «?» se usa en lugar del parámetro, uno puede pasar el parámetro dinámicamente usando los métodos de DECLARACIÓN PREPARADA en tiempo de ejecución.

Ilustración: 

Considerando en la base de datos de personas si existe la necesidad de INSERTAR algunos valores, se utilizan sentencias SQL como estas: 

INSERT INTO people VALUES ("Ayan",25);
INSERT INTO people VALUES("Kriya",32);

Para hacer lo mismo en Java, uno puede usar declaraciones preparadas y establecer los valores en el ? titulares, setXXX() de una declaración preparada se usa como se muestra: 

String query = "INSERT INTO people(name, age)VALUES(?, ?)";
Statement pstmt = con.prepareStatement(query);
pstmt.setString(1,"Ayan");
ptstmt.setInt(2,25);
// where pstmt is an object name

Implementación: una vez que se crea el objeto PreparedStatement, hay tres formas de ejecutarlo: 

• ejecutar(): esto devuelve un valor booleano y ejecuta una declaración de SQL estático que está presente en el objeto de declaración preparado.
• executeQuery() : Devuelve un ResultSet de la declaración preparada actual.
• executeUpdate() : Devuelve el número de filas afectadas por las declaraciones DML como INSERTAR, ELIMINAR y más que están presentes en la Declaración preparada actual.

Ejemplo: 

// Java Program illustrating Prepared Statement in JDBC
 
// Step 1: Importing DB(SQL here) classes
import java.sql.*;
// Importing Scanner class to
// take input from the user
import java.util.Scanner;
 
// Main clas
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // try block to check for exceptions
        try {
 
            // Step 2: Establish a connection
 
            // Step 3: Load and register drivers
 
            // Loading drivers using forName() method
            Class.forName("com.mysql.cj.jdbc.Driver");
 
            // Scanner class to take input from user
            Scanner sc = new Scanner(System.in);
 
            // Display message for ease for user
            System.out.println(
                "What age do you want to search?? ");
 
            // Reading age an primitive datatype from user
            // using nextInt() method
            int age = sc.nextInt();
 
            // Registering drivers using DriverManager
            Connection con = DriverManager.getConnection(
                "jdbc:mysql:///world", "root", "12345");
 
            // Step 4: Create a statement
            PreparedStatement ps = con.prepareStatement(
                "select name from world.people where age = ?");
 
            // Step 5: Execute the query
            ps.setInt(1, age);
            ResultSet result = ps.executeQuery();
 
            // Step 6: Process the results
 
            // Condition check using next() method
            // to check for element
            while (result.next()) {
 
                // Print and display elements(Names)
                System.out.println("Name : "
                                   + result.getString(1));
            }
 
            // Step 7: Closing the connections
            // (Optional but it is recommended to do so)
        }
 
        // Catch block to handle database exceptions
        catch (SQLException e) {
 
            // Display the DB exception if any
            System.out.println(e);
        }
 
        // Catch block to handle class exceptions
        catch (ClassNotFoundException e) {
 
            // Print the line number where exception occurred
            // using printStackTrace() method if any
            e.printStackTrace();
        }
    }
}

Producción: 

3. Las declaraciones invocables son procedimientos almacenados que son un grupo de declaraciones que compilamos en la base de datos para alguna tarea, son beneficiosas cuando tratamos con múltiples tablas con escenarios complejos y en lugar de enviar múltiples consultas a la base de datos, podemos enviar los datos requeridos al procedimiento almacenado y reducir la lógica ejecutada en el propio servidor de la base de datos. La interfaz Callable Statement proporcionada por la API de JDBC ayuda a ejecutar procedimientos almacenados.

Sintaxis: Para preparar un CallableStatement

CallableStatement cstmt = con.prepareCall("{call Procedure_name(?, ?}");

Implementación: una vez que se crea el objeto de declaración invocable

• ejecutar() se utiliza para realizar la ejecución de la declaración.

Ejemplo:

// Java Program illustrating Callable Statement in JDBC
 
// Step 1: Importing DB(SQL) classes
import java.sql.*;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Try block to check if any exceptions occurs
        try {
 
            // Step 2: Establish a connection
 
            // Step 3: Loading and registering drivers
 
            // Loading driver using forName() method
            Class.forName("com.mysql.cj.jdbc.Driver");
 
            // Registering driver using DriverManager
            Connection con = DriverManager.getConnection(
                "jdbc:mysql:///world", "root", "12345");
 
            // Step 4: Create a statement
            Statement s = con.createStatement();
 
            // Step 5: Execute the query
            // select * from people
 
            CallableStatement cs
                = con.prepareCall("{call peopleinfo(?,?)}");
            cs.setString(1, "Bob");
            cs.setInt(2, 64);
            cs.execute();
            ResultSet result
                = s.executeQuery("select * from people");
 
            // Step 6: Process the results
 
            // Condition check using next() method
            // to check for element
            while (result.next()) {
 
                // Print and display elements (Name and Age)
                System.out.println("Name : "
                                   + result.getString(1));
                System.out.println("Age : "
                                   + result.getInt(2));
            }
        }
 
        // Catch statement for DB exceptions
        catch (SQLException e) {
 
            // Print the exception
            System.out.println(e);
        }
 
        // Catch block for generic class exceptions
        catch (ClassNotFoundException e) {
 
            // Print the line number where exception occurred
            e.printStackTrace();
        }
    }
}

Producción: