WRITELOG

---

Ya ha pasado mucho tiempo desde la última entrada que escribí en este blog, lamentablemente hasta me había olvidado de él y lo había dejado de lado para atender otros temas.

He querido retomarlo con un tema que me resultó muy interesante y que significó en una que otra discusión álgida con otro proveedor de un cliente.

Sucede que el cliente estaba experimentando una lentitud muy importante en las transacciones de índole de escritura, es decir los queries del tipo INSERT, DELETE, UPDATE, MERGE, etc.

¿Qué es lo primero que hay que hacer?, darle una revisada a lo que se está ejecutando en este momento, analizar lo que lleva más tiempo ejecutándose y el tipo de bloqueo que está reportando.    Esta información la podríamos obtener con el siguiente query:

SELECT ER.session_id, DB_NAME(ES.database_id) AS database_name, DATEDIFF(SECOND, ER.start_time, GETDATE()) AS seconds_elapsed, ER.command, ES.host_name, ES.program_name, ES.host_process_id, ER.blocking_session_id, ER.wait_type
FROM sys.dm_exec_requests ER
INNER JOIN sys.dm_exec_sessions ES
ON ER.session_id = ES.session_id
WHERE ES.is_user_process = 1
AND ER.last_wait_type NOT IN ('BROKER_RECEIVE_WAITFOR', 'XE_TIMER_EVENT', 'XE_DISPATCHER_WAIT', 'XE_LIVE_TARGET_TVF', 'FT_IFTS_SCHEDULER_IDLE_WAIT')

Me encontré con que había una lista importante de queries en ejecución y cuya cantidad de segundos transcurridos ya estaba por encima de los 10 segundos.    Noté que el valor de la columna wait_type en casi todos los casos era "WRITELOG".

Si verificamos la documentación de este tipo de wait, encontraremos que está relacionado con el tiempo que le está llevando el escribir en el archivo de transacciones de las bases de datos, es decir que se está tardando en escribir en el sistema de almacenamiento.

Para confirmar la sospecha generé un medidor de rendimiento en el PerfMon y agregué el contador Physical Disk - Avg. Disk sec/Write seleccionando la unidad de almacenamiento donde se encontraban los archivos de registro de transacciones de las bases de datos.

¿Qué fue lo que encontré?, que la escritura le estaba tomando, en promedio, 170 milisegundos en ejecutarse.   ¡Sí!, 170 milisegundos; no perdamos de vista que el tiempo máximo de escritura y de lectura es de 15 milisegundos, es decir que estaban muy por encima del tiempo máximo aceptable.

Después de correos, revisiones, discusiones, reuniones y llamadas; el proveedor del sistema de almacenamiento encontró (y aceptó) que el sistema de almacenamiento estaba teniendo problemas y que solamente tenía que cambiar las unidades problemáticas.

Hay veces que le echarán la culpa a SQL porque es lo que ven y lo que percibe tanto el usuario final como el departamento de TI de nuestro cliente, pero es importante tener información sólida a la mano para determinar que el problema no es el motor sino algún recurso que necesita el motor para ejecutarse correctamente.

¡Saludos y que este 2024 esté lleno de salud y de trabajo!

---

CONVERT vs FORMAT

Hace poco estaba revisando el código T-SQL de un cliente y le comentaba que resulta un poco complicado el deducir qué formato de fecha se estará devolviendo al usuario cuando utiliza la función CONVERT, por ejemplo:

CONVERT(VARCHAR(10), GETDATE(), 23)

De forma inmediata recordé que existe la función FORMAT que hace mucho más legible el código. Si tomamos como base la expresión que anteriormente mencioné, su versión en FORMAT sería:

FORMAT(GETDATE(), 'yyyy-MM-dd')

Es evidente que es muchísimo más legible, y de manera inevitable me brincó la pregunta, ¿cuál de las dos opciones es mejor? Para responder a esta pregunta he preparado un ejercicio bastante sencillo, pero que nos ayudará a comprender la enorme diferencia.

Comencemos por crear nuestra tabla y llenarla con 500 mil registros:

CREATE TABLE TestFormat(
    Fecha DATETIME2(0)
)
GO
SET NOCOUNT ON
INSERT INTO TestFormat (Fecha)
VALUES (DATEADD(MINUTE, ABS(CHECKSUM(NEWID())) % 15768000, '1992-01-01 00:00:00'))
GO 500000


Vamos a comenzar por obtener las fechas en el formato yyyy-MM-dd con CONVERT y tomaremos los tiempos de ejecución.   Para tener una mejor perspectiva, ejecutaremos el ejercicio tres veces.

SET STATISTICS TIME ON
SELECT CONVERT(VARCHAR(10), Fecha, 23)
FROM TestFormat


Y después vamos a obtener el mismo formato pero utilizando la función FORMAT.   Al igual que en el ejercicio anterior, vamos a ejecutarlo unas tres veces para tener más datos de comparación.

SET STATISTICS TIME ON
SELECT FORMAT(Fecha, 'yyyy-MM-dd')
FROM TestFormat


La diferencia en las métricas es muy importante:

Ahora vamos a hacer el mismo ejercicio pero obteniendo la fecha y hora en formato yyyy-MM-dd HH:mm:ss.    Con CONVERT quedaría de la siguiente manera:

SET STATISTICS TIME ON
SELECT CONCAT(CONVERT(VARCHAR(10), Fecha, 23), ' ', CONVERT(VARCHAR(10), Fecha, 24))
FROM TestFormat


Y con FORMAT quedaría de la siguiente manera:

SET STATISTICS TIME ON
SELECT FORMAT(Fecha, 'yyyy-MM-dd HH:mm:ss')
FROM TestFormat


En la imagen siguiente podremos notar que el tiempo de CPU de CONVERT se incrementa y que el tiempo de CPU de FORMAT se mantiene muy parecido:

Pero ni con el incremento de tiempo de CPU en el formato yyyy-MM-dd HH:mm:ss nos acercamos al tiempo de CPU de FORMAT, porque FORMAT se ejecuta casi 10 veces más lento cuando incluimos la hora y casi 20 veces más lento cuando únicamente tenemos la fecha.

¿Qué factores debemos tomar en cuenta para entender estos datos?

1. FORMAT está implementada a través de un ensamblado de .NET, es decir que se está ejecutando de forma externa.
2. CONVERT se va al doble cuando hay que incluir la hora porque podemos ver que hay dos ejecuciones de la función, una para obtener la fecha y otra para obtener la hora.

La recomendación que te puedo hacer, es que en el código incluyan un comentario donde se indique el formato de fecha que se estará obteniendo, por ejemplo:

--yyyy-MM-dd HH:mm:ss
SELECT CONCAT(CONVERT(VARCHAR(10), Fecha, 23), ' ', CONVERT(VARCHAR(10), Fecha, 24))
FROM TestFormat


De esta forma será mucho más sencillo el darle mantenimiento al código porque podremos ver de forma inmediata lo que se está obteniendo.   La programación considerada no es una buena práctica, es una obligación.

Espero te haya resultado útil esta entrada.

PAGEIOLATCH_EX

---

He querido hacer esta entrada porque este tipo de wait es muy buscado, poco entendido y puede significar un dolor de cabeza.

El día de hoy recibimos el reporte de un cliente de que su sistema estaba sumamente lento, que la cantidad de timeouts estaba siendo insoportable y que estaba afectando seriamente la operación.

Al ingresar y visualizar la lista de sentencias que estaban en ejecución, notamos que la mayoría de ellas estaban con un wait del tipo PAGEIOLATCH_EX o del tipo PAGEIOLATCH_SH.

Primero, ¿qué diferencia existe entre un PAGEIOLATCH_XX y un PAGELATCH_XX?, es simple, el primer grupo se refiere a eventos de lectura y escritura desde el sistema de almacenamiento y el segundo se refiere a eventos de lectura y escritura sobre el buffer de datos de SQL Server.    En nuestro caso notamos que todas las esperas eran del tipo PAGEIOLATCH_XX.

Utilizando la función sys.dm_io_virtual_file_stats obtuvimos información acerca de los tiempos de espera para actividades de IO desde y hacia el sistema de almacenamiento por cada uno de los archivos de la base de datos del ERP.    El query utilizado fue el siguiente:

SELECT F.name, F.filename, FS.io_stall_read_ms / FS.num_of_reads END AS avg_read_wait_ms, FS.io_stall_write_ms / FS.num_of_writes AS avg_write_wait_ms
FROM sys.sysfiles F
CROSS APPLY sys.dm_io_virtual_file_stats(DB_ID(), F.fileid) FS

Los resultados que obtuvimos nos indicaron problemas catastróficos sobre la unidad de almacenamiento donde están ubicados los archivos de datos de la base de datos del ERP. Recordemos que el tiempo de espera ideal no debe de pasar de los 15 milisegundos.

El personal de infraestructura nos ayudó a verificar la situación actual del arreglo de discos y fue posible determinar que uno de los tres discos que formaban el RAID estaba dando muchos problemas, y es por ello que los tiempos de espera de lectura y escritura estaban por los cielos.

Se quitó el disco del arreglo y después de que pasó algún tiempo en lo que SQL terminaba de "calentar" la memoria, el rendimiento volvió a su estado óptimo.

Espero te resulte de utilidad esta información, nos vemos la siguiente.

---

Login failed for user 'X'

---

Hace bastante tiempo que no venía por aquí para compartir otra entrada en relación a SQL Server o .NET. Pero en esta ocasión la situación lo amerita, debido que un cliente me pidió solucionar un problema de conexión que jamás había visto en 18 años y me gustaría compartir lo que he ido haciendo para encontrar la solución.

Problema: No te puedes conectar con el SSMS a la instancia local utilizando autenticación de SQL Server, el mensaje que devuelve al momento de conectarse es el famosísimo:

Login failed for user 'X' (Microsoft SQL Server, Error: 18456)

Si abres la ventana para obtener mayor información del error te muestra:

Server Name: .

Error Number: 18456

Severity: 14

State: 1

Line Number: 65536

Y si vas al archivo ErrorLog de la instancia te encuentras algo así:

Logon       Error: 18456, Severity: 14, State: 8.

Logon       Login failed for user 'X'. Reason: Password did not match that for the login provided. [CLIENT: <local machine>]

Antes de que comiences a pensar en lo que podría ser, te comparto la configuración verificada:

1. Autenticación de SQL Server habilitada en la instancia y ésta ya fue reiniciada en cuanto fue aplicado el cambio.
2. Ya se verificó que la contraseña sea correcta, inclusive estableciendo la contraseña en el login copiando su valor desde un bloc de notas.
3. Debido a que la conexión es local, ya se verificó que el protocolo Shared Memory esté habilitado.
4. Service Pack 4 instalado sobre la instancia (SQL Server 2012) y aplicado también en el SQL Server Management Studio.

Pruebas que ya se realizaron y su resultado:

1. Conexión local utilizando sqlcmd y con autenticación de SQL: la conexión fue exitosa.
2. Conexión remota con SQL Server Management Studio y autenticación de SQL: la conexión fue exitosa. 

Con todo lo anterior podemos saber que el problema no es la autenticación debido a que sí se ha podido establecer una conexión tanto local como remota con autenticación de SQL Server.    El único lugar donde está fallando la conexión es en el SSMS local, ya se intentó por ".", "localhost" y por dirección IP, y el resultado siempre es el mismo.

Para poder averiguar un poco más de lo que podría estar haciendo el SSMS al momento de intentar iniciar la conexión con autenticación de SQL Server, utilizamos el procmon de sysinternals pero nada de lo que encontramos ayudó a intentar identificar el problema.

Releí el mensaje de error que se almacena en el archivo ErrorLog de la instancia y encontré algo extraño, que está reportando que la contraseña no es correcta para el login.    Lo que me parece súper extraño por lo siguiente:

• Si la contraseña la copio desde un bloc de notas y la pego en la línea de comandos con el sqlcmd, sí se conecta.
• Si la contraseña la copio desde un bloc de notas y la pego en la caja de texto de contraseña del SSMS, ¡no conecta!

La siguiente prueba que se me ocurrió fue cambiarle la contraseña al login "X" y ponerle una contraseña vacía, ¿y qué crees?, ¡SÍ CONECTÓ DESDE EL SSMS!

Lo anterior me lleva a pensar que por alguna muy extraña razón (y me parece extraña porque al momento de escribir esto la desconozco) la contraseña escrita en la caja de texto de la pantalla de ingreso del SSMS, está siendo alterada de alguna manera antes de llegar a SQL Server.

Para no dejar algo de lado y sin probar, se me ocurrió hacer un programa que pidiera servidor, usuario y contraseña para conectarse, en los framework 2.0, 3.5, 4 y 4.5.   Todas las pruebas fueron exitosas.

No encontré alguna referencia del lenguaje de programación utilizado para el SSMS 2012, no sé si fue hecho en C++ o en el .NET Framework.    Pero para verificar que no solamente fuera local el problema, generé un login en otro servidor de base de datos de pruebas y que está expuesto a la internet, hice la prueba de conexión ¡y no conectó!, el error reportado en el otro servidor es el mismo: Password did not match that for the login provided.

Esto comienza a preocuparme un poco más de lo normal, primero por la incertidumbre de no saber lo que está sucediendo, y segundo porque la contraseña que escribes en la caja de texto no es la misma que le está llegando al servidor destino, ¿habrá sido comprometido el servidor?, lo revisaré más a fondo para ver si encuentro algo extraño (sí, más)

En cuanto tenga más noticias, regresaré a actualizar esta entrada.

Se realizó una revisión de componentes del sistema operativo y también se corrió una revisión completa contra malware, ambas operaciones no reportaron problemas.

Lamentablemente, no se encontró otra alternativa que reinstalar el SQL Server Management Studio y el problema dejó de ocurrir.    Y pongo "lamentablemente" porque no me deja satisfecho la solución, pero el tiempo ya se tenía encima y no había forma de seguir investigando para encontrar el problema de raíz.

---

Leyendo RSS desde SQL Server

---

En esta entrada quiero abordar una forma en la que podemos obtener información de un RSS e integrarla a una base de datos.

Es común que haya información que resulte relevante o interesante para la operación de una empresa y ésta se encuentre disponible a través de fuentes RSS, el cual es un formato bien definido a través de un esquema XML que podemos encontrar en RSS 2.0 at Harvard Law.

Elegí esa dirección para mostrar el esquema del documento porque siento que la documentación ahí mostrada está ordenada de una forma muy sencilla de entender.

Para implementar una solución que nos permita obtener fuentes RSS necesitamos de un módulo que lea la información de la URL donde está ubicado el XML y posteriormente se lo dé a SQL Server para que tome el XML y lo convierta a una representación entidad-relación que es mucho más manejable.

Este proyecto lo dividiremos en los siguientes pasos:

1. Tomar una fuente RSS como muestra.
2. Crear un módulo en .NET que pueda ser integrado a SQL Server.
3. Crear un assembly en SQL Server y crear la función que devuelva la información contenida en la URL que reciba como parámetro.

URL de muestra

Tomaré como base el RSS de deportes del sitio web de ESPN, si abrimos la liga nos mostrará un XML con el contenido de la fuente.

Módulo de .NET

Voy a crear un proyecto del tipo Biblioteca de Clases en Visual Studio 2017 y lo llamaré SQLRSSReader, en él crearemos un par de clases:

1. RSSItem para representar cada entrada de la fuente RSS.
2. Lector para implementar la función que SQL Server llamará.

A continuación el código de RSSItem:

namespace SQLRSSReader
{
    public class RSSItem
    {
        public string Title { get; set; }
        public string Description { get; set; }
        public string Link { get; set; }
        public string PubDate { get; set; }
    }
}

Para exponer una función tabular a SQL Server, es necesario que se den las siguientes condiciones:

1. Tener el atributo SqlFunctionAttribute.
2. Pública y estática.
3. Devolver IEnumerable.
4. Los tipos de parámetros de entrada deben ser de SQL Server.

La función quedaría de la siguiente manera:

[SqlFunction(FillRowMethodName = "LlenarItem")]
public static IEnumerable ObtenerRSS(SqlString url)
{
    HttpWebRequest webRequest = HttpWebRequest.Create(url.Value) as HttpWebRequest;
    HttpWebResponse webResponse = webRequest.GetResponse() as HttpWebResponse;
    List<RSSItem> result = null;

    using (StreamReader sr = new StreamReader(webResponse.GetResponseStream()))
    {
        XmlDocument xdRSS = new XmlDocument();
        xdRSS.LoadXml(sr.ReadToEnd());
        result = new List<RSSItem>();
        foreach (XmlNode xnItem in xdRSS.SelectNodes("/rss/channel/item"))
        {
            result.Add(new RSSItem()
            {
                Description = (xnItem.SelectSingleNode("./description") != null ? xnItem.SelectSingleNode("./description").InnerText : null),
                Link = (xnItem.SelectSingleNode("./link") != null ? xnItem.SelectSingleNode("./link").InnerText : null),
                PubDate = (xnItem.SelectSingleNode("./pubDate") != null ? xnItem.SelectSingleNode("./pubDate").InnerText : null),
                Title = (xnItem.SelectSingleNode("./title") != null ? xnItem.SelectSingleNode("./title").InnerText : null)
            });
        }
    }

    return result;
}

Lo que hace nuestra función es descargar el RSS, llenar una lista de objetos RSSItem y devolverla como resultado.

Notarás que el atributo SqlFunction tiene un parámetro llamado FillRowMethodName, en él se coloca el nombre de la función que se mandará a llamar para llenar la tabla resultante.    Por cada objeto que contenga IEnumerable se llamará a la función a la que apunta FillRowMethodName.

Ahora veamos la función LlenarItem:

public static void LlenarItem(object rssItemObject, out SqlString Title, out SqlString Description, out SqlString Link, out SqlString PubDate)
{
    RSSItem rssItem = rssItemObject as RSSItem;
    if (rssItem.Title != null)
        Title = new SqlString(rssItem.Title);
    else
        Title = SqlString.Null;
    if (rssItem.Description != null)
        Description = new SqlString(rssItem.Description);
    else
        Description = SqlString.Null;
    if (rssItem.Link != null)
        Link = new SqlString(rssItem.Link);
    else
        Link = SqlString.Null;
    if (rssItem.PubDate != null)
        PubDate = new SqlString(rssItem.PubDate);
    else
        PubDate = SqlString.Null;
}

Vamos a analizar los parámetros uno por uno:

1. rssItemObject.   Es donde recibiremos la instancia de RSSItem que se quiere operar en ese momento.
2. Title.    Primera columna de la tabla resultante.
3. Description.    Segunda columna de la tabla resultante.
4. Link.    Tercera columna de la tabla resultante.
5. PubDate.    Cuarta columna de la tabla resultante.

También debemos notar que cada una de las columnas tiene "out", eso nos obliga a darle un valor (aunque sea null) antes de terminar la ejecución de la función.

Compilemos nuestro proyecto para generar el DLL correspondiente.

Función en SQL Server

Para probar nuestra función vamos a crear una base de datos llamada SQLBlog y le habilitaremos la opción TrustWorthy para que se le considere una base de datos de confianza.

USE master
GO
IF EXISTS (SELECT name FROM sys.databases WHERE name = N'SQLBlog')
BEGIN
ALTER DATABASE SQLBlog
    SET SINGLE_USER
    WITH ROLLBACK IMMEDIATE;
    DROP DATABASE SQLBlog
END
GO
CREATE DATABASE SQLBlog
ON PRIMARY (
    NAME = 'SQLBlog_dat',
    FILENAME = 'C:\LaCarpeta\SQLBlog.mdf'
)
LOG ON (
    NAME = 'SQLBlog_log',
    FILENAME = 'C:\LaCarpeta\SQLBlog.ldf'
)
GO
ALTER DATABASE SQLBlog
SET TRUSTWORTHY ON

Ahora vamos a crear el ensamblado que alojará el DLL que acabamos de crear en .NET:

USE SQLBlog
GO
CREATE ASSEMBLY SQLRSSReader
FROM 'C:\ElEnsamblado\SQLRSSReader.dll'
WITH PERMISSION_SET = UNSAFE

Finalmente creamos la función y la probamos:

CREATE FUNCTION udfGetRSS(
    @URL NVARCHAR(256)
)
RETURNS TABLE(
    Title NVARCHAR(200),
    Description NVARCHAR(4000),
    Link NVARCHAR(256),
    PubDate NVARCHAR(50)
)
AS EXTERNAL NAME SQLRSSReader.[SQLRSSReader.Lector].ObtenerRSS
GO
SELECT * FROM udfGetRSS(N'http://www.espn.com/espn/rss/news')

Antes de terminar con esta entrada quiero que notes lo siguiente:

1. El ensamblado debe ser creado con PERMISSION_SET en UNSAFE porque va a realizar lectura de sitios web, es decir que necesita salir del servidor.
2. Las cadenas expuestas por la función deben ser del tipo UNICODE, por ello notarás que son NVARCHAR.
3. La notación para apuntar a la función es la siguiente: AssemblyName.[Namespace.Class].Function

Prueba con otra dirección, por ejemplo: https://www.tendencias21.net/xml/syndication.rss

Espero te haya resultado de utilidad esta entrada, ¡saludos!

---

Vistas, funciones y procedimientos almacenados

---

¿Para qué utilizar vistas, funciones y procedimientos almacenados?, ¿solamente para que se vea bonita la base de datos con muchos objetos de todos los tipos posibles?

Tenemos dos objetivos principales cuando ocupamos estos objetos en nuestra base de datos:

1. Encapsular la forma en que se obtienen los datos de la base de datos.
2. Implementar una capa de seguridad por encima del acceso a los datos.

Encapsulamiento

Para atacar este tema lo voy a dividir en dos partes, en "Vistas y funciones" y en "Procedimientos almacenados".

Funciones y vistas

No sé si te haya tocado trabajar con la base de datos de algún ERP o con la base de datos de un sistema a cuyo programador le resultó divertido ofuscar los nombres de los objetos.

La irremediable consecuencia de lo anterior es que la extracción de datos se vuelve un dolor de cabeza debido a que los nombres de los objetos no es descriptivo por sí mismo.

Supongamos que tenemos una tabla de este estilo:

CREATE TABLE XT56(
    A INT IDENTITY(1, 1),
    B VARCHAR(80) NOT NULL,
    C DECIMAL(8, 2) NOT NULL,
    D BIT NOT NULL DEFAULT 1,
    CONSTRAINT pkXT56 PRIMARY KEY (Id)
)

Resulta muy complejo establecer para qué es la tabla XT56 y el objetivo funcional de la información que está guardando.    Si después de un trabajo de revisión del sistema y de la base de datos determinamos que es la tabla de productos, bien podríamos hacer lo siguiente para clarificar la extracción de los productos:

CREATE VIEW vProductos
AS
    SELECT A AS Id, B AS Nombre, C AS Precio, D AS Activo
    FROM XT56

Al utilizar esta vista podremos obtener la información de una forma mucho más clara y entendible.

¿Qué pasaría si frecuentemente estamos obteniendo la lista de productos activos cuyo precio sea mayor o igual a un valor X?    Podemos encapsular el código para clarificar la forma en que devuelve la información y también para reutilizar un algoritmo que ya resolvió un problema en específico:

CREATE FUNCTION udfDameProductosPorPrecio(
    @Precio DECIMAL(8, 2)
)
RETURNS TABLE
AS
    RETURN
    SELECT A AS Id, B AS Nombre, C AS Precio
    FROM XT56
    WHERE C = @Precio
    AND D = 1


A través del encapsulamiento podemos proyectar la información de la forma en la que lo necesitamos y también crear objetos que nos permitan reutilizar algo que ya fue resuelto previamente.

Procedimientos almacenados

En un grupo de programación en T-SQL siempre habrá alguien que tenga una forma óptima de codificar y que resuelva los problemas utilizando la menor cantidad de recursos posibles.

Una excelente idea es que esta persona se encargue de resolver los problemas operativos (en la base datos) más complejos y encapsule el algoritmo dentro de un procedimiento almacenado, de manera tal que éste pueda ser utilizado por otros sin tener que estarse quebrando la cabeza en cómo resolver un problema.

