Archive for the 'Bases de Datos' Category

03
dic
09

Fechas ANSI para SQL Server

Hace algunos dias me topé con un problema mayúsculo cuando una de mis aplicaciones trató de meter una fecha en un servidor SQL Server 2000 con la distribución de idioma en Ingles

Luego de muchas tazas de café y varias horas de investigación encontré que segun su distribución de idioma, SQL Server toma las fechas de distintas formas, por ejemplo, en ingles las toma en el formato MM/DD/AAA, en español es DD/MM/AAAA, lo que se traduce en que:

en inglés la fecha 01/10/2009 le corresponde al diez de enero de 2009

en español la fecha 01/10/2009 le corresponde al primero de octubre de 2009

el problema fue este:

en español la fecha 30/11/2009 le corresponde al 30 de noviembre de 2009

y en ingles la fecha dispara un error.

La solución que primero se me vino a la mente fue que antes de meter una fecha al servidor se le cambiara el idioma, pero luego pensé que al servidor no le iba a gustar que estuvieran jugando con sus fechas a cada rato, dado que al terminar de ejecutar el SP con la instrucción Sql el servidor vuelve automaticamente a su idioma original, se imaginan 70,000 cambios de idioma del servidor en una hora? yo no.

Entonces pense que debia existir un formato universal de fecha y hora, y bingo, el formato universal que el servidor acepta se llama ANSI y es el siguiente:

20091001 00:00:00 ——>  añomesdia hora:minuto:segundo

y de esta forma no importa si el servidor esta en chino, eslavo o español.

Identificado el problema y determinada la solución procedí a escribir la función en Visual Basic .Net que me convierte fechas en variables DateTime a Strings con las fechas en el formato ANSI (no encontré en .net algo que me las convirtiera así que me lo fabriqué yo)

‘Conversion de la fecha del sistema a fecha ANSI en formato ‘yyyymmdd hh:mm:ss’
‘Dado que las fechas se ingresan igual que los string, devuelve un valor string
‘porque .net no reconoce formato de fecha ANSI, o al menos yo no lo encontré XD.

Public Function ConvertirFecha(ByVal Fecha As DateTime, ByVal FFH As String)
Dim ANSI As String = “”
Dim FANSI As String = “”
Dim FHANSI As String = “”
Dim Año As String
Dim MesI As Integer
Dim Mes As String
Dim DíaI As Integer
Dim Día As String
Dim Hora As String
Dim Minuto As String
Dim Segundo As String
Try
Año = CStr(Fecha.Year)
MesI = CInt(Fecha.Month)
DíaI = CInt(Fecha.Day)
If MesI < 10 Then
Mes = “0” & CStr(MesI)
Else
Mes = CStr(MesI)
End If
If DíaI < 10 Then
Día = “0” & CStr(DíaI)
Else
Día = DíaI
End If
Hora = Fecha.Hour
Minuto = Fecha.Minute
Segundo = Fecha.Second
FANSI = Año & Mes & Día
FHANSI = Año & Mes & Día & ” ” & Hora & “:” & Minuto & “:” & Segundo
If FFH = “F” Then
ANSI = FANSI
ElseIf FFH = “FH” Then
ANSI = FHANSI
End If
Return ANSI
Catch ex As Exception
ANSI = ex.ToString
Return ANSI
End Try
End Function

Los parámetros que pide esta función son : el objeto DateTime contenieno la fecha/fecha y hora que queremos almacenar en el servidor, el segundo parametro da dos opciones, pasar la lerta “F” con el que la función solo formará la cadena de la fecha “20091001“, o pasar “FH” con el que la función formará la cadena de la fecha y hora “20091001 12:00:00″.

Espero que a mas de alguien le sea de utilidad esta pequeña pero útil función ya que para mi fue de gran ayuda…

Saludos, Axl_505.

09
oct
09

Transact Sql Básico – Stored Procedures (SP)

Bueno, dando continuidad al Transact Sql, me gustaría comentar sobre otro importante tema como son los Stored Procedures o Procedimientos almacenados.

Un procedimiento almacenado es un bloque de código de que se ejecuta dentro del motor de la base de datos con el fin de realizar tareas dentro de la misma base y en consecuencia, evitar que el usuario tenga que ver con dichas tareas; Esto se puede aplicar tanto a procesos delicados como la actualización o modificación de muchos registros a la vez, y también a procesos sencillos como un select o un delete, la diversidad puede ser muy extensa ya que son herramientas muy potentes del motor de base de datos.

