Video 2: Cómo Crear una plantilla para Generar Procedimientos Almacenados

Video 2: Cómo Crear una plantilla para Generar Procedimientos Almacenados A continuación se detallará paso a paso el proceso para generar Procedimientos Almacenados (SQL Stored Procedures) con Amonsys Software Factory. Un video sobre los pasos descritos en este documento puede ser encontrado en /Videos/How-To-Create-A-Template-To-Generate- Microsoft-SQL-Server-Stored-Procedures.html Antes de crear la plantilla deberemos contar con un código objetivo, el código objetivo es la salida que deseamos generar o el proceso que deseamos automatizar. En este caso usaremos un Procedimiento Almacenado preexistente que sirve para actualizar la tabla Categories de la base de datos Northwind de Microsoft SQL Server, usted puede utilizar su propio Stored Procedure para realizar este tutorial. ------------------------------------------------ -- Creado por: Daniel Andrade -- Fecha de Creacion: 11/SEP/2009 ------------------------------------------------ CREATE PROCEDURE [dbo].[categories_update] ( @CategoryID int, @CategoryName nvarchar(15), @Description ntext, @Picture image ) AS Update [dbo].[categories] Set CategoryName = @CategoryName, Description = @Description, Picture = @Picture Where CategoryID = @CategoryID

Los pasos a seguir son los siguientes: 1. Abrir Amonsys Software Factory. 2. Cree un nuevo proyecto dando clic derecho sobre el nodo raíz del Explorador de Plantilla (Template Explorer), esta raíz tiene por Nombre AMONSYS, luego seleccione la opción Add->New Project Se mostrará una ventana de dialogo solicitando el nombre y Ubicación del proyecto, en Nombre escriba Example. 3. Una buena práctica para conservar el orden dentro de nuestros proyectos es utilizar Carpetas para agrupar funcionalidad común. Para realizar esto debe dar clic derecho sobre la raíz del proyecto (Example) y seleccionar la opción Add->New Folder

Se le mostrará una venta de Dialogo solicitando el nombre de la carpeta, en este caso la llamaremos StoredProcedures. 4. Cree una nueva plantilla, esta servirá para generar el procedimiento Almacenado (Nuestro código Objetivo). Para realizar esto de clic derecho sobre la carpeta creada en el paso anterior (StoredProcedures) y seleccione la opción Add->New Template Se le mostrará una venta de dialogo solicitando el nombre de la plantilla, en este caso la llamaremos SP_Update

5. Abra la plantilla creada en el paso anterior para editarla. Para realizar esto de doble clic sobre el nodo de la plantilla creada (SP_Update.amst). Se abrirá la Vista Template, en este lugar procederemos a pegar nuestro código Objetivo. 6. Analizando nuestro código objetivo nos podemos dar cuenta que el nombre del procedimiento está compuesto por el nombre de la tabla seguido del postfijo _Update. Debido a lo anteriormente mencionado necesitaremos agregar una propiedad del tipo Table a nuestra plantilla para contar con la funcionalidad necesaria para leer la metada de las tablas.

Para realizar esto nos vamos a la Vista Properties y arrastramos una propiedad Table desde del ToolBox al contenedor de propiedades. Aparecerá un cuadro de diálogo solicitando ingresar información sobre la propiedad creada. En el campo Nombre digitaremos table y luego clic en OK.

7. Ahora que tenemos la propiedad del tipo Table creada vamos a la Vista Template Code Behind para crear el método que devolverá el nombre del Procedimiento Almacenado. En esta vista agregaremos la siguiente porción de código: public string GetSPName() return "["+this.table.scheme+"].["+this.table.name + "_Update]"; 8. Regresamos a la Vista Template y sustituimos el nombre del Procedimiento Almacenado [dbo].[categories_update] por la llamada al método creado <%=this.getspname()%>. La sentencia <%= %> son Tags que indican que al ejecutar la plantilla esa sección se sustituirá por una cadena de texto que puede provenir como en el ejemplo actual de una llamada a un método del Template Code Behind o podría provenir también de una lectura de alguna propiedad de la plantilla. 9. A continuación compile la plantilla con Shift + F6 o desde el menú principal. Si la compilación de la plantilla fue exitosa vaya a la Vista Preview para ejecutar o previsualizar la plantilla. Le aparecerá un mensaje informándole que tiene que asignar todas las propiedades de la plantilla y le preguntará si desea hacerlo ahora.