Planes de ejecución

Otra gran ventaja de los objetos parametrizados (funciones y procedimientos almacenados) es que permiten que se almacene el plan de ejecución de éstos y así no tenga que recalcularse la siguiente ocasión que se requiera su utilización.

El caché de planes de ejecución es una cosa muy valiosa de SQL Server debido a que reduce el trabajo de uno de los procesos más caros, el cálculo del plan de ejecución.

Capa de seguridad

Habitualmente no es buena idea que se tenga acceso directo de lectura y/o escritura a las tablas de una base de datos.   En este momento se me ocurren por lo menos las siguientes X razones:

1. El usuario debe poder leer datos de una tabla, pero ella contiene información confidencial a la que no debería tener acceso el usuario.    Es decir, solamente necesita acceso a un subconjunto de columnas.
2. El usuario debe poder insertar datos pero necesitamos estar absolutamente seguros que la información que ingrese sea consistente con la especificación de requerimientos.
3. Si el usuario tiene permiso de escritura sobre la tabla, entonces podrá eliminar información y hacerlo de forma equivocada.

Seguramente habrá más de uno que inmediatamente pensó "pero si le puedo dar permisos muy granulares a un usuario de manera tal que solamente pueda leer o escribir ciertas columnas".    Coincido totalmente en que se podría, pero la administración de la seguridad se haría un dolor de cabeza y el dar esos permisos granulares no nos asegura que la información insertada sea adecuada.

Supongamos que tenemos una tabla como la siguiente:

CREATE TABLE Productos(
    Id INT IDENTITY(1, 1),
    Nombre VARCHAR(80) NOT NULL,
    Precio DECIMAL(8, 2) NOT NULL,
    Activo BIT NOT NULL DEFAULT 1,
    CONSTRAINT pkProductos PRIMARY KEY (Id)
)

Si un usuario únicamente tuviera permitido actualizar precios, podríamos crearle un procedimiento como el siguiente:

CREATE PROC pActualizaPrecioProducto(
    @Id INT,
    @Precio DECIMAL(8, 2)
)
AS
BEGIN
    UPDATE Productos
    SET Precio = @Precio
    WHERE Id = @Id
END

Vamos a mejorar este tema, vamos a crear una tabla de histórico de precios guardando auditoría de quién lo ejecutó:

CREATE TABLE ProductosHistoricoPrecio(
    Id INT IDENTITY(1, 1)
    Id_Producto INT NOT NULL,
    PrecioAnterior DECIMAL(8, 2),
    PrecioNuevo DECIMAL(8, 2),
    Usuario SYSNAME,
    Fecha DATETIME2(0) NOT NULL DEFAULT GETDATE(),
    CONSTRAINT pkProductosHistoricoPrecio PRIMARY KEY (Id),
    CONSTRAINT fkProductosHistoricoPrecio_Productos FOREIGN KEY (Id_Producto) REFERENCES Productos (Id)
)

Y nuestro procedimiento almacenado quedaría de la siguiente manera:

CREATE PROC pActualizaPrecioProducto(
    @Id INT,
    @Precio DECIMAL(8, 2)
)
AS
BEGIN
    BEGIN TRAN
    BEGIN TRY
        INSERT INTO HistoricoProductosPrecio (Id_Producto, PrecioAnterior, PrecioNuevo, Usuario)
        SELECT Id, Precio, @Precio, SUSER_NAME()
        FROM Productos
        WHERE Id = @Id

        UPDATE Productos
        SET Precio = @Precio
        WHERE Id = @Id

        COMMIT
    END TRY
    BEGIN CATCH
        ROLLBACK

        DECLARE @Error VARCHAR(4000) = ERROR_MESSAGE()
        THROW 50001, @Error, 1
    END CATCH
END

Si a nuestro usuario le damos permiso de ejecución sobre el procedimiento almacenado:

1. No será necesario que tenga permiso de escritura sobre HistoricoProductosPrecio ni sobre Productos.
2. No es necesario que sepa que se está guardando un histórico de precios, tarea que podría olvidar realizar si él actualizara directamente el precio del producto.

Espero te haya resultado de utilidad esta entrada, ¡saludos!

---

optimize for ad hoc workloads

---

Ya tiene mucho tiempo que no me metía a publicar alguna entrada en mi blog. Hay muchas razones para explicarlo, pero intentaré tener ventanas de tiempo que me permitan seguir creando más entradas y compartir un poco de lo que he podido aprender a lo largo de estos años.

Durante los proyectos de consultoría en SQL Server en los que he estado trabajando de un tiempo para acá, me he encontrado algo muy interesante, que la memoria de SQL está sumamente ocupada almacenando planes de ejecución.

Antes de abordar el tema de este blog de forma directa, me gustaría platicar un poco de los planes de ejecución para que se entienda de mejor manera el impacto que tendrá la opción optimize for ad hoc workloads de SQL Server.

Cuando mandas a ejecutar un query, SQL server realiza una revisión sintáctica y semántica del mismo, una vez que ha pasado la validación procede a calcular un plan de ejecución que resulte óptimo para el query en cuestión.    Para este cálculo toma en cuenta estadísticas, índices, llaves, cantidad de filas, tipos de dato, etc.

El proceso del cálculo de plan de ejecución es de lo más pesado y costoso para SQL Server, realmente mucha parte de la magia de SQL se encuentra ahí.    Debido a este costo SQL Server guarda en memoria el plan de ejecución para que pueda ser reutilizado por un query posterior, es decir que se ahorrará el proceso de cálculo y simplemente se avocará a la ejecución del mismo, optimizando el uso de recursos y mejorando los tiempos de respuesta.

Hasta aquí todo pinta re bien, el problema es cuando nuestra memoria se llena de planes de ejecución de uso único, es decir que el plan de ejecución únicamente ha sido utilizado una vez y nunca volvió a ser reutilizado por otro query.

Para ejemplificar esto vamos a hacer un ejercicio sobre la base de datos AdventureWorks2012 (pueden elegir otra versión de AdventureWorks y no habrá mayor problema)

Es indispensable que no realices este ejercicio en un servidor productivo.

Lo primero será vaciar la memoria de planes de ejecución y el buffer de datos para que tengamos el espacio en blanco:

DBCC FREEPROCCACHE
DBCC DROPCLEANBUFFERS

Después nos conectaremos a la base de datos AdventureWorks2012 y ejecutaremos primero este query:

SELECT ProductID, ListPrice, Color FROM Production.Product WHERE ProductID = 321

Y después este otro query:

SELECT ProductID, ListPrice, Color FROM Production.Product WHERE ProductID = 328

Recordemos que vaciamos la memoria de planes de ejecución y por lo tanto SQL Server tuvo que calcular el mejor plan de ejecución (de los que encontró)    Vamos a revisar la memoria de nuestros planes de ejecución para ver qué tiene:

SELECT CP.usecounts, CP.size_in_bytes, CP.cacheobjtype, CP.objtype, QP.query_plan
FROM sys.dm_exec_cached_plans CP
CROSS APPLY sys.dm_exec_query_plan(CP.plan_handle) QP


Nos deberá dar un resultado como el que muestro en la siguiente imagen:

Podemos ver que tenemos tres planes de ejecución que han sido ocupados una sola vez.    Abre cada uno de los planes de ejecución y notarás que:

• Uno corresponde al query que buscó al producto 321.
• Uno corresponde al query que buscó al producto 328
• Uno corresponde al query que obtuvo la información de los planes de ejecución.

Si ejecutamos ahora el siguiente query:

SELECT ProductID, ListPrice, Color FROM Production.Product WHERE ProductID = 329

Y volvemos a obtener el contenido del caché de planes de ejecución, ahora veremos que se incrementó el usecounts del plan de ejecución que obtiene el contenido del caché de planes de ejecución y que tenemos un nuevo plan almacenado resultado de la búsqueda del producto 329.

