jueves, 26 de octubre de 2017

ResultSet

  




                                          "AÑO DEL BUEN SERVIDOR AL CIUDADANO"

                                           ESCUELA ACADÉMICA DE INGENIERÍA DE SISTEMAS Y TELEPÁTICA

                                                                                            ASIGNATURA
                                                                       LABORATORIO DE PROGRAMACIÓN II

                                                                                            TEMA
                                                                                     ResultSet 

                                                                                           AUTORES
                                                                            LUZ CLARITA PEREZ DIAZ
                                                                            LUZ ISELA FLORES CHIGUEL
                                                                            LUZ CLARITA CHILCON SANCHEZ

                                                                                          DOCENTE
                                                                          ING.MARCO AURELIO PORRO CHULLI


                                                                    BAGUA GRANDE-UTCUBAMBA 
                                                                                       AMAZONAS


2017



1.DEFINICIÓN

Un ResultSet contiene todas las filas que satisfacen las condiciones de una sentencia SQL y proporciona el acceso a los datos de estas filas mediante un conjunto de métodos get que permiten el acceso a las diferentes columnas de la filas. El método ResultSet.next se usa para moverse a la siguiente fila del result set, convirtiendo a ésta en la fila actúal.
El formato general de un result set es una tabla con cabeceras de columna y los valores correspondientes devueltos por la ‘query’. Por ejemplo, si la ‘query’ es SELECT a, b, c FROM Table1, el resultado tendrá una forma semejante a :
a b c
-------- --------- --------
12345 Cupertino CA
83472 Redmond WA
83492 Boston MA
El siguiente fragmento de código es un ejemplo de la ejecución de una sentencia SQL que devolverá una colección de filas, con la columna 1 como un int, la columna 2 como una String y la columna 3 como un array de bytes:
java.sql.Statement stmt = conn.createStatement();
ResultSet r = stmt.executeQuery("SELECT a, b, c FROM Table1");
while (r.next())
{
// print the values for the current row.
int i = r.getInt("a");
String s = r.getString("b");
float f = r.getFloat("c");
System.out.println("ROW = " + i + " " + s + " " + f);
}
5.1.1 Filas y Cursores
Un ResultSet mantiene un cursor que apunta a la fila actúal de datos. El cursor se mueve una fila hacia abajo cada vez que se llama al método next. Incialmente se sitúa antes de la primera fila, por lo que hay que llamar al método next para situarlo en la primera fila conviertiendola en la fila actúal. Las filas de ResultSet se recuperan en secuencia desde la fila más alta a la más baja.
Un cursor se mantiene válido hasta que el objeto Resultset o su objeto padre Statement se cierra.

