STATEMENT


1. CONTENIDO
1.1. Definición
Un objeto Statement se usa para enviar sentencias SQL a la base de datos. Actualmente hay tres tipos de objetos Statement, todos los cuales actúan como contenedores para la ejecución de sentencias en una conexión dada: Statement, PreparedStatement que hereda de Statement y CallableStatement que hereda de PreparedStatement. Estas estàn especializadas para enviar tipos particulares de sentencias SQL, Un objeto Statement se usa para ejecutar una sentencia SQL simple sin parámetros. Un objeto PreparedStatement se usa para ejecutar sentencias SQL precompiladas con o sin parámetros IN; y un objeto CallableStatement se usa para ejecutar un procedimieno de base de datos almacenado.
La interfase Statement suminstra métodos básicos para ejecutar sentencias y devolver resultados. La interfase PreparedStatement añade métodos para trabajat con los parámetros IN; y la interfase CallableStatement añade métodos para trabajar con parameters OUT.
El objeto Statement (sentencia) sirve para procesar una sentencia SQL estática y obtener los resultados producidos por ella. Solo puede haber un ResultSet abierto para cada objeto Statement en un momento dado. Todos los métodos statement que procesan una sentencia SQL cierran implícitamente el ResultSet actual de una sentencia si existe uno abierto.
Creación de objetos Statement
Una vez establecida la conexión con una base de datos particular, esta conexión puede usarse para enviar sentencias SQL. Un objeto Statement se crea mediante el método de Connection createStatement, como podemos ver en el siguiente fragmento de código.
Connection con = DriverManager.getConnection(url, "sunny", "");
Statement stmt = con.createStatement();
La sentencia SQL que será enviada a la base de datos es alimentada como un argumento a uno de los métodos de ejecución del objeto Statement. Por ejemplo:
ResultSet rs = stmt.executeQuery("SELECT a, b, c FROM Table2").
1.2. Propiedades
Empezamos por descargar el conector MySQL para Java desde su sitio web: conector MySQL. Una vez que hemos descargado el fichero .zip correspondiente a nuestra plataforma lo descomprimimos en el equipo y  buscamos dentro de la carpeta principal un archivo llamado mysql-connector con extensión .jar.
Ahora tenemos que agregar este archivo jar a nuestra aplicación de NetBeabs, para ello  hacemos Click derecho sobre el nombre del proyecto y seleccionamos propiedades. En la ventana siguiente seleccionamos en librerías y posteriormente pulsamos en el botón –>Add Jar/folder. Finalmente accedemos a la localización del conector que descargamos anteriormente y pulsamos OK.

Después de importar el conector ya casi estamos preparados, aunque antes de continuar necesitamos un servidor local y una base de datos.
En mi caso utilizo phpMyAdmin para crear la bd java1 con nombre de usuario root y sin contraseña. También la tabla Motor con 3 columnas: Marca, Modelo y Potencia.

En la siguiente clase insertamos 2 registros en la tabla motor con el método executeUpdate(). Finalmente mostramos los datos en pantalla ordenados por Potencia.

Encapsula las instrucciones SQL a la BD
Se crea a partir de la conexión
Instruccion = conexion.createStatement();
        Métodos
  • executeQuery(String sql)
  • Ejecución de consultas: SELECT
  • Devuelve un objeto ResultSet.
  • executeUpdate(String sql).
  • Modificaciones en la BD: INSERT, UPDATE, DELETE
  • Devuelve el número de columnas afectadas.
  • execute(String sql).
  • Ejecución de instrucciones que pueden devolver varios conjuntos de resultado.
  • Requiere usar luego getResultSet() o getUpdateCount() para recuperar.