¿Estamos de acuerdo que pudo haberse utilizado el mismo plan de ejecución para buscar los productos 321, 328 y 329?, finalmente la búsqueda se hizo en base al CLUSTERED INDEX.    Peor aún, si nos pusiéramos a buscar muchos productos por su identificador acabaríamos con muchos planes de ejecución idénticos en la memoria, desperdiciando recursos que podríamos ocupar en cosas más valiosas.

Aquí es donde entra la configuración del optimize for ad hoc workloads.    Esta opción de SQL Server busca parametrizar planes de ejecución para que puedan ser reutilizados varias veces y no terminar con una memoria atascada de basura.

Para probar esto, vamos a habilitar la opción optimize for ad hoc workloads de la siguiente manera:

sp_configure 'show advanced options', 1
GO
RECONFIGURE
GO
sp_configure 'optimize for ad hoc workloads', 1
GO
RECONFIGURE

Ahora vamos a limpiar la memoria:

DBCC FREEPROCCACHE
DBCC DROPCLEANBUFFERS


Acto seguido ejecutaremos las cosas en el mismo orden que lo hicimos antes de habilitar la opción optimize for ad hoc workloads:

SELECT ProductID, ListPrice, Color FROM Production.Product WHERE ProductID = 321

Después:

SELECT ProductID, ListPrice, Color FROM Production.Product WHERE ProductID = 328

Después:

SELECT CP.usecounts, CP.size_in_bytes, CP.cacheobjtype, CP.objtype, QP.query_plan
FROM sys.dm_exec_cached_plans CP
CROSS APPLY sys.dm_exec_query_plan(CP.plan_handle) QP

Después:

SELECT ProductID, ListPrice, Color FROM Production.Product WHERE ProductID = 329

Y finalmente:

SELECT CP.usecounts, CP.size_in_bytes, CP.cacheobjtype, CP.objtype, QP.query_plan
FROM sys.dm_exec_cached_plans CP
CROSS APPLY sys.dm_exec_query_plan(CP.plan_handle) QP

Si revisamos y comparamos la memoria utilizada del antes y el después de habilitar la opción optimize for ad hoc workloads notaremos un ahorro ¡del 39.68%!

Esto resulta especialmente útil en entornos donde SQL Server recibe solicitudes enviadas desde sistemas que utilizan el .NET Entity Framework.

¡Aguas!, no es la cura para todos los males, esto nos obligará a realizar las mejores prácticas y crear una capa de acceso a datos mediante vistas, procedimientos almacenados y funciones para obtener la información de nuestras bases de datos.    Aunque, siendo sincero, la opción de la capa de datos la considero obligatoria independientemente del estado de la opción optimize for ad hoc workloads.

De hecho es considerada una buena práctica el habilitar esta opción en toda instalación de SQL Server.

Espero te haya resultado de utilidad esta entrada, ¡saludos!

---

¿Qué PAC debo elegir?

---

Desde la entrada de la facturación electrónica a México, ha ido creciendo el número de proveedores certificados que ofrecen sus servicios para poder realizar el proceso de timbrado y/o cancelación de tus comprobantes fiscales.

La elección del proveedor te puede significar una enorme diferencia entre detener la operación de embarques de tu empresa y tener fluidez en dicha tarea, entre tener dolores de cabeza interminables y pagar un poco más pero tener tranquilidad.

Lo más probable es que te inclines por buscar a uno económico, que por la cantidad de timbres que quieras comprar te puedan dar un precio bajo y así te ahorres una buena lana. Antes de elegir un proveedor, debes preguntarte lo siguiente:

1. ¿Puedo soportar todo un fin de semana sin respuesta de soporte?
2. ¿Estoy dispuesto a modificar los precios de mis productos para que el proveedor me timbre mi comprobante?
3. ¿Significaría un problema para la operación que no se pueda facturar?

La facturación no siempre significa un proceso restrictivo en las empresas, algunas pueden esperar horas o días para poder emitir o cancelar su factura y otras dependen de la emisión para poder continuar con su operación.

Es importante señalar que he colaborado en muchos sistemas diferentes que están relacionados con la facturación electrónica, desde procesamiento de archivos planos, lectura de bases de datos del ERP, obtención de los datos desde Web Services, recepción de datos por Webhooks, captura en sistemas, etc.   Me ha tocado convivir (y sufrir) a algunos PAC, de los cuales en esta entrada platicaré de 4 en particular: Edicom, SolucionFactible.com, Expide tu Factura y Profact.

¿Por dónde comenzamos?, ¿por las buenas noticias o por las malas?   Para no terminar con un mal sabor de boca esta entrada, comenzaremos con los peores y terminaremos con el mejor (desde mi punto de vista)

Expide tu factura
El compromiso en este PAC es inexistente y su personal de soporte se ve desbordado por la cantidad de problemas que tienen (o tenían hasta que tuve la lamentable experiencia de utilizar sus servicios), lo cual se traduce en respuestas al vuelo y promesas que escribieron en el hielo.

El año pasado se había comenzado con la implementación del CFDI v3.3 con meses de anticipación, esto con el fin de evitar las sorpresas que se pudieran recibir durante las validaciones ejecutadas por el PAC.

En agosto de 2017 se había obtenido el dato de que su servicio web de timbrado quedaría en productivo durante la primera semana de septiembre. En cada comunicación que se tenía con ellos al llegar la fecha comprometida, lo único que se recibía era un "el departamento de sistemas está trabajando duro", al final tiraron la toalla y el compromiso ya fue imposible de obtener (porque no lo iban a cumplir)

Llegó el Día D, ¡y qué crees!, lo que ya sabíamos que iba a pasar pero nos negábamos a creer, ¡no servía el servicio web!, ya en fechas de productivo obligatorias por el SAT, su servicio seguía inundado de problemas y el personal de soporte estaba que se arrancaba las pestañas de la cantidad de trabajo que les cayó encima.

¿Los utilizaría?, no, en definitiva perdieron el rumbo desde la versión 3.3 del CFDI. Antes estaban bien, funcionaba en niveles muy aceptables pero se vinieron abajo con la nueva versión.

Profact
Este proveedor se compromete a tener el servicio activo el 99.9% del tiempo, te comentan que utilizarán 8 horas al mes para mantenimiento y éstas no deberán considerarse dentro del 99.9%, es decir que 96 horas al año no estarán disponibles por cuestiones de mantenimiento.

Por el mantenimiento no le veo mayor problema, todo sistema necesita mantenimiento y lo más probable es que tenga que estar fuera de línea para recibirlo.   Tomando en cuenta esto, el 99.9% se deberá calcular sobre las 8664 horas restantes del año.

Con la caída que tuvieron apenas ya andan en 99.9569%, lo cual los deja con poco margen para lo que resta del año, pero no se les puede reclamar aún porque siguen dentro del parámetro anunciado. Es curioso que en su SLA le hacen pensar al usuario que lograrán un 99.9999%, pero con inteligencia únicamente se comprometen al 99.9%

Tienen errores en su codificación, errores que no reconocen aunque se les demuestre que sí existen y que son latentes... así que si eres programador y te gira un poco el coco, te causarán muchos disgustos estos personajes (si es que encuentras los errores)

El personal con el que se tuvo intercambio de información demostró un conocimiento bastante cortito, tan corto que no sabían lo que es el timbrado del Sector Primario, se quedaron con la mente en blanco y no supieron qué contestar.

¿Los utilizaría?, solamente si la facturación fuera algo casi sin importancia en la operación y vendiera en precios que tengan una posición decimal como máximo.

SolucionFactible.com
Tiene un nivel de servicio muy aceptable, al menos en el tiempo que se ha estado utilizando. Su personal de soporte atiende las solicitudes de información y se esfuerzan en apoyarte en todo lo posible.

Timbran todos los complementos y también el sector primario, cuentan con librerías para todos los lenguajes o conectividad por Web Service si quieres establecer la comunicación por esa vía.

¿Por qué no lo coloco como el mejor?, porque el que le sigue solamente me ha tocado verlo caer una vez en los años que llevo en esto.

¿Lo utilizaría y lo recomendaría?, seguro que sí, la experiencia ha sido muy grata.

Edicom
Como lo he mencionado antes, solamente me ha tocado verlo caer una vez en años. La caída fue por un error en sus bases de datos, error que se corrigió después de unas horas, pero cumplieron con su SLA al final del año.

