La versión de SQL Server 2008 trajo consigo muchísimas novedades. De entre todas las que podríamos considerar enfocadas al desarrollo, he creído interesante hablar de dos de ellas, que combinadas consiguen un resultado bastante más que interesante en la mayoría de situaciones. En este artículo, veremos como plantear una solución óptima de modificación de datos utilizando las características “TVP” (parámetros de tabla) y la sentencia MERGE. Cada una de las dos, por si solas son interesantes para proporcionar solución a determinados problemas, pero juntas nos dan la posibilidad de escribir un código que además de sencillo y limpio, es realmente eficiente desde el punto de vista de la escalabilidad.

En la realización de este artículo he contado con:

SQL Server 2008 R2

La solución es compatible con SQL Server 2008

Powershell 2.0 sobre Windows Server 2008 R2

La razón de utilizar Powershell no es otra que la de dar la opción al lector de realizar rápidamente las pruebas que crea convenientes sin disponer de código compilado ni un compilador cerca. Se sobreentiende que el lenguaje de programación de la aplicación cliente es indiferente.

Sql Server Native Client 2008 o superior.

Puesto que vamos a hacer uso de características propias de SQL Server 2008, si nuestra instancia de SQL Server no se encuentra en local, debemos cerciorarnos que disponemos de los drivers de conexión a SQL Server instalados en el equipo que contiene el código de aplicación cliente.

Problemática a resolver

El tipo de problemas que pretendemos resolver con estas características es ampliamente conocido: Mi aplicación quiere propagar “n” modificaciones a mi base de datos.

Un caso típico de esta situación lo podemos ver resumido así:

  1. Aplicación posee estructura en memoria con la información a procesar
    Por ejemplo, internamente existe un DataTable con “n” filas gestionadas por nuestra aplicación
  2. Usuario modifica la información (usa la aplicación y cambia ciertos valores)
    Esto implicaría que por ejemplo, el código de nuestra aplicación modificará nuestro DataTable en memoria. Todavía no propagamos datos.
  3. Después de realizar cualquier acción más, el usuario pulsa sobre el botón “Guardar”
    Esto implicaría que todos los cambios realizados al DataTable sean propagados a nuestra base de datos.

Como vemos, el problema a resolver es muy común.

Planteamiento de la solución

Lo habitual en estos casos es que nuestra aplicación, mande “n” peticiones de actualización a nuestra base de datos. Tantas peticiones de actualización, como filas en nuestro DataTable tengamos. Esto quiere decir, que para cada una de esas llamadas, SQL Server va a tener que realizar un procesamiento, que en el mejor de los casos será el siguiente (simplificando):

  1. Capa de acceso a datos de aplicación detecta que nuevas filas deben insertarse
  2. Capa de acceso a datos de aplicación envía “n” operaciones “insert”
  3. Capa de acceso a datos de aplicación detecta qué filas han sido actualizadas
  4. Capa de acceso a datos de aplicación envía “n” operaciones “update”
  5. Capa de acceso a datos de aplicación detecta qué filas han sido eliminadas
  6. Capa de acceso a datos de aplicación envía “n” operaciones “delete”

Por su parte, SQL Server va a tratar a todas y cada una de esas operaciones, de forma independiente. Esto quiere decir que por ejemplo cuando lanza una actualización o un borrado, al no disponer del resto de filas a actualizar y borrar, no podrá plantearse una estrategia de bloqueos óptima. Quiero decir con esto, que cada operación es independiente del resto y por lo tanto SQL Server las tratará como tal.

¿Qué son los TVP o parámetros de tabla?

Los parámetros de tabla ó TVP (Table-valued parameters) son un nuevo tipo de parámetro que apareció en SQL Server 2008. Estos parámetros se declaran como tipos de datos tabla definidos por el usuario y puedes utilizarlos para enviar múltiples filas desde una instrucción T-SQL, procedimiento o función sin necesidad de crear una tabla temporal o realizar cualquier estrategia diferente.

