viernes, 31 de octubre de 2014

Entrada 6

Fecha: 31 de octubre

Acciones realizadas:

--------------------------------------------------------------------------------------------------------------------------

 Los movimientos son una parte esencial de un generador de estados de cuenta, por ende, para poder generar estados de cuenta en una base de datos, se necesita una tabla real con todos los movimientos que realizan los clientes de la base de datos, cada uno en sus propias cuentas. En este caso, los movimientos fueron dados en un archivo de formato .json. Este formato es muy diferente al .xml o .txt, por poner dos ejemplos. Es diferente por la forma en que acomoda los datos, las formas de separarlos y la forma en que se leen también es muy diversa.
 
El archivo .json que contiene los movimientos es el siguiente:



Como se puede observar, el formato de este tipo de archivos es muy peculiar y diferente. Las formas de separar los datos no son con comas o puntos y comas, sino con llaves. Hubo que encontrar la forma de leer el archivo y cargarlo también con el comando "bulk". Esta vez la forma de separar las filas fue con "},{" y las columnas fue con una coma ",".

--------------------------------------------------------------------------------------------------------------------------

Para la lectura y carga del archivo, se creó un procedimiento almacenado llamado "CargarArchivoJson_Movs". Este procedimiento almacenado funciona de la siguiente manera:

1. Se crea una tabla temporal que lee los datos del archivo .json, se colocan en ella misma mediante el comando "bulk insert" usando como separador de de columna una coma(","), y para separador de fila dos llaves y una coma, de esta manera: "}.{". En esta tabla se insertan los datos de la forma: "nombre":"dato".

2. Se crea otra tabla temporal. Se extraen los datos de las parejas "nombre":"dato" de la tabla anterior y se insertan en la nueva tabla temporal, todo esto por medio de las funciones agregadas (van a ser explicadas más adelante) "extraer" y "extraerSinComa".

3. Se crea otra tabla temporal, la cual posee la estructura similar a la tabla real dbo.Movimientos en cuanto a tipos de datos de la columnas, a nombres y número de columnas. La función de esta tabla es sustituir las hileras "null" de los campos, por valores null verdaderos, por medio de otra función agregada llamada "SiEsNull". También, se insertan las fechas de aplicación de los movimientos pendientes.

4. Como parte del bloque transaccional y como paso final, se insertan los valores de la tabla temporal anterior, en la tabla real de movimientos.

El código de este procedimiento es el siguiente:




Funciones agregadas:

1. ExtraerSinComa:


 Es una función agregada que separa una tira o string en partes, usando un separador que puede ser una coma, pueden ser dos puntos, punto y coma, etc. Es usada en el procedimiento para separar datos que están separados por medio del separador ":".

2. Extraer:

Esta función agregada lo que hace es extraer el texto que esté en medio de comillas, de cualquier string o tira. En el procedimiento se usa para eso mismo, para extraer los datos que estén en medio de comillas, debido a la forma "nombre":"dato".

3. SiEsNull
Esta función agregada lo que hace es que cambia los campos que poseen un string o tira que dice "NULL", por un valor null verdadero, reemplazando el simple string "NULL". En el procedimiento se usa para cambiar los strings "NULL" en la segunda tabla temporal, por valores null verdaderos.

--------------------------------------------------------------------------------------------------------------------------

Para poder saber la manera de realizar la lectura y carga de un archivo .json, se tuvo que investigar características de este tipo de archivos y de como se realiza con el comando "bulk insert". Para esta investigación, fueron de mucha utilidad links como:

http://www.forosdelweb.com/f29/rest-service-usando-json-sql-server-1008129/

http://www.weboomania.com/2009/04/10/dynamic-json-parser/

http://www.solvusoft.com/es/file-extensions/file-extension-json/

Con esta investigación, y con la que se había realizado anteriormente acerca de las características de los archivos .json, se pudo lograr la lectura y carga de los movimientos en su tabla real, para después ser usados de la mejor manera a la hora de generar estados de cuenta.

--------------------------------------------------------------------------------------------------------------------------

Horas trabajadas: 2 horas, 30 minutos

Participantes: Jonathan Salazar García
Luis Ricardo Gutiérrez Aguilar

miércoles, 29 de octubre de 2014

Entrada 5

Fecha: 29 de octubre

Acciones realizadas:

-----------------------------------------------------------------------------------------------------------------------

   Ya teniendo el modelo físico bien definido, con las tablas hechas de acuerdo a los datos necesarios y sus campos con los tipos bien declarados, se realiza la inserción de datos a las tablas catálogo. Entre las tablas catálogo se encuentran TipoMovimiento, TipoMedio, TipoGestion, TipoCuenta, Cliente, entre otras. Para los datos de estas tablas, se usó un archivo .txt que contenía todos los datos, acomodados de una manera bien definida. El archivo .txt que se usó para cargar todos estos datos lucía como este:


    Hubo que encontrar la manera de poder leer este .txt, de manera que leyera los datos separados por un "separador", en este caso es una coma, los cargara en la tabla correspondiente y formara bien las columnas en cada tabla.