Hay poco qué decir de este proveedor, porque casi todo es positivo. La única mosca en el arroz es que el soporte lo prefieren telefónico, y hay algunas personas que preferimos la comunicación vía correo elctrónico.

¿Lo utilizaría y lo recomendaría?, ¡por supuesto!, ciertamente tendrá un costo más elevado, pero si tu operación está muy ligada a tu proceso de facturación, este es el proveedor por excelencia.

Comentarios finales
Es importante notar que cada quién habla de cómo le fue en la fiesta, estos comentarios son expuestos a partir de la experiencia que he tenido con cada uno de ellos. Es muy probable que tú no tengas la misma percepción de alguno de ellos si es que ya te tocó que te causaran un problema.

La persona que se dedica al desarrollo sabe que todos los sistemas fallan, lo importante es que:

1. El impacto sea tan mínimo como sea posible.
2. El tiempo de respuesta para solucionarlo sea reducido.
3. Se acepten los errores y se corrijan.

Espero te haya resultado de utilidad esta entrada, ¡saludos!

---

cross database ownership chaining

---

En esta entrada exploraremos una característica muy interesante de SQL Server que permite brincar de una base de datos a otra con permisos mínimos para el usuario.

Para que esto sea posible será necesario que ambas bases de datos tengan el mismo propietario.

Vamos a crear dos bases de datos, cada una con una tabla muy sencilla.

USE master
GO
CREATE DATABASE DatabaseA
GO
CREATE DATABASE DatabaseB
GO
USE DatabaseA
GO
CREATE TABLE TableA(
    Valor VARCHAR(10)
)
GO
USE DatabaseB
GO
CREATE TABLE TableB(
    Valor VARCHAR(10)
)


Ahora vamos a crear un procedimiento almacenado que nos permita insertar un registro en TableA de DatabaseA y que en el mismo procedimiento se inserte un registro en TableB de DatabaseB.

USE DatabaseA
GO
CREATE PROC pAgregarValor(
    @Valor VARCHAR(10)
)
AS
BEGIN
    BEGIN TRAN
    BEGIN TRY
        INSERT INTO TableA (Valor) VALUES (@Valor)
        INSERT INTO DatabaseB.dbo.TableB (Valor) VALUES (@Valor)

        COMMIT
    END TRY
    BEGIN CATCH
        ROLLBACK

        DECLARE @Error VARCHAR(4000) = ERROR_MESSAGE()
        RAISERROR (@Error, 16, 1)
    END CATCH
END

Crearemos un login y le daremos acceso a DatabaseA, también dándole permiso de ejecución sobre el procedimiento almacenado que acabamos de crear.

USE master
GO
CREATE LOGIN LoginA WITH PASSWORD = 'password'
GO
USE DatabaseA
GO
CREATE USER LoginA FOR LOGIN LoginA
GO
GRANT EXEC ON pAgregarValor TO LoginA

Si nos conectamos con el login que acabamos de crear e intentamos ejecutar el procedimiento almacenado en DatabaseA nos va a marcar el siguiente error:

El login por lo menos debe tener acceso a DatabaseB.   Vamos a darle un usuario al login en esa base de datos para que pueda ingresar.    Aquí hay que notar que lo único que tendrá permitido es entrar a la base de datos y ejecutar las tareas que tenga permitidas el rol "public".

USE DatabaseB
GO
CREATE USER LoginA FOR LOGIN LoginA

Si volvemos a ejecutar el procedimiento almacenado en DatabaseA, el mensaje de error cambiará debido a que el usuario ya puede entrar a DatabaseB pero no tiene permiso de inserción sobre TableB.

He aquí donde utilizaremos la opción "cross database ownership chaining" de SQL Server.    Al darle permiso de ejecución en un procedimiento almacenado de DatabaseA que realice una modificación en DatabaseB, el usuario tendrá la autorización porque ambas bases de datos tienen el mismo propietario.

Vamos a habilitar la opción cross database ownership chaining.

sp_configure 'cross db ownership chaining', 1
GO
RECONFIGURE
GO
sp_configure 'cross db ownership chaining'

Si ejecutamos nuestro procedimiento almacenado de nuevo, veremos que la inserción resultó exitosa.

Notarás que no es necesario darle permiso de inserción a LoginA sobre TableB de DatabaseB, tuvo permiso porque el propietario de ambas bases de datos es el mismo y cross database ownership chaining está habilitado.

Espero esta entrada te haya gustado y te ayude a mejorar en tu trabajo.   Te espero en la siguiente, ¡saludos!

---

ORDER BY

---

Durante la semana pasada estaba de visita con un cliente y me encontré con un tema que resulta muy interesante, los conjuntos de resultados ordenados.

Cuando uno ejecuta una sentencia en SQL Server sin utilizar ORDER BY, los resultados son contemplados como conjuntos de datos, éstos no tienen un orden bien definido, son simplemente conjuntos donde sus datos satisfacen las características de los predicados utilizados en las sentencias.

Si utilizas el ORDER BY, entonces lo que estás solicitando es conocido como CURSOR.   Es importante no confundirlos con los objetos que nos permiten lecturas fila a fila.

Cuando la combinación de las columnas que aparecen en el criterio de ordenamiento no aseguran una combinación única, el orden del resultado no está totalmente asegurado, esto se debe a que varias formas de ordenar el mismo resultado cumplirían con los criterios de ordenamiento.

Para explicar mejor este punto vamos a realizar un ejercicio bastante sencillo pero que ayudará a entender mejor este tema tan interesante.

Vamos a conectarnos a una base de datos que tengas de pruebas (yo usaré AdventureWorks2014), crearemos una tabla de prueba y la llenaremos con datos aleatorios con el siguiente query.

IF NOT OBJECT_ID('dbo.TestOrderTORAB') IS NULL
    DROP TABLE dbo.TestOrderTORAB
GO
CREATE TABLE dbo.TestOrderTORAB(
    Id INT IDENTITY(1, 1),
    Nombre VARCHAR(32) NOT NULL,
    Color VARCHAR(8) NOT NULL,
    CONSTRAINT pkTestOrderTORAB PRIMARY KEY (Id)
)
GO
DECLARE @i INT = 1
WHILE @i <= 500
BEGIN
    INSERT INTO dbo.TestOrderTORAB (Nombre, Color) VALUES (REPLACE(CAST(NEWID() AS VARCHAR(36)), '-', ''), 'Amarillo')
    INSERT INTO dbo.TestOrderTORAB (Nombre, Color) VALUES (REPLACE(CAST(NEWID() AS VARCHAR(36)), '-', ''), 'Blanco')
    INSERT INTO dbo.TestOrderTORAB (Nombre, Color) VALUES (REPLACE(CAST(NEWID() AS VARCHAR(36)), '-', ''), 'Rojo')
    INSERT INTO dbo.TestOrderTORAB (Nombre, Color) VALUES (REPLACE(CAST(NEWID() AS VARCHAR(36)), '-', ''), 'Azul')

    SET @i += 1
END

En una nueva conexión (ventana) ejecuta la siguiente sentencia.    Es importante mencionar que tu resultado y mi resultado serán muy diferentes, esto es debido a que la tabla fue poblada con información aleatoria.   Aquí lo importante es que veas en tu resultado las filas que forman parte de él.

SELECT TOP 10 Id, Nombre, Color FROM dbo.TestOrderTORAB ORDER BY Color


Supongamos que por tareas de optimización se vio la necesidad de crear un índice sobre la tabla TestOrderTORAB.    Ejecuta este query en otra ventana para que no pierdas el resultado de la sentencia que anteriormente ejecutamos.

CREATE INDEX ixTestOrderTORAB ON dbo.TestOrderTORAB (Color, Nombre)

Si abrimos otra ventana y volvemos a ejecutar la misma sentencia que obtiene los 10 primeros productos ordenados por color, ¡veremos que es diferente el resultado!

Esto a pesar de que es el mismo query y que los datos de la tabla no han sido modificados.    ¿Cuál es la razón?, que el plan de ejecución con el que se despachó el query cambió de uno a otro y que la condición de tomar los primeros 10 productos ordenados por color sigue siendo cumplida con un conjunto de resultados diferente.