Debido a su naturaleza, los escenarios típicos de uso en los que tienen aplicación directa son:

  • Actualización en lotes del servidor
  • Parámetros en lote para usar en consultas
  • Pasar una tabla entre rutinas
  • Migración de otros motores de bases de datos

Esto quiere decir que están pensados para resolver soluciones que impliquen enviar gran cantidad de datos al servidor y para facilitar un procesamiento lógico en el mismo, previo a una actualización de datos persistente. Justo lo que buscamos en nuestro caso puesto que gracias a esta característica, vamos a poder enviar datos tabulares entre ambos extremos (cliente y servidor), lo cual nos va a facilitar el trabajo por conjuntos de resultados ya que en lugar de procesar fila a fila, vamos a poder realizar soluciones orientadas a conjuntos de filas (una única petición de actualización por tanto):

El uso de los parámetros de tabla lo podemos resumir en:

  • Empaquetado de la lógica de negocio
    • Ejecutar lógica de negocio en el servidor
  • Mejor modelo de programación
  • Operaciones basadas en conjuntos
  • Transporte de datos eficiente
    • Se pueden enviar datos ordenados por clave única para optimizar el procesamiento
  • Reducción de viajes de ida y vuelta al servidor
    • Pueden enviarse múltiples lotes para conseguir un buen balance concurrencia/rendimiento
      Esto es recomendable analizarlo puesto que dependiendo del tipo de operación a realizar, en ocasiones es mejor dividir el procesamiento y en lugar de una única llamada con 100.000 filas, conviene realizar 10 de 10.000 por ejemplo. Cada escenario es diferente, pero en la siguiente tabla (que proviene de los libros en pantalla de SQL Server) se puede ver una comparativa para situarnos.
  • Tipado de datos fuerte
    • Tipo de datos seguro: Intercambiado con el servidor
    • Información de tipos compleja, fácil de utilizar y sin impactos de rendimiento

 

¿Qué es la cláusula MERGE?

La cláusula Merge, no es solo una cláusula DML normal, podemos verla como una “super-cláusula” DML. Gracias a ella, se pueden realizar en una única instrucción: inserción, borrado y actualización de un conjunto de datos. El propósito para el que vamos a querer utilizar esta cláusula será entonces para optimizar las cargas de datos provenientes de nuestra capa de acceso a datos de la aplicación.

Sin entrar en detalles, la cláusula MERGE podemos seccionarla en 5 partes con la que construir nuestra “super-cláusula”:

MERGE

Especifica el objetivo a actualizar

USING

Especifica la fuente de información

ON

Especifica la unión entre la fuente y el destino

WHEN

Especifica las acciones a acometer mediante reglas MATCH

(INSERT, UPDATE, DELETE)

OUTPUT

Cláusula opcional, que devuelve valores de información nuevos y antiguos usando los objetos “inserted“ y “deleted“

Las ventajas más interesantes de la cláusula MERGE para nuestro propósito son:

  • Permite actualizar nuestros datos conociendo el bloque completo a modificar. Gracias a esta información, será capaz de generar planes de ejecución basados en el lote completo puesto que tiene información de qué rango de filas van a ser modificados de golpe.
  • Nos permitirá especificar el nivel de detalle que queramos en la propia cláusula.

De esta forma, podremos evitar actualizar información que no haya sido modificada por ejemplo, sin hacer uso de bifurcadores de código T-SQL ni estructuras similares.

  • Podremos devolver a la aplicación cliente si lo deseamos, el conjunto de acciones que finalmente se ha realizado, así como el valor anterior y posterior a la modificación. (ver palabra reservada $action en la descripción de la cláusula MERGE)

 

Ejemplo práctico

Como ejemplo práctico, vamos a resolver la problemática de obtener los eventos de inicio y apagado de un equipo. Este escenario nos viene bien para ilustrar la solución, puesto que los datos de inicio-fin varían poco, y podemos mandarlos siempre de nuevo al servidor y ahí tratar solo con la información nueva. Recordemos que es un ejemplo de demostración, obviamente cada problemática puede ser diferente pero la esencia es:

  • Aplicación cliente posee información a actualizar al servidor
  • A priori no sabemos qué información se actualizará ni como
  • Deseamos aprovechar las nuevas capacidades de SQL Server 2008 para conseguir un proceso mas escalable