10. Damos clic en SÍ y se desplegará un cuadro de dialogo mostrándole las propiedades de la plantilla para que sean asignadas. Para nuestro ejemplo tenemos que asignar la tabla que utilizará la plantilla. 11. En el cuadro de dialogo anterior damos clic en el botón y nos aparecerá un cuadro de dialogo para seleccionar o crear una conexión a la Base de Datos.

12. Si no tenemos la conexión creada damos clic en el botón Create New para crear una nueva conexión. Se desplegará un cuadro de dialogo para ingresar los datos de conexión. En este cuadro de dialogo ingrese la siguiente información: i) DataSource: SQL Server Provider for Microsoft SQL Server 2000 o higher. ii) Server Name: El nombre de la instancia donde se encuentra la base de datos. iii) Ingresar el User Name y Password en el caso de autenticación SQL y dar clic en OK.

13. Aparecerá una nueva ventana de Dialogo con todas las tablas de la base de Datos seleccionada. En esta ventana debe seleccionar la tabla que desea que utilice la plantilla, en nuestro ejemplo seleccionaremos la tabla Region y luego daremos clic en OK 14. Para probar o visualizar lo que hemos hecho hasta ahora vaya a la Vista Preview. La plantilla se ejecutará y mostrará un informe de ejecución como el siguiente.

Y la salida será: 15. Ahora que nuestro nombre de Procedimiento Almacenado ya se genera dinámicamente según la tabla seleccionada lo siguiente que debemos hacer es programar la plantilla para generar los parámetros del Stored Procedure. Analizando la sección de código correspondiente a los parámetros de entrada del SP nos damos cuenta que cada línea está compuesta por el prefijo @ seguido del nombre del campo, luego se encuentra el tipo de dato del campo y una coma al final. Este formato se repite en todas las líneas a excepción de la última que no lleva coma al final. 16. Vamos a crear el método que genere los parámetros de entada del SP, para esto vaya a la Vista Template Code Behind para escribir el método que devolverá el código deseado. public string GetSPParameters() string code=""; foreach(ndk.amonsys.engine.amonsyscolumn col in table.columns) code+= "\t@"+col.name + " "+col.declaredatastring + ","+Environment.NewLine; if(code.length>0) code=code.substring(0,code.length-3); return code; 17. Al igual que en los pasos anteriores, luego de crear el método vamos a la Vista Template y sustituimos el texto de los parámetros de entrada del SP por la

llamada a nuestro método <%=this.getspparameters() %> luego de la sustitución debería tener algo como lo siguiente: 18. Para Previsualizar la salida de la plantilla o ejecutarla vaya nuevamente a la Vista Preview. Se le debería generar algo como lo siguiente: 19. Si desea probar con otra tabla, ubíquese en la Vista Template y vaya a las propiedades de la plantilla. En la propiedad table de clic sobre los 3 puntos ( ). Le saldrá el cuadro de dialogo en donde podrá seleccionar la nueva tabla con la que desea trabajar. Nota: También puede cambiar la tabla a utilizar estando en la Vista Preview y dar click en el botón ejecutar de la parte superior para actualizar el contenido de la vista. 20. Lo siguiente que debemos hacer en la plantilla es crear un método que devuelva el nombre de la tabla. Para esto vamos a la Vista Template Code Behind y creamos un método llamado GetTableName. Por comodidad vamos a copiar el método que creamos anteriormente llamado GetSPName y lo modificaremos para que quede de la siguiente manera: public string GetTableName() return "["+this.table.scheme+"].["+this.table.name+ "]";

21. Regresamos a la Vista Template y sustituimos el nombre de la tabla a actualizar Update [dbo].[categories] por Update <%=this.gettablename() %> 22. Para visualizar la salida o ejecutar esta plantilla vaya a la vista Preview. Deberá ver algo como lo siguiente: 23. Repitamos los mismos pasos anteriores ahora con respecto a la parte de actualización de campos de la tabla. Para realizar esto crearemos un método en la Vista Template Code Behind similar al método GetSpParameter, lo llamaremos GetUpdateFields y contendrá lo siguiente: public string GetUpdateFields() string code=""; foreach(ndk.amonsys.engine.amonsyscolumn col in table.columns) code+= "\t\t "+col.name + "= @"+ col.name + ","+Environment.NewLine; if(code.length>0) code=code.substring(0,code.length-3); return code;