Realización de Statement
Cuando una conexión está en modo auto-commit, las sentencias ejecutadas son ‘comitadas’ o rechazadas cuando se completan. Un sentencia se considera completa cuando ha sido ejecutada y se han devuelto todos los resultados. Pare el método executeQuery, que devuelve un único result set, la sentencia se completa cuando todas las filas del objeto ResultSet se han devuelto. Para el método executeUpdate, un sentencia se completa cuando se ejecuta. En los raros casos en que se llama al método execute, de cualquier modo, no se completa hasta que los result sets o update counts que se generan han sido devueltos. 
Algunos DBMS tratan cada sentencia en un procedimiento almacenado como sentencias separadas. Otros tratan el procedimiento entero como una sentencia compuesta. Esta diferencia se convierte en importante cuando está activo el modo auto-commit porque afecta cuando se llama al método commit. En el primer caso, cada sentencia individual es commitada. En el segundo, se commiten todas juntas.
La interfaz Statement nos suministra tres métodos diferentes para ejecutar sentencias SQL, executeQuery, executeUpdate y execute. El método a usar está determinado por el producto de la sentencia SQL

 2.El método executeQuery está diseñado para sentencias que producen como resultado un único ResultSet tal como las sentencias SELECT.
3.El método executeUpdate se usa para ejecutar sentencias INSERT, UPDATE ó DELETE así como sentencias SQL DDL (Data Definition Language) como CREATE TABLE o DROP TABLE. 
El efecto de una sentencia INSERT, UPDATE o DELETE es una modificación de una o más columnas en cero o más filas de una tabla. El valor devuelto de executeUpdate es un entero que indica el número de filas que han sido afectadas (referidos como update count).
Para sentencias tales como CREATE TABLE o DROP TABLE, que no operan sobre filas, el valor devuelto por executeUpdate es siempre cero.
4.El método execute se usa solamente para ejecutar sentencias que devuelven más de un Result Set, más que un update count o una combinación de ambos.
1.3. Ejemplos
1.3.1. Ejemplo 01
       
       ((stmt.getMoreResults() == false) && (stmt.getUpdateCount() == -1))

El siguiente código muestra una forma de asegurarse que se ha accedido a todos los result sets y update counts de una llamada al método execute:

stmt.execute(queryStringWithUnknownResults);
while (true) {
int rowCount = stmt.getUpdateCount();
if (rowCount > 0) { // this is an update count
System.out.println("Rows changed = " + count);
stmt.getMoreResults();
continue;
}
if (rowCount == 0) { // DDL command or 0 updates
System.out.println(" No rows changed or statement was DDL
command");
stmt.getMoreResults();
continue;
}

// if we have gotten this far, we have either a result set 
// or no more results

ResultSet rs = stmt.getResultSet; 
if (rs != null) {
. . . // use metadata to get info about result set columns
while (rs.next()) {
. . . // process results
stmt.getMoreResults();
continue;
}
break; // there are no more results
1.3.1. Ejemplo 02
       
Establecemos la conexión con la base de datos. 
Connection conexion = DriverManager.getConnection ("jdbc:mysql://localhost/prueba","root", "la_clave");

// Preparamos la consulta 
Statement s = conexion.createStatement(); 
ResultSet rs = s.executeQuery ("select * from persona");

// Recorremos el resultado, mientras haya registros para leer, y escribimos el resultado en pantalla. 
while (rs.next()) 
{ 
    System.out.println (rs.getInt (1) + " " + rs.getString (2)+ " " + rs.getDate(3)); 
}

// Cerramos la conexion a la base de datos. 
conexion.close();
1.3.3. Ejemplo 03
El ejemplo que sigue muestra cómo se utiliza un objeto Statement.
       
     // Conéctese al servidor.
     Connection c = DriverManager.getConnection("jdbc:as400://mySystem");

                       // Cree un objeto Statement.
     Statement s = c.createStatement();

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

                       // Ejecute una sentencia SQL que inserte
                       // un registro en la tabla.
     s.executeUpdate("INSERT INTO MYLIBRARY.MYTABLE (NAME, ID) VALUES ('DAVE', 123)");

                       // Ejecute una sentencia SQL que inserte
                       // un registro en la tabla.
     s.executeUpdate("INSERT INTO MYLIBRARY.MYTABLE (NAME, ID) VALUES ('CINDY', 456)");

                       // Ejecute una consulta SQL en la tabla.
     ResultSet rs = s.executeQuery("SELECT * FROM MYLIBRARY.MYTABLE");

                       // Cierre el objeto Statement y
                       // el objeto Connection.
     s.close();
     c.close();
1.3.3. Ejemplo 04
       
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.");
}

        }
    }
}
1.3.5. Ejemplo 05
       