En este caso particular, en principio, podríamos pensar que podemos gestionar nosotros mismos los cambios. Obviamente esto es así y para ello deberíamos conocer el último evento que existe almacenado y solo enviar los nuevos…pero eso no es lo que queremos ahora mismo mostrar en este ejemplo. En este ejemplo, aprovecharemos TVP y MERGE para enviar todos los eventos de nuevo y gestionarlos en el procedimiento almacenado para descartar los ya existentes. Estamos por tanto, viendo el escenario que comentábamos al principio: “la aplicación modifica DataTable y envía todo”.

Evidentemente, si solo enviamos los cambios, pues la ganancia será mayor.

 

El código del lado del servidor SQL Server

Lo primero será por tanto crear la tabla donde almacenaremos la información. Esta será muy sencilla:

insert_date: Esto nos vendrá bien para saber cuándo se insertó esta fila. En principio irrelevante, pero quizás algún día resulte útil

server_name: Nombre del equipo

event_type: Tipo de evento: capturaremos inicio y fin

event_time: Hora del evento

Create table
  1. create table dbo.WindowsStartAndStopEvents
  2. ( insert_date smalldatetime not null default(getdate()),
  3.   server_name varchar(255) not null,
  4.   event_type varchar(255) not null,
  5.   event_time datetime2 not null)
  6. go

Ahora, crearemos un índice agrupado, que cubrirá las futuras consultas que queremos hacer (no llegaremos a esa parte en este artículo, pero está bien crearlos):

  1. create clustered index ci_WindowsStartAndStopEvents on dbo.WindowsStartAndStopEvents(server_name,event_type)
  2. go

Preparándonos para el procedimiento almacenado que recibirá por parámetro un tipo tabla, lo siguiente que deberemos hacer es crearnos dicho tipo de datos tabla que queremos que nuestro futuro procedimiento almacenado reciba. En este caso, vamos a crear un tipo tabla con las mismas columnas que nuestra tabla destino previamente creada (sobra decir que la columna insert_date no es necesario asignarla puesto que su valor se asigna en el momento de la inserción gracias a que hemos especificado un valor por defecto).

Create user table type
  1.   CREATE TYPEdbo.WINDOWS_EVENT_TYPE as table (
  2.             server_name varchar(255) not null,
  3.             event_type varchar(255) not null,
  4.             event_time datetime2 not null
  5. )
  6. GO

En este momento, podemos ver que dicho tipo de datos ha sido creado y podremos declarar variables con él, como si se tratara de un tipo de datos definido por usuario más:

image_thumb_1_33E89774

Prueba de concepto
  1. declare @ejemplo dbo.WINDOWS_EVENT_TYPE
  2. insert into @ejemplo values (‘server_name’,‘event_type’,‘20110101’)
  3. select * from @ejemplo

image_thumb_2_33E89774

Ahora, el código de nuestro procedimiento almacenado, utilizará como parámetro dicho tipo de datos tabla, que obviamente nuestra aplicación enviará relleno:

Procedimiento almacenado
  1. create procedure dbo.insert_WindowsStartAndStopEvents @windows_event_table WINDOWS_EVENT_TYPE READONLY
  2.   as
  3. begin
  4.     MERGE  dbo.WindowsStartAndStopEvents as target
  5.     USING @windows_event_table as source
  6.     ON   target.server_name = source.server_name
  7.         and target.event_type = source.event_type
  8.         and target.event_time = source.event_time
  9.     WHEN NOT MATCHED THEN
  10.         INSERT (server_name,event_type,event_time)
  11.         values (source.server_name,source.event_type,source.event_time)    
  12.     ;
  13. end
  14. go

Si recordamos el problema que queremos solucionar, sabemos que estamos enviando eventos que no varían, junto con eventos nuevos. En ese escenario concreto, solo nos interesa conocer qué filas existen en origen (lo que nuestra aplicación envía) que no existen en destino (la tabla llamada dbo.WindowsStartAndStopEvents). Por lo tanto, solo debemos crear una sección WHEN NOT MATCHED en la que indiquemos que la acción será insertar las filas del origen en el destino.