--------------------------------------------------------------------------------------------------------------------------

    Para poder leer el archivo y cargar los datos de la manera antes mencionada, se hizo un procedimiento almacenado, al cual se le llamó CargarArchivoTxt. Este procedimiento sigue los siguientes pasos:

            1. Crea una tabla temporal, con 9 columnas, todas de tipo varchar de tamaño 50.

             2. Por medio de un comando llamado "bulk insert", se insertan los datos del archivo
             .txt en la tabla temporal antes mencionada. El comando "bulk" usa un separador
              por columna, en este caso es una coma. Tambien usa un separador para las filas, el
              cual es un espacio, un "enter".

             3. Una vez insertados los datos en la tabla temporal, por medio de una transacción se
              van haciendo las inserciones en las tablas reales, dependiendo del tipo de movi-
              miento que se vaya a realizar.
              El código es el siguiente:

                           


-------------------------------------------------------------------------------------------------------------------------

   En este caso, lo que se tuvo que investigar fue la forma de leer y cargar los datos en las tablas. Lo 
más indicado fue usar el comando "bulk insert", por ende se tuvo que empezar a buscar y conocer 
acerca de la manera del mejor uso del comando. Para ello, fueron de mucha utilidad algunos links 
como:

http://msdn.microsoft.com/es-es/library/ms188365.aspx

http://microsoftsqlsecret.fullblog.com.ar/carga-masiva-con-bulk-insert-sql-server.html

http://msdn.microsoft.com/es-es/library/ms175915.aspx

  De esta manera, se logró crear un concepto mucho más claro del comando "bulk" y su manera de cargar datos. Ideas como la creación de tablas temporales para la inserción en ellas, antes de la inserción en las reales, fueron tomadas de las investigaciones.

--------------------------------------------------------------------------------------------------------------------------

Horas trabajadas: 3 horas

Participantes:
Jonathan Salazar García
Luis Ricardo Gutiérrez Aguilar


martes, 28 de octubre de 2014

Entrada 4

Fecha: 28 de octubre del 2014

Acciones realizadas:

--------------------------------------------------------------------------------------------------------------------------

Se finalizo el stored procedure con mayor nivel de dificultad del proyecto, me refiero al procedure que genera los estados de cuenta, el mismo lleva mucho nivel de complejidad puesto que se deben realizar muchas cosas al mismo tiempo talez con hacer un debito a los intereses y sumarlos al saldo (y generar los movimientos correspondientes) y ademas debe verificar el monto diario de cada cuenta para validar las multas por saldo negativo o saldo minimo, el codigo del mismo es adjuntado a continuacion :






--------------------------------------------------------------------------------------------------------------------------

Horas trabajadas:

1 hora 30 minutos

Participantes:

Jonathan Salazar Garcia
Luis Ricardo Gutierrez

lunes, 20 de octubre de 2014

Entrada 3

Fecha: 20 de Octubre del 2014

Acciones Realizadas:

--------------------------------------------------------------------------------------------------------------------------

Para tener una mayor facilidad a la hora de probar los datos migrados desde los archivos de datos y poder realizar pruebas con mayor facilidad se creo el stored procedure "SP_BorradoBase" el cual lo que hace es un delete a todos los datos de todas la tablas y ademas reinicia el identity de cada una de las tablas de la base de datos , el mismo puede necesitar ejecutarse varias veces para borrar bien los datos ya que en ocaciones puede dar errores al borrar puesto que las tablas no las borra en un orden en cascada y hay algunas que no las puede borrar en una primera ejecucion pero ya en la segunda si se pueden borrar sus datos, como vemos a continuacion el codigo del procedure (mostrando solo 3 tablas) :


y con lo visto en la imagen se corrobora lo que dije anterior mente pues vemos que primero se eliminan los datos de una tabla y posteriormente se hace un reseed a la misma tabla volviendo su identity de vuelta a 0, pero la pregunta aqui es , ¿Por que a 0, si los ID deben conmenzar en 1? , esto es muy sencillo pues el identity funcion igual que un ++i en el que primer incrementa su valor y despues lo asigna, por lo tanto al hacer el reseed en 0 , el primer ID siempre sera 1.

--------------------------------------------------------------------------------------------------------------------------

Se creo el SP para el calculo de intereses el cual aplica intereses diariamente a las cuentas que cuenten con el requisito de tener su saldoReal mayor o igual al Saldo minimo , el cual esta especificado,
La formula utilizada para dicho calculo es tasa anual / 365 (cantidad de dias del año) 

--------------------------------------------------------------------------------------------------------------------------

Se genera el stored procedure "SP_VerificarMovimientosPendientes" el cual recorre todos los movimientos que  tienen estado pediente y si ya es su fecha de aplicacion entonces genera un movimiento nuevo y resta el saldo de movimientos pendientes de la cuenta respectiva como lo podemos ver en el codigo del mismo:


--------------------------------------------------------------------------------------------------------------------------

Ademas tambien se crea el SP que guarda todos los dias el saldo de cada cuenta para verificar posteriormente si la cuenta tiene una multa por saldo minimo o saldo negativo

