Parte 3:
Mostrar los datos de un usuario y actualizar los datos de usuarios existentes
Pasos:
• 1- Abre el proyecto según se indico en clases.
• 2- Añade un nuevo WebForm (ya sabes los pasos).
• 2.a- El nombre será ModificarUsuario.aspx, dile que el código lo ponga en un fichero aparte.
• 3- Como el formulario de modificar los datos será casi igual que el de introducir nuevos datos, vamos a copiar el que ya tenemos y después le haremos los cambios necesarios para darle la funcionalidad que queremos que tenga.
• 3.a- Abre la página AgregarUsuario.aspx en modo de Código, ya que vamos a copiar todo el código HTML para pegarlo en la página que acabas de crear en el punto 2.
• 3.b- Selecciona desde la etiqueta hasta el final, lo copias y lo pegas en la página nueva.
• 3.c- Por supuesto, al pegar, debes hacerlo desde hasta el final, pero esto supongo que ya te lo imaginabas.
• 4- Ahora lo que hay que hacer es añadir un nuevo control (un botón), que estará al lado de la caja de textos Correo.
• 4.a- Ese botón, al que le darás el nombre btnMostrar, servirá para mostrar el usuario que quieres modificar.
• 4.b- El texto a mostrar en el botón será precisamente Mostrar.
• 5- Al botón que ya estaba, debes cambiarle el nombre y el texto para que sean: btnActualizar y Actualizar respectivamente.
• 5.b- Si estás usando C# tendrás un pequeño problema al copiar el texto anterior y cambiarle el nombre al botón, ya que si haces dobleclic en ese botón, en la ventana de código se mostrará el método btnNuevo_Click en lugar del nombre que debería mostrarse: btnActualizar_Click.
• 5.c- Esto es así porque en C# en las propiedades del botón estará asignado el valor del atributo OnClick con el valor "btnNuevo_Click".
• 5.d- En Visual Basic esto no suele ocurrir, ya que si tenemos el código separado del diseño (se usa un fichero aparte para el código), los métodos de los eventos se manejan con la cláusula Handles, por tanto, lo importante es que esa instrucción esté en un método para que ese método esté asociado con el evento que se indique después de Handles.
• 5.e- Pero si en lugar de tener el código separado del diseño, está todo en el mismo fichero, el problema será el mismo tanto en Visual Basic como en C#.
• 6- Para que en C# tenga el nombre "adecuado", lo que tienes que hacer es quitar ese atributo (OnClick) y el código que se ha añadido al hacer antes dobleclic en el botón.
• 6.a- Una vez que lo has borrado, vuelve a hacer dobleclic en el botón Actualizar y esta vez si que se creará el método con el nombre que debe tener.
¿Qué hacer para modificar un usuario?
• 7- Esa es la pregunta que tenemos que hacernos ahora, en principio, escribirás la cuenta de correo del usuario a modificar, pulsarás en el botón Mostrar, se mostrarán los datos del usuario si es que existe, y en caso de que no exista se avisará de ese hecho y no pasará nada.
• 7.a- Una vez que tenemos los datos del usuario que queremos modificar, los podremos modificar y al pulsar en el botón Actualizar, se guardarán los datos en la base de datos.
• 8- Ahora tenemos que plantearnos que hacemos con la clave, al menos si nuestra intención es poder cambiarla. Ya que la guardamos como un valor SHA1.
• 8.a- La primera posibilidad que tenemos es introducir la clave en modo "normal" y hacer lo mismo que hicimos en la parte de introducir un nuevo usuario, es decir, crear la clave SHA1 a partir del texto que introduzcamos.
• 8.b- El problema es que si queremos modificar otros datos, pero dejar la clave como estaba, pues... lo tendremos complicado, ya que en realidad no sabremos que clave es... porque recuerda que si solo conocemos el valor SHA1 será imposible saber que clave era... y como me imagino que no te vas a saber todas las claves de memoria, pues... habrá que hacer algo para que no tengamos que preguntarle al usuario cual era su clave, o decirle que se la hemos cambiado.
• 8.c- Si introducimos la clave directamente como un valor SHA1, ya no tendremos el problema de saber que clave era, y de esa forma, si hacemos algún cambio en cualquiera de los otros datos, no habrá problemas con la clave, ya que en esta ocasión no volveremos a generar el valor SHA1, sino que guardaremos lo que haya en la caja de textos.
• 8.d- El problema lo tendremos a la hora de introducir una nueva clave (porque queramos cambiarla), ya que tendremos que saber el valor SHA1 de esa nueva clave.
• 8.e- Una solución es tener un "generador" de valores SHA1 a partir de un texto, de esa forma, si queremos cambiar una clave, escribiremos el texto de la nueva clave, pulsaremos en el botón de generar el valor SHA1 y el resultado será lo que usemos para guardar en el campo Clave.
• 8.f- Es decir, lo mismo (o casi) que hicimos a la hora de añadir un nuevo usuario, pero sin que sea automático. Mejor te explico cómo hacerlo y así lo tendrás más claro.
• 9- Añade un botón junto a la caja de textos de la clave.
• 9.a- Modifica las propiedades del botón para que muestre el texto Generar clave SHA1 y el nombre sea btnClaveSha1.
• 10- Como el editor de formularios Web se empeña en manejar el tamaño de las celdas con valores en pixel, y para que se vea bien los 40 caracteres que tiene el valor SHA1 generado, tendremos que "engañar" al editor... o casi.
• 10.a- Así que, vamos a seleccionar todas las columnas en las que están las cajas de textos y le vamos a dar un valor en porcentaje.
• 10.b- Si mueves el cursor encima de la primera fila (el borde de la tabla), verás que se muestra una especie de flecha.
• 10.c- Pon el ratón encima de la segunda columna y pulsa en la flechita esa, de esa forma se seleccionarán todas las columnas (en realidad las columnas que están en las filas que tienen dos columnas).
• 10.d- Una vez que tienes las columnas seleccionadas, en la ventana de propiedades ve a la propiedad Style, verás que pone WIDTH: 100px, borra desde los dos puntos, y escribe 80%, de forma que ahora muestre WIDTH: 80%.
• 10.e- Ahora selecciona el control txtClave y en la propiedad Width escribe 90% (o 100%, como quieras), esto hará que la caja de texto ocupe ese porcentaje de la celda en la que está.
• 11- Ahora es tiempo de escribir el código. Te explico lo que hará al pulsar en el botón de generar la clave SHA1
• 11.b- Se leerá el valor que haya en txtClave, se usará para generar el valor SHA1 y se volverá a asignar a ese mismo control.
• 11.c- Como en este caso queremos que se vea lo que se generará, asegúrate de que el control txtClave NO tiene el valor Password en la propiedad TextMode, sino que tiene el valor SingleLine.
• 12- Haz dobleclic en el botón de generar la clave y escribe este código:
Protected Sub btnClaveSha1_Click(ByVal sender As Object, _
ByVal e As System.EventArgs) _
Handles btnClaveSha1.Click
' Generar la clave SHA1 a partir de lo que haya en txtClave
' y asignar nuevamente a ese mismo textBox el resultado
Dim clave As String
clave = FormsAuthentication.HashPasswordForStoringInConfigFile( _
txtClave.Text, "SHA1")
txtClave.Text = clave
End Sub
• 12.a- El código para C# es el siguiente:
protected void btnGenerarClaveSha1_Click(object sender, EventArgs e)
{
// Generar la clave SHA1 a partir de lo que haya en txtClave
// y asignar nuevamente a ese mismo textBox el resultado
string clave;
clave = FormsAuthentication.HashPasswordForStoringInConfigFile(
txtClave.Text, "SHA1");
txtClave.Text = clave;
}
• 13- Prueba esto que acabas de hacer, pero para que se pueda "navegar" a esta nueva página, tendrás que añadir un nuevo control HyperLink en la página Default.aspx para que vayas a esta nueva página al pulsar en él.
• 13.a- Para probar, escribe una clave y pulsa en el botón Generar clave SHA1 y verás que se muestra el valor que le corresponde al texto que has escrito, por ejemplo, para el valor 123456, el valor de SHA1 será: 7C4A8D09CA3762AF61E59520943DC26494F8941B.
• 13.b- Por supuesto, para hacer esa prueba, debes escribir una cuenta de correo y un nombre, ya que al tener los validadores, pues... nos avisará de que esos campos deben tener algo.
Mostrar los datos de un usuario
• 14- Ahora le toca al código del botón Mostrar, en ese botón vamos a comprobar si el correo indicado está en la tabla, y en caso de que así sea, mostraremos los datos en las cajas de texto que correspondan.
• 14.a- Para leer los datos, usaremos un objeto SqlConnection, un objeto SqlCommand con la cadena de selección para recuperar todos los datos del usuario que tenga la cuenta de correo que indiquemos. Para poder acceder a esos datos devueltos por la consulta, usaremos un objeto SqlDataAdapter y un objeto DataTable.
• 14.b- En realidad no nos hacen falta ni el objeto para la conexión ni el comando, ya que lo podríamos hacer todo con el adaptador, pero así podrás ver otra forma de acceder a los datos, ya que te será útil si, por ejemplo usas un procedimiento almacenado (stored procedure) para hacer esa comprobación.
• 14.c- ¿Que dices? ¿Quieres que usemos un procedimiento almacenado?
• 14.d- Vale... pero primero te muestro el código para hacerlo de forma normal.
• 15- En el formulario ModificarUsario.aspx, pulsa en el botón Mostrar y escribe lo siguiente:
15.a- Primero en Visual Basic:
Protected Sub btnMostrar_Click(ByVal sender As Object, _
ByVal e As System.EventArgs) _
Handles btnMostrar.Click
Me.lblAviso.Text = ""
'
' Comprobamos si el nombre ya existe
Using cnn As New SqlConnection(Me.SqlDataSource1.ConnectionString)
' La cadena de slección será la que tenga el DataSource,
' pero buscando el correo que hemos escrito
Dim sel As String
sel = Me.SqlDataSource1.SelectCommand & _
" WHERE Correo = @Correo"
Dim cmd As New SqlCommand(sel, cnn)
' Abrimos la conexión
cnn.Open()
' Añadimos el valor del parámetro de la consulta
cmd.Parameters.AddWithValue("@Correo", txtCorreo.Text)
' El resultado lo guardaremos en una tabla
Dim tabla As New DataTable
' Usaremos un DataAdapter para leer los datos
Dim da As New SqlDataAdapter(cmd)
' Llenamos la tabla con los datos leídos
da.Fill(tabla)
' Si la tabla no tiene filas, es que no existe ese usuario
If tabla.Rows.Count = 0 Then
' Avisamos y salimos
Me.lblAviso.Text = "El usuario NO existe"
Exit Sub
End If
' Mostramos los datos
' que estarán en la primera fila de la tabla,
' ya que solo debería haber un solo usuario con ese correo
Me.txtClave.Text = tabla.Rows(0)("Clave").ToString
Me.txtFecha.Text = tabla.Rows(0)("Fecha").ToString
Me.txtNombre.Text = tabla.Rows(0)("Nombre").ToString
Me.txtComentarios.Text = tabla.Rows(0)("Comentarios").ToString
Me.lblAviso.Text = "El usuario existe y se han leído los datos."
' Al salir del bloque Using se cierra la conexión
End Using
End Sub
• 15.b- Ahora el código de C#:
protected void btnMostrar_Click(object sender, EventArgs e)
{
this.lblAviso.Text = "";
//
// Comprobamos si el nombre ya existe
using (SqlConnection cnn = new SqlConnection(this.SqlDataSource1.Connec
{
// La cadena de slección será la que tenga el DataSource,
// pero buscando el correo que hemos escrito
string sel;
sel = this.SqlDataSource1.SelectCommand +
" WHERE Correo = @Correo";
SqlCommand cmd = new SqlCommand(sel, cnn);
// Abrimos la conexión
cnn.Open();
// Añadimos el valor del parámetro de la consulta
cmd.Parameters.AddWithValue("@Correo", txtCorreo.Text);
// El resultado lo guardaremos en una tabla
DataTable tabla = new DataTable();
// Usaremos un DataAdapter para leer los datos
SqlDataAdapter da = new SqlDataAdapter(cmd);
// Llenamos la tabla con los datos leídos
da.Fill(tabla);
// Si la tabla no tiene filas, es que no existe ese usuario
if (tabla.Rows.Count == 0)
{
// Avisamos y salimos
this.lblAviso.Text = "El usuario NO existe";
return;
}
// Mostramos los datos
// que estarán en la primera fila de la tabla,
// ya que solo debería haber un solo usuario con ese correo
this.txtClave.Text = tabla.Rows[0]["Clave"].ToString();
this.txtFecha.Text = tabla.Rows[0]["Fecha"].ToString();
this.txtNombre.Text = tabla.Rows[0]["Nombre"].ToString();
this.txtComentarios.Text = tabla.Rows[0]["Comentarios"].ToString();
this.lblAviso.Text = "El usuario existe y se han leído los datos.";
// Al salir del bloque Using se cierra la conexión
}
}
• 15.c- Acuérdate de añadir las importaciones para System.Data y System.Data.SqlClient
• 16- Si quieres probar esto... pruébalo, pero antes de ir a probarlo, deberías leer lo que te voy a decir...
• 16.a- Tal como está el código de esta página, si no escribes nada en la clave ni en el nombre, te mostrará el mensaje de error y no te dejará hacer nada.
• 16.b- Así que, lo mejor será que quitemos los controles de validación, al menos los de la clave y los del nombre.
• 16.c- Pero al hacer eso, tenemos el problema de que nos olvidemos de escribir algo en esas cajas de texto, y... bueno... que no podemos tenerlo todo, así que... tienes que decidir que quieres hacer...
• 17- ¿Quieres dejar los controles de validación?
• 17.a- En ese caso, cuando solo quieras mostrar los datos, tendrás que rellenar los controles que se validan.
• 18- ¿Quieres quitar los controles de validación?
• 18.a- En ese caso, si modificas y borras el contenido de la clave o del nombre, pues no habrá nadie que te avise.
• 19- Mejor quita los controles de validación que controlan la clave y el nombre. Pero puedes hacer lo que quieras.
• 19.a- Si quitas los controles de validación, al menos deja los dos que validan la cuenta de correo.
Crear un procedimiento almacenado
• 20- Ahora vamos a añadir un procedimiento almacenado a la base de datos.
• 20.a- Muestra la ventana del Explorador de bases de datos.
• 20.b- Si es preciso, expande la conexión de la base vwdTut01.mdf.
• 20.c- En la carpeta Procedimientos almacenados, pulsa con el botón derecho del ratón y selecciona Agregar nuevo procedimiento almacenado.
• 20.d- Se abrirá una nueva ventana en la que podemos escribir el código de ese procedimiento almacenado, inicialmente tendrá este código:
CREATE PROCEDURE dbo.StoredProcedure1
/*
(
@parameter1 int = 5,
@parameter2 datatype OUTPUT
)
*/
AS
/* SET NOCOUNT ON */
RETURN
• 20.e- Sustitúyelo por este otro y pulsa en el botón guardar.
ALTER PROCEDURE dbo.MostrarUsuario
@Correo nvarchar(64)
AS
SELECT Correo, Clave, Nombre, Fecha, Comentarios
FROM dbo.Usuarios
WHERE Correo = @Correo
RETURN
• 20.f- Este procedimiento almacenado hace lo mismo que en el código anterior (punto 15)
• 21- Ahora solo falta cambiar el código del objeto SqlCommand para que use este procedimiento almacenado.
• 21.a- En el código del método del botón mostrar, sustituye el código de la declaración del comando (y el de la variable sel) y pon este para Visual Basic:
' Usando un procedimiento almacenado
Dim cmd As New SqlCommand()
cmd.CommandText = "MostrarUsuario"
cmd.CommandType = CommandType.StoredProcedure
cmd.Connection = cnn
• 21.b- Este es el de C#:
// Usando un procedimiento almacenado
SqlCommand cmd = new SqlCommand();
cmd.CommandText = "MostrarUsuario";
cmd.CommandType = CommandType.StoredProcedure;
cmd.Connection = cnn;
• 21.c- El resto del código es exactamente igual, pruébalo y saldrás de dudas.
• 21.d- Fíjate que al usar un procedimiento almacenado, asignamos a la propiedad CommandType del comando el valor CommadType.StoredProcedure para que se entere de que estamos usando un procedimiento almacenado en lugar de una sentencia T-SQL directa.
• 21.e- Cuando no asignamos el valor StoredProcedure a la propiedad CommandType, el valor que tiene es Text, que es el predeterminado de esa propiedad.
El código para actualizar los datos modificados
• 22- Lo siguiente que tienes que hacer es escribir el código para actualizar los datos escritos.
• 22a- En el evento Click del botón Actualizar tendrás que escribir el código para actualizar los datos del usuario cuyo correo hayas escrito.
• 22b- ¿Que haremos en ese método?
• 22c- Pues, comprobar que el correo indicado está en la base de datos.
• 22d- Si no está, mostrar un error.
• 22.e- Si existe, usaremos el contenido de la propiedad UpdateCommand del DataSource para actualizar los datos.
• 22.f- La llamada a ese comando de actualización la hacemos por medio del método ExecuteNonQuery del comando, pero una vez que hemos asignado los valores de los parámetros, que en este caso, también usamos el método AddWithValue.
• 22.g- Este es el código para Visual Basic:
Protected Sub btnActualizar_Click(ByVal sender As Object, _
ByVal e As System.EventArgs) _
Handles btnActualizar.Click
Me.lblAviso.Text = ""
'
' Comprobamos si el nombre ya existe
Using cnn As New SqlConnection(Me.SqlDataSource1.ConnectionString)
' El valor que necesitamos es el ID
Dim cmd As New SqlCommand( _
"SELECT ID " & _
"FROM Usuarios " & _
"WHERE Correo = @Correo", cnn)
' Abrimos la conexión
cnn.Open()
' Añadimos el valor del parámetro de la consulta
cmd.Parameters.AddWithValue("@Correo", txtCorreo.Text)
' Si devuelve cero, es que no existe
Dim i As Integer
i = CInt(cmd.ExecuteScalar())
If i = 0 Then
' Avisamos y salimos
Me.lblAviso.Text = "El usuario NO existe"
Exit Sub
End If
' Si llegamos aquí, es que el usuario existe
' Deberíamos hacer las comprobaciones de que haya datos que guardar,
' pero... eso te lo dejo a ti...
'
' Seguimos usando la misma conexión, pero cambiamos el comando
' Usamos el comando Update del DataSource
cmd = New SqlCommand(Me.SqlDataSource1.UpdateCommand, cnn)
' Añadimos el valor del parámetro de la consulta
cmd.Parameters.AddWithValue("@Correo", txtCorreo.Text)
' La clave la guardaremos como un valor SHA1
' pero como ya estará como SHA1, simplemente la asignamos
cmd.Parameters.AddWithValue("@Clave", txtClave.Text)
' Esto nos puede dar problemas dependiendo del forma
' del servidor en el que está la base de datos
cmd.Parameters.AddWithValue("@Fecha", txtFecha.Text)
cmd.Parameters.AddWithValue("@Nombre", txtNombre.Text)
cmd.Parameters.AddWithValue("@Comentarios", txtComentarios.Text)
' El valor de la variable i es el ID a actualizar
cmd.Parameters.AddWithValue("@ID", i)
' Ejecutamos el comando de actualización
' podemos usar el método Update del DataSource
' (pero no actualiza nada)
'Me.SqlDataSource1.Update()
' Mejor con una llamada a ExecuteNonQuery
cmd.ExecuteNonQuery()
' Al salir del bloque Using se cierra la conexión
End Using
Me.lblAviso.Text = "Se han actualizado los datos correctamente"
End Sub
• 22.h- Este es el código del método de evento del botón Actualizar para C#:
protected void btnActualizar_Click(object sender, EventArgs e)
{
this.lblAviso.Text = "";
//
// Comprobamos si el nombre ya existe
using (SqlConnection cnn =
new SqlConnection(this.SqlDataSource1.ConnectionString))
{
// El valor que necesitamos es el ID
SqlCommand cmd = new SqlCommand(
"SELECT ID " +
"FROM Usuarios " +
"WHERE Correo = @Correo", cnn);
// Abrimos la conexión
cnn.Open();
// Añadimos el valor del parámetro de la consulta
cmd.Parameters.AddWithValue("@Correo", txtCorreo.Text);
// Si devuelve cero, es que no existe
int i = (int)cmd.ExecuteScalar();
if (i == 0)
{
// Avisamos y salimos
this.lblAviso.Text = "El usuario NO existe";
return;
}
// Si llegamos aquí, es que el usuario existe
// Deberíamos hacer las comprobaciones de que haya datos que guardar,
// pero... eso te lo dejo a ti...
//
// Seguimos usando la misma conexión, pero cambiamos el comando
// Usamos el comando Update del DataSource
cmd = new SqlCommand(this.SqlDataSource1.UpdateCommand, cnn);
// Añadimos el valor del parámetro de la consulta
cmd.Parameters.AddWithValue("@Correo", txtCorreo.Text);
// La clave la guardaremos como un valor SHA1
// pero como ya estará como SHA1, simplemente la asignamos
cmd.Parameters.AddWithValue("@Clave", txtClave.Text);
// Esto nos puede dar problemas dependiendo del forma
// del servidor en el que está la base de datos
cmd.Parameters.AddWithValue("@Fecha", txtFecha.Text);
cmd.Parameters.AddWithValue("@Nombre", txtNombre.Text);
cmd.Parameters.AddWithValue("@Comentarios", txtComentarios.Text);
// El valor de la variable i es el ID a actualizar
cmd.Parameters.AddWithValue("@ID", i);
// Ejecutamos el comando de actualización
// con una llamada a ExecuteNonQuery
cmd.ExecuteNonQuery();
// Al salir del bloque using se cierra la conexión
}
this.lblAviso.Text = "Se ha añadido el nuevo usuario correctamente";
}
• 23- En el código hay un par de cosas que te quiero comentar.
• 23.a- En el primer comando he usado el ID como valor a recuperar para comprobar si existe el usuario, ya que ese valor del ID lo necesitaremos para el comando UpdateCommand del DataSource.
• 23.b- La conexión no la he cerrado, ya que después hay que volver a abrirla, y en realidad podemos aprovecharla para las dos cosas que hay que hacer. Por eso solo hay un bloque Using.
• 23.c- La otra cosa es que en teoría, el objeto DataSource tiene un método Update, que supuestamente es para actualizar los datos usando la cadena de UpdateCommand, pero... bueno, a mi no me funciona, así que, mejor usar el método ExecuteNonQuery del objeto SqlCommand, que si que funciona.
Y esto es todo, creo que con lo explicado en estas tres partes tendrás una pequeña idea de cómo manejar los datos en un sitio Web creado con ASP.NET.
NOTA: Utilizando la base de datos NorthWind crear el mismo proceso
El Sitio de Oscar Chevez Ulloa
- Lic. Oscar O. Chévez Ulloa
- San Salvador, El Salvador, El Salvador
- Lic. Administración de Empresas Preespecialización en Tecnologìa de Información Analista Programador de Sistemas Servicios que Ofrece: * Capacitación Office * Lenguajes de Programación * Base de Datos * Consultorías de Sistemas (Análisis, Diseño e Implementación) * Asesoría de Tésis Otros Servicios: * Panadería y Pastelería por **Encargo** * Bisuteria y Artesanias
miércoles, 24 de marzo de 2010
Segunda parte ASPX
*-----------------------------------------------------------------------------------*
Parte 2:
Mostrar todos los datos en un GridView
Nota:
Como este ejemplo no necesita ni una sola línea de código, solo te muestro lo que hay aquí, pero verás que es muy fácil de crear la página para que muestre los datos en el GridView y que no hace falta que te muestre nada más.
Estos son los pasos para completar esta segunda parte del tutorial:
• 1- Abre el proyecto que creamos en la parte I.
• 2- Añade una nueva página:
• 2.a- En el menú Sitio Web selecciona Agregar nuevo elemento...
• 2.b- Del cuadro de diálogo de agregar nuevo elemento, selecciona WebForms y dale el nombre MostrarUsuarios.aspx
• 2.c- Como en este primer caso no vamos a escribir ni una línea de código, si quieres, quita la casilla que hay junto a Colocar el código en un archivo independiente.
• 3- Si ya le habías dado a Aceptar antes de terminar de leer el punto anterior, puedes modificar el código interno de ese fichero para que no use un fichero de código por separado.
• 3.a- Muestra el fichero, y pulsa en la ficha Código para que se muestre el código HTML de la página.
• 3.b- En la parte superior, deja solo <%@ Page Language="VB" %>(si estás usando C#, en vez de VB, pues pondrá C#)
• 3.c- Elimina el fichero extra que tendrá el mismo nombre de la página, pero con la extensión del lenguaje que hayas elegido, por ejemplo, si has usado Visual Basic, ese fichero se llamará MostrarUsuarios.aspx.vb
• 3.d- Seguramente en la página .aspx habrá un bloque para escribir el código:
• 3.e- Puedes borrarlo sin problemas.
• 4- Ahora vamos a mostrar todos los datos que tenemos de los usuarios
• 4.a- Como seguramente te imaginarás, la forma de hacerlo es como te mostré en el punto 24 de la parte anterior. Te lo explico de nuevo para que no te líes... ;-)))
• 4.b- Muestra la página MostrarUsuarios.aspx en modo de diseño.
• 4.c- Del Explorador de bases de datos selecciona la conexión vwdTut01.mdf y expándela
• 4.d- De las Tablas, selecciona la de Usuarios y arrástrala hasta la página (el formulario Web)
• 4.e- Esto hará que se creen dos controles: un GridView y un SqlDataSource
• 4.f- Déjalos tal como están, ahora los personalizaremos.
• 5- Haz que se muestre la página Default.aspx y que esté en modo de diseño (si no está en modo diseño, ya sabes, pulsa en la ficha Diseño)
• 5.a- Es posible que para que se muestren los ficheros de nuestro sitio Web tengas que pulsar en la ficha Explorador de soluciones, ya que en el Visual Web Developer 2005 Express, la ficha del Explorador de bases de datos suele estar en el mismo grupo de ventanas que el explorador de soluciones.
• 6- Arrastra un control HyperLink a la página (se pondrá debajo del que ya había)
• 6.a- Selecciona ese control, y en la ventana de propiedades, asigna la cadena Mostrar todos los usuarios a la propiedad Text
• 6.b- En la propiedad NavigateUrl tendrás que pulsar en el botoncito ese de los puntos suspensivos para que te muestre las páginas disponibles y así poder elegir a la que quieres que vaya cuando se pulse en ese link, en este caso, la página MostrarUsuaurios.aspx
• 7- Prueba que todo está bien, pulsa F5 para iniciar la aplicación
• 7.a- Si seguiste mis indicaciones del punto 35 de la primera parte, se mostrará la página Default.aspx, si no se muestra esa página y se muestra otra, ya sabes lo que tienes que hacer para que la página Default.aspx sea la página de inicio.
• 7.b- Recuerda que si no indicas la página que se usará como inicio, al pulsar F5, la página que se mostrará será la que en ese momento esté seleccionada... y de casualidad, puede que sea Default.aspx, pero... para que siempre se inicie en esa página, sigue los pasos esos que te indiqué antes.
• 8- Pulsa en el link de Mostrar todos los usuarios para ver todos los datos que tienes en la tabla de Usuarios.
• 8.a- Verás que se muestra todo, incluso el código SHA1 de las claves.
• 9- Como esa información no tiene ninguna utilidad, mejor la quitamos.
• 9.a- Para quitar la columna Clave lo podemos hacer de varias formas.
• 9.b- Cierra la ventana del explorer y haz que se muestre la página MostrarUsuarios.aspx en modo de diseño.
• 10- Quitar columnas del GridView, método 1: Modificando el origen de datos.
• 10.a- Selecciona el control GridView y pulsa en la flecha que tiene en la parte superior derecha para que se muestre la ventana de Tareas de GridView.
• 10.b- De las opciones que te da, puedes elegir Configurar origen de datos... lo que hará que te muestre el asistente del origen de datos.
• 10.c- En la primera ventana, pulsa en Siguiente (se supone que en la lista desplegable de las conexiones estará seleccionada la que estamos usando: vwdTur01ConnectionString1).
• 10.d- En la siguiente ventana te mostrará las columnas que estás usando, quita la marca de la columna Clave (verás que el texto de la cadena usada para seleccionar los datos ya no muestra el campo Clave) y pulsa en Siguiente.
• 10.e- En la siguiente pantalla pulsa en Finalizar.
• 10.f- Te mostrará un mensaje de advertencia diciéndote que si quieres eliminar los campos del GridView bla, bla, bla. Dile que NO (es decir, pulsa en el botón No).
• 10.g- Si pulsas en el botón Si, parecerá que todo está bien, pero al mostrar la ventana, (ejecutando la aplicación y mostrando todos los datos), verás que no se ve nada.
• 10.h- Esto es porque se eliminan las columnas del control GridView, aunque el DataSource se configura de forma adecuada para que no incluya ese campo.
• 10.i- Si lo que quieres es añadir una columna que antes has eliminado tendrás que decirle que sí en vez de que no.
• 10.j- Pero claro, si le dices que sí, se eliminan las columnas, así que... ¡no verás los datos!
• 10.k- Si te ocurre eso de que no se ven lo datos, lo mejor es eliminar el GridView y el SqlDataSource y volver a crearlo.
• 11- Quitar columnas del GridView, método 2: Editando las columnas
• 11.a- Selecciona el GridView y pulsa en la flecha de arriba...
• 11.b- Pulsa en la opción Editar columnas...
• 11.c- Te mostrará un cuadro de diálogo con las columnas de la tabla.
• 11.d- En la parte de abajo a la izquierda, selecciona la columna Clave y pulsa en el botón con la X roja para borrarla.
• 11.e- NO marques la casilla esa que dice Generar campos automáticamente, ya que te mostrará dos veces las columnas, además de que se incluirán todos los campos de la tabla
• 11.f- Pulsa en Aceptar para cerrar el cuadro de diálogo.
• 11.g- Si pruebas, (F5 y esas cosas, ya sabes), verás que se muestran los datos sin la clave, que es lo que queríamos.
• 11.h- Si te fijas en el código de la página, verás que en el DataSource sigue estando el campo Clave, incluso en el comando Select, pero como no está "boundado" (¿existe ese palabra? lo que quiere decir, es que no está vinculada automáticamente ninguna columna del grid a ese campo) en las columnas del GridView, pues no se verá.
• 12- Quitar columnas del GridView, método 3: Editando el código HTML generado (sin asistentes, así a lo bravo)
• 12.a- Para modificar manualmente lo que se va a mostrar en el GridView, debes mostrar el código HTML de la página MostrarUsuarios.aspx
• 12.b- Si estás en modo de diseño, pulsa en la ficha Código y ve a la parte en la que está la etiqueta
• 12.c- Selecciona la fila en la que está la definición de la columna que quieres quitar, es decir, la que empieza con:
• 13.d- OJO al borrar el DeleteCommand (el último antes de los parámetros), ya que suele tener el carácter > de cierre, y si lo borras, te dará error y puede que no te fijes en que es lo que ocurre.
• 14- Ahora vas a usar el asistente de origen de datos para que solo se quede el comando Select.
• 14.a- Si has estado haciendo lo que te comenté en el paso anterior, puedes borrar el GridView y el SqlDataSource y agrega nuevamente la tabla de Usuarios para que esté todo como en un principio.
• 14.b- Bien, si ya tienes otra vez todo como estaba originalmente (se mostrará la columna Clave), haz que se muestre la página en modo de diseño y pulsa en la flechita de arriba del control GridView.
• 14.c- Pulsa en la opción Configurar origen de datos...
• 14.d- En la primera pantalla del asistente, pulsa en Siguiente.
• 14.e- Quita la marca de la casilla que hay junto a Clave y pulsa en el botón Avanzadas... (el que está a la derecha del panel con los campos).
• 14.f- Del cuadro de diálogo que te muestra, quita la marca de la opción Generar instrucciones Insert, Update y Delete y pulsa en Aceptar.
• 14.g- Pulsa en Siguiente y después en Finalizar, si te muestra el aviso ese que te comenté en el punto 10, dile que NO.
• 14.h- Si muestras el código de la página verás que solo está el comando Select, pero que en los campos enlazados está la clave, así que... borra esa línea (ver el punto 12).
• 14.i- Pulsa la tecla F5 para comprobar que todo está bien y no se muestra el campo Clave.
Mejorar el aspecto del GridView
• 15- Ahora vamos a juguetear un poco con el control GridView para cambiar el aspecto del mismo, permitir la paginación y esas monadas...
• 16- Empezaremos por el aspecto del GridView propiamente dicho, es decir, la forma en que se verán los datos.
• 16.a- Muestra el diseño de la página que tiene el grid, pulsa en el botoncito ese de arriba (para ver las Tareas de GridView)
• 16.b- Pulsa en la primera opción: Formato automático...
• 16.c- Te mostrará un cuadro de diálogo con los diferentes formatos que puedes usar, elige uno, por ejemplo: Clásica.
• 16.d- Verás que el aspecto del grid ha cambiado, y que se ha añadido el código necesario para que se vea de esa forma, pero esto último es lo de menos.
• 17- Ahora vamos a permitir la paginación, para que de esta forma, se muestre cada vez un número determinado de usuarios, ya que si no se pagina, se mostrarán todos los datos de una vez...
• 17.a- Muestra las Tareas de GridView y marca la casilla Habilitar paginación, de esta forma se mostrarán los datos de 10 en 10.
• 17.b- Si quieres que en vez de 10 datos se muestre otra cantidad, puedes cambiar el valor de la propiedad PageSize por el número de datos que quieras mostrar en cada página.
• 17.c- Esa propiedad está accesible en modo de diseño, además de poder asignarlo desde el código.
• 18- Si quieres que se puedan mostrar los datos ordenados por cualquiera de los campos, selecciona la opción Habilitar ordenacion (de las Tareas de GridView)
• 18.a- En el caso de las fechas, las ordenará como cadenas (o eso me parece, pero creo que ni como cadenas... en fin...), así que no te asustes si ves que no están "correctamente" ordenadas.
• 19- Si marcas la casilla Habilitar selección, decirte que... bueno... solo sirve para seleccionar una fila, pero nada más.
martes, 23 de marzo de 2010
Primera Parte Ejercicios ASPX.NET
** COMO OBTENER USUARIOS DE WINDOWS
Dim Usuario as String
Usuario = Request.ServerVariables("REMOTE_USER")
Luego retornará Usuario con todo y dominio, es decir
DOMINIO\usuario
Para exrtraer solo el usuario, puedes hacer un split
Usuario = Split(Request.ServerVariables("REMOTE_USER"), "\")(1)
*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*
Acceso a datos desde un sitio Web creado con
Dim Usuario as String
Usuario = Request.ServerVariables("REMOTE_USER")
Luego retornará Usuario con todo y dominio, es decir
DOMINIO\usuario
Para exrtraer solo el usuario, puedes hacer un split
Usuario = Split(Request.ServerVariables("REMOTE_USER"), "\")(1)
*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*
Acceso a datos desde un sitio Web creado con
Visual Web Developer 2005 Express y SQL Server 2005 Express
EJERCICIOS ASPX.NET
*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*
Parte 1:
Crear el sitio y crear nuevos usuarios, comprobando si ya existen para no repetirlos
•0- Abre el Visual Studio 2005 (o el Visual Web Developer 2005 Express)
•1- Crea un nuevo proyecto ASP.NET (vwdTut01)
•1.a- Elege el lenguaje a usar para el código de forma predeterminada
•2- Añade un nuevo elemento
•2.a- Elige Base de datos de SQL Server y dale el nombre vwdTut01.mdf
•2.b- Nos avisa de que la base de datos debe estar en la carpeta App_Data, acepta
•3- Crea una tabla (debes mostrar la ficha Explorador de bases de datos)
•3.a- Usa estos campos:
◦3.b- ID, int, Identidad
◦3.c- Correo, nvarchar(64)
◦3.d- Clave, nvarchar(40)
◦3.e- Nombre, nvarchar(50)
◦3.f- Fecha, datetime
◦3.g- Comentarios, nvarchar(300)
•3.h- Dale a guardar y ponle el nombre Usuarios
•4- Ahora te explico cómo crear el formulario de introducción de datos.
•4.a- En el menú Sitio Web selecciona Agregar nuevo elemento
•4.b- Selecciona WebForms y dale el nombre AgregarUsuario.aspx
•4.c- El lenguaje será el indicado al principio, pero lo puedes cambiar
•4.d- Marca la casilla Colocar el código en un archivo independiente para que se separe el diseño del formulario del código que vamos a escribir.
•5- Ahora vamos a añadir una tabla, para que queden alineado los textos y las cajas de textos
•5.a- En el menú Diseño seleccionar Insertar tabla
•5.b- En el cuadro de diálogo de insertar tabla, selecciona:
3 filas y 2 columnas, ancho 90%, Alinear: center, Atributos: borde: 1, Espaciado celdas: 4
•6- En la tabla recién creada, añade una etiqueta en la primera columna, un textBox
en la segunda columna
•7- Queremos que estén alineadas a la izquierda y arriba
•7.a- Selecciona la celda (pulsando en la flecha que sale al pasar el ratón)
•7.b- En la ventana de propiedades, en align selecciona left y en VAlign selecciona top
•8- Selecciona esa fila y pulsa en Copiar de la barra de herramientas
•8.a- Ahora, al pulsar en el botón Pegar y se añadirá una nueva fila con los controles
•8.b- Selecciona la siguiente fila (la vacía) y pulsa en pegar
•8.c- Repite los pasos anteriores hasta que tengas 4 filas con los controles
•9- Añade un botón en la siguiente fila
•9.a- Selecciona la fila del botón
•9.b- En el menú Diseño selecciona Combinar celda
•9.c- De esa forma, esa columna ocupará toda la fila
•10- En la última fila, añade una etiqueta
•10.a- Selecciona esa última fila para que ocupe las dos columnas, ya sabes:
•10.b- En el menú Diseño, selecciona Combinar celda
•11- Selecciona esa etiqueta y en la ventana de propiedades busca la propiedad Width
y escribe 100% para que ocupe todo el ancho.
•12- Cambia el texto de las 4 primeras etiquetas para que muestre: Correo, Clave,
Nombre y Comentarios
•13- Como puede ser que no interese que se vea la clave escrita, selecciona la
segunda caja de textos
•13.a- En la ventana de propiedades, en la propiedad TextMode selecciona Password
•14- Selecciona la última caja de textos, te digo lo que hay que hacer para que
tenga más espacio para escribir
•14.a- En la ventana de propiedades, en la propiedad TextMode selecciona Multiline
•14.b- En la propiedad Rows escribe 4 y en Columns escribe 60
•15- Selecciona el botón y en el texto escribe Nuevo usuario
•16- Lo correcto es que los controles tengan nombres que indiquen para que son
•16.a- Siguiendo el orden de arriba abajo, a las cajas de texto dale estos nombres:
◦16.b- txtCorreo, txtClave, txtNombre y txtComentarios
•17- Al botón dale el nombre btnNuevo
•18- A la etiqueta del final, dale el nombre lblAviso, el resto déjalas con el
nombre que tienen ya que no las usaremos desde el código y da igual el nombre,
pero si quieres, le puedes dar el nombre que te apetezca, aunque ya puestos,
podría ser como el de la caja de textos que tienen al lado, pero en lugar de
txt puedes usar lbl.
•19- Ahora vamos a darle funcionalidad al botón, de forma que al pulsar en él se
cree un nuevo usuario con los datos que tenemos
•19.a- Como queremos que las cosas se hagan bien, después añadiremos validadores
para que se escriba lo que haya que escribir
•19.b- Haz dobleclic en el botón para que se muestre la ventana de código
•19.c- El código se habrá mostrado en un fichero aparte con el mismo nombre que la página y con la extensión del lenguaje que has elegido, en mi caso es: AgregarUsuario.aspx.vb
•19.d- Antes de hacer nada te explico que es lo que habría que hacer para añadir correctamente los datos.
•20- No debemos admitir ninguna de las cajas en blanco, salvo la de comentarios (ahora veremos como)
•21- La fecha la podremos nosotros de forma automática, para que tenga la fecha actual
•21.a- Para que se muestre la fecha, deberíamos agregar una nueva fila, por ejemplo, entre el nombre y los comentarios
•21.b- Selecciona la fila del nombre y pulsa en copiar
•21.c- Selecciona la fila de los comentarios y pulsa en pegar, se insertara una nueva fila
•21.d- Cambia el texto de la etiqueta a Fecha y el nombre de la caja de textos a txtFecha
•21.e- Como la fecha es de solo lectura, selecciona la caja de textos y en las propiedades, asigna el valor True a la propiedad ReadOnly
•21.f- Para que se vea de otro color, en las propiedades, selecciona BackColor y en el cuadro de propiedades que te muestra, selecciona la ficha Web y el color WhiteSmoke
•22- Otra cosa a hacer es que si ese correo ya existe, que diga que no es válido
•23- Pero antes de hacer nada, necesitamos crear la conexión a la base de datos
•24- Con el Visual Web Developer Express y el SQL Express la forma mas fácil de
crear una conexión a la base que hemos creado es haciendo lo siguiente: (a lo
mejor hay otra forma mejor, pero... esto me funciona siempre)
•24.a- Muestra la página de agregar usuario en modo diseño
•24.b- En el explorador de bases de datos, arrastra la tabla de Usuarios a la página
•24.c- Esto creará un GridView y un control DataSource, el GridView lo vamos a borrar
•24.d- Selecciona solo el GridView y pulsa la tecla suprimir, pulsa antes en cualquier parte de la página y después selecciona el grid
•24.e- Ahora tendrás un control llamado SqlDataSource1 que tendrá todos los comandos para insertar, eliminar, actualizar, etc.
•24.f- También se habrá creado el fichero web.config con los datos de conexión a la base de datos
•25- Vamos a añadir controles de validación para que el usuario tenga que escribir algo en ellos
•25.a- Muestra la página en modo de diseño y del Cuadro de herramientas, selecciona el grupo Validación
•25.b- Arrastra un control RequiredFieldValidator y déjalo al lado del textBox del correo
•25.c- Seguramente se pondrá debajo de la caja de textos, posiciónate justo delante del control de validación y borra (con la tecla backspace) el espacio que habrá, para que quede pegado al textBox, después puedes pulsar un espacio para que haya algo de separación
•25.d- Añade otro al lado de la caja de textos de la clave y otro al lado del textBox del nombre
•25.e- Para la fecha y los comentarios no hace falta añadir ninguno
•26- Como queremos que la cuenta de correos sea valida, vamos a añadir un control de
validación de expresiones regulares junto al textBox del correo (detrás del
validador que ya había)
•26.a- En la ventana de propiedades, selecciona la propiedad ValidationExpression y pulsa en el botón
•26.b- Del cuadro de dialogo selecciona Dirección de correo electrónico de Internet y pulsa en aceptar
•27- Ahora vamos a enlazar esos controles de validación con las cajas de texto
correspondientes
•27.a- Selecciona el primer RequiredFieldValidator (Correo) y busca la propiedad
ControlToValidate y de la lista desplegable que te mostrará, selecciona
txtCorreo
•27.b- Haz lo mismo con el control RegularExpressionValidator (el de la expresiones regulares)
•27.c- Ahora el de la clave y después el del nombre, seleccionando los controles correspondientes en la propiedad ControlToValidate
•27.d- Puedes cambiar el mensaje de aviso de cada uno de los controles de validación, con idea de que si, por ejemplo, no se escribe nada en la clave diga que debe escribir algo... La propiedad que debes asignar es ErrorMessage.
•28- Si queremos que la clave tenga un mínimo de caracteres, podemos agregar un
control CustomValidator, indica que control se debe validar, escribe el texto
del mensaje de error, por ejemplo: Debes escribir más de 5 caracteres
•28.a- Haz dobleclic en el control de validación y en el evento que se crea en el fichero de código, escribe lo siguiente: (args es el nombre del segundo parámetro) args.IsValid = (args.Value.Length > 5)
•28.b - Esto hará que se compruebe que no este vacío y que tenga más de 5 caracteres
•29- Si en lugar de hacer la validación en el servidor, quieres hacerla en el lado del cliente, tendrás que crear un código Script en la pagina con este código:
•29.a- Selecciona el control y en la propiedad ClientValidationFunction escribe el nombre de la función, en este caso comprobarClave.
•30- Como los controles de validación se empeñan en ponerse como les da la gana, si quieres, puedes poner todos esos controles de validación en la parte inferior de la tabla, aunque en el caso de que, por ejemplo, el usuario pulse en el botón sin haber escrito nada, le mostrará todos los mensajes de error, por tanto, esos mensajes deberían decir lo que queremos que haga el usuario, es decir, no lo dejes con el texto predeterminado.
•31- Antes de seguir, decirte que si la caja de textos está en modo Password, y cuando se compruebe por código si el usuario existe, etc., y se cancele la creación del usuario, lo que se escriba se borrará, así que si quieres que se siga manteniendo la contraseña, debes dejarla como texto normal. En cualquier caso, mejor dejarlo como Password y si el usuario se equivoca, pues... que hubiese prestado más atención
•32- Ahora vamos a escribir el código de validación de que el usuario no exista ya y en caso de que exista, que se cancele la inserción de datos, y si no existe, que se añada a la base de datos.
•32.a- Muestra el código del evento del botón (el que creaste en el punto 19)
•32.b- Al principio del fichero añade las importaciones de los espacios de nombres que vamos a usar, en particular el System.Data.SqlClient
•32.c- Lo primero es comprobar si el usuario ya existe, por tanto vamos a ejecutar la siguiente sentencia (cadena de selección):
SELECT Count(*) FROM Usuarios WHERE Correo = @Correo
EJERCICIOS ASPX.NET
*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*
Parte 1:
Crear el sitio y crear nuevos usuarios, comprobando si ya existen para no repetirlos
•0- Abre el Visual Studio 2005 (o el Visual Web Developer 2005 Express)
•1- Crea un nuevo proyecto ASP.NET (vwdTut01)
•1.a- Elege el lenguaje a usar para el código de forma predeterminada
•2- Añade un nuevo elemento
•2.a- Elige Base de datos de SQL Server y dale el nombre vwdTut01.mdf
•2.b- Nos avisa de que la base de datos debe estar en la carpeta App_Data, acepta
•3- Crea una tabla (debes mostrar la ficha Explorador de bases de datos)
•3.a- Usa estos campos:
◦3.b- ID, int, Identidad
◦3.c- Correo, nvarchar(64)
◦3.d- Clave, nvarchar(40)
◦3.e- Nombre, nvarchar(50)
◦3.f- Fecha, datetime
◦3.g- Comentarios, nvarchar(300)
•3.h- Dale a guardar y ponle el nombre Usuarios
•4- Ahora te explico cómo crear el formulario de introducción de datos.
•4.a- En el menú Sitio Web selecciona Agregar nuevo elemento
•4.b- Selecciona WebForms y dale el nombre AgregarUsuario.aspx
•4.c- El lenguaje será el indicado al principio, pero lo puedes cambiar
•4.d- Marca la casilla Colocar el código en un archivo independiente para que se separe el diseño del formulario del código que vamos a escribir.
•5- Ahora vamos a añadir una tabla, para que queden alineado los textos y las cajas de textos
•5.a- En el menú Diseño seleccionar Insertar tabla
•5.b- En el cuadro de diálogo de insertar tabla, selecciona:
3 filas y 2 columnas, ancho 90%, Alinear: center, Atributos: borde: 1, Espaciado celdas: 4
•6- En la tabla recién creada, añade una etiqueta en la primera columna, un textBox
en la segunda columna
•7- Queremos que estén alineadas a la izquierda y arriba
•7.a- Selecciona la celda (pulsando en la flecha que sale al pasar el ratón)
•7.b- En la ventana de propiedades, en align selecciona left y en VAlign selecciona top
•8- Selecciona esa fila y pulsa en Copiar de la barra de herramientas
•8.a- Ahora, al pulsar en el botón Pegar y se añadirá una nueva fila con los controles
•8.b- Selecciona la siguiente fila (la vacía) y pulsa en pegar
•8.c- Repite los pasos anteriores hasta que tengas 4 filas con los controles
•9- Añade un botón en la siguiente fila
•9.a- Selecciona la fila del botón
•9.b- En el menú Diseño selecciona Combinar celda
•9.c- De esa forma, esa columna ocupará toda la fila
•10- En la última fila, añade una etiqueta
•10.a- Selecciona esa última fila para que ocupe las dos columnas, ya sabes:
•10.b- En el menú Diseño, selecciona Combinar celda
•11- Selecciona esa etiqueta y en la ventana de propiedades busca la propiedad Width
y escribe 100% para que ocupe todo el ancho.
•12- Cambia el texto de las 4 primeras etiquetas para que muestre: Correo, Clave,
Nombre y Comentarios
•13- Como puede ser que no interese que se vea la clave escrita, selecciona la
segunda caja de textos
•13.a- En la ventana de propiedades, en la propiedad TextMode selecciona Password
•14- Selecciona la última caja de textos, te digo lo que hay que hacer para que
tenga más espacio para escribir
•14.a- En la ventana de propiedades, en la propiedad TextMode selecciona Multiline
•14.b- En la propiedad Rows escribe 4 y en Columns escribe 60
•15- Selecciona el botón y en el texto escribe Nuevo usuario
•16- Lo correcto es que los controles tengan nombres que indiquen para que son
•16.a- Siguiendo el orden de arriba abajo, a las cajas de texto dale estos nombres:
◦16.b- txtCorreo, txtClave, txtNombre y txtComentarios
•17- Al botón dale el nombre btnNuevo
•18- A la etiqueta del final, dale el nombre lblAviso, el resto déjalas con el
nombre que tienen ya que no las usaremos desde el código y da igual el nombre,
pero si quieres, le puedes dar el nombre que te apetezca, aunque ya puestos,
podría ser como el de la caja de textos que tienen al lado, pero en lugar de
txt puedes usar lbl.
•19- Ahora vamos a darle funcionalidad al botón, de forma que al pulsar en él se
cree un nuevo usuario con los datos que tenemos
•19.a- Como queremos que las cosas se hagan bien, después añadiremos validadores
para que se escriba lo que haya que escribir
•19.b- Haz dobleclic en el botón para que se muestre la ventana de código
•19.c- El código se habrá mostrado en un fichero aparte con el mismo nombre que la página y con la extensión del lenguaje que has elegido, en mi caso es: AgregarUsuario.aspx.vb
•19.d- Antes de hacer nada te explico que es lo que habría que hacer para añadir correctamente los datos.
•20- No debemos admitir ninguna de las cajas en blanco, salvo la de comentarios (ahora veremos como)
•21- La fecha la podremos nosotros de forma automática, para que tenga la fecha actual
•21.a- Para que se muestre la fecha, deberíamos agregar una nueva fila, por ejemplo, entre el nombre y los comentarios
•21.b- Selecciona la fila del nombre y pulsa en copiar
•21.c- Selecciona la fila de los comentarios y pulsa en pegar, se insertara una nueva fila
•21.d- Cambia el texto de la etiqueta a Fecha y el nombre de la caja de textos a txtFecha
•21.e- Como la fecha es de solo lectura, selecciona la caja de textos y en las propiedades, asigna el valor True a la propiedad ReadOnly
•21.f- Para que se vea de otro color, en las propiedades, selecciona BackColor y en el cuadro de propiedades que te muestra, selecciona la ficha Web y el color WhiteSmoke
•22- Otra cosa a hacer es que si ese correo ya existe, que diga que no es válido
•23- Pero antes de hacer nada, necesitamos crear la conexión a la base de datos
•24- Con el Visual Web Developer Express y el SQL Express la forma mas fácil de
crear una conexión a la base que hemos creado es haciendo lo siguiente: (a lo
mejor hay otra forma mejor, pero... esto me funciona siempre)
•24.a- Muestra la página de agregar usuario en modo diseño
•24.b- En el explorador de bases de datos, arrastra la tabla de Usuarios a la página
•24.c- Esto creará un GridView y un control DataSource, el GridView lo vamos a borrar
•24.d- Selecciona solo el GridView y pulsa la tecla suprimir, pulsa antes en cualquier parte de la página y después selecciona el grid
•24.e- Ahora tendrás un control llamado SqlDataSource1 que tendrá todos los comandos para insertar, eliminar, actualizar, etc.
•24.f- También se habrá creado el fichero web.config con los datos de conexión a la base de datos
•25- Vamos a añadir controles de validación para que el usuario tenga que escribir algo en ellos
•25.a- Muestra la página en modo de diseño y del Cuadro de herramientas, selecciona el grupo Validación
•25.b- Arrastra un control RequiredFieldValidator y déjalo al lado del textBox del correo
•25.c- Seguramente se pondrá debajo de la caja de textos, posiciónate justo delante del control de validación y borra (con la tecla backspace) el espacio que habrá, para que quede pegado al textBox, después puedes pulsar un espacio para que haya algo de separación
•25.d- Añade otro al lado de la caja de textos de la clave y otro al lado del textBox del nombre
•25.e- Para la fecha y los comentarios no hace falta añadir ninguno
•26- Como queremos que la cuenta de correos sea valida, vamos a añadir un control de
validación de expresiones regulares junto al textBox del correo (detrás del
validador que ya había)
•26.a- En la ventana de propiedades, selecciona la propiedad ValidationExpression y pulsa en el botón
•26.b- Del cuadro de dialogo selecciona Dirección de correo electrónico de Internet y pulsa en aceptar
•27- Ahora vamos a enlazar esos controles de validación con las cajas de texto
correspondientes
•27.a- Selecciona el primer RequiredFieldValidator (Correo) y busca la propiedad
ControlToValidate y de la lista desplegable que te mostrará, selecciona
txtCorreo
•27.b- Haz lo mismo con el control RegularExpressionValidator (el de la expresiones regulares)
•27.c- Ahora el de la clave y después el del nombre, seleccionando los controles correspondientes en la propiedad ControlToValidate
•27.d- Puedes cambiar el mensaje de aviso de cada uno de los controles de validación, con idea de que si, por ejemplo, no se escribe nada en la clave diga que debe escribir algo... La propiedad que debes asignar es ErrorMessage.
•28- Si queremos que la clave tenga un mínimo de caracteres, podemos agregar un
control CustomValidator, indica que control se debe validar, escribe el texto
del mensaje de error, por ejemplo: Debes escribir más de 5 caracteres
•28.a- Haz dobleclic en el control de validación y en el evento que se crea en el fichero de código, escribe lo siguiente: (args es el nombre del segundo parámetro) args.IsValid = (args.Value.Length > 5)
•28.b - Esto hará que se compruebe que no este vacío y que tenga más de 5 caracteres
•29- Si en lugar de hacer la validación en el servidor, quieres hacerla en el lado del cliente, tendrás que crear un código Script en la pagina con este código:
•29.a- Selecciona el control y en la propiedad ClientValidationFunction escribe el nombre de la función, en este caso comprobarClave.
•30- Como los controles de validación se empeñan en ponerse como les da la gana, si quieres, puedes poner todos esos controles de validación en la parte inferior de la tabla, aunque en el caso de que, por ejemplo, el usuario pulse en el botón sin haber escrito nada, le mostrará todos los mensajes de error, por tanto, esos mensajes deberían decir lo que queremos que haga el usuario, es decir, no lo dejes con el texto predeterminado.
•31- Antes de seguir, decirte que si la caja de textos está en modo Password, y cuando se compruebe por código si el usuario existe, etc., y se cancele la creación del usuario, lo que se escriba se borrará, así que si quieres que se siga manteniendo la contraseña, debes dejarla como texto normal. En cualquier caso, mejor dejarlo como Password y si el usuario se equivoca, pues... que hubiese prestado más atención
•32- Ahora vamos a escribir el código de validación de que el usuario no exista ya y en caso de que exista, que se cancele la inserción de datos, y si no existe, que se añada a la base de datos.
•32.a- Muestra el código del evento del botón (el que creaste en el punto 19)
•32.b- Al principio del fichero añade las importaciones de los espacios de nombres que vamos a usar, en particular el System.Data.SqlClient
•32.c- Lo primero es comprobar si el usuario ya existe, por tanto vamos a ejecutar la siguiente sentencia (cadena de selección):
SELECT Count(*) FROM Usuarios WHERE Correo = @Correo
•32.d- Esto hará que se compruebe en la tabla de Usuarios si el correo escrito ya está, el truco es que si esas instrucciones devuelven algún valor que no sea cero, es que ya hay una cuenta de correo como la que buscamos.
•32.e- Para ejecutar esa sentencia de SQL vamos a usar un objeto SqlConnection y un objeto SqlCommand
•32.f- Para el objeto Connection necesitas la cadena de conexión, y como ya tenemos en el formulario (pagina Web) un objeto SqlDataSource, pues la tomamos de ahí.
•32.g- Este es el código para comprobar si el usuario ya existe, verás que uso una instrucción Using para controlar la conexión, de esa forma, si nos salimos nos aseguramos de que el objeto se destruye y se cierra la conexión, ya que esa instrucción se encarga de liberar todos los recursos que estuviera usando al llegar al final del bloque, en Visual Basic, será al llegar a End Using.
' Comprobamos si el nombre ya existe
Using cnn As New SqlConnection(Me.SqlDataSource1.ConnectionString)
Dim cmd As New SqlCommand( _
"SELECT Count(*) " & _
"FROM Usuarios " & _
"WHERE Correo = @Correo", cnn)
' Abrimos la conexión
cnn.Open()
' Añadimos el valor del parámetro de la consulta
cmd.Parameters.AddWithValue("@Correo", txtCorreo.Text)
' Si devuelve algún valor, es que ya existe
Dim i As Integer
i = CInt(cmd.ExecuteScalar())
If i > 0 Then
' Avisamos y salimos
Me.lblAviso.Text = "El usuario ya existe"
Exit Sub
End If
' Al salir del bloque Using se cierra la conexión
End Using
•32.h- El parámetro @Correo lo asignamos usando el método AddWithValue que es la forma más cómoda de crear los parámetros al tiempo que se le asigna el valor que tendrá.
•32.i- Al llamar al método ExecuteScalar del comando, le estamos diciendo que devuelva la primera columna de la primera fila, y como resulta que lo que queremos es el número de veces que esté en la tabla Usuarios esa cuenta de correo, pues si ya está una vez, devolverá un 1, si no está devolverá un cero. El valor que devuelve esa función es de tipo Object, ya que en realidad el tipo devuelto depende de lo que pongamos después de SELECT, en este caso es un valor entero, que es lo que devuelve la función Count(*).
•32.j- Si lo que devuelve es mayor de cero, es que hay algún correo como el que se ha escrito, por tanto mostramos el mensaje de error y salimos del método.
•33- Si se continúa, es decir, se llega después del End Using, es que no existe esa cuenta de correo, por tanto debemos agregar los datos.
•33.a- Ahora debemos hacer casi lo mismo de antes, pero ejecutando el comando Insert, el cual también lo tomaremos del objeto SqlDataSource1.
•33.b- Aunque antes de guardar nada en la base de datos debemos asignar los valores de los parámetros, que si te fijas en el código de la página, esos parámetros se llaman igual que los campos, pero empezando con la arroba (@).
•33.c- Otra cosa que debemos hacer es convertir el password (la clave) en un valor SHA1. Esto es para no guardar la clave como un texto en la base de datos, de esa forma, el que vea los datos que hay no sabrá cual es la clave de cada usuario. Ese valor SHA1 lo podemos crear usando un objeto de tipo SHA1CryptoServiceProvider o bien usar la función HashPasswordForStoringInConfigFile de la clase FormsAuthentication, que es lo que normalmente haremos en una pagina Web, ya que así nos evitamos tener que crear nuestro propio código. De todas formas, en el código completo, he añadido la función para crear ese valor SHA1, por si quieres ver como hacerlo, por ejemplo para una aplicación de Windows.
•33.d- Una vez que tenemos todo esto, lo juntamos y lo mezclamos bien... mejor es que veas el código para que lo tengas más claro:
' El usuario no existe, lo añadimos
Using cnn As New SqlConnection(Me.SqlDataSource1.ConnectionString)
' Usamos el comando Insert del DataSource
Dim cmd As New SqlCommand(Me.SqlDataSource1.InsertCommand, cnn)
' Abrimos la conexión
cnn.Open()
' Añadimos el valor del parámetro de la consulta
cmd.Parameters.AddWithValue("@Correo", txtCorreo.Text)
' La clave la guardaremos como un valor SHA1
Dim clave As String
clave = FormsAuthentication.HashPasswordForStoringInConfigFile(txtClave.Text, "SHA1")
'clave = generarClaveSHA1(txtClave.Text)
cmd.Parameters.AddWithValue("@Clave", clave)
' La fecha a guardar es la actual
txtFecha.Text = DateTime.Now.ToString()
cmd.Parameters.AddWithValue("@Fecha", txtFecha.Text)
cmd.Parameters.AddWithValue("@Nombre", txtNombre.Text)
cmd.Parameters.AddWithValue("@Comentarios", txtComentarios.Text)
' Ejecutamos el comando de inserción
cmd.ExecuteNonQuery()
' Al salir del bloque Using se cierra la conexión
End Using
Me.lblAviso.Text = "Se ha añadido el nuevo usuario correctamente"
•34- Ya lo único que nos queda es poner en la pagina principal (Default.aspx) un link para que podamos entrar a la página de crear nuevos usuarios. En esa misma página crearemos links para otras funcionalidades, por ejemplo, modificar un dato o ver los datos que tenemos, etc.
•34.a- Muestra la página Default.aspx en modo diseño y del Cuadro de herramientas añade un control HyperLink, en la propiedad Text escribe Añadir usuario y en la propiedad NavigateUrl pulsa en el botón con los puntos suspensivos para que puedas seleccionar la página a la que quieres que navegue cuando se pulse en el link, en este caso la página que debes seleccionar del cuadro de diálogo que te muestra es AgregarUsuario.aspx
•35- Vamos a probar que todo funciona, pero antes, en el explorador de soluciones, selecciona la página Default.aspx y pulsando con el botón derecho, selecciona del menú contextual la opción Establecer como página de inicio, de esta forma, cada vez que pulses F5 se iniciara con esa página, si no haces esto que te acabo de comentar, cuando pulses F5 se iniciara por la página que en ese momento esté seleccionada.
•36- Una vez que esté en ejecución, prueba a no escribir nada en las cajas de texto y pulsa en el botón, verás que salen los mensajes de aviso. Sigue haciendo pruebas de validación, por ejemplo no escribas bien el correo, escribe menos de 6 caracteres en la clave, etc.
•37- Una vez que hayas probado que las validaciones funcionan, introduce un usuario (o varios) y después intenta introducir uno que ya exista, para que veas que se muestra el mensaje de error y esas cosas.
SQL Server 2008: DATE, TIME, DATETIME2, DATETIMEOFFSET
Con la llegada de SQL Server 2008, algunos de los nuevos tipos de datos que ya son (o serán) novedades tenemos a los siguientes: HIERARCHY ID (para almacenar valores de nodos en un jerarquía), FILESTREAM (para almacenar data de tipo grande, documentos, imágenes), tipos para almacenar datos espaciales como GEOGRAPHY, GEOMETRY, así como los tipos de datos TIME (3 a 5 bytes de tamaño) y DATE (3bytes), DATETIME2 (6 a 8 bytes), DATETIMEOFFSET (8 a 10 bytes), entre otros más.
En este post vamos a hablar acerca de los tipos de datos para manejar fechas y tiempo, es decir, los 4 últimos arriba mencionados. Los otros tipos de datos serán motivos de otro post!.
DATETIME es un tipo de dato compuesto que almacena fecha y tiempo. La novedad es que en SQL Server 2008, el tipo de dato DATETIME se ha separado en dos: DATE y TIME, con esto no quiero decir que DATETIME se haya eliminado, este sigue siendo necesario para otros escenarios, pocos pero en fin. Esta noticia es muy buena ya que por ejemplo, siempre, casi siempre... sólo necesitabamos almacenar la fecha, más no el tiempo, y el único tipo de dato que podiamos usar era DATETIME, el cual "amablemente" guardaba algo más: el tiempo, aunque no lo necesitemos, pues no habia solución. DATETIME aparte de ser un tipo de dato cuyo tamaño es 8 bytes (realmente bastante), es pesado pudiendo originarse problemas de performance general.
Particularmente casi nunca uso DATETIME, prefieron usar con mucho criterio SMALLDATETIME, Porqué?, pues su tamaño es 4 bytes, y para lo que necesito está bien, puedo manejar fechas entre el rango de 1900 y 1979. Obviamente, SMALLDATETIME también almacena la hora, cosa que no se necesita en la mayoria de aplicaciones. De manera semejante sucedía cuando queriamos trabajar sólo con la hora, no había forma de separar la hora de la fecha. Ejemplo:
-- creando un tipo de datos DATE, y asignándole un valor
DECLARE @FechaTiempo DATETIMESET
@FechaTiempo= GETDATE()
SELECT @FechaTiempo AS FechaTiempo
Ejemplos utilizando la función DATEDIFF y DATEADD
*////////////////////////////////////////////////////////////////*
*/ El primer dia del mes:
*////////////////////////////////////////////////////////////////*
SELECT DATEADD(mm, DATEDIFF(mm,0,getdate()), 0)
*////////////////////////////////////////////////////////////////*
*/El Ultimo dia del mes:
*////////////////////////////////////////////////////////////////*
SELECT dateadd(ms,-3,DATEADD(mm, DATEDIFF(m,0,getdate() )+1, 0));
*////////////////////////////////////////////////////////////////*
*/ El Lunes de la semana actual:
*////////////////////////////////////////////////////////////////*
SELECT DATEADD(wk, DATEDIFF(wk,0,getdate()), 0)
*////////////////////////////////////////////////////////////////*
*/ Primer dia del año:
*////////////////////////////////////////////////////////////////*
SELECT DATEADD(yy, DATEDIFF(yy,0,getdate()), 0)
*////////////////////////////////////////////////////////////////*
*/ Ultimo dia del mes anterior:
*////////////////////////////////////////////////////////////////*
SELECT dateadd(ms,-3,DATEADD(mm, DATEDIFF(mm,0,getdate() ), 0));
*////////////////////////////////////////////////////////////////*
*/ Ultimo dia del año anterior:
*////////////////////////////////////////////////////////////////*
SELECT dateadd(ms,-3,DATEADD(yy, DATEDIFF(yy,0,getdate() ), 0))
*////////////////////////////////////////////////////////////////*
*/ Primer lunes del mes:
*////////////////////////////////////////////////////////////////*
SELECT DATEADD(wk, DATEDIFF(wk,0,dateadd(dd,6-datepart(day,getdate()),getdate())), 0);
De aquí en adelante usaremos el Analizador de consultas (Query Analyzer), pero recordemos que cuando desarrollamos aplicaciones, las consultas las hacemos a través de la aplicación; al final de este artículo ampliaré un poco más sobre este tema.
/* Creamos un usuario donde su idioma predefinido es el Español */
sp_addlogin 'UserFechas','oocu','master','Español'
/* vamos a darle acceso a nuestra Base de Datos Northwind */
use Northwind
GO
sp_grantdbaccess 'UserFechas'
GO
Ahora salimos de QA (Analizador de Consultas) y volvemos a entrar con este nuevo usuario que creamos (Recordar que la autentificación de nuestro motor, en este caso, debe ser mixta y que el uso de cuentas de SQL Server no es aconsejable. Por el contrario, siempre hay que tratar de utilizar la autenticación Windows, pero para hacer el ejemplo mas fácil es que usé autenticación SQL con un usuario SQL).Lo primero que haremos es verificar que el idioma esté en español, tal como lo hemos indicado anteriormente al usuario; para ello usaremos la siguiente instrucción: Select @@Language
Este debería ser el resultado, luego de ejecutar la consulta:
Ahora usaremos la tabla Orders y haremos la consulta de fechas de dos formas distintas: la primera usando los formatos como la mayoría está acostumbrado, y la segunda utilizando el formato ANSI, que sería lo correcto:
use northwind
go
-- Opcion que estamos acostumbrados a usar
select count(*) from orders where orderdate >='01-08-1997' -- Opcion con Ansi
select count(*) from orders where orderdate >='19970801'
Veremos que en ambas consultas nos trae como resultado del Count la cantidad 460, esto quiere decir que encontró 460 registros donde su orderdate es mayor o igual al 1 de Agosto de 1997. Cambiaremos el lenguaje de nuestra sesión a Inglés y hagamos la misma consulta para ver qué sucede:
use northwind
go /* Cambiamos el lenguaje para esta sesión a Inglés, esta opción no cambia el lenguaje del Usuario sino que solo la sesión que al cerrarla volverá a tomar la del usuario si es que no se especifico ningún SET LANGUAGE */
SET LANGUAGE us_english
GO -- Opción que estamos acostumbrados a usar
select count(*) from orders where orderdate >='01-08-1997' -- Opción con ANSI
select count(*) from orders where orderdate >='19970801'
Como vemos aquí la primer consulta pasó de los 460 registros a los 670, ¿Porqué sucedió esto? Bueno, como el lenguaje de la sesión es inglés, ahora la fecha que estamos consultando es realmente mayor al 8 de enero de 1997; pero si se ejecuta la segunda consulta se verá que ésta sigue retornando los 460 registrs originales; pues bien, esto es por todo lo que hemos comentado antes. De ahí que es muy, pero muy importante, utilizar este tipo de formato (YYYYMMDD hh:mm:ss).Hemos aprendido a usar el formato ANSI para nuestras consultas (querys) pero eso no es todo, ahora trataremos de ver algunos ejemplos típicos de búsquedas con fechas para poder analizar bien estos casos. Una consulta muy recurrente es: ¿Cómo busco los registros de una fecha en particular, ya que me toma también la hora? Esto es totalmente cierto; si ponemos por ejemplo = '20040101', esto traerá los registros no del día 01 de enero del 2004 totalmente, sino sólo aquellos que sean de las 0 horas; para solucionar esto, me gusta usar esta consulta muy simple:
Select * from orders Where orderdate >='19970805' and orderdate DATEADD
Devuelve un valor datetime nuevo que se basa en la suma de un intervalo a la fecha especificada.
DATEDIFF
Devuelve el número de límites de fecha y hora que hay entre dos fechas especificadas.
DATENAME
Devuelve una cadena de caracteres que representa la parte de la fecha especificada de la fecha especificada.
DATEPART
Devuelve un entero que representa la parte de la fecha especificada de la fecha indicada..
DAY
Devuelve un entero que representa la parte del día de la fecha especificada.
GETDATE
Devuelve la fecha y hora actuales del sistema en el formato interno estándar de Microsoft® SQL Server™ para los valores datetime.
GETUTCDATE
Devuelve el valor de datetime que representa la hora UTC actual (Universal Coordinated Time u hora del meridiano de Greenwich). La hora UTC actual se deriva de la hora local actual y la configuración de zona horaria del sistema operativo del equipo en el que se ejecuta SQL Server.
MONTH
Devuelve un entero que representa el mes de una fecha especificada.
YEAR
Devuelve un entero que representa la parte de año de la fecha especificada.
Observaciones
Cuando desarrollamos nuestra aplicación es muy común preguntarnos si utilizar Procedimientos Almacenados (Stored Procedures) o directamente hacer que nuestra aplicación envíe las sentencias TSQL.Es importante destacar en estos casos porqué recomiendo el uso de los Procedimientos Almacenados en lugar de que nuestra aplicación haga los TSQL y luego los pase al motor. Los Procedimientos Almacenados deben ser las reinas de los motores y de los DBA, ¿Porqué? Simple: Poner nuestras consultas en Procedimientos Almacenados nos brinda las siguientes ventajas:
Mayor optimización para el motor. Este no debe compilar cada instrucción TSQL (a menos que así lo indiquemos), sino que ya debe tenerla compilada, lo cual genera mucho mayor rendimiento. También se da el caso de que el procedimiento reside en nuestro servidor por lo que el tráfico de red es muy inferior al que produciríamos si enviáramos las TSQL desde nuestro cliente.
Seguridad. Los Procedimientos Almacenados no sólo son buenos por rendimiento, sino que nos permiten hacer las operaciones no directamente sobre nuestras tablas.Un ejemplo clásico: supongamos que tenemos una aplicación de Clientes donde sólo queremos que el listado de precios sea ejecutado por nuestras aplicaciones autorizadas y no que por medio de una planilla de Excel el usuario lo pueda hacer, en este caso si para esa consulta usamos un Procedimiento Almacenado, lo que haremos será darle permisos a nuestros usuarios al mismo y no a las tablas, por lo que para sacar la consulta debe ejecutar dicho Procedimiento.
Reutilización de código. El uso de Procedimientos Almacenados es muy útil para esto; si la consulta de rangos de fechas para buscar los pedidos en firme de un cliente, por ejemplo, la necesitamos en más de una aplicación, entonces podemos reutilizar el procedimiento sin problemas.
Reglas de negocio. En un procedimiento podemos poner reglas de negocio y hacer así que nuestras aplicaciones se beneficien de ello, aunque se debe tener cuidado con esto, pues no se debe abusar.Mi regla es que si debo usar cursores o cosas complicadas donde el desempeño esté en juego, prefiero hacerlo en un componente; de no ser ése el caso, los Procedimientos Almacenados son muy buenos y óptimos para todo esto.
Un punto a tener en cuenta respecto al uso de procedimientos (por lo menos mi experiencia así lo indica), es que si no lo hacemos en procedimiento y lo ponemos en la aplicación, luego si hay que cambiar algo seguramente debamos recompilar nuestras aplicaciones y esto es muy doloroso de verdad y difícil de mantener; y ¿Qué ocurre con los Procedimientos Almacenados? En la mayoría de los casos las modificaciones (si no tienen nuevos parámetros de entrada o salida) no afectan a la aplicación; según mi experiencia con los casos de este tipo, suelen ser casi la mayoría.
Conclusión
El uso de las fechas es un gran problema si no lo entendemos bien, y nos puede provocar múltiples dolores de cabeza; pero además de eso es muy importante que nuestras consultas puedan estar en su mayoría dentro de Procedimientos Almacenados (hay casos donde esto no es viable) y saber que TSQL no es un lenguaje de programación ni mucho menos; por lo que debemos usarlo para lo que en realidad fue creado
En este post vamos a hablar acerca de los tipos de datos para manejar fechas y tiempo, es decir, los 4 últimos arriba mencionados. Los otros tipos de datos serán motivos de otro post!.
DATETIME es un tipo de dato compuesto que almacena fecha y tiempo. La novedad es que en SQL Server 2008, el tipo de dato DATETIME se ha separado en dos: DATE y TIME, con esto no quiero decir que DATETIME se haya eliminado, este sigue siendo necesario para otros escenarios, pocos pero en fin. Esta noticia es muy buena ya que por ejemplo, siempre, casi siempre... sólo necesitabamos almacenar la fecha, más no el tiempo, y el único tipo de dato que podiamos usar era DATETIME, el cual "amablemente" guardaba algo más: el tiempo, aunque no lo necesitemos, pues no habia solución. DATETIME aparte de ser un tipo de dato cuyo tamaño es 8 bytes (realmente bastante), es pesado pudiendo originarse problemas de performance general.
Particularmente casi nunca uso DATETIME, prefieron usar con mucho criterio SMALLDATETIME, Porqué?, pues su tamaño es 4 bytes, y para lo que necesito está bien, puedo manejar fechas entre el rango de 1900 y 1979. Obviamente, SMALLDATETIME también almacena la hora, cosa que no se necesita en la mayoria de aplicaciones. De manera semejante sucedía cuando queriamos trabajar sólo con la hora, no había forma de separar la hora de la fecha. Ejemplo:
-- creando un tipo de datos DATE, y asignándole un valor
DECLARE @FechaTiempo DATETIMESET
@FechaTiempo= GETDATE()
SELECT @FechaTiempo AS FechaTiempo
Ejemplos utilizando la función DATEDIFF y DATEADD
*////////////////////////////////////////////////////////////////*
*/ El primer dia del mes:
*////////////////////////////////////////////////////////////////*
SELECT DATEADD(mm, DATEDIFF(mm,0,getdate()), 0)
*////////////////////////////////////////////////////////////////*
*/El Ultimo dia del mes:
*////////////////////////////////////////////////////////////////*
SELECT dateadd(ms,-3,DATEADD(mm, DATEDIFF(m,0,getdate() )+1, 0));
*////////////////////////////////////////////////////////////////*
*/ El Lunes de la semana actual:
*////////////////////////////////////////////////////////////////*
SELECT DATEADD(wk, DATEDIFF(wk,0,getdate()), 0)
*////////////////////////////////////////////////////////////////*
*/ Primer dia del año:
*////////////////////////////////////////////////////////////////*
SELECT DATEADD(yy, DATEDIFF(yy,0,getdate()), 0)
*////////////////////////////////////////////////////////////////*
*/ Ultimo dia del mes anterior:
*////////////////////////////////////////////////////////////////*
SELECT dateadd(ms,-3,DATEADD(mm, DATEDIFF(mm,0,getdate() ), 0));
*////////////////////////////////////////////////////////////////*
*/ Ultimo dia del año anterior:
*////////////////////////////////////////////////////////////////*
SELECT dateadd(ms,-3,DATEADD(yy, DATEDIFF(yy,0,getdate() ), 0))
*////////////////////////////////////////////////////////////////*
*/ Primer lunes del mes:
*////////////////////////////////////////////////////////////////*
SELECT DATEADD(wk, DATEDIFF(wk,0,dateadd(dd,6-datepart(day,getdate()),getdate())), 0);
De aquí en adelante usaremos el Analizador de consultas (Query Analyzer), pero recordemos que cuando desarrollamos aplicaciones, las consultas las hacemos a través de la aplicación; al final de este artículo ampliaré un poco más sobre este tema.
/* Creamos un usuario donde su idioma predefinido es el Español */
sp_addlogin 'UserFechas','oocu','master','Español'
/* vamos a darle acceso a nuestra Base de Datos Northwind */
use Northwind
GO
sp_grantdbaccess 'UserFechas'
GO
Ahora salimos de QA (Analizador de Consultas) y volvemos a entrar con este nuevo usuario que creamos (Recordar que la autentificación de nuestro motor, en este caso, debe ser mixta y que el uso de cuentas de SQL Server no es aconsejable. Por el contrario, siempre hay que tratar de utilizar la autenticación Windows, pero para hacer el ejemplo mas fácil es que usé autenticación SQL con un usuario SQL).Lo primero que haremos es verificar que el idioma esté en español, tal como lo hemos indicado anteriormente al usuario; para ello usaremos la siguiente instrucción: Select @@Language
Este debería ser el resultado, luego de ejecutar la consulta:
Ahora usaremos la tabla Orders y haremos la consulta de fechas de dos formas distintas: la primera usando los formatos como la mayoría está acostumbrado, y la segunda utilizando el formato ANSI, que sería lo correcto:
use northwind
go
-- Opcion que estamos acostumbrados a usar
select count(*) from orders where orderdate >='01-08-1997' -- Opcion con Ansi
select count(*) from orders where orderdate >='19970801'
Veremos que en ambas consultas nos trae como resultado del Count la cantidad 460, esto quiere decir que encontró 460 registros donde su orderdate es mayor o igual al 1 de Agosto de 1997. Cambiaremos el lenguaje de nuestra sesión a Inglés y hagamos la misma consulta para ver qué sucede:
use northwind
go /* Cambiamos el lenguaje para esta sesión a Inglés, esta opción no cambia el lenguaje del Usuario sino que solo la sesión que al cerrarla volverá a tomar la del usuario si es que no se especifico ningún SET LANGUAGE */
SET LANGUAGE us_english
GO -- Opción que estamos acostumbrados a usar
select count(*) from orders where orderdate >='01-08-1997' -- Opción con ANSI
select count(*) from orders where orderdate >='19970801'
Como vemos aquí la primer consulta pasó de los 460 registros a los 670, ¿Porqué sucedió esto? Bueno, como el lenguaje de la sesión es inglés, ahora la fecha que estamos consultando es realmente mayor al 8 de enero de 1997; pero si se ejecuta la segunda consulta se verá que ésta sigue retornando los 460 registrs originales; pues bien, esto es por todo lo que hemos comentado antes. De ahí que es muy, pero muy importante, utilizar este tipo de formato (YYYYMMDD hh:mm:ss).Hemos aprendido a usar el formato ANSI para nuestras consultas (querys) pero eso no es todo, ahora trataremos de ver algunos ejemplos típicos de búsquedas con fechas para poder analizar bien estos casos. Una consulta muy recurrente es: ¿Cómo busco los registros de una fecha en particular, ya que me toma también la hora? Esto es totalmente cierto; si ponemos por ejemplo = '20040101', esto traerá los registros no del día 01 de enero del 2004 totalmente, sino sólo aquellos que sean de las 0 horas; para solucionar esto, me gusta usar esta consulta muy simple:
Select * from orders Where orderdate >='19970805' and orderdate DATEADD
Devuelve un valor datetime nuevo que se basa en la suma de un intervalo a la fecha especificada.
DATEDIFF
Devuelve el número de límites de fecha y hora que hay entre dos fechas especificadas.
DATENAME
Devuelve una cadena de caracteres que representa la parte de la fecha especificada de la fecha especificada.
DATEPART
Devuelve un entero que representa la parte de la fecha especificada de la fecha indicada..
DAY
Devuelve un entero que representa la parte del día de la fecha especificada.
GETDATE
Devuelve la fecha y hora actuales del sistema en el formato interno estándar de Microsoft® SQL Server™ para los valores datetime.
GETUTCDATE
Devuelve el valor de datetime que representa la hora UTC actual (Universal Coordinated Time u hora del meridiano de Greenwich). La hora UTC actual se deriva de la hora local actual y la configuración de zona horaria del sistema operativo del equipo en el que se ejecuta SQL Server.
MONTH
Devuelve un entero que representa el mes de una fecha especificada.
YEAR
Devuelve un entero que representa la parte de año de la fecha especificada.
Observaciones
Cuando desarrollamos nuestra aplicación es muy común preguntarnos si utilizar Procedimientos Almacenados (Stored Procedures) o directamente hacer que nuestra aplicación envíe las sentencias TSQL.Es importante destacar en estos casos porqué recomiendo el uso de los Procedimientos Almacenados en lugar de que nuestra aplicación haga los TSQL y luego los pase al motor. Los Procedimientos Almacenados deben ser las reinas de los motores y de los DBA, ¿Porqué? Simple: Poner nuestras consultas en Procedimientos Almacenados nos brinda las siguientes ventajas:
Mayor optimización para el motor. Este no debe compilar cada instrucción TSQL (a menos que así lo indiquemos), sino que ya debe tenerla compilada, lo cual genera mucho mayor rendimiento. También se da el caso de que el procedimiento reside en nuestro servidor por lo que el tráfico de red es muy inferior al que produciríamos si enviáramos las TSQL desde nuestro cliente.
Seguridad. Los Procedimientos Almacenados no sólo son buenos por rendimiento, sino que nos permiten hacer las operaciones no directamente sobre nuestras tablas.Un ejemplo clásico: supongamos que tenemos una aplicación de Clientes donde sólo queremos que el listado de precios sea ejecutado por nuestras aplicaciones autorizadas y no que por medio de una planilla de Excel el usuario lo pueda hacer, en este caso si para esa consulta usamos un Procedimiento Almacenado, lo que haremos será darle permisos a nuestros usuarios al mismo y no a las tablas, por lo que para sacar la consulta debe ejecutar dicho Procedimiento.
Reutilización de código. El uso de Procedimientos Almacenados es muy útil para esto; si la consulta de rangos de fechas para buscar los pedidos en firme de un cliente, por ejemplo, la necesitamos en más de una aplicación, entonces podemos reutilizar el procedimiento sin problemas.
Reglas de negocio. En un procedimiento podemos poner reglas de negocio y hacer así que nuestras aplicaciones se beneficien de ello, aunque se debe tener cuidado con esto, pues no se debe abusar.Mi regla es que si debo usar cursores o cosas complicadas donde el desempeño esté en juego, prefiero hacerlo en un componente; de no ser ése el caso, los Procedimientos Almacenados son muy buenos y óptimos para todo esto.
Un punto a tener en cuenta respecto al uso de procedimientos (por lo menos mi experiencia así lo indica), es que si no lo hacemos en procedimiento y lo ponemos en la aplicación, luego si hay que cambiar algo seguramente debamos recompilar nuestras aplicaciones y esto es muy doloroso de verdad y difícil de mantener; y ¿Qué ocurre con los Procedimientos Almacenados? En la mayoría de los casos las modificaciones (si no tienen nuevos parámetros de entrada o salida) no afectan a la aplicación; según mi experiencia con los casos de este tipo, suelen ser casi la mayoría.
Conclusión
El uso de las fechas es un gran problema si no lo entendemos bien, y nos puede provocar múltiples dolores de cabeza; pero además de eso es muy importante que nuestras consultas puedan estar en su mayoría dentro de Procedimientos Almacenados (hay casos donde esto no es viable) y saber que TSQL no es un lenguaje de programación ni mucho menos; por lo que debemos usarlo para lo que en realidad fue creado
Saludos a Mi Mamita y Papito
Mi Oración
Una petición pido a DIOS
Que en tus benditas manos SEÑOR, Este mi madresita que es la luz de mis ojos, la razón de mi sonrisa el motivo de mis carcajadas y mi ánimo de seguir adelante.Ella es para para mi tu representación que me toca de cerca, tu abrazo y tu amor. Que me llena como nada ni nadie lo hará. Cuídala y bendícela con salud y felicidad para que seán muchos años más de tu amor en mi caminar ... Mamita tu eres siempre mi luz en la orcuridad.
!TE AMO CON TODA EL ALMA, MI MADRE QUERIDA!
Suscribirse a:
Entradas (Atom)