Quizá la función mas importante y el mayor beneficio que podemos sacar de los SP es que se puede limitar o incluso evitar que el usuario tenga acceso directo a las tablas de nuestra base de datos, haciendo que las tareas de consulta las realicen los SP mediante parametros que podamos pasarles

Veamos como hacer un sencillo SP desde el Analizador de Consultas de nuestro SQL Server…

Create Procedure SP_EliminarEstudiante @PId_Estudiante varchar(20) As
Delete From Estudiantes
Where Id_Estudiante = @PId_Estudiante
go

Explico el código:

Create es la palabra reservada en Sql para crear un nuevo elemento, una base, una tabla, un SP, etc.

Con Procedure le decimos que lo que estamos creando es un Procedimiento Almacenado

lo siguiente es escribir el nombre de nuestro procedimiento: SP_EliminarEstudiante, (Por lo del SP_  he de recordar la entrada sobre Nomenclaruta Hungara, para no confundirnos)

Al SP le pasaremos un parámetro, el numero de la cuenta que eliminaremos, los parametos para los SP se declaran con @P, seguidos por el nombre del parámetro y su tipo de dato: @PId_Estudiante VarChar (20) si pasaremos más de un parámetro los separaremos por comas…

Al final colocamos la palabra AS

Después de esto, colocamos las instrucciones que queremos que nuestro SP ejecute cuando sea llamado…

Delete From Estudiantes
Where Estudiante = @PId_Estudiante

(Ojo, que aqui es donde utilizamos los parámetros que llamamos)

y al final, colocamos la célebre palabra Go.

Esto es básicamente un SP, ejecutando lo que le queramos y lo único que hay que hacer es llamarlo por una sencilla linea en nuestro Analizador de Consultas:

SP_EliminarEstudiante ‘CFPDM01′

(el nombre de nuestro SP y los parámetros que le hayamos declarado)…

Cabe mencionar que el poder del SP reside en el alto grado de complejidad que puede adoptar, ya que es capaz de controlar estructuras de manejo de flujo de datos, IF THEN ELSE, entre otros: Aqui pongo un ejemplo de un SP mas complejo:
Create Procedure SP_ObtenerEstudiante @PId_Estudiante varchar(50), @PFull int As
If
@PId_Estudiante is null and @PFull = 0
Select Id_Estudiante, Nombres, Apellidos
From Estudiantes
Order By Id_Estudiante
else if
@PId_Estudiante is not null and @PFull = 0
Select Id_Estudiante, Nombres, Apellidos
From Estudiantes
Where IdEstudiante =
@PId_Estudiante
Order By Id_Estudiante
else if
@PId_Estudiante is null and @PFull = 1
Select *
From Estudiantes
Order By Id_Estudiante
else if
@PId_Estudiante is not null and @PFull = 1
Select *
From Estudiantes
Where Id_Estudiante = @PId_Estudiante
Order By Id_Estudiante
Go

El procedimiento anterior lleva a cabo una seleccion de los posiles valores de los dos parametros requeridos, evaluando cada caso y dando una cadena de consulta distinta para cada uno…

Nota Importante: Cuando se asignan parámetros a los SP, es posible evaluar no solo los valores que contienen, sino también, si contienen o no valores; Tal es el caso del procedimiento anterior que verifica si el parámetro @PId_Estudiante es nulo o no. Por lo que las posibilidades con los SP que se nos vengan en mente son ilimitadas…

Saludos…

28
sep
09

ADO.NET.- Conectar Base de Datos SQL con VB.NET

Bueno, esta vez hablaremos sobre ADO.NET, la evolución de la arquitectura de acceso a datos de Micro$oft…

ADO = ACtiveX Data Objects, ADO.NET provee a los programadores .NET de un acceso a las fuentes de datos relacionales, XML y aplicaciones de datos, es una gran herramienta que puede trabajar con diversos proveedores de datos, desde Sql Server, hasta Oracle y MySql…

Esta vez voy a mostrarles como crear procedimientos con los objetos básicos de ADO.NET para conectarse y trabajar con una base de datos hecha en Sql Server…

Primero pasarémos a revisar los principales objetos de ADO.NET:

Objeto DataReader: proporciona un acceso rápido y unidireccional (solo hacia adelante) a los datos, es de solo lectura.

Objeto DataSet: proporciona una representación relacional de los datos en memoria, es decir, es capaz de crear tablas y relaciones en memoria para trabajar en ellas.

Objeto DataAdapter: sirve como un puente entre el DataSet y el origen de los datos.

Objeto Command: proporciona lo que Micro$oft llama Funcionalidad Explícita, que consiste en los métodos ExecuteNonQuery para las operaciones que no devuelven un resultado a la consulta, (Insert, Update, Delete), y ExecuteScalar para funciones que devuelven un único valor en lugar de un conjunto de filas.

Ahora, una forma de optimizar nuestro trabajo es identificar el tipo de cosulta que haremos, a modo de ejemplo tomaremos tres casos:

  1. Consulta Lineal con un flujo de datos hacia adelante y de solo lectura: Puede utilizarse este modo para el tipo de consultas simples que no requieren de mucha interacción del usuario o de actualizarse o regresar a un registro anterior, esto lo hacemos con el objeto DataReader, que fue diseñado para mantener una conexión permanente con el origen de datos mientras este activo, su función, básicamente, es leer los registros de la consulta de a uno en uno y en dirección hacia adelante (Forward-Only).
  2. Consulta de tipo Desconectado: Puede proveer una representación totalmente desconectada de los datos, para que el usuario pueda manipularlos sin verse restringido por problemas de recursos del servidor o disponibilidad de la fuente de datos, podemos utilizar el objeto DataSet, dentro del cual podemos contener tablas con los resultados de nuestras consultas no importando el origen de estos, (base de datos, archivos xml, o datos que genera la aplicación), esto permite una flexibilidad mayor cuando se trabaja con datos relacionados y permite exportarlos como archivos Xml.
  3. Recuperar y actualizar desde una fuente de datos: Bueno, esto es medio sencillo si se ve así: el DataAdapter se conecta con el origen de datos y permite llenar el DataSet con los resultados, al manipular, modificar o/y actualizar los datos en el DataSet, también permite actualizarlos en el origen de datos.

Ahora, después de toda esta (necesaria) chachara, hemos de pasar a los ejemplos prácticos de utilización de los objetos de ADO.NET para establecer conexión y trabajar con un origen de Datos, (Micro$oft Sql Server)

Veremos primero como importar el espacio de nombre necesario para trabajar con los objetos para el servidor sql, luego, declarar los objetos y conectarse a la base de datos…

Imports System.Data.SqlClient

Luego necesitamos declarar una variable que nos diga dónde está el servidor y como se llama la base…

Public Conexion As String = “Server =Server_1;packet size=4096;integrated security=SSPI;data source=Server_1;persist security info=False;initial catalog=Estudiantes”

Esta es una de las cadenas más sencillas donde se establece el nombre del servidor y la base de datos, aunque si necesitamos declarar Usuario y Password utilicemos esta:

Public Conexion As String = “Server =Server_1;packet size=4096;User Id=Axl;Password=123;data source=Server_1;initial catalog=Estudiantes”

Tengo que recordarles, que en SQL, si utilizamos un usuario y password para entrar a la base, tenemos que darle permisos a ese usuario en todas las propiedades de las tablas que queramos que tenga acceso, en especial los Stored Procedures, que hay que marcarlos uno por uno :(

luego declaramos los objetos necesarios para empezar a trabajar…

Dim Cmd As New SqlCommand
Dim Cnn As New SqlConnection
Dim Sql As String
Dim Dr As DataRow
Dim Da As New SqlDataAdapter

Estos objetos los utilizaremos en cuatro procedimientos que crearemos a continuación, Consulta de Busqueda, Inserción, Actualización y Eliminación…

Busqueda:

Dim ds As New Data.DataSet
Sql = “Select * from Materias”
Cnn = New SqlConnection(Conexion)
Cnn.Open()
Da = New SqlDataAdapter(Sql, Cnn)
Da.Fill(ds)
Cnn.Close()

Explicación (línea por línea):

Declara un Objeto tipo Dataset para depositar los datos de la consulta.

Asigna la cadena de la consulta a la variable “Sql” (tipo string)

Le da al objeto SqlCommand la dirección de la base y lo instancia para poder utilizarlo

Abre la conexión con la propiedad .Open() del SqlCommand

Le da al SqlDataAdapter la cadena de consulta y el objeto de conexión

El SqlDataAdapter tiene la especial propiedad .Fill que vuelca todo lo que tiene en el objeto entre los paréntesis, (el dataset), y ojo que solo lo hace en un dataset.

Cuando has volcado el contenido de la consulta en el dataset simplemente cerras la conexión.

Ojo y doble ojo en esto, se debe cerrar cada conexión que se abra, no importa que tipo de consulta se haga, las conexiones abiertas se acumulan y pueden volar tu servidor y simplemente se quedará pegado.

Actualización:

Sql = “Update ” & tabla & ” Set ” & camposyvalores & ” Where ” & condicion
Cnn = New SqlConnection(Conexion)
Cnn.Open()
Cmd = New SqlCommand(Sql, Cnn)
Cmd.ExecuteNonQuery()
Cnn.Close()

Explicación (Línea por línea):

Asigna la cadena de la consulta a la variable “Sql” (tipo string)

Le da al objeto SqlCommand la dirección de la base y lo instancia para poder utilizarlo

Abre la conexión con la propiedad .Open() del SqlCommand

Le damos al SqlCommand el objeto de conexión y la cadena con la instrucción Sql

Aquí utilizamos la propiedad .ExecuteNonQuery del SqlCommand que permite ejecutar una instrucción sin arrojar ningún resultado.

Como ya lo he dicho antes, hay que cerrar la conexión.

Eliminación:

Sql = “Delete From ” & tabla & ” Where ” & condicion
Cnn = New SqlConnection(Conexion)
Cnn.Open()
Cmd = New SqlCommand(Sql, Cnn)
Cmd.ExecuteNonQuery()
Cnn.Close()

Explicación (Línea por línea):

Asigna la cadena de la consulta a la variable “Sql” (tipo string)

Le da al objeto SqlCommand la dirección de la base y lo instancia para poder utilizarlo

Abre la conexión con la propiedad .Open() del SqlCommand

Le damos al SqlCommand el objeto de conexión y la cadena con la instrucción Sql

Aquí utilizamos la propiedad .ExecuteNonQuery del SqlCommand que permite ejecutar una instrucción sin arrojar ningún resultado.

Como ya lo he dicho antes, hay que cerrar la conexión.

Inserción:

Sql = “Insert Into ” & tabla & ” (” & campos & “) Values (” & valores & “)”
Cnn = New SqlConnection(Conexion)
Cnn.Open()
Cmd = New SqlCommand(Sql, Cnn)
Cmd.ExecuteNonQuery()
Cnn.Close()

Explicación (Línea por línea):

Asigna la cadena de la consulta a la variable “Sql” (tipo string)

Le da al objeto SqlCommand la dirección de la base y lo instancia para poder utilizarlo

Abre la conexión con la propiedad .Open() del SqlCommand

Le damos al SqlCommand el objeto de conexión y la cadena con la instrucción Sql

Aquí utilizamos la propiedad .ExecuteNonQuery del SqlCommand que permite ejecutar una instrucción sin arrojar ningún resultado.

Como ya lo he dicho antes, hay que cerrar la conexión.

Ok, si han sido buenos observadores habrán descubierto que en los últimos tres procedimientos solo cambia la instrucción Sql, por lo demás son iguales, ¿Porque?, porque a mi juicio, hay dos tipos de instrucciones, Las que te devuelven algo y las que no te devuelven nada. El Select te devuelve algo, lo que sea, un campo, una fila, una columna, una tabla, cualquier cosa, los demás (Insert, Update, Delete) no te devuelven nada por eso usamos el .ExecuteNonQuery del amigo SqlCommand y podemos utilizar el mismo código para los tres.

Como lo he dicho desde la primera entrada que hice en nuestro blog, utilizaré los métodos más simples para hacer las cosas, porque bueno, Occam dijo que la respuesta más simple y obvia es casi siempre la mas probable, (en nuestro caso, no es solo la única), pero no siempre la correcta. Hay muchas formas de hacer las cosas, pero trataremos de tomar las más fáciles y las más prácticas.

Saludos…

11
sep
09

Transact Sql Básico – Crear una Base de Datos con llaves primarias y relaciones en SQL-Server 2005

Bueno, creo que este es un buen tema para publicar, como hacer una base de datos en Sql Server con sus llaves primarias y relaciones pero a puro código, asi que comparto este código con ustedes, lo único que deben hacer es pegarlo en el editor de consultas de SQL y listo…

Lo primero es crear la base de datos…

Create Database Inscripciones
go

luego le decimos que cambie a la base que hemos creado

Use Inscripciones
go

Ahora creamos las tablas en nuestra base de datos:

Create Table Estudiantes
(IdEstudiante int,
Nombres VarChar(25),
Apellidos VarChar(25),
Direccion VarChar(50),
Telefono VarChar(8),
Primary Key (IdEstudiante))
go

Create Table Materias
(IdMateria int,
Materia VarChar(30),
Primary Key (IdMateria))
go

Create Table Notas
(IdEstudiante int,
IdMateria int,
Nota decimal (10,2))
go

Ahora que tenems nuestras tablas creadas con sus respectivas llaves primarias, procederemos a crear los constraint o relaciones para las tablas.

Alter Table Notas
add constraint fk_Notas_IdEstudiante
Foreign key (IdEstudiante)
References Estudiantes(IdEstudiante)
go

Alter Table Notas
add constraint fk_Notas_IdMateria
Foreign key (IdMateria)
References Materias(IdMateria)
go

ahora podemos perfectamente ver el diagrama de la base de datos que queda de esta forma:

Diagrama DB Inscripciones

Ahora nuestra base de datos está lista para que podamos trabajar con ella, y para que sea mas real, le agregaremos algunos registros y jugaremos con ella un poco…

Primero, agregaremos algunos estudiantes…

Insert Into Estudiantes Values (01, ‘Maria’, ‘Hernandez’, ‘Col. Santa Isabel’, ‘22542121’)
Insert Into Estudiantes Values (02, ‘Oscar’, ‘Mejía’, ‘Final 4º calle ote.’, ‘26098345’)
Insert Into Estudiantes Values (03, ‘Hilario’, ‘Urrutia’, ‘Final calle el progreso’, ‘29078341’)
Insert Into Estudiantes Values (04, ‘José’, ‘Quezada’, ‘Mejicanos’, ‘23456895’)
Insert Into Estudiantes Values (05, ‘Adriana’, ‘Urrutia’, ‘San Jacinto’, ‘22204789’)

Ahora agregamos algunas materias…

Insert Into Materias Values(111, ‘Base de Datos II’)
Inset Into Materias Values(114, ‘Ingeniería del Software’)
Insert Into Materias Values(115, ‘SQL Server’)

Ahora algunos registros de notas…

Insert Into Notas Values (01, 111, 7)
Insert Into Notas Values (01, 115, 6.0)
Insert Into Notas Values (01, 115, 4)
Insert Into Notas Values (02, 111, 6)
Insert Into Notas Values (02, 114, 10)
Insert Into Notas Values (02, 115, 8.0)

Ahora, con la base creada y con registros en ella podemos modificar lo que queramos…

por ejemplo, borrar los registros de notas que correspondan a la materia ‘Base de Datos II':

Delete From notas Where IdMateria = 111

Modificarle a 9.0 la nota a Oscar Mejía para la materia ‘Sql Server':

Update notas Set nota = 9.0 Where IdEstudiante = 02 and IdMateria = 115

Modificar el nombre de la materia ‘Ingeniería del Software’ a ‘Desarrollo de Software:

Update Materias Set Materia = ‘Desarrollo del Software’ Where Materia = ‘Ingeniería del Software’

Borrar a los estudiantes que tengan apellido ‘Urrutia':

Delete From Estudiantes Where Apellidos = ‘Urrutia’

Mostrar a todos los estudiantes:

Select * From Estudiantes

Mostrar el apellido y la dirección del estudiante 01

Select Apellidos, Direccion From Estudiantes Where IdEstudiante = 01

Seleccionar el código de materia, el nombre de materia y la nota de las materias que cursa el estudiante 02, (Este inner join esta bueno para los que nunca han consultado dos tablas a la vez).

Select Materias.IdMateria, Materias.Materia, Notas.Nota From Materias inner join Notas on Materias.IdMateria = Notas.IdMateria Where Notas.IdEstudiante = 02

Muestra la nota media de cada estudiante para las materias que cursa.

Select IdEstudiante, AVG(Nota) From Notas Group By IdEstudiante

bueno… espero que les sirva para crear bases de datos más grandes, completas y funcionales.

Creo que siempre es bueno saber como hacer las cosas a pie, es decir, con código, porque los nuevos lenguajes tratan de acostumbrar a los nuevos programadores a trabajar con los asistentes, cosa que no considero que este bién, es bueno conocer las herramientas, utilizarlas hasta cierto punto, pero no hay nada mejor que crear tu propio código sin que el sistema te diga como o con que elementos crearlo, sobre todo con sistemas de Micro$oft…

Saludos…




Eres el visitante número

  • 515,324 hits
julio 2014
L M X J V S D
« jun    
 123456
78910111213
14151617181920
21222324252627
28293031  

Seguir

Recibe cada nueva publicación en tu buzón de correo electrónico.