--------------------------------------------------------------------------------------------------------------------------

Horas Trabajadas: 

2 horas 45 minutos

Participantes:

Jonathan Salazar Garcia
Luis Ricardo Gutierrez


miércoles, 15 de octubre de 2014

Entrada 2

Fecha: 15 de Octubre del 2014

Acciones Realizadas:

-------------------------------------------------------------------------------------------------------------------------

Se realizaron los bocetos iniciales sobre la estructura que tendran los archivos de prueba ademas que se comenzo con la elaboracion del archivo de datos generales cuya estructura quedo establecida de la siguiente manera:

TipoOperacion,Nombre,Comision,TasaAnual,SaldoMinimo,MultaSaldoMinimo,MultaSaldoNegativo,Usuario,Contraseña

todos los datos separados por coma ' , ' y solo se utilizaria para cada tipo de operacion los datos cuyo valor fuese diferente a null, ya que si el campo es null significa que el dato no aplica para el mencionado tipo de operacion, podemos ver en la siguiente imagen como se muestran los datos de algunas inserciones:



-------------------------------------------------------------------------------------------------------------------------

Investigando en internet sobre la lectura de archivos JSON desde sql server encontre los siguientes links que sirvieron de guia para poder realizar la lectura:

https://www.simple-talk.com/blogs/2013/03/26/sql-server-json-to-table-and-table-to-json/

https://www.simple-talk.com/sql/t-sql-programming/consuming-json-strings-in-sql-server/

ambos links fueron escritos por 

--------------------------------------------------------------------------------------------------------------------------

Problemas Encontrados:

-Al iniciar el proyecto nuestro grupo de trabajo era de 3 personas, pero este dia Mariano decidio decir que abandonaria el curso y por lo tanto los dos miembros que quedamos en el grupo nos vimos obligados a hacer una restructuracion de las tareas por realizar de cada uno ademas de cambiar citas de reunion entre los miembros del grupo. 

--------------------------------------------------------------------------------------------------------------------------
Horas Trabajadas:

2 horas 20 minutos


Participantes:

Jonathan Salazar Garcia
Luis Ricardo Gutierrez

domingo, 12 de octubre de 2014

Entrada 1

Fecha: 12 de Octubre del 2014

Acciones Realizadas:

---------------------------------------------------------------------------------------------------------------------
Luego de discultir sobre el modelo para la base de datos del presente proyecto tomando en cuenta el modelo proporcionado por el profesor:



Analizando lo anterior modelo y realizando una lectura exahustiva de la especificacion del proyecto se llego a la decision grupal de realizar el modelo fisico de la siguiente manera:


Como se puede apreciar en ambas fotografias el modelo cambia bastante entre una imagen y otra, los principales cambios a destacar serian los que mencionare acontinuacion, 

1. Se unificaron las tres tablas de movimientos que se tenian (Movimientos, MovimientosIntereses,MovimientosPendientes) esto para  facilitar un poco las consultas realizadas a lo largo del proyecto puesto que para futuros procedures no seria necesario crear 3 tablas variantes para cada tipo de movimiento sino que con una solo se pueden manejar las 3 y de esta manera ahorramos memoria y le quitamos peso a la consulta y posterior transaccion.

2. Se normalizo la tabla de estado de cuenta , la misma ya no cuenta con atributos repetitivos para manejar las cantidades de cada tipo de movimiento en vez de esto se realizo un cambio en dicha tabla y se agregaron dos tablas mas , las cuales pueden almacenar varias cantidades de diferentes tipos de movimientos sean 3 o 4 o 5 o los que la empresa desee agregar.

3. Se elimino la relacion entre los movimientos y el estado de Cuenta esto para evitar varios problemas como el que se permitan nulos en ese fk puesto que a la hora de insertar un movimiento este no esta relacionado directamente al estado de cuenta hasta el momento que se genera el mismo y tambien porque se puede acceder a los movimientos de cada estado de cuenta atravez del FK_Cuenta que tiene cada estado de cuenta y con este atributo se puede obtener los datos de cada movimiento.

-------------------------------------------------------------------------------------------------------------------------

Se creo la estructura utilizada para el archivo de datos generales el cual sera de tipo TXT para este proyecto , ademas se busco informacion sobre los archivos JSON para poder crear de la mejor manera los archivos de Cuentas y Movimientos, la informacion de la misma fue obtenida de los siguientes links :

http://tarjuccino.com/tutoriales/programacion-web/introduccion-a-json/

http://es.wikipedia.org/wiki/JSON

http://www.json.org/json-es.html

http://blog.openalfa.com/introduccion-al-formato-json

https://www.youtube.com/watch?v=pkZV8Vuvu28

y con toda la informacion recopilada se creo un concepto claro sobre lo que es un archivo JSON y sobre como es su formato y ya se tenia todo lo necesario para poder comenzar en un futuro cercano con la elaboracion de los archivos para la base de datos.
--------------------------------------------------------------------------------------------------------------------------

Horas trabajadas : 

3 horas 15 minutos


Participantes:

Jonathan Salazar Garcia
Luis Ricardo Gutiérrez