public class UnaClase {
   // Aqui guardamos un unico PreparedStatement para insertar 
   PreparedStatement psInsertar = null;
   ...
   public void unMetodoDeInsertar () {
   try {
      // Creamos el PreparedStatement si no estaba ya creado. 
      if (null == psInsertar) { 
         psInsertar = conexion.prepareStatement(
            "insert into person values (null,?,?,?)");
      ...
   } catch (SQLException e) {
      e.printStackTrace();
   }

2. RESUMEN
La interfase Statement nos suministra tres métodos diferentes para ejecutar sentencias SQL, executeQuery, executeUpdate y execute. El método a usar esta determinado por el producto de la sentencia SQL.
El método executeQuery esta diseñado para sentencias que producen como
resultado un único result set tal como las sentencias SELECT.
El método executeUpdate se usa para ejecutar sentencias INSERT, UPDATE ó
DELETE así como sentencias SQL DDL (Data Definition Language) como CREATE TABLE o DROP TABLE. El efecto de una sentencia INSERT, UPDATE o DELETE es una modificación de una o más columnas en cero o más filas de una tabla. El valor devuelto de executeUpdate es un entero que indica el número de filas que han sido afectadas (referido como update count). Para sentencias tales como CREATE TABLE o DROP TABLE, que no operan sobre filas, le valor devuelto por
executeUpdate es siempre cero.
El método execute se usa para ejecutar sentencias que devuelven más de un
result set, más que un update count o una combinación de ambos. Como es esta
una característica avanzada que muchos programadores no necesitarñan nunca se verá en su propia sección. 
Todos los métodos que ejecutan sentencias cierran los objetos Resultset abiertos
como resultado de las llamadas a Statement. Esto quiere decir que es necesario
completar el proceso con el actual objeto Resulset antes de reejecutar una
sentencia Statement. 

Cuando una conexión está en modo auto-commit, las sentencias ejecutadas son ‘comitadas’ o rechazadas cuando se completan. Un sentencia se considera completa cuando ha sido ejecutada y se han devuelto todos los resultados. Pare el método executeQuery, que devuelve un único result set, la sentencia se completa cuando todas las  filas del objeto ResultSet se han devuelto. Para el método executeUpdate, un sentencia se completa cuando se ejecuta. En los raros casos en que se llama al método execute, de cualquier modo, no se completa hasta que los result sets o update counts que se generan han sido devueltos.
Algunos DBMS tratan cada sentencia en un procedimiento almacenado como sentencias separadas. Otros tratan el procedimiento entero como una sentencia compuesta. Esta diferencia se convierte en importante cuando está activo el modo auto-commit porque afecta cuando se llama al método commit. En el primer caso, cada sentencia individual es commitada. En el segundo, se commiten todas juntas.

3. SUMMARY
The Statement interface provides three different methods for executing SQL statements, executeQuery, executeUpdate, and execute. The method to use is determined by the product of the SQL statement.
The executeQuery method is designed for statements that produce as
result a single result set such as the SELECT statements.
The executeUpdate method is used to execute INSERT, UPDATE, or DELETE as well as Data Definition Language (DDL) SQL statements such as CREATE TABLE or DROP TABLE. The effect of an INSERT, UPDATE, or DELETE statement is a modification of one or more columns to zero or more rows in a table. The return value of executeUpdate is an integer that indicates the number of rows that have been affected (referred to as update count). For statements such as CREATE TABLE or DROP TABLE, which do not operate on rows, the value returned by executeUpdate is always zero.
The execute method is used to execute statements that return more than one
result set, more than an update count or a combination of both. How is this
an advanced feature that many programmers do not need to ever see in their own section.
All methods that execute statements close open Resultset objects
as a result of Statement calls. This means that it is necessary
complete the process with the current Resulset object before re-executing a

Statement.
When a connection is in auto-commit mode, executed statements are 'committees' or rejected when they are completed. A statement is considered complete when it has been executed and all results returned. Stop the executeQuery method, which returns a single result set, the statement is completed when all rows of the ResultSet object have been returned. For the executeUpdate method, a statement is completed when it is executed. In the rare cases where the execute method is called, however, it is not completed until the result sets or update counts that are generated have been returned.
Some DBMSs treat each statement in a stored procedure as separate statements. Others treat the whole procedure as a compound sentence. This difference becomes important when the auto-commit mode is active because it affects when the commit method is called. In the first case, each individual statement is committed. In the second, they commit all together.

4. RECOMENDACIONES
1) Investigación más amplia sobre este tema porque es indispensable para conectarnos a una base de datos.
2) Tener en cuenta ciertos puntos tratados en este tema por ejemplo los métodos que son de suma importancia al momento de desarrolla software.
3) Ponerlo en práctica todo lo aprendido, guiándose de los prototipos planteados en el trascurso del desarrollo del tema.
5. CONCLUSIONES
1) El objeto Statement sirve para procesar una sentencia SQL estática y obtener los resultados producidos por ella.
2) Los objetos Statement se crean a partir de objetos Connection con el método createStatement.
3) Las características de los ResultSets están asociadas con la sentencia que finalmente los crea el objeto Statement.
4) El proceso de sentencias SQL con un objeto Statement se realiza mediante los métodos executeQuery(), executeUpdate() y execute().
5) Tener en cuenta que si una sentencia SQL que se procesa con el método executeQuery no devuelve un ResultSet, se lanza una SQLException.
6. APRECIACIÓN DEL EQUIPO
En los preliminares contenidos hemos venido tratando temas relacionados a la conexión a una base de datos desde java, pero en esta ocasión profundizamos más sobre el objeto statement en este punto desarrollamos argumentos indispensables tales como definición propiedades y muchos ejemplos.