En SQL, el cursor resultado para una tabla tiene nombre. Si una base de datos permite upadtes posicionados o deletes posicionados, el nombre del cursor es necesario y debe ser proporcionado como un parámetro del comando update o delete. El nombre del cursor puede obtenerse mediante una llamada al método getCursorName.
No todas las bases de datos soportan updates o deletes posicionados. Los métodos DatabaseMetaData.supportsPositionedDelete y DatabaseMetaData.supportsPositionedUpdate nos permiten descubrir si estas operaciones están soportadas en una conexión dada. Cuando lo están, el driver o la DBMS deben asegurarse que las filas seleccionadas están apropiadamente bloquedas y por tanto que estas operaciones no provoquen actualizaciones anomalas ni otros problemas de concurrencia.
5.1.2 Columnas
Los métodos getXXX suministran los medios para recuperar los valores de las columnas de la fila actúal. Dentro de cada fila, los valores de las columnas pueden recuperarse en cualquier orden, pero para asegurar la máxima portabilidad, deberían extraerse las columnas de izquierda a derecha y leer los valores de las columnas una única vez.
Puede usarse o bien el nombre de la columna o el número de columna para referirse a esta. Por ejemplo: si la columna segunda de un objeto RecordSet rs se denomina “title” y almacena valores de cadena, cualquiera de los dos ejemplos siguientes nos devolverá el valor almacenado en la columna.
String s = rs.getString("title");
String s = rs.getString(2);
Nótese que las columnas se numeran de izquierda a derecha comenzando con la columna 1. Además los nombres usados como input en los métodos getXXX son insensibles a las mayúsculas.
La opción de usar el nombre de columna fue provista para que el usuario que especifica nombres de columnas en una ‘query’ pueda usar esos nombres como argumentos de los métodos getXXX. Si, por otro lado, la sentencia select no especifica nombres de columnas (tal como en “select * from table1” o en casos donde una columna es derivada), deben usarse los números de columna. En estas situaciones , no hay forma de que el usuario sepa con seguridad cuales son los nombres de las columnas.
En algunos casos, es posible para una query SQL devolver un result set con más de una columna con el mismo nombre. Si se usa el nombre de columna como argumento en un método getXXX, éste devolverá el valor de la primera columna que coincida con el nombre. Por eso, si hay múltiples columnas con el mismo nombre, se necesita usar un índice de columna para asegurarse que se recupera el valor de la columna correcta. Esto puede ser ligeramente más eficiente que usar los números de columna.
Información acerca de las columnas en un ResultSet es accesible mediante el método ResultSet.getMetaData. El objeto ResultSetMetaData devuelto nos da el numero, tipo y propiedades de las columnas de los objetos ResultSet.
Si se conoce el nombre de una columna, pero no su indice, puede usarse el método findColumn para encontrar el número de columna.



PROPIEDADES

Recuperar datos de ResultSet
El objeto ResultSet proporciona varios métodos para obtener los datos de columna correspondientes a un fila. Todos los tienen el formato set<Tipo>, siendo <Tipo> un tipo de datos Java. Algunos ejemplos de estos métodos son getInt, getLong, getString, getTimestamp y getBlob. Casi todos estos métodos toman un solo parámetro, que es el índice que la columna tiene dentro del ResultSet o bien el nombre de la columna.
Las columnas de ResultSet están numeradas, empezando por el 1. Si se emplea el nombre de la columna y hay más de una columna que tenga ese mismo nombre en el ResultSet, se devuelve la primera. Algunos de los métodos get<Tipo> tienen parámetros adicionales, como el objeto opcional Calendar, que se puede pasar a los métodos getTime, getDate y getTimestamp. Consulte el Javadoc del paquete java.sql para obtener todos los detalles.
En los métodos get que devuelven objetos, el valor de retorno es null cuando la columna del ResultSet es nula. En tipos primitivos, no puede devolverse null. En estos casos, el valor es 0 o false. Si una aplicación debe distinguir entre null, y 0 o false, puede utilizarse el método wasNull inmediatamente después de la llamada. A continuación, este método puede determinar si el valor era un valor 0 o false real o si ese valor se ha devuelto debido a que el valor de ResultSet era de hecho null.
Consulte el Ejemplo: interfaz ResultSet para IBM Developer Kit para Java para obtener un ejemplo de utilización de la interfaz ResultSet.

Soporte de ResultSetMetaData
Cuando se llama al método getMetaData en un objeto ResultSet, el método devuelve un objeto ResultSetMetaData que describe las columnas de ese objeto ResultSet. En los casos en que la sentencia SQL que se va a procesar no se conoce hasta el momento de la ejecución, puede utilizarse ResultSetMetaData para determinar cuál de los métodos get hay que emplear para recuperar los datos. El ejemplo de código siguiente utiliza ResultSetMetaData para determinar cada uno de los tipos de columna del conjunto de resultados.

EJEMPLOS
 utilizar ResultSetMetaData para determinar cada tipo de columna de un conjunto de resultados
Nota: lea el apartado Declaración de limitación de responsabilidad sobre el código de ejemplo para obtener información legal importante.
ResultSet rs = stmt.executeQuery(sqlString);
ResultSetMetaData rsmd = rs.getMetaData();
int colType [] = new int[rsmd.getColumnCount()];
for (int idx = 0, int col = 1; idx < colType.length; idx++, col++)
colType[idx] = rsmd.getColumnType(col);


