“Año del Buen Servicio
al Ciudadano”
Tema: Preparedstatement.
Docente: Marco Aurelio Porro Chulli.
Asignatura: Laboratorio
de Programación III.
Carrera: Ingeniería
de Sistemas y Telemática.
Ciclo: VII
– “B”
Integrantes:
·
Rafael Estela Sandrita.
·
Soto Horna Karin Juneth
Año:
2017
PREPAREDSTATEMENT
La interfaz PreparedStatement hereda
de Statement y difiere de esta en dos maneras.
Las instancias de PreparedStatement contienen una
sentencia SQL que ya ha sido compilada. Esto es lo que hace que se le llame
‘preparada’.
La sentencia SQL
contenida en un objeto PreparedStatement puede tener uno o más parámetros IN.
Un parámetro IN 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 ‘ancla’ para
cada parámetro IN. Debes suministrar un valor para cada interrogante mediante
el método apropiado, que puede ser: setInt, setString, etc., antes de ejecutar
la sentencia.
Un objeto PreparedStatement se usa para
sentencias SQL que toman uno o más parámetros como argumentos de entrada
(parámetros IN). Un objeto PreparedStatement es potencialmente más eficiente
que un objeto Statement porque este ha sido precompilado y almacenado
para su uso futuro.
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. Desde el controlador JDBC 3.0
de MicrosoftSQL Server, executeUpdate devolverán el número correcto de filas
actualizado en una operación MERGE.
Un objeto CallableStatement es una interface JDBC
utilizado para llamar o ejecutar procedimientos almacenados de la base de datos
desde una aplicación Java.
Antes de usar CallableStatement debemos saber si
nuestro Gestor de Base de Datos soporta y usa procedimientos almacenados, para
este propósito el método supportsStoredProcedures devolverá
true si la DBMS soporta llamadas a procedimientos almacenados y el método getProcedures devolverá
una descripción de los procedimientos almacenados disponibles.
CALLABLESTATEMENT hereda los
métodos de Statement, los cuales tratan sentencias SQL en general, y también
hereda los métodos de PreparedStatement, que tratan los parámetros IN. Todos
los métodos definidos para CallableStatement tratan los parámetros OUT o los
aspectos de salida de los parámetros INOUT: registro de los tipos JDBC (tipos
genéricos SQL) de los parámetros OUT, recuperación de valores desde ellos o
chequear si el valor devuelto es un JDBC NULL.
Los objetos CallableStatement se crean con el
método prepareCall de Connection. El siguiente ejemplo crea una instancia de
CallableStatement que contiene una llamada al procedimiento almacenado
getTestData, con dos argumentos y no devuelve resultados.
CallableStatement cs = cn. prepareCall (¿” {call
getTestData (?,)} “);
Aparte de MySQL 5.0 cuando se usa con Conector/J
3.1.1 o posterior la interfaz CallableStatements está completamente
implementada excepto el método getParameterMetaData ().
Partimos de la situación inicial de un
procedimiento almacenado que retorna el valor de un inOutParam incrementado en
1 y la cadena de caracteres pasada vía inputParam como Resultset:
Para usar el procedimiento almacenado seguimos los
siguientes pasos:
1. Preparamos el
callable statement usando Connection.prepareCall().
Debemos tener siempre en cuenta que debemos de usar
la sintaxis de escape de JDBC siendo obligatorios los paréntesis que rodean los
parámetros.
Nota: Connection.prepareCall() es un método
costoso, debido a la petición de metadatos que hace el driver para suportar los
parámetros de salida.
Por razones de rendimiento, intentad minimizar llamadas innecesarias a Connection.prepareCall() reusando instancias de CallableStatement.
Por razones de rendimiento, intentad minimizar llamadas innecesarias a Connection.prepareCall() reusando instancias de CallableStatement.
2. Registramos los
parámetros de salida (si existen).
Para recibir los valores de los parámetros de
salida (parámetros especificados como OUT o INOUT cuando se crea el
procedimiento), JDBC requiere que estén especificados antes de la ejecución del
statement usando los distintos modos de registrar un parámetro con el método registerOutputParameter
():
3. Especificamos
los parámetros de entrada (si existen).
Los parámetros de entrada y de entrada/salida se
especifican como en los objetos PreparedStatement. Sin embargo,
CallableStatement también soporta especificar los parámetros por nombre:
4. Ejecutamos
CallableStatement, y recibimos cualquier conjunto de resultados o parámetros de
salida.
Mientras CallableStatement soporta llamar a
cualquiera de los métodos de ejecución de Statement (executeUpdate (), executeQuery
() o execute () ), el método más flexible es execute(), ya que no necesita
saber de antemano si el procedimiento almacenado retorna un conjunto de
resultados:
Ejemplo 1
public class InsertarDatos {
public static void main (String [] args) {
Connection con = null;
PreparedStatement stmt =
null;
String sDriver = "com.
mysql. jdbc. Driver";
String sURL = "jdbc:
mysql://localhost:3306/lineadecodigo";
try {
Class.forName(sDriver).
newInstance ();
con =
DriverManager.getConnection(sURL,"root","");
String
sISBN = "84-9815-212-7";
String
sTitulo = "Yo, Claudio";
String
sDescripcion="Supuesta autobiografía de Claudio";
String
sCategoria = "Novela Histórica";
int
idAutor =
3;
stmt =
con.prepareStatement("INSERT INTO libros VALUES (?,?,?,?,?)");
stmt.setString(1,sISBN);
stmt.setInt(2,idAutor);
stmt.setString(3,sTitulo);
stmt.setString(4,sDescripcion);
stmt.setString(5,sCategoria);
int
retorno = stmt.executeUpdate();
if
(retorno>0)
System.out.println("Insertado
correctamente");
} catch (SQLException
sqle){
System.out.println("SQLState: "
+ sqle.getSQLState());
System.out.println("SQLErrorCode: "
+ sqle.getErrorCode());
sqle.printStackTrace();
} catch (Exception e){
e.printStackTrace();
} finally {
if
(con != null) {
try{
stmt.close();
con.close();
} catch(Exception e){
e.printStackTrace();
}
}
}
}
}
Ejemplo 2
import java.sql.*;
import java.util.Properties;
public class PreparedStatementExample {
public static void main(java.lang.String[] args)
{
String
DRIVER = "com.ibm.db2.jdbc.app.DB2Driver";
String
URL = "jdbc:db2://*local";
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;
try
{
Properties properties = new Properties ();
properties.put ("user", "userid");
properties.put ("password",
"password");
c
= DriverManager.getConnection(URL, properties);
s = c.createStatement();
try {
s.executeUpdate("DROP TABLE MYLIBRARY.MYTABLE");
}
catch (SQLException e) {
}
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 {
try {
if (s != null) {
s.close();
}
} catch (SQLException e) {
System.out.println("El borrado no ha podido cerrar Statement.");
}
}
PreparedStatement
ps = null;
String[]
nameArray = {"Rich", "Fred", "Mark",
"Scott", "Jason",
"John",
"Jessica", "Blair", "Erica", "Barb"};
try {
ps = c.prepareStatement("INSERT INTO
MYLIBRARY.MYTABLE (NAME, ID) VALUES (?, ?)");
for
(int i = 0; i < nameArray.length; i++) {
ps.setString(1,
nameArray[i]);
ps.setInt(2,
i+1);
ps.executeUpdate();
}
} catch
(SQLException sqle) {
System.out.println("El proceso de base de datos ha fallado.");
System.out.println("Razón: " + sqle.getMessage());
}
finally {
try {
if (ps != null) {
ps.close();
}
} catch (SQLException e) {
System.out.println("El borrado no ha podido cerrar Statement.");
}
}
try {
ps = c.prepareStatement("SELECT * FROM
MYLIBRARY.MYTABLE " + "WHERE ID <= ?");
ps.setInt(1, 5);
ResultSet rs = ps.executeQuery();
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 {
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.");
}
}
}
}
El objeto PreparedStatement es aquel se usa para
sentencias SQL que toman uno o más parámetros como argumentos de entrada
(parámetros IN). Además,
es aquel que representa una sentencia precompilada de SQL.
6 SUMARY
The PreparedStatement object is one that is used
for SQL statements that take one or more parameters as input arguments (IN
parameters). It is also one that represents a precompiled SQL statement.
7. 7 RECOMENDACIONES
· Se recomienda
usar esta clase porque nos permite hacer uso de los procedimientos almacenados.
Ya que todos sabemos que gracias a los procedimientos almacenados a nosotros
los programadores nos permite hacer una programación más ordenada y de esta
manera poder hacer que nuestro programa no esté muy pesado.
· Es recomendable
también porque al utilizar procedimientos el programa que se esté realizando va
a tener una mayor seguridad, un mayor rendimiento y una reutilización.
88 CONCLUSIONES
Concluimos que utilizando este objeto en java el programador
tiene que saber usar sentencias SQL
que toman uno o más parámetros como argumentos de entrada (parámetros IN). Además,
que este objeto PreparedStatement es potencialmente más eficiente que un objeto
Statement porque este ha sido precompilado y almacenado para su uso futuro.
· Desde nuestro
punto de vista la clase PreparedStatement resulta muy indispensable, no solo
esta clase sino también las demás que hemos estado viendo anteriormente, en
otras palabras, este objeto es el componente que nos permitirá hacer uso de los
procedimientos almacenados en donde nosotros los creamos a partir de nuestra
base de datos, para luego poder ejecutarlos y así poderlos llamar desde un
formulario creado en nuestro proyecto que estemos realizando.
·
Compilación: Significa
traducir un código de programación a código ejecutable por la
máquina. Para compilar un código fuente y convertirlo en ejecutable
hay distintas formas dependiendo del compilador que se utilice.
·
Sentencia
·
Precompilada: Significa que
cuando se ejecuta el objeto PreparedStatement, el controlador de base de
datos puede ejecutarla sin tener que compilarla primero.
·
Parámetro: Es un tipo
de variable que es recibida por
una función, procedimiento subrutina.
11. BIBLIOGRAFÍA
O LINKOGRAFÍA
· http://seduca.uaemex.mx/material/LIA/POO/materiales/PreparedStatement.html
· https://www.adictosaltrabajo.com/tutoriales/usando-callable-statements-to-execute-stored-procedure/
· http://www.w3api.com/wiki/Java:PreparedStatement#Descripcion
· https://msdn.microsoft.com/es-es/library/ms378630(v=sql.110).aspx
LINK DIAPOSITIVAS https://es.slideshare.net/SandritaRafaelEstela/preparedstatemet-83691780
No hay comentarios:
Publicar un comentario