Ambos resultados son correctos, y la razón es que ambos cumplen con devolver los primeros 10 elementos que SQL Server encontró ordenándolos por nombre.

Si deseamos que esto no suceda, es necesario incluir una columna que ayude a que sea única la combinación de valores de las columnas utilizadas en el ORDER BY, a esta columna se le conoce como tiebreaker.

Vamos a eliminar el índice con la siguiente sentencia:

DROP INDEX ixTestOrderTORAB ON dbo.TestOrderTORAB

Modificamos el query para incluir la columna id como tiebreaker y ejecutamos para observar los resultados:

SELECT TOP 10 Id, Nombre, Color FROM dbo.TestOrderTORAB ORDER BY Color, Id


Creamos de nueva cuenta el índice con la siguiente sentencia:

CREATE INDEX ixTestOrderTORAB ON dbo.TestOrderTORAB (Color, Id, Nombre)

Ejecutamos el mismo query (el que tiene id como tiebreaker) en otra ventana y veremos que el resultado es el mismo.   No importa que se haya creado un índice, el resultado no fue modificado y la razón es que la combinación de valores de las columnas utilizadas en el ORDER BY es única.

Si comparamos los planes de ejecución de ambas sentencias (antes del índice vs después del índice) veremos que cambió, lo cual es totalmente deseable cuando uno genera índices, que éstos sean contemplados por el optimizador de consultas para mejorar el rendimiento.

En conclusión, es muy recomendable incluir una columna tiebreaker en caso de que la combinación de valores de las columnas utilizadas en un ORDER BY no sean únicos.

Espero esta entrada te haya gustado y te ayude a mejorar en tu trabajo.   Te espero en la siguiente, ¡saludos!

---

Chat uno a uno del SAT

---

El día 30 de septiembre de 2016 el tres veces heroico cuerpo de desarrollo de la Secretaría de Administración Tributaria (o uno de sus fabulosísimos proveedores) liberó la versión 1.2 del esquema para el complemento de Nómina.

Inmediatamente tuvimos que ponernos manos a la obra para poder comenzar a trabajar en los ajustes necesarios en los sistemas para poder generar XML que respeten ese esquema en enero de 2017, y... ¡oh sorpresa!, ¡lo que esperaba!, le encontramos un error (no sé cuántos vaya a tener)

Fíjense cómo está el texto que acompaña al atributo "CuentaBancaria" del nodo "Receptor":

"Atributo condicional para la expresión de la cuenta bancaria a 11 posiciones o número de teléfono celular a 10 posiciones o número de tarjeta de crédito, débito o servicios a 15 ó 16 posiciones o la CLABE a 18 posiciones o número de monedero electrónico, donde se realiza el depósito de nómina."

Siendo que el número más grande que aparece en la documentación es de 18 posiciones, entonces te esperas una expresión regular más o menos así: "\d{10,18}", y sí, nos encontramos con algo así:

<xs:simpleType name="t_CuentaBancaria">
  <xs:annotation>
    <xs:documentation>Tipo definido para expresar la cuenta bancarizada.</xs:documentation>
  </xs:annotation>
  <xs:restriction base="xs:int">
    <xs:whiteSpace value="collapse"/>
    <xs:pattern value="[0-9]{10,18}"/>
  </xs:restriction>
</xs:simpleType>

Después de notar que el valor máximo que soportaría es de 2147483647, realizamos una conexión para hacerle saber al heorico equipo de soporte técnico del SAT lo que estaba pasando.    Y, como dijera la canción que cantaban Alberto Vázquez y Joan Sebastian, "esto fue lo que sucedió".

Para el equipo de soporte técnico en el chat uno a uno del SAT el problema es de los bancos, supongo que es culpa de los bancos que hayan hecho la CLABE de 18 dígitos, inclusive también sería culpa de los bancos por hacer que los números de tarjeta sean de 15 o 16 dígitos.

No es triste que la gente que trabaja ahí no tenga capacidad cerebral para identificar que le está siendo reportado algo que está fuera de su alcance, lo triste es que se monten en su caballo de que la culpa es de todos menos de ellos y que su pequeño conjunto de neuronas les permita tener un sueldo para cobrar por no trabajar.

Esperemos algún día (antes del 1 de enero de 2017) el brillante equipo de desarrollo del SAT, o de su proveedor, se den cuenta del error y lo corrijan.    A menos que lo hayan hecho con la intención de que esté mal y así dar prórroga hasta junio de 2017... lo cual también es probable.

---

EIG - Abonando a un ladrón de varias cabezas

---

Hace algunos meses realicé la adquisición de un servicio de alojamiento con un proveedor llamado Arvixe, no puedo quejarme de esos primeros meses, el servicio muy bueno, la atención por parte del personal de soporte muy buena, y el rendimiento del servidor bastante bueno.

Después de un buen tiempo, hubo un cambio radical en sus servicios, y puedo decir que en toda su gama por la cantidad de tickets y quejas que llueven en twitter, a lo que nuestros amigos siempre se limitan a responder algo así:

1. "Gracias por proporcionar el id del ticket, te responderé en él".
2. "¿Podrías proporcionar el id del ticket?"

Obviamente tienen un programa muy sencillo donde reciben sus tweets y apretando un botón, se realiza la respuesta del mismo.    ¿El esfuerzo?, elegir entre la respuesta 1 o la respuesta 2, de ahí en fuera, nada.

Después de esperar por más de 3 horas y media con el chat abierto, finalmente una persona atiende la conversación, después de comentar la situación y mencionar que el 99.99% que GARANTIZAN en su página de inicio no se estaba cumpliendo, esta personita comentaba que como era un problema grave ellos no podían dar ese 99.99%.

En este momento pensé, vamos 2-0 y la atención es inexistente.    Procedí a levantar un ticket, después de esperar 6 horas, levanté otro... y así siguió el ciclo, el cual no interrumpí para verificar en qué momento o qué tipo de ticket es el que responden.

¡Finalmente respondieron!, después de 48 horas con el servidor totalmente caído y sin respuesta por ningún lado, pude ver en la lista que uno de tantos estaba respondido, ¿qué podría ser?, entre emoción y coraje abrí el ticket, ¡wow!, la respuesta fue increíble: "olvidó colocar los últimos 4 caracteres de la contraseña de su usuario de facturación, para poder atender su ticket, necesitamos esa información".

Este ir y venir con esta gente lo voy a hacer a un lado, y no por falta de más cosas qué decir, sino que me llamaba la atención que la calidad en el servicio decayera de una forma tan estrepitosa y en tan poco tiempo.

Después de investigar un poco, supe que un corporativo con las siglas EIG (Endurance International Group) había adquidido a Arvixe, y ahí comencé a darle al clavo.

Sucede que estos amigos de EIG son dueños de muchos (pero muchos) proveedores de alojamiento, ¿qué tienen en común aparte del dueño?, que sus primeros meses de servicio son "aceptables", posteriormente comienzan los problemas y niegan cualquier posibilidad de devolución de dinero para sus clientes, ¿qué sucede?, el cliente termina yéndose a otra compañía.

Encontrarán muchas entradas de blog donde te recomiendan pasarte del proveedor X al proveedor Y, que con el proveedor Y están súper contentos y que el servicio es espectacular.    Si le buscamos un poco, ¡el proveedor Y pertenece también a EIG!, ¿resultado?, basta con buscar un poco en los foros de soporte y cuentas de redes sociales del proveedor Y, para darte cuenta que es igual de asqueroso que el proveedor X.

Al final, en todos estos blogs encuentras que te recomiendan ir saltando entre proveedores que pertenecen a esta empresa EIG, al final le caerá dinero a los mismos ladrones y tu servicio seguirá siendo de pésima calidad.

Quiero finalizar esta entrada de blog con una recomendación sumamente simple, cuando vayas a contratar algún servicio de alojamiento, ¡verifica que no sea una empresa que forme parte del grupo EIG!, te ahorrarás muchos dolores de cabeza y pérdidas económicas.

---

Incorrect syntax near 'go'

---