Por otro lado, en este escenario no nos interesa cubrir acciones de modificación de filas ni eliminación, porque sabemos de antemano el tipo de información que enviaremos (solo incremental). Cada problema es diferente, pero se solucionará adaptando la sentencia MERGE a cada caso particular. Otra solución podría pasar por crear un código tipo “INSERT … FROM SELECT”, pero lo interesante es ver que en este caso simplemente adaptando la sentencia MERGE, podemos dar solución a cualquier escenario.

El código del lado cliente

Como se puede leer en la introducción del artículo,, la razón de crear código powershell no es otra que el lector pueda realizar las pruebas en un entorno interpretado, sin necesidad de compilar código .NET. En cualquier caso, se han utilizado objetos ADO.NET desde powershell, para que la metodología sea similar (mismos métodos y objetos) a la de utilizar cualquier lenguaje .NET.

Codigo aplicacion cliente
  1. #  Enrique Catalá Bañuls:
  2. #   Código de ejemplo para obtener los eventos de inicio y fin de servicio de SQL Server efectivos.
  3. #
  4. # Esta función crea una cadena de conexión contra SQL Server
  5. #
  6. function getStringConnection([string]$instanceName,[string]$user,[string]$pass,[string]$database)
  7. {    
  8.     if(($user ne $null -and $user ne ») -and ($pass ne $null -and $pass ne »))    
  9.     {
  10.         $strCon=«Data Source=$instanceName;User ID=$user;Password=$pass;Integrated Security=TRUE;Initial Catalog=$database»
  11.     }
  12.     else
  13.     {
  14.         $strCon=«Data Source=$instanceName;Integrated Security=TRUE;Initial Catalog=$database»
  15.     }
  16.     return $strCon
  17. }
  18. # nos viene bien tener un nombre de instancia bien dado (nombremaquinanombreinstancia)
  19. #
  20. function getInstanceName([string]$ProviderName)
  21. {
  22.    if($ProviderName eq «MSSQLSERVER»)
  23.    {
  24.       $retorno = $Env:computername
  25.    }
  26.    else
  27.    {
  28.      $retorno = $Env:computername+«»+$ProviderName.Substring($ProviderName.IndexOf(‘$’)+1)
  29.    }
  30.    return $retorno
  31. }
  32. ##
  33. ## MAIN BODY
  34. ##
  35. try
  36. {
  37. # Asigno la instancia y el nombre de BBDD donde he creado los objetos anteriores
  38. #
  39. $instance=«(local)sql2008r2»
  40. $catalog=«tempdb»
  41. # Obtenemos los eventos interesantes de SQL Server para nuestro ejemplo:
  42. #   17126: Evento que indica que SQL Server ya acepta conexiones entrantes (está online)
  43. #   17147: Evento que indica que SQL Server ha dejado de aceptar conexiones (está offline oficialmente)
  44. #
  45. $events= GetWinEvent FilterXml «
  46. <QueryList>
  47.   <Query Id=’0′ Path=’Application’>
  48.     <Select Path=’Application’>*[System[(Level=4 or Level=0 or Level=5) and (EventID=17126 or EventID=17147)]]</Select>
  49.   </Query>
  50. </QueryList>»  | SortObject Property «TimeCreated»
  51. # Creamos un objeto DataTable que contendrá la información que simulamos nuestra aplicación gestionará.
  52. # Obviamente, debe cumplir el esquema del tipo de datos definido anteriormente que hemos llamado WINDOWS_EVENT_TYPE
  53. #
  54. $table = NewObject system.Data.DataTable «$TableName»
  55. $col0 = NewObject System.Data.DataColumn InstanceName,([string])
  56. $col1 = NewObject system.Data.DataColumn Type,([string])
  57. $col2 = NewObject system.Data.DataColumn Date,([datetime])
  58. #Añadimos las columnas al objeto DataTable
  59. #
  60. $table.Columns.Add($col0)
  61. $table.columns.add($col1)
  62. $table.columns.add($col2)
  63. # Ahora simplemente, recorremos la lista de eventos y dependiendo del tipo de evento,
  64. # indicaremos qué haremos con el
  65. #
  66. foreach($event in $events){    
  67.     # Eventid 17126 is sql indicating that can accept connections
  68.     #
  69.     if($event.Id eq 17126){
  70.      $dr = $table.NewRow()
  71.      $dr[0]=getInstanceName $event.ProviderName
  72.      $dr[1]=«Started»
  73.      $dr[2]=$event.TimeCreated
  74.      $table.Rows.Add($dr)    
  75.     }
  76.     # Eventid 17147 is sql indicating stop event
  77.     #
  78.     elseif($event.Id eq 17147)
  79.     {
  80.      $dr = $table.NewRow()
  81.      $dr[0]=getInstanceName $event.ProviderName
  82.      $dr[1]=«Stoped»
  83.      $dr[2]=$event.TimeCreated
  84.      $table.Rows.Add($dr)    
  85.     }
  86. }
  87. # Una vez procesada la información, nos encontramos con que tenemos el DataTable listo
  88. # para mandar las actualizaciones a la Base de datos
  89. #
  90. $SqlServer = $instance
  91. $SqlCatalog = $catalog
  92. # Creamos el objeto SqlConnection y abrimos conexion
  93. #
  94. $SqlConnection = NewObject System.Data.SqlClient.SqlConnection
  95. $SqlConnection.ConnectionString = getStringConnection $instance $user $pass $catalog
  96. $SqlConnection.Open()
  97. # Indicamos qué procedimiento almacenado utilizaremos para inserter la información
  98. #
  99. $cmd = NewObject System.Data.SqlClient.SqlCommand(«dbo.insert_WindowsStartAndStopEvents»,$SqlConnection)
  100. $cmd.CommandType = [System.Data.CommandType]‘StoredProcedure’
  101. # Aqui está la magia: Indicamos que el parámetro @windows_event_table es un tipo de datos “Structured”
  102. # y le decimos que su valor es el objeto $table (el datatable)
  103. #
  104.   $parameter =$cmd.Parameters.AddWithValue(«@windows_event_table»,$table)
  105. $parameter.SqlDbType=[System.Data.SqlDbType]‘Structured’
  106. # Finalmente solo queda efectuar la llamada
  107. #
  108.     $cmd.executenonquery()
  109. # Y cerrar la conexión. Los datos se han procesado correctamente
  110. #
  111. $SqlConnection.Close()
  112. «Se han procesado correctamente los datos»
  113. }
  114. catch
  115. {
  116.   throw
  117. }

