PREPARED STATEMENT JAVA

Cuando se ejecuta una sentencia SQL, la sentencia se compila y se envía al SGBD

para su ejecución. Si esta misma sentencia se va a ejecutar varias veces, puede ser
conveniente precompilarla para que su ejecución sea más eficiente.

Una PreparedStatement es una sentencia SQL precompilada.

Las utilizaremos en lugar de una Statement cuando haya que ejecutar varias veces
una misma sentencia SQL con distintos parámetros.

Ventajas de  PreparedStatement sobre Statement:

     Mayor velocidad de ejecución.
     No tendremos que revisar los datos que introduzca el usuario para formar
la sentencia SQL. Por Ejemplo:
En un Statement s si hacemos una operación como esta:
s.executeUpdate("UPDATE contacto SET nombre = '" +nombre + "' WHERE
id=100");
y nombre contiene por ejemplo O'Donnell obtendremos una instrucción mal
formada ya que habrá una comilla simple dentro del nombre que se tomará como
final de la cadena nombre, provocando un error. Esto se evita utilizando Prepared
Statements. A una PreparedStatement le pasamos los datos y realizará todo lo
necesario para crear una sentencia SQL correcta.

Tanto el servidor de bases de datos como el driver de conexión deben soportarlas.

Si no es así funcionarán igual que Statement.
Además, en la conexión debemos indicar al servidor que active el uso de Prepared
Statements.
  DriverManager.getConnection("jdbc:mysql://localhost/prueba?
useServerPrepStmts=true","root", "1daw");

Las Prepared Statements son un método para prevenir el SQL Injection.

Una PreparedStatement se crea utilizando el método prepareStatement() de

Connection,  escribiendo el signo ? en lugar de los parámetros.

Por ejemplo:
PreparedStatement ps = conexion.prepareStatement("INSERT INTO
contactos values (null,?,?,?)");
Una PreparedStatement es una sentencia SQL que contiene ? en los lugares donde
posteriormente se asignarán los valores. De este modo estamos indicando al SGBD
cuál es el código y cuáles son las variables que el usuario debe ingresar.

Estos valores se asignan mediante métodos setXxx(posición, valor). Donde Xxx es

el tipo de dato, posición indica la posición del interrogante que vamos a asignar y
valor contiene el valor asignado.

Ejemplo de uso de una Prepared Statement:

Insertar un registro en la tabla contactos

import java.sql.*;
public class EjemploAccesoBD8 {
public static void main(String[] args) {
Connection conexion = null;
try {
Class.forName("com.mysql.jdbc.Driver");
 conexion =
DriverManager.getConnection("jdbc:mysql://localhost/prueba?
useServerPrepStmts=true", "root", "1daw");
PreparedStatement ps = conexion.prepareStatement("INSERT INTO
contactos values (null,?,?,?)");
//Asigno al primer ? el String "Leopoldo".
//Corresponde al campo nombre de tipo VARCHAR
ps.setString(1, "Leopoldo");
// Asigno al segundo ? el String "Pelayo".
//Corresponde al campo apellidos de tipo VARCHAR
ps.setString(2, "Pelayo");
// Asigno al tercer ? el String "987876509".
//Corresponde al campo telefono de tipo VARCHAR
ps.setString(3, "999878765");
// Se ejecuta la operación.
ps.executeUpdate();
} catch (SQLException e) {
System.out.println(e.toString());
} catch (ClassNotFoundException e) {
System.out.println(e.toString());
} finally {
try {
if (conexion != null) {
conexion.close();
}
} catch (SQLException ex) {
System.out.println(ex.toString());
}
}
}
}

La clase PreparedStatement: 
1.      CONTENIDO:

DEFICICION:
La interfase PreparedStatement hereda de Statement y se diferencia de esta de dos
maneras.
• Las instancias de PreparedStatement contienen una sentencia SQL que ya ha sido
compilada. Esto es lo que hace que se le llame ‘prepared’ (preparada).
• La sentencia SQL contenida en un objeto PreparedStatement pueden tener uno o
más parámetros IN (entrada). Un parámetro de entrada es aquel cuyo valor no se
especifica en la sentencia SQL cuando se crea; en vez de ello la sentencia tiene un
interrogante (‘?’) como un ‘encaje’ para cada parámetro de entrada. Antes de
ejecutarse la sentencia se debe suministrar un valor para cada interrogante mediante
los métodos apropiados setXXX, que son añadidos por el interfaz PreparedStatement.
Debido a que los objetos PreparedStatement están precompilados, su ejecución será
más rápida que de los objetos Statement. Por lo tanto, a una sentencia SQL que se le
 va a ejecutar constantemente, se le suele crear como PreparedStatement para
incrementar su eficacia.
Siendo una subclase de la interfaz Statement, el interfaz PreparedStatement hereda
toda la funcionalidad del interfaz Statement. Además, se añade un set completo de
métodos necesarios para fijar los valores que van a ser enviados a la base de datos en
el lugar de los ‘encajes’ para los parámetros de entrada. También se modifican los tres
métodos execute, executeQuery y executeUpdate de tal forma que no toman
argumentos. Los formatos de Statement de estos métodos (los formatos que toman
una sentencia SQL como argumento) no deberían usarse nunca con objetos
PreparedStatement. 

              METODO ExecuteUpdate()
Ejecuta la instrucción SQL determinada, que puede ser una instrucción INSERT,
UPDATE o DELETE; o una instrucción SQL que no devuelve nada, como una
instrucción DDL de SQL.

 Sintaxis:
 
public int executeUpdate(java.lang.String sql) 
  Parámetros:
sql

Un objeto String que contiene la instrucción SQL.

 Valor devuelto
Un valor int que indica el número de filas afectadas o 0 si se usa una instrucción DDL.

              USO DE CallableStatement:

Este interfaz hereda del interfaz PreparedStatement y ofrece la posibilidad de manejar

parámetros de salida y de realizar llamadas a procedimientos almacenados de la base
de datos (ultimo tipo de sentencias a utilizar en JDBC).

Un objeto CallableStatement ofrece la posibilidad de realizar llamadas a

procedimientos almacenados de una forma estándar para todos los DBMS. Un
procedimiento almacenado se encuentra dentro de una base de datos; la llamada a un
procedimiento es lo que contiene un objeto CallableStatement. Esta llamada está
escrita con una sintaxis de escape, esta sintaxis puede tener dos formas diferentes:
una con un parámetro de resultado, es un tipo de parámetro de salida que representa
el valor devuelto por el procedimiento y otra sin ningún parámetro de resultado. Ambas
formas pueden tener un número variable de parámetros de entrada, de salida o de
entrada/salida. Una interrogación representará al parámetro.
 La sintaxis para realizar la llamada a un procedimiento almacenado es la siguiente:

{call nombre_del_procedimiento[(?,?,...)]}

Si devuelve un parámetro de resultado:

{?=call nombre_del_procedimiento[(?.?...)]}

La sintaxis de una llamada a un procedimiento sin ningún tipo de parámetros sería:

{call nombre_del_procedimiento}

              EJEMPLOS:
Este es un ejemplo de utilización del método executeQuery de un objeto
PreparedStatement para obtener un ResultSet.
import java.sql.*;
import java.util.Properties;

public class PreparedStatementExample {

    public static void main(java.lang.String[] args)

    {
        // Cargar lo siguiente desde un objeto de propiedades.
        String DRIVER = "com.ibm.db2.jdbc.app.DB2Driver";
        String URL    = "jdbc:db2://*local";

        // Registrar el controlador JDBC nativo. Si el controlador no puede

        // registrarse, la prueba no puede continuar.
        try {
            Class.forName(DRIVER);
        } catch (Exception e) {
            System.out.println("Imposible registrar el controlador.");
            System.out.println(e.getMessage());
            System.exit(1);
        }

        Connection c = null;

        Statement s = null;

        //    Este programa crea una tabla que

        //    las sentencias preparadas utilizan más tarde.
        try {
            // Crear las propiedades de conexión.
            Properties properties = new Properties ();
            properties.put ("user", "userid");
            properties.put ("password", "password");

            // Conectar con la base de datos local de iSeries.

            c = DriverManager.getConnection(URL, properties);

            // Crear un objeto Statement.

            s = c.createStatement();
            // Se suprime la tabla de prueba, si existe. Observe que
            // en todo este ejemplo se presupone que la colección
            // MYLIBRARY existe en el sistema.
            try {
                s.executeUpdate("DROP TABLE MYLIBRARY.MYTABLE");
            } catch (SQLException e) {
                // Se continúa simplemente... es probable que la tabla no exista.
            }

            // Se ejecuta una sentencia SQL que crea una tabla en la base de datos.
            s.executeUpdate("CREATE TABLE MYLIBRARY.MYTABLE (NAME
VARCHAR(20), ID INTEGER)");

        } catch (SQLException sqle) {

            System.out.println("El proceso de base de datos ha fallado.");
            System.out.println("Razón: " + sqle.getMessage());
        } finally {
            // Se cierran los recursos de base de datos.
            try {
                if (s != null) {
                    s.close();
                }
            } catch (SQLException e) {
                System.out.println("El borrado no ha podido cerrar Statement.");
}
        }

        //    A continuación, este programa utiliza una sentencia preparada para
        //    insertar muchas filas en la base de datos.
        PreparedStatement ps = null;
        String[] nameArray = {"Rich", "Fred", "Mark", "Scott", "Jason",
            "John", "Jessica", "Blair", "Erica", "Barb"};
        try {
            // Crear un objeto PreparedStatement utilizado para insertar datos en la
            // tabla.
            ps = c.prepareStatement("INSERT INTO MYLIBRARY.MYTABLE (NAME, ID)
VALUES (?, ?)");

            for (int i = 0; i < nameArray.length; i++) {

                ps.setString(1, nameArray[i]);  // Se establece el nombre a partir de nuestra
matriz.
                ps.setInt(2, i+1);              // Se establece el ID.
                ps.executeUpdate();
            }

        } catch (SQLException sqle) {

            System.out.println("El proceso de base de datos ha fallado.");
            System.out.println("Razón: " + sqle.getMessage());
        } finally {
            // Se cierran los recursos de base de datos.
            try {
                if (ps != null) {
                    ps.close();
                }
            } catch (SQLException e) {
                System.out.println("El borrado no ha podido cerrar Statement.");
}
        }

        //    Utilizar una sentencia preparada para consultar la tabla de

        //    base de datos que se ha creado y devolver datos desde ella. En
        //    este ejemplo, el parámetro utilizado se ha establecido de manera arbitraria
        //    en 5, lo que implica devolver todas las filas en las que el campo ID sea
        //    igual o menor que 5.
        try {
            ps = c.prepareStatement("SELECT * FROM MYLIBRARY.MYTABLE " +
                                    "WHERE ID <= ?");

            ps.setInt(1, 5);

            // Se ejecuta una consulta SQL en la tabla.

            ResultSet rs = ps.executeQuery();
            // Visualizar todos los datos de la tabla.
            while (rs.next()) {
                System.out.println("El empleado " + rs.getString(1) + " tiene el ID " +
rs.getInt(2));
            }

        } catch (SQLException sqle) {

            System.out.println("El proceso de base de datos ha fallado.");
            System.out.println("Razón: " + sqle.getMessage());
        } finally {
             // Se cierran los recursos de base de datos.
            try {
                if (ps != null) {
                    ps.close();
                }
            } catch (SQLException e) {
                System.out.println("El borrado no ha podido cerrar Statement.");
}

            try {
                if (c != null) {
                    c.close();
                }
            } catch (SQLException e) {
                System.out.println("El borrado no ha podido cerrar Connection.");
}

        }
    }
}

  Ejemplo de PreparedStatement de consulta

Por ejemplo supongamos que hay un campo de texto en el que el usuario puede
introducir su dirección de correo electrónico y con este dato se desea buscar al
usuario:

Connection con = DriverManager.getConnection(url);

String consulta = "SELECT usuario FROM registro WHERE email like ?";

PreparedStatement pstmt = con.prepareStatement(consulta);

pstmt.setString(1 , campoTexto.getText());

ResultSet resultado = ps.executeQuery();

Ejemplo de PreparedStatement de modificación

En el siguiente ejemplo se va a insertar un nuevo registro en una tabla:

 Connection con = DriverManager.getConnection(url);

String insercion = "INSERT INTO registro(usuario , email , fechaNac) values

( ? , ? , ? )");

PreparedStatement pstmt = con.prepareStatement(consulta);

String user = . . . ;

String email = . . . ;

Date edad = . . . ; //O int edad;

pstmt.setString(1 , user);

pstmt.setString(2 , email);

pstmt.setDate(3 , edad); // setInt(3, edad);

ps.executeUpdate();

         El siguiente fragmento de código, donde con es un objeto Connection, crea un objeto
PreparedStatement que contiene una instrucción SQL:
//Creamos un objeto PreparedStatement desde el objeto Connection
PreparedStatement ps = con.prepareStatement(
"select * from Propietarios where DNI=? AND NOMBRE=? AND EDAD=?");
//Seteamos los datos al prepared statement de la siguiente forma:
ps.setString(1, dni);
ps.setString(2, nombre);
ps.setInt(3, edad);

//Ejecutamos el PreparedStatement, en este caso con executeQuery()

ResultSet rs= ps.executeQuery();

2. Este es un ejemplo de utilización del método executeUpdate del objeto

Statement.
import java.sql.*;

import java.util.Properties;

public class StatementExample {

    public static void main(java.lang.String[] args)

     {

        // Sugerencia: cargarlos desde un objeto de propiedades.

2.       RESUMEN:
El interfaz PreparedStatement hereda del interfaz Statement y se diferencia de eelo de
dos maneras:
         Las instancias de PreparedStatement contienen una sentencia SQL que ya ha sido
compilada. Esto es lo que hace que se le llame ‘prepared’ (preparada).

         La sentencia SQL contenida en un objeto PreparedStatement pueden tener uno o más
parámetros IN (entrada).

Esta interfaz nos permite ejecutar sentencias SQL sobre una conexión establecida con
una base de datos. pero en ella se ejecutan sentencias SQL más especializadas,
estas sentencias SQL se van a denominar sentencias SQL precompiladas y van a
recibir parámetros de entrada lo cual hace más rápido su ejecución que de los objetos
Statement .

3.       SUMMary:

The PreparedStatement interface inherits from the Statement interface and differs from
it in two ways:
• The PreparedStatement instances contain an SQL statement that has already been
compiled. This is what causes it to be called 'prepared'.
• The SQL statement contained in a PreparedStatement object can have one or more
IN parameters.

This interface allows us to execute SQL statements on a connection established with a

database. But it runs more specialized SQL statements, these SQL statements are
going to be called precompiled SQL statements and will receive input parameters
which makes their execution faster than the Statement objects.

4.       RECOMENDACIONES:
Cuando trabajamos con una base de datos es posible que haya sentencias SQL que
tengamos que ejecutar varias veces durante la sesión, aunque sea con distintos
parámetros. Por ejemplo, durante una sesión con base de datos podemos querer
insertar varios registros en una tabla. Cada vez los datos que insertamos serán
 distintos, pero la sentencia SQL será la misma: Un INSERT sobre determinada tabla
que será simpre igual, salvo los valores concretos que queramos insertar.
Para poder ejecutar un objeto PreparedStatement, primero hay que establecer un valor
en cada uno de los marcadores de parámetro. El objeto PreparedStatement
proporciona varios métodos para establecer parámetros. Todos ellos tienen el formato
set<Tipo>, siendo <Tipo> un tipo de datos Java. Ejemplos de estos métodos son
setInt, setLong, setString, setTimestamp y setBlob. 
Se utiliza el método prepareStatement() de Connection para crear nuevos objetos
PreparedStatement. A diferencia de lo que sucedía con los objetos Statement, la
sentencia SQL se suministra en el momento de crear el objeto PreparedStatement. En
ese momento, se precompila la sentencia SQL. 

5.       Conclusiones
Permite realizar operaciones (consultas, actualizaciones, ...) sobre bases de datos
relacionales utilizando SQL (Structured Query Language).
La ejecucion de sentencias en la base de datos a traves de JDBC se realiza mediante
las interfaces Statement o PreparedStatement.
Para obtener un objeto del tipo Statement se llama al metodo createStatement() del
objeto Connection.
La interfaz PreparedStatement extiende a la interfaz Statement y utiliza una plantilla
para crear la sentencia SQL. Se utiliza en aquellas situaciones en las que se necesita
ejecutar varias veces una consulta en la que pueden cambiar ´unicamente los par
´ametros. De esta forma (si el SGBD lo permite) se optimiza la consulta una sola vez.
A la hora de obtener tanto un Statement como un PreparedStatement es posible
especificar (si la base de datos lo acepta) el tipo de desplazamiento deseado y si se
desea que las modificaciones en el resultado se reflejen en la base de datos.

6.       APRECIACION DEL EQUIPO

Al realizar este trabajo se ha entendido acerca de cómo y cuándo usar
preparedstetment también se ha comprendido que para enviar sentencias sql. Una
Prepared Statement es una sentencia SQL de base de datos precompilada. Al estar
precompilada, su ejecución será más rápida que una SQL normal, por lo que es
adecuada cuando vamos a ejecutar la misma sentencia SQL (con distintos valores)
muchas veces.

7.       GLOSARIO DE TERMINOS
 Sentencias: son los elementos básicos en los que se divide el código en un lenguaje
de programación. Al fin y al cabo, un programa no es más que un conjunto
de sentencias que se ejecutan para realizar una cierta tarea. 

Parámetros: es una variable utilizada para recibir valores de entrada en una rutina o
subrutina. Dichos valores, que serán enviados desde la rutina invocante, son llamados
argumentos.
 Interfaz: es un conjunto de subrutinas, funciones y procedimientos (o métodos, en
la programación orientada a objetos) que ofrece cierta biblioteca para ser utilizado
por otro software como una capa de abstracción.

Sentencias compiladas: puede contener sentencias de control SQL y sentencias

SQL. Las sentencias SQL compuestas (compiladas) se pueden utilizar para
implementar la lógica de procedimiento a través de una secuencia de sentencias SQL
con un ámbito local para variables, condiciones, cursores y manejadores.

DBMS: database management system  que permiten almacenar y posteriormente

acceder a los datos de forma rápida y estructurada.

8.       BIBLIOGRAFÍA
http://seduca.uaemex.mx/material/LIA/POO/materiales/PreparedStatement.html

http://www.forosdelweb.com/f45/diferencias-entre-preparestatement-statement- 612469/

http://www.vc.ehu.es/jiwotvim/ISOFT2009-2010/Teoria/BloqueIV/JDBC.pdf

 http://www.euskalnet.net/jaoprogramador/j2ee/JDBC/jdbc25.htm

https://www.ibm.com/support/knowledgecenter/es/ssw_i5_54/rzaha/prepex.htm

Declaración de JDBC
 Crear declaración
 Ejecución de una consulta mediante una declaración
 Ejecutar una actualización a través de una declaración
 Cerrar una declaración
o Cerrar una declaración usando Java Pruebe con recursos
 Declaración frente a declaración preparada
Jakob Jenkov
Última actualización: 2019-02-27
    

El Java JDBC Declaración , java.sql.Statement, interfaz se

utiliza para ejecutar sentencias SQL contra una base de datos
relacional. Obtiene un JDBC Statementde una conexión
JDBC . Una vez que tenga una Statementinstancia de Java ,
puede ejecutar una consulta de base de datos o una actualización
de la base de datos con ella. Este Statementtutorial de Java
JDBC explicará cómo se usa Statementpara ejecutar consultas,
actualizaciones y cómo cerrar correctamente
la Statementinstancia cuando haya terminado.

Crear declaración
Para utilizar un JDBC de Java Statement, primero debe crear un
archivo Statement. A continuación, se muestra un ejemplo de
cómo crear una Statementinstancia de Java :

Declaración declaración = connection.createStatement ();

La connectioninstancia es una instancia de Java JDBC

Connection .

Ejecución de una consulta mediante una

declaración
Una vez que haya creado un Statementobjeto Java , puede
ejecutar una consulta en la base de datos. Lo hace llamando a
su executeQuery()método, pasando una declaración SQL como
parámetro. El Statement executeQuery()método devuelve
un ResultSet JDBC de Java que se puede utilizar para navegar por la
respuesta de la consulta. A continuación, se muestra un ejemplo de
cómo llamar a Java JDBC Statement executeQuery()y
navegar por el devuelto ResultSet:

String sql = "seleccionar * de personas";

ResultSet resultado = statement.executeQuery (sql);

while (result.next ()) {

String name = result.getString ("nombre");

long age = result.getLong ("edad");

Recuerde que ResultSetdebe cerrarse cuando haya terminado.

Ejecutar una actualización a través de una

declaración
También puede ejecutar una actualización de la base de datos a
través de una Statementinstancia de Java JDBC . Por ejemplo,
puede ejecutar una inserción de SQL, actualizar o eliminar a través de
una Statementinstancia. A continuación, se muestra un ejemplo de
cómo ejecutar una actualización de la base de datos a través de
una Statementinstancia de Java JDBC :

Declaración declaración = connection.createStatement ();

String sql = "actualizar el nombre del conjunto de personas = 'John'

donde id = 123";

int rowsAffected = statement.executeUpdate (sql);

El rowsAffecteddevuelto por
la statement.executeUpdate(sql)llamada indica cuántos
registros de la base de datos se vieron afectados por la instrucción
SQL.

Cerrar una declaración

Una vez que haya terminado con una Statementinstancia, debe
cerrarla. Cierras una Statementinstancia llamando a
su close()método. A continuación, se muestra un ejemplo de
cierre de una Statementinstancia de JDBC de Java :

declaración.close ();

Cerrar una declaración usando Java Pruebe con recursos

Para cerrar Statementcorrectamente un después de su uso, puede

abrirlo dentro de un bloque Java Try With Resources . A
continuación, se muestra un ejemplo de cómo cerrar
una Statementinstancia de JDBC de Java mediante la
construcción try-with-resources:

try (Statement statement = connection.createStatement ()) {

// usa la declaración aquí.
} captura (SQLException e) {

Una vez que el trybloque salga, Statementse cerrará

automáticamente.
Declaración frente a declaración preparada
La API de Java JDBC tiene una interfaz similar a
la Statementdenominada PreparedStatement . Se PreparedS
tatementpueden insertar parámetros en la declaración SQL, por lo
que PreparedStatementse pueden reutilizar una y otra vez con
diferentes valores de parámetros. No puede hacer eso con
un Statement. A Statementrequiere una sentencia SQL
terminada como parámetro.

Siguiente: JDBC ResultSet