El día de hoy me encontré con que un compañero estaba sufriendo bastante para crear un programa en .NET (aplicación de escritorio) que instalara una base de datos, desde su aprovisionamiento hasta la inicialización.

Al revisar el código que estaba utilizando, me encontré que los comandos en el archivo de recursos incluían la palabra GO.

Antes de abordar una solución simple, me gustaría explicar para qué sirve la palabra reservada GO en una sentencia SQL.

Vamos a abrir la página de opciones del SQL Server Management Studio:

Notemos que la opción "Batch separator" tiene el valor GO.    De ello podemos deducir que es una opción de configuración para SQL, de manera tal que en un sólo script podamos meter varias sentencias sin que una interfiera con la otra.    La palabra reservada GO no hace más que decir que ya terminó la sentencia y que la sentencia posterior es totalmente independiente a la anterior.

Vamos a probar esto con un ejemplo muy sencillo:

DECLARE @CurrentTime DATETIME = GETDATE()
PRINT @CurrentTime
GO
PRINT @CurrentTime

El resultado será el siguiente:

La primera sentencia PRINT sí se está ejecutando de forma exitosa, pero la segunda está marcando un error, y esto se debe a que la palabra reservada GO hace un "borrón y cuenta nueva", de manera tal que la variable @CurrentTime ya no existe en la segunda sentencia PRINT.

Debido a esto, el query que está ocupando mi compañero, está marcando el mensaje de error "Incorrect syntax near 'GO'"

Lo que menos se quería era tener que modificar el script para poder instalar la base de datos, por lo que encontramos una solución muy sencilla, crear una función que recibiera el script completo (con todo y GO) y lo dividiera en varios scripts tal como hipotéticamente se hace en SQL Server cuando se ejecuta, y el resultado fue el siguiente:

static void ExecuteCommand(string sqlCommandText, SqlConnection conn)
{
  SqlCommand comm = new SqlCommand("", conn);
  foreach (string sqlCommand in sqlCommandText.Split(new string[] { "GO\r\n" }, StringSplitOptions.RemoveEmptyEntries))
  {
    comm.CommandText = sqlCommand;
    comm.ExecuteNonQuery();
  }
}

Nuestra función aparte recibe una conexión abierta y disponible para ser utilizada.

Podemos notar que lo único que se está haciendo es dividir el script completo en pedazos ejecutables desde .NET.

La solución es sumamente simple, no hubo que ajustar nada en el código del script y la instalación de la base de datos ya tiene un resultado exitoso.

Espero te haya resultado de utilidad, nos vemos la siguiente entrada.

---

Covering indexes

---

Los índices de cobertura, son aquellos que nos ayudan a mejorar el rendimiento de ciertas consultas que utilizan un índice y que cuyo resultado incluye un mismo conjunto de columnas.

Tal como en las anteriores entradas, vamos a aterrizar esto en un ejercicio para que se vea la utilidad de estos elementos.

Tomaremos la base de datos AdventureWorks como ejemplo y partiremos del siguiente query:

SELECT ProductID, Name, ProductNumber, MakeFlag
FROM Production.Product
WHERE Color = 'White'

Si revisamos el plan de ejecución, notaremos que se está llevando a cabo un barrido del CLUSTERED INDEX de la tabla Production.Product:

Con un costo estimado de 0.0127253, el cual ciertamente es bastante bajo, pero esto se debe a la poca cantidad de elementos que tiene nuestro conjunto.

¿Qué es lo primero que haríamos para mejorar el rendimiento de esta consulta?, claro, irnos a la parte del WHERE y analizar el predicado.    Después de revisarlo podemos proponer un índice sobre la columna Color de la tabla Production.Product.

CREATE INDEX ixColor
ON Production.Product (Color)

Vamos a revisar nuevamente nuestro plan de ejecución:

Notaremos que hay un cambio importante, ahora se está realizando una búsqueda en el índice ixColor, justamente el que acabamos de crear.    Notemos también que se está llevando a cabo una tarea Key Lookup que sirve para encontrar las columnas que nos faltan para poder dar el resultado, las cuales son ProductID, Name, ProductNumber y MakeFlag.

El costo de este query cambió de 0.0127253 a 0.0126079, lo cual significa una variación menor al 1%, en verdad que no es nada impresionante si lo comparamos contra el costo que tendrá para la base de datos el mantener al día este nuevo índice respecto a los cambios que sufra la tabla a la que apunta.

Pero bueno, tomemos en cuenta que tenemos sólo 504 filas en la tabla de productos, también es por ello que la variación es tan pequeña.

Ahora, vamos a ahondar un poco más en el Key Lookup:

Nuestro índice ixColor, sólo guarda los valores del Color y una liga hacia la tabla Production.Product donde se almacena la fila a la que pertenece, de ahí que se tenga que hacer ese Key Lookup para encontrar los datos que le hacen falta al query para devolver el resultado completo.     Notemos que en la imagen aparecen en Output List Name, ProductNumber y MakeFlag.

¿Qué pasa si siempre regresamos las mismas columnas?, ¿qué pasa si este query regresa un subconjunto de columnas que habitualmente se ocupan?    Si este es el caso, estamos ante la perfecta opción de utilizar un índice de cobertura (covering index)

¿Qué es un covering index?, es aquel que almacena también los valores que forman parte del resultado, es decir, que ya no debe de ir a la tabla original por ellos dado que tiene una copia actualizada en él.

Vamos a crearlo:

CREATE INDEX ixColorCovering
ON Production.Product (Color)
INCLUDE (Name, ProductNumber, MakeFlag)

Y analicemos nuevamente el plan de ejecución para ver los cambios:

Podemos notar que ahora se está utilizando únicamente nuestro índice ixColorCovering.    ¿Qué costo tiene actualmente el query?, el costo es de 0.0032864, lo cual significa una mejora del 74.17%.

¿Qué tal?, ahora sí impresiona ¿no?, y eso que estamos hablando de una tabla con 504 filas, ahora imagina que estuviéramos trabajando en una tabla con miles o millones de filas, verás dos impactos mayúsculos:

1. Tiempo de respuesta muchísimo menor.
2. Menor uso de memoria de SQL Server para poder despachar el resultado.

Antes de dar por finalizada esta entrada, quisiera remarcar lo siguiente: cuidado con los índices, recuerda que cada vez que generas un nuevo índice, SQL debe actualizar su valor si es que el valor original en la tabla fue alterado, esto significa que una simple escritura se puede traducir en muchas más.

Espero te haya resultado de utilidad esta entrada, nos vemos la siguiente.

---

Twitter automatizado

---

¿Tienes cuenta en Twitter?, lo más probable es que tu respuesta sea "sí".     ¿Qué haces en Twitter?, siendo una red del tipo microblog, lo más probable es que sea para chismear un rato, ya sea para lo bueno o para lo malo, es decir, estar al día o encontrar personas a las cuales molestar mediante comentarios incómodos, insultantes e hirientes.

Seguro habrás notado que muchos de los mensajes publicados en esta red social, vienen de calendarios programados de publicación, es decir, creo mi lista de mensajes, les pongo fecha y hora ¡y listo!

Realmente no hay algo de malo en ello si es que se le da un seguimiento a las respuestas o a los comentarios recibidos, de manera tal que la red se enriquezca y también se exploten las características de ésta.   Pero, qué pasa cuando...

1. Se programan respuestas automáticas.
2. Se monitorean cuentas de otras personas o instituciones y se hace retweet sobre cada una de sus publicaciones.
3. Un sistema recopila los tweets con mayor impacto de las personas que se siguen para después hacer un "resumen personal y ejecutivo" de lo que otros publicaron.

Vayamos un poco más allá, ¿qué pasa si se deja que estos sistemitas se pongan a jugar y recopilar información para que entre ellos mismos se sigan y se den un retweet, follow, unfollow, etc.?, ¿no sería lo mismo que no existiera la red?

Me disculparás por ser tan tradicional, creo más en la relación personal, en ese ir y venir de ideas, comentarios, aseveraciones, discusiones, etc.    ¿Para qué colocar sistemas de actividad automatizada en una red social?, es como un "me invitaron a una fiesta, voy a ir, pero dejo a mi robot para que haga como que estoy porque me importa un cacahuate la interacción".

---