24. Regresamos a la Vista Template y sustituimos los parámetros de actualización por <%=this.getupdatefields() %> 25. Para visualizar la salida o ejecutar esta plantilla vaya a la Vista Preview. 26. Para finalizar la creación de la planilla nos hace falta la condición del where, que está en el Stored Procedure. En nuestro ejemplo, en el where se encuentran los campos de la clave primaria de la tabla, con esto en mente debemos crear un método que nos devuelva esta sentencia Where. Para hacer esto vamos a la Vista Template Code Behind y creamos un método llamado GetWhere con el siguiente código: public string GetWhere() string code=""; foreach(ndk.amonsys.engine.amonsyscolumn col in table.columns) if(col.ispk) code+= "\t\t "+col.name + "= @"+ col.name + " AND"+Environment.NewLine; if(code.length>0) code=code.substring(0,code.length-6); return code;

27. En la Vista Template sustituimos los parámetros de la condición del where por <%=this.getwhere() %> 28. Para visualizar la salida o ejecutar la plantilla vaya a la Vista Preview. 29. Con los pasos anteriores ya tenemos todo lo necesario para crear el SP pero para dale los último toques podemos hacer dinámica la asignación del nombre de Autor y la Fecha de creación. Para esto tenemos que crear una propiedad del tipo String en la Vista Properties, una vez hecho agregada la propiedad procedemos a darle un nombre que en nuestro caso será Author.

30. Luego vamos a la Vista Template y sustituimos el encabezado por lo siguiente: ----------------------------------------------------------------------------------------- --Creado por: <%= this.author %> --Fecha de Creacion: <%= System.DateTime.Now.ToString("dd/MMM/yyyy") %> ----------------------------------------------------------------------------------------- 31. Para visualizar la salida o ejecutar la plantilla vaya a la Vista Preview 32. Como podrá darse cuenta no aparece nada en autor, esto se debe que no hay un valor asignado para la propiedad Author. Para asignarla vamos a la ventana de propiedades y escribiremos el nombre del autor del SP, para nuestro ejemplo pondremos Amonsys, usted puede colocar su nombre como Autor para que aparezca en el encabezado. Luego damos clic en el botón de Ejecutar para compilar la plantilla y ver el resultado. 33. Felicidades!!!, si siguió los pasos anteriores ya tiene programada la plantilla para generar el SP. Ahora solo faltaría hacer que se cree el SP en la base de datos automáticamente.

Para ejecutar el script del SP generado automáticamente utilizaremos un método que se encuentra implementado en la clase base de la cual descienden todas las plantillas llamado SaveStoredProcedure el cual recibe los siguientes 3 parámetros: La conexión a la Base de Datos, esta puede ser obtenida de la propiedad del tipo Table mediante su atributo Connection. El nombre del Procedimiento Almacenado, este es obtenido a partir del método GetSPName creado en los pasos anteriores. El Script del Procedimiento Almacenado, este se obtiene a partir de salida de la plantilla que la cual es dada por propiedad de la plantilla base llamada TemplateOutput. Para crear el método que cree el SP automáticamente debemos ir a la Vista Template Code Behind y crear un método al cual llamaremos SaveSP, este método será el encargado de llamar a SaveStoredProcedure de la plantilla base. El código de este método contendrá lo siguiente: public void SaveSP() string spname=this.getspname(); this.savestoredprocedure(this.table.connection, spname, this.templateoutput.tostring()); 34. En la Vista Template debemos realizamos la llamada al método creado en el paso anterior. Para realizar esto agregamos al final de la plantilla lo siguiente: 35. Damos clic en la vista Template o en el botón de Execute Template para ejecutar la plantilla.

36. Verificamos que el Procedimiento Almacenado se creó en labase de Datos. ANTES DE EJECUTAR LA PLANTILLA DESPUES DE EJECUTAR LA PLANTILLA