Ejemplo 01
 
Statement stmt = null;
try {
   stmt = conn.createStatement( );
   ResultSet rs= stmt.executeQuery("SELECT nombre, apellido FROM usuario");
 
   while(rs.next()){
       String nom=rs.getString(1);
       String ape=rs.getString("apellido");
   }
}
catch (SQLException e) {
}
finally {
   stmt.close();
   conn.close();
}


Ejemplo.2

package py.devtroce;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.PreparedStatement;

public class Test {

    public static Connection conn;

    public static Connection conectar() throws Exception {
        Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
        String databaseURL = "jdbc:sqlserver://192.168.5.22:1433;databaseName=Portabilidad";
        return conn = java.sql.DriverManager.getConnection(databaseURL, "devtroce", "9¿¡e.3h++*pC46*h-?+");
    }

    public static void main(String[] args) {
        try {
            conn = conectar();

            PreparedStatement ps = conn.prepareStatement("{ call miProcedimientoAlmacedaoQuerySQL(?,?) }");

            ps.setInt(1, 1);
            ps.setString(2, "xxxyyy");

            ResultSet rs = ps.executeQuery();

            if (!rs.next())
                System.out.println("no hay registros");
            else do {
                System.out.println(rs.getString("ColumnaX"));
            } while (rs.next());
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}



2. Resumen

Puede utilizar un objeto ResultSet para acceder a una tabla de datos generada ejecutando una consulta. Las filas de la tabla se recuperan en secuencia. Dentro de una fila, es posible acceder a los valores de las columnas en cualquier orden.
Los datos almacenados en ResultSet se recuperan mediante los diversos métodos get, en función del tipo de datos que se vaya a recuperar.El método net () permite desplazarse a la fila siguiente.
ResultSet permite obtener y actualizar columnas por nombre, aunque el uso del índice de columna mejora el rendimiento.
Movimiento de cursor
Un cursor, que es un puntero interno utilizado por un conjunto de resultados, señala a la fila perteneciente a dicho conjunto y a la que está accediendo el programa Java.
Se ha mejorado el rendimiento del método getRow(). Antes de la versión V5R2, al utilizar ResultSet.last(), ResultSet.afterLast() y ResultSet.absolute() con un valor negativo, el número de fila actual no estaba disponible. Las restricciones anteriores se han eliminado, con lo que el método getRow() es ahora totalmente funcional.


3. Summary
You can use a ResultSet object to access a generated data table by running a query. The rows of the table are retrieved in sequence. Within a row, you can access the values ​​of the columns in any order.
The data stored in ResultSet is retrieved using the various get methods, depending on the type of data being retrieved. The net () method allows you to move to the next row.
ResultSet allows you to retrieve and update columns by name, although using the column index improves performance.
Cursor movement
A cursor, which is an internal pointer used by a result set, points to the row belonging to that set and to which the Java program is accessing.
The performance of the getRow () method has been improved. Prior to V5R2, using ResultSet.last (), ResultSet.afterLast () and ResultSet.absolute () with a negative value, the current row number was not available. The above restrictions have been removed, so the getRow () method is now fully functional.



4. RECOMENDACIONES

ü    ·    Se recomienda usar esta clase para poder obtener los datos de una tabla mediante métodos ofrecidos por el resultset que luego los obtendrás en un formulario.
ü    ·   Se recomienda declarar un objeto de la clase resultset para poder obtener las consultas que le hayamos dicho que nos muestre.

5. CONCLUSIONES

·                    Usar un objeto que almacena todos los datos del resultado de una consulta y que devuelva los resultados en un objeto ResultSet resulta muy importante, por eso necesitamos declarar un ejemplar de la clase ResultSet para contener los resultados.

6. APRECIACIÓN DEL EQUIPO
Ø    Desde nuestro punto de vista la clase resultset resulta muy indispensable, no solo esta clase si no las demás que hemos estado viendo, en otras palabras, este objeto es como un deposito en donde nosotros le enviamos las consultas desde un formulario para que después en la BD se ejecute, pero los datos obtenidos están depositados en el objeto resultset para después llamarla a una tabla, lista, combobox, etc.

7. Glosario de Término

ü     Interfaz: Una interfaz en Java es una colección de métodos abstractos y propiedades.En las interfaces se especifica qué se debe hacer pero no su implementación. Serán las clases que implementen estas interfaces las que describan la lógica del comportamiento de los métodos.

ü     Javadoc: Es una utilidad de Oracle para la generación de documentación de APIs en formato HTML a partir de código fuente Java. Javadoc es el estándar de la industria para documentar clases de Java. La mayoría de los IDEs los generan automáticamente.

ü    Query: SQL (por sus siglas en inglés Structured Query Language; en español lenguaje de consulta estructurada) es un lenguaje declarativo de acceso a bases de datos relacionales que permite especificar diversos tipos de operaciones en ellas.

8 BIBLIOGRAFÍA O LINKOGRAFÍA


ü      https://es.wikipedia.org/wiki/SQL

 diapositiva
https://www.slideshare.net/LUZCLARITAPEREZDIAZ/resultset-81265930


jueves, 19 de octubre de 2017

Statement




                                      "AÑO DEL BUEN SERVIDOR AL CIUDADANO"

                                           ESCUELA ACADÉMICA DE INGENIERÍA DE SISTEMAS Y TELEPÁTICA

                                                                                            ASIGNATURA
                                                                       LABORATORIO DE PROGRAMACIÓN II

                                                                                            TEMA
                                                                                        Statement

                                                                                           AUTORES
                                                                                   LUZ CLARITA PEREZ DIAZ
                                                                                   LUZ ISELA FLORES CHIGUEL
                                                                                   LUZ CLARITA CHILCON SANCHEZ

                                                                                               DOCENTE
                                                                                    ING.MARCO AURELIO PORRO CHULLI


                                                                                    BAGUA GRANDE-UTCUBAMBA 
                                                                                                     AMAZONAS


                                                                                                   2017


 1.Definicion:
Vista Preliminar.- 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.

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");

Ejecución de sentencias usando objetos Statement.- 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. Debe notarse que la interfase PreparedStatement, que hereda los métodos de la interfase Statement, tiene sus propias versiones de los métodos executeQuery, executeUpdate y execute. Los objetos Statement en si mismos no contienen una sentencia SQL, por tanto debe suministrarse como un argumento a los métodos Statement.execute. Los objetos PreparedStatement no suministran una sentencia SQL como argumento a estos métodos puesto que ya tienen la sentencia precompilada. Los objetos CallableStatement heredan las formas de estos métodos de PreparedStatement. Usar un parametro de query con las versiones de los métodos de PreparedStatement o CallableStatement producirái una SQLException,.

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.

Cerrar objetos Statement.- Los objetos Statement se cerrarán automáticamente por el colector de basura de Java (garbage collector). No obstante se recomienda como una buena práctica de programación que se cierren explicitamente cuando no sean ya necesarios. Esto libera recursos DBMS inmediatamente y ayuda a evitar potenciales problemas de memoria.

Sintaxis de Escape SQL en objetos Statement.- Los objetos Statement pueden contener sentencias SQL que usen sintaxis de escape SQL. La sintaxis de escape señala al driver que el código que lleva debe ser tratado diferentemente. El driver buscará por cualquier sintaxis de escape y lo traducirá en código que entiende la base de datos en particular. Esto hace que la sintaxis de escape sea independiente de la DBMS y permite al programador usar características que de otro modo no estarían disponibles. Una clausula de escape se enmarca entre llaves y tiene una palabra clave:
{keyword . . . parameters . . . }

La palabra clave (keyword) indica el tipo de clausula de escape, según se muestra:
escape para caracteres LIKE
Los caracteres “%” y “_” trabajan como wildcards en la clausula SQL LIKE
(“%” significa cero o más caracteres y “_” significa exactamente un carácter”.
En orden a interpretarlos literalmente, pueden estar precedidos por un
backslash (‘\’), que es un carácter de escape especial en cadenas. Se puede
especificar un carácter que se use como carácter de escape por la inclusión
de la sintaxis siguiente al final de la consulta.
{escape 'escape-character'}
Por ejemplo, la siguiente query, usando backslash como caracter de escape,
encuentra nombres de identificador que comiencen con ‘_’.
stmt.executeQuery("SELECT name FROM Identifiers
WHERE Id LIKE `\_%' {escape `\'};
fn para funciones escalares
Casi todas las DBMS tienen funciones numèricas, de cadena, de fecha y
conversión sobre valores escalares. Una de estas funciones puede usarse
colocándola en la sintaxis de escape con la clave fn seguida del nombre de
la función deseada y sus argumentos. Por ejemplo, para llamar a la función
concat con dos argumentos que serán concatenados:
{fn concat("Hot", "Java")};
El nombre del usuario actual de la base de datos puede obtenerse mediante:
 {fn user()};
Las funciones escalares pueden estar soportadas por diferentes DBMS con
ligeras diferencias de sintaxis, y pueden no estar disponibles en todos los
drivers. Varios métodos de DatabaseMetaData nos listarán las funciones
que están soportadas. Por ejemplo, el método getNumericFunctions devuelve
una lista de los nombres de las funciones numéricas separadas por comas, el
método getStringFunction nos devuelve los nombres de las funciones de
cadena, y así varías más.
EL driver o bien mapeará la llamada a la función ‘escapada’ en su propia
sintaxis o implementará la función el mismo.

• d, t y ts para literales de fecha y tiempo
Las DBMS difieren en la sintaxis que usan para los literales de fecha, tiempo
y timestamp. JDBC soporta un formato estándar ISO para estos literales y
usa una clausula de escape que el driver debe traducir a la representación
del DBMS.
Por ejemplo, una fecha se especifica en SQL JDBC mediante la sintaxis:
{d `yyyy-mm-dd'}
En esta sintaxis, yyyy es el año, mm es el mes y dd es el dia. El driver
reemplazará la clausula de escape por la representaciòn propia equivalente
de la DBMS. Por ejemplo, el driver reemplazaría {d 1999-02-28} por ’28-
FEB-99’ si este es el formato apropiado para la base subyacente.
Hay clausulas de escape análogas para TIME y TIMESTAMP
{t `hh:mm:ss'}
 {ts `yyyy-mm-dd hh:mm:ss.f . . .'}
La parte fraccional de los segundos (.f . . .) del TIMESTAMP puede
omitirse.
• call ó ? = call para procedimientos almacenados
Si una database soporta procedimientos almacenados, estos pueden ser
invocados desde JDBC mediante:
{call procedure_name[(?, ?, . . .)]}
o, cuando el procedimiento devuelve como resultado un parámetro
{? = call procedure_name[(?, ?, . . .)]}
Los corchetes indican que el material encerrado en ellos es opcional. Estos
no forman parte de la sintaxis.
Los argumentos de entrada pueden ser bien literales, bien parámetros. Ver la
sección 7 “CallableStatement” de esta guía.
Se puede llamar al método
DatabaseMetaData.supportsStoredProcedures para ver si la base de
datos soporta procedimientos almacenados.

• oj para joins de salida
La sintaxis para un outer join es:
{oj outer-join}
donde outer-join es de la forma:
table LEFT OUTER JOIN {table | outer-join} ON search-condition
Las Outer joins son una característica avanzada, y solo puede chequearse la
gramática SQL mediente una explicación de ella. JDBC provee tres métodos
de DatabaseMetaData para determinar que tipos de outer joins soporta un
driver: supportsOuterJoins, supportsFullOuterJoins, y
supportsLimitedOuterJoins.
El método Statement.setEscapeProcessing activa o desactiva el
procesamiento de escape. Por defecto la característica se encuentra activada. Un
programador debería desactivar esta característica en tiempo de ejecución cuando
el rendimiento ha de ser máximo, pero normalmente debe estar activado. Debería
notarse que setEscapeProcesing no trabaja con objetos PreparedStatement
por que la sentencia ya está preparada para enviar a la base de datos antes de
poder ser llamada.
4.1.6 Uso del método execute
El método execute debería usarse solamente cuando es posible que una sentencia
nos devuelva más de un objeto Resultset., mas de un update count o una
combinación de ambos. Estas múltiples posibilidades para resultados, aunque raras,
son posibles cuando se ejecutan ciertos procedimientos almacenados o por la
ejecución dinámica de una string SQL desconocida (esto es, desconocida para el
programador de la aplicación en tiempo de compilación). Por ejemplo, una usuario
podría ejecutar un procedimiento almacenado (usando una objeto
CallableStatement y este procedimiento podría ejecutar una actualización,
después una select, luego una actualización, después una select y así.
Normalmente, alguien que usa un procedimiento almacenado sabrá que se le va a
devolver.
Porque el método execute maneja los casos que se salen de lo ordinario, no
sorprende que los resultados devueltos requieren algun manejo especial. Por
ejemplo, supongamos que se sabe que el procedimiento devuelve dos result sets.

Después de usar el método execute para ejecutar el procedimiento, se debe llamar
al método getResultSet para conseguir el primer result set y después los
métodos apropiados getXXX para recuperar los valores de él. Para conseguir el
segundo result set, se necesita llamar al método getMoreResults y y despues a
getResultSet de nuevo. Si se sabe que el procedimiento devuelve dos upadte
counts, se llama primero al método getUpdateCount, seguido de
getMoreResults y de nuevo getUpdateCount.
Aquellos casos en los que no se conoce que devolverá se nos presenta una
situación más compleja. El método execute devuelve true si el resultado es un
objeto ResultSet y false si es un int Java. Si devuelve un int, esto quiere
decir que el resultado o bien es un update count o que la sentencia que ha
ejecutado es un comando DDL. Lo primero que hay que hacer después de llamar
execute es llmar o bien a getResultSet o getUpdateCount. Al método
getResultSet se le llama para conseguir el primero de los dos o más objetos
ResultSet y al método getUpdateCount para conseguir el primero de dos o más
update counts.
Cuando el resultado de una sentencia SQL no es un result set, el método
getResultSet devolverá null. Esto quiere decir que el resultado es un update
count o que no hay más resultados. La única manera de encontrar que significa el
valor null en este caso es llamar al método getUpdateCount, que devolverá un
entero. Este entero será el número de filas afectadas por la sentencia ejecutada o
–1 para indicar o bien que el resultado es un result set o bien que no hay más
resultados. Si el método getResultSet ya ha devuelto null, el resultado no puede
ser un objeto ResultSet, por lo que el valor devuelto de –1 tiene que ser que no
hay más resultados. En otras palabras, no hay más resultados cuando lo siguiente
es cierto:
((stmt.getResultSet() == null) && (stmt.getUpdateCount() == -1))
Si se ha llamado al método getResultSet y se ha procesado el objeto
ResultSet devuelto, es necesario llamar al método getMoreResults para ver si
hay más result sets o update counts.. Si getMoreResults devuelve true, entonces
es necesario llamar de nuevo a getResultSet para recuperar el siguiente result
set. Como ya se ha indicado anteriormente, si getResultset devuelve null hay
que llamar a GetUpdateCount para buscar que significa ese null si un update
count o que no hay más resultados.
Cuando getMoreResults devuelve false quiere decir que la sentencia SQL ha
devuelto un update count o que no hay más resultados. Por tanto es necesario
llamar al método getUpdateCount para encontrar cual es el caso. En esta situación,
no habrá más resultados cuando lo siguiente es cierto:

((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

Propiedades (C# y Java)


En C#, una propiedad es un miembro con nombre de una clase, estructura o interfaz que ofrece una forma ordenada de tener acceso a campos privados mediante lo que se denomina métodos de descriptor de accesoget y set.
En el ejemplo de código siguiente declara una propiedad denominada Species para la clase Animal, que resume el acceso a la variable privada denominada name:
C#
public class Animal
{
    private string name;

    public string Species
    {
        get
        {
            return name;
        }
        set
        {
            name = value;
        }
    }
}


A menudo, la propiedad tendrá el mismo nombre que el miembro interno al que tiene acceso, pero con una letra mayúscula inicial, por ejemplo, Nameen el caso anterior o el miembro interno tendrá un prefijo _. Observe también el parámetro implícito denominado value que se utiliza en el descriptor de acceso set; éste tiene el tipo de la variable miembro subyacente.
De hecho, los descriptores de acceso se representan en forma interna como métodos get_X() y set_X() para mantener la compatibilidad con los lenguajes basados en .NET Framework, que no admiten descriptores de acceso. Una vez que una propiedad está definida, es muy fácil obtener o establecer su valor:
C#
class TestAnimal
{
    static void Main()
    {
        Animal animal = new Animal();
        animal.Species = "Lion";                   // set accessor
        System.Console.WriteLine(animal.Species);  // get accessor

    }
}


Si una propiedad sólo tiene un descriptor de acceso get, es una propiedad de sólo lectura. Si sólo tiene un descriptor de acceso set, es una propiedad de sólo escritura. Si tiene ambos, es una propiedad de lectura y escritura.

Structs (C# y Java)


C# admite la palabra clave struct, que es otro elemento que se origina en C pero no está disponible en Java. struct se puede considerar como una clase ligera. Aunque las structs pueden contener constructores, constantes, campos, métodos, propiedades, indizadores, operadores y tipos anidados, se utilizan principalmente para encapsular grupos de campos relacionados. Dado que las estructuras son tipos de valor, se pueden asignar de un modo ligeramente más eficaz que las clases. Las structs difieren de las clases en que no pueden ser abstractas y no admiten la herencia de implementaciones.
En el ejemplo siguiente, se inicializa struct con la palabra clave new, se llama al constructor predeterminado sin parámetros y, a continuación, se establecen los miembros de la instancia.
C#
public struct Customer
{
    public int ID;
    public string Name;

    public Customer(int customerID, string customerName)
    {
        ID = customerID;
        Name = customerName;
    }
}

class TestCustomer
{
    static void Main()
    {
        Customer c1 = new Customer();  //using the default constructor

        System.Console.WriteLine("Struct values before initialization:");
        System.Console.WriteLine("ID = {0}, Name = {1}", c1.ID, c1.Name);
        System.Console.WriteLine();

        c1.ID = 100;
        c1.Name = "Robert";

        System.Console.WriteLine("Struct values after initialization:");
        System.Console.WriteLine("ID = {0}, Name = {1}", c1.ID, c1.Name);
    }
}





Resultado
Cuando se compila y ejecuta el código anterior, el resultado muestra que las variables struct se inicializan de manera predeterminada. La variable int se inicializa en 0 y la variable string se inicializa en una cadena vacía:
Struct values before initialization:
ID = 0, Name =
Struct values after initialization:
ID = 100, Name = Robert

Ejemplos
Especificar características de ResultSet
Las características de los ResultSets están asociadas con la sentencia que finalmente los crea. El método Connection.createStatement permite especificar estas características de ResultSet. A continuación se ofrecen algunos ejemplos de llamadas válidas al método createStatement:
Ejemplo: método createStatement

// El siguiente código es nuevo en JDBC 2.0

Statement stmt2 = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATEABLE);

// El siguiente código es nuevo en JDBC 3.0

Statement stmt3 = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSOR_OVER_COMMIT);

 Ejemplo: utilizar el método executeUpdate de un objeto Statement
Este es un ejemplo de utilización del método executeUpdate del objeto Statement.
Nota
Utilizando los códigos de ejemplo, acepta los términos de Información de licencia de código y declaración de limitación de responsabilidad.
import java.sql.*;
import java.util.Properties;

public class StatementExample {

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

        // Sugerencia: estos se cargan a partir de 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;

        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 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)");

            // Se ejecutan algunas sentencias SQL que insertan registros en la tabla.
            s.executeUpdate("INSERT INTO MYLIBRARY.MYTABLE (NAME, ID) VALUES ('RICH', 123)");
            s.executeUpdate("INSERT INTO MYLIBRARY.MYTABLE (NAME, ID) VALUES ('FRED', 456)");
            s.executeUpdate("INSERT INTO MYLIBRARY.MYTABLE (NAME, ID) VALUES ('MARK', 789)");

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

            // 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 (s != null) {
                    s.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.");
}
        }
    }
  }

    2.   RESUMEN

STATEMENT -  JAVA.SQL.STATEMENT:
java.sql.Statement
Se usa para ejecutar sentencias SQL.
Lleva asociada una conexión que sirvió como origen para su creación.
·         Se crea con el método de la clase:
java.sql.Connection:
public Statement createStament() trows java.sql.SQLException;
·         Las sentencias se cierran con el método:
public void close() trows java.sql.SQLException;
El método para ejecutarla depende del tipo de sentencia SQL que contenga.
Sentencias SELECT:
Se usa el método: executeQuery(String sql). Devuelve una instancia de java.sql.ResultSet.
Sentencias INSERT, UPDATE, DELETE:
Se usa el método: executeUpdate(String sql).devuelve un int con el número de filas afectadas

  3.   SUMMARY
STATEMENT - java.sql.Statement:
java.sql.Statement
It is used to execute SQL statements.
It is associated with a connection that served as the source for its creation.
• is created with the method of the class:
java.sql.Connection:
Statement public createStament () trows java.sql.SQLException;
• The sentences are closed with the method:
public void close () trows java.sql.SQLException;
The method to execute depends on the type of SQL statement containing.
SELECT statements:
executeQuery (String sql) method is used. Returns an instance of java.sql.ResultSet.
INSERT, UPDATE, DELETE:
the method is used: executeUpdate (String sql) .devuelve an int with the number of rows affected
  4.   RECOMENDACIONES
Ø  Un objeto Statement se debe crear, mediante el método de Connection createStatement
Ø Un objeto Statement solo, es usado 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.
Ø Un objeto CallableStatement se usa para ejecutar un procedimiento de base de datos almacenado.



   3. CONCLUSIONES
Ø Para el método de conexión se utilizan los siguientes componentes: Connection, Statement y ResultSet.
Ø  El Statement es el que genera el comando de ejecución, para ello todo este comando lo mandamos en el parámetro SQL.


  6.   APRECIACIÓN DEL EQUIPO
Ø Nuestra apreciación con respecto al trabajo realizado, sobre el tema deStatement es que Statement es un objeto que es usado 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 y CallableStatement.
Ø  Esperamos que este trabajo le sea útil a la persona interesadas.

  7.   GLOSARIO 
·    MÉTODO.- Un método en Java es un conjunto de instrucciones definidas dentro de una clase, que realizan una determinada tarea y a las que podemos invocar mediante un nombre.
·  CONTENEDOR.- Se trata de unidades estancas que protegen las mercancías de la climatología.
·      PARÁMETROS.- Variable que establece un conjunto de características a ser reproducidas dentro de un patrón establecido por un programa o lenguaje dados.
·     INTERFACE.- es el 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.
·       SINTAXIS.- Forma correcta en que deben estar dispuestos los símbolos que componen una instrucción ejecutable por el ordenador.
·  OBJETO.-entidad existente en la memoria del ordenador que tiene unas propiedades (atributos o datos sobre sí mismo almacenados por el objeto) y unas operaciones disponibles específicas (métodos).

  8.   LINKOGRAFIA

ahí les dejo algunas diapositivas en ese link espero les guste.

https://www.slideshare.net/LUZCLARITAPEREZDIAZ/statement-80876117