De la misma manera podemos indicar que gracia a la investigación más amplia que tuvimos con respecto al trabajo anterior aclaramos algunos interrogantes que teníamos sobre este importante objeto (STATEMENT).
7. GLOSARIO DE TÉRMINOS
   INTERFAZ STATEMENT 
   Ejecuta una sentencia SQL simple que no tiene ningún parámetro. 

     INTERFAZ PREPAREDSTATEMENT 
    Ejecuta una sentencia SQL precompilada que puede tener o no tener parámetros IN.

     INTERFAZ CALLABLESTATEMENT 
    Ejecuta una llamada a un procedimiento almacenado de base de datos. El objeto  
    CallableStatement puede tener o no tener parámetros IN, OUT e INOUT.
   
    AS400JDBCSTATEMENT
    Proporciona métodos que permiten llevar a cabo muchas acciones

    EXECUTE
    Se usa solamente para ejecutar sentencias que devuelven más de un Result Set
     
    EXECUTEQUERY 
     está diseñEado para sentencias que producen como resultado un único ResultSet

     EXECUTEUPDATE 
    se usa para ejecutar sentencias INSERT, UPDATE ó DELETE

     EXECUTEQUERY(STRING SQL)  
    Devuelve un objeto ResultSet con el conjunto de resultados obtenidos de la ejecución de      la instrucción indicada. 
    Es comúnmente usado con sentencias SQL SELECT
    Invoque el método 

     CONNECTION.CREATESTATEMENT 
     crear un objeto Statement.

    GETRESULTSET

     para conseguir el primer result set


8. LINKOGRAFÍA

https://msdn.microsoft.com/es-es/VBA/Office-Shared-VBA/articles/serverpolicy-statement-property-office

 https://en.wiktionary.org/wiki/statemen

https://www.ibm.com/support/knowledgecenter/es/ssw_i5_54/rzahh/jdbcst.htm