Cómo Crear una plantilla principal que llame a nuestra plantilla creada anteriormente En la mayoría de los casos, se desea contar con un proceso que pueda ejecutar varias plantillas de una sola vez en lugar de ejecutarla una a una. Para estos casos deberemos crear una plantilla principal que se encargue de pasarle los parámetros necesarios al resto de plantillas. A continuación se muestra cómo crear una plantilla principal que ejecute la plantilla anteriormente creada para una colección de tablas seleccionadas. 1. Cree una nueva plantilla, para efecto de seguir con el ejemplo del video la llamaremos Main. 2. Vamos a la Vista Properties y agregamos una propiedad del tipo TableCollection y la llamaremos Tables.

Para ejecutar la plantilla creada anteriormente también necesitamos agregar una propiedad llamada Author del tipo String 3. En la Vista Template CodeBehind creamos un método llamado GenerateStoredProcedures, este método utilizará la colección de tablas seleccionadas y se la pasará como parámetro a la plantilla SP_Update que creamos en la sección anterior. La plantilla SP_Update creada anteriormente tiene 2 propiedades que son Table y Author, estas propiedades necesitan ser asignadas antes de ejecutar la plantilla. Cada interacción debe crear un objeto del tipo TemplateProperties para poder asignar las propiedades de la plantilla. Esto se hace de la siguiente manera: private void GenerateStoredProcedures() foreach(ndk.amonsys.engine.amonsystable table in this.tables) Example.SP_Update.TemplateProperties updateprop=new Example.SP_Update.TemplateProperties(); updateprop.author=this.author; updateprop.table=table; Example.SP_Update.Execute(updateProp);

4. Regresamos a la Vista Template de la plantilla Main y colocamos la llamada al método creado en la paso anterior. 5. Damos clic sobre la Vista Preview para ejecutar la plantilla, y elegimos las tablas para las cuales deseamos generar Procedimientos almancenados.

6. Para finalizar Verificamos que los Procedimientos Almacenados se hayan creado en la base de datos. ANTES DE EJECUTAR LA PLANTILLA DESPUES DE EJECUTAR LA PLANTILLA

Anexo A: Código de la plantilla SP_Update A continuación encontrará el código de la plantilla SP_Update: Vista Template: ---------------------------------------------------------------------- ------------------- --Creado por: <%= this.author %> --Fecha de Creacion: <%= System.DateTime.Now.ToString("dd/MMM/yyyy") %> ---------------------------------------------------------------------- ------------------- CREATE PROCEDURE <%= this.getspname() %> ( <%= this.getspparameters() %> ) AS Update <%=this.gettablename() %> Set <%=this.getupdatefields() %> Where <%= this.getwhere()%> <% this.savesp(); %> Vista Template Code Behind: using System; using System.Collections.Generic; using NDK.Amonsys.SDK; namespace Example public class SP_Update public static string GetTemplateName() return "SP_Update"; public string GetSPName()

return "["+this.table.scheme+"].["+this.table.name + "_Update]"; public string GetSPParameters() string code=""; foreach(ndk.amonsys.engine.amonsyscolumn col in table.columns) code+= "\t@"+col.name + " "+col.declaredatastring + ","+Environment.NewLine; if(code.length>0) code=code.substring(0,code.length-3); return code; public string GetTableName() return "["+this.table.scheme+"].["+this.table.name+ "]"; public string GetUpdateFields() string code=""; foreach(ndk.amonsys.engine.amonsyscolumn col in table.columns) code+= "\t\t "+col.name + "= @"+ col.name + ","+Environment.NewLine; if(code.length>0) code=code.substring(0,code.length-3); return code; public string GetWhere() string code=""; foreach(ndk.amonsys.engine.amonsyscolumn col in table.columns) if(col.ispk) code+= "\t\t "+col.name + "= @"+ col.name + " AND"+Environment.NewLine; if(code.length>0) code=code.substring(0,code.length-6); return code;

public void SaveSP() string spname=this.getspname(); this.savestoredprocedure(this.table.connection, spname, this.templateoutput.tostring()); Anexo B: Código de la plantilla Main A continuación encontrará el código de la plantilla Main: Vista Template: <% GenerateStoredProcedures(); %> Vista Template Code Behind: using System; using System.Collections.Generic; using NDK.Amonsys.SDK; namespace Example public class Main public static string GetTemplateName() return "Main"; private void GenerateStoredProcedures() foreach(ndk.amonsys.engine.amonsystable table in this.tables) Example.SP_Update.TemplateProperties updateprop=new Example.SP_Update.TemplateProperties(); updateprop.author=this.author; updateprop.table=table; Example.SP_Update.Execute(updateProp);