Conclusión

La ventaja de esta aproximación radica por un lado en la sencillez del código, que produce tanto un código cliente sencillo con una única instrucción, como un T-SQL que aglutina todas las acciones mediante la sentencia MERGE y la escalabilidad que produce eliminar de raíz el potencialmente elévalo número de peticiones al servidor, que independientemente deben resolverse.

Siguiendo esta metodología, podemos conseguir que nuestras operaciones de actualización sean más fáciles de tratar por SQL Server, dado que le proporcionamos la información en el formato para el que más está optimizado, los conjuntos.

 

Enrique Catalá

Enrique Catalá es Mentor en SolidQ, Microsoft Data Platform MVP desde 2013 e Ingeniero en informática. Es Microsoft Certified Trainer (MCT) y está centrado en el motor relacional SQL Server, tanto en la resolución de problemas de rendimiento y escalabilidad en sistemas OLTP como la definición e implementación de entornos de alta disponibilidad confiables, en donde ha llevado con éxito más de 100 proyectos no solo en España, sino en diferentes países como EEUU, Holanda, México, Arabia Saudí, Austria... Es el arquitecto principal de las soluciones para SolidQ llamadas HealthCheck, SQL2Cloud, SCODA y del generador de SSIS de SolidQ. Ponente habitual del SolidQ SUMMIT, miembro y ponente en SQL PASS tanto en España como Iberoamérica ponente en varios SQLSaturday

Latest posts by Enrique Catalá (see all)