https://www.ibm.com/support/knowledgecenter/es/ssw_ibm_i_71/rzaha/statemnt.htm

http://profesores.fi-b.unam.mx/sun/Downloads/Java/jdbc.pdf

https://www.ibm.com/support/knowledgecenter/es/SSEPGG_9.7.0/com.ibm.db2.luw.apdv.java.doc/src/tpc/imjcc_tjvstxqu.html

https://docs.microsoft.com/en-us/sql/connect/jdbc/reference/executeupdate-method-sqlserverstatement

https://desarrollosoftwareana.blogspot.pe/


Comentarios

  1. Unknown29 de octubre de 2017, 5:26

    Ilustrar su trabajo agregar IMAGENES. Se tiene que definir 3 CONCLUSIONES y RECOMENDACIONES. En el GLOSARIO se debe definir al menos 10 términos. Gracias por su investigación.

    ResponderEliminar

Publicar un comentario

Entradas populares de este blog

RESULTSET

Imagen
1. CONTENIDO 1.1. Definición Es la representación en memoria de las tablas de la base de datos en disco, se puede entender como una tabla virtual, recordar que generalmente todos los procesos que se realizen con la tabla (insertar registros, eliminar registros, etc) se realizaran realmente contra un resulset y no provocaran ningun cambio en la tabla fisica en disco, resulset tiene un conjunto de metodos muy utiles y muy usados para el proceso de los renglones de la tabla virtual. Puede utilizar un objeto ResultSet para ejecutar una consulta y examinar los resultados de la consulta. Cuando crea consultas por medio del objeto QueryDef, debe crear un objeto ResultSet correspondiente para ejecutar la consulta y obtener los resultados. Cada objeto ResultSet se personaliza para la consulta que se ejecuta. El objeto ResultSet contiene estructuras de datos que organizan los datos de la consulta en filas y columnas, donde cada fila representa un único registro de datos y cada columna r...
Leer más

CONTROL JTABLE CON BASE DE DATOS

Imagen
1. CONTENIDO 1.1. Definición Jtable es una clase que me permite organizar una determinada información en tabla, esta difiere de una base de datos normal porque al utilizar Jtable tu puedes visualizar esta tabla, brindándole a el usuario organización de información, oportunidades de editar y cambiar el tamaño de las columnas entre otras. Como programadores, sabemos muy bien que la presentación de datos tabulados es una de las tareas más comunes que se presentan al momento de crear interfaces gráficas; desde la simple tabla que permite únicamente mostrar el resultado de una consulta, hasta las que permiten editar directamente el contenido de cada celda, ordenar las columnas, personalizar su apariencia, etc. Todas las tareas antes descritas, y muchas otras, son posibles de realizar utilizando la clase JTable; por supuesto, mientras más complejo sea el requerimiento a cubrir, se requerirá en igual medida utilizar más métodos o recursos de la clase. Los modelos de tabla son objetos...
Leer más

Reportes

Imagen
1. CONTENIDO 1.1. Instalación de iReport en NetBeans Una de las mejores soluciones en Netbeans a la hora de crear informes es usar JasperReports pero antes de poder crearlos debemos tenerlo todo preparado y listo para usarlo, en esta ocasión explicaré la que a mi juicio es la mejor forma de tenerlo todo atado. Necesitaremos instalar el plugin iReport para Netbeans, que nos ayudará en el diseño del informe que tengamos que elaborar, además prepararemos las librerías esenciales para poder usar las clases necesarias en nuestros proyectos. A continuación los pasos detallados. Primer paso. Instalación del plugin iReport. Bajaremos la última versión que encontremos del plugin iReport de la web oficial de Netbeans. Una vez descargado lo descomprimiremos y tendremos la siguiente estructura de archivos: ${distro.zipfilename.extensions}.nbm iReport-5.5.0.nbm jasperreports-components-plugin-5.5.0.nbm jasperserver-plugin-5.5.0.nbm Ya en NetBeans deberemos insta...
Leer más