SQL dinámico en Transact SQL

Transcripción

1 SQL dinámico en Transact SQL Transact SQL permite dos formas de ejecutar SQL dinamico(construir sentencias SQL dinamicamente para ejecutarlas en la base de datos): La instrucción EXECUTE - o simplemente EXEC El procedimiento almacenado sp_executesql Desde aquí recomendamos la utilización de sp_executesql si bien vamos a mostrar la forma de trabajar con ambos métodos. La instrucción EXECUTE La instrucción EXECUTE - o simplemente EXEC - permite ejecutar una cadena de caracteres que representa una sentencia SQL. La cadena de caracteres debe ser de tipo nvarchar. El siguiente ejemplo muestra como ejecutar una cadena de caracteres con la instrucción EXEC. nvarchar(1000) = 'SELECT COD_PAIS, NOMBRE_PAIS, ACTIVO, FX_ALTA FROM PAISES' EXEC (@sql) También con SQL dinamico podemos ejecutar sentencias de tipo DDL (Data Definition Languaje), como CREATE TABLE. nvarchar(1000) TABLE TEMPORAL ( ID int IDENTITY, DATO varchar(100))' EXEC (@sql) = 'SELECT * FROM TEMPORAL' EXEC (@sql) El principal incoveniente de trabajar con la instrucción EXEC es que no permite el uso de parametros abriendo la puerta a potenciales ataques de Sql Injections - Además el uso de la instrucción EXEC es menos eficiente, en terminos de rendimiento, que sp_executesql.

2 Para solventar el problema debemos trabajar siempre con sq_executesql, que permite el uso de parametros y con el que obtendremos un mejor rendimiento de nuestras consultas. El procedimiento almacenado sp_executesql Para ejecutar sql dinamico, se recomienda utilizar el procedimiento almacenado sp_executesql, en lugar de una instrucción EXECUTE. sp_executesql admite la sustitución de parámetros sp_executesql es más seguro y versátil que EXECUTE sp_executesql genera planes de ejecución con más probabilidades de que SQL Server los vuelva a utilizar, es más eficaz que EXECUTE. El siguiente ejemplo muestra el uso (muy simple) de sp_executesql. nvarchar(1000) = 'SELECT COD_PAIS, NOMBRE_PAIS, ACTIVO, FX_ALTA FROM PAISES' EXEC sp_executesql admite la sustitución de valores de parámetros para cualquier parámetro especificado en la cadena Transact-SQL a ejecutar. El siguiente ejemplo muestra el uso de sp_executesql con parámetros: char(3) = '@codpais char(3)' = 'ESP' = 'SELECT COD_PAIS, NOMBRE_PAIS,

3 ACTIVO, FX_ALTA FROM PAISES WHERE COD_PAIS @paramvalue

4 SQL Dinámico: Exec y sp_executesql La ejecución dinámica de instrucciones SQL es algo a lo que tarde o temprano (más bien temprano) tenemos que enfrentarnos. Y ya que tenemos que hacerlo más vale saber como funciona y tener un poco de cuidado Por qué dinámico Hablamos de ejecución dinámica porque la sentencia SQL que va a ejecutar nuestro servidor no esta escrita en ningún sitio, sino que se crea cada vez que tenemos que ejecutarla. Frente a esta forma de trabajar tenemos el SQL normal, donde la sentencia SQL esta previamente escrita y lo único que hay que hacer es decidir cuando la ejecutamos. Tipos de SQL dinámico Siempre es difícil hacer una clasificación, pero en este caso vamos a intentar diferenciar el SQL dinámico que se crea en el servidor y el que creamos en nuestras aplicaciones. Por ejemplo si trabajamos en Visual Basic NET y en nuestro código tenemos algo como esto: Dim ssql as string Dim entrada as string Dim micon As New SqlConnection( cadena conexión ) de alguna manera el usuario escribe una condición y metemos ese valor en la variable entrada ssql= SELECT * FROM Clientes WHERE Nombre = ssql=ssql + + entrada + ` Dim cmdproductos As New SqlCommand(sSQL, micon) cmdproductos.commandtype = CommandType.Text micon.open()... =cmdproductos.executereader() y todo lo que haga falta para usar los datos devueltos... Esto sería SQL dinámico generado en el cliente. Pero no es esto lo que nos interesa. Nosotros vamos a centrarnos en el SQL generado en el servidor, generalmente dentro de un procedimiento almacenado. Primero veamos como podemos pasar el código anterior a un procedimiento almacenado que recibe un parámetro: CREATE PROCEDURE varchar(50) AS SELECT * FROM Productos WHERE Nombre GO Más o menos lo mismo no? Pues sí, pero no. La diferencia está en que cuando creamos la sentencia desde el cliente podemos hacer prácticamente de todo para editar y construir esa sentencia. Y cuando lo hacemos un procedimiento almacenado tenemos limitaciones a la hora de utilizar variables para construir nuestra sentencia. Supongamos que necesitamos una sentencia SQL donde la parte dinámica es el nombre de la tabla. Parece lógico escribir algo así: CREATE PROCEDURE VarChar(128) AS SELECT * GO Pero si lo ejecutamos lo único que obtenemos es un error. Incorrect syntax near '@NombreTalba' No podemos utilizar variables en cualquier parte de una sentencia! Por ejemplo no podemos utilizarlas en la cláusula FROM. Ejecutar SQL dinámico con EXEC Ahora es cuando ya tenemos que utilizar SQL dinámico de servidor propiamente dicho. Para solucionar el error de antes generaremos dentro de nuestro procedimiento almacenado una sentencia en una variable de texto como hacíamos desde Visual Basic NET y luego le diremos al SQL Server que ejecute esa sentencia mediante el comando EXEC. CREATE PROCEDURE VarChar(128) AS VarChar(1000) --El truco esta en tener la sentencia dentro de una variable SELECT ssql = 'SELECT * FROM ' --Y ejecutar ese texto contenido en nuestra variable EXEC GO Como vemos es sencillo, pero utilizar el SQL así dentro de un procedimiento almacenado nos ocasiona dos problemas. En primer lugar utilizar así los parámetros da lugar a problemas de seguridad porque estamos permitiendo que el usuario utilice trucos de inyección de código y que nuestro procedimiento almacenado haga cosas para las que no fue creado. Un ejemplo de lo que alguien podría llegar a hacer es: EXEC ElegirTabla Clientes GO DROP TABLE Pedidos''' Que un usuario pueda ejecutar sentencias como esta no es algo muy deseable verdad. El segundo problema que nos plantea el uso de EXEC es de rendimiento. Como ya sabemos una de las ventajas de los procedimientos almacenados es que cuando se ejecuta la primera vez se compila, y no es necesario recompilarlo en ejecuciones sucesivas. Pero esto deja de ser

5 cierto cuando usamos EXEC para ejecutar SQL dinámico porque cada ejecución requiere una compilación. Esto nos lleva al segundo modo de ejecutar SQL dinámico dentro de un procedimiento almacenado. SP_EXECUTESQL El procedimiento 'sp_executesql puede utilizarse como alternativa a los procedimientos almacenados para ejecutar varias veces una instrucción de Transact-SQL si la única modificación es que cambian los valores de los parámetros. Como dicen los BOL, al permanecer constante la propia instrucción SQL y variar sólo los valores de los parámetros, es probable que el optimizador de consultas del SQL Server vuelva a utilizar el plan de ejecución que genera para la primera ejecución. El funcionamiento de sp_executesql es el siguiente: sp_executesql [@stmt =] stmt [ {, [@params =] N'@parameter_name data_type [,...n]' } {, [@param1 =] 'value1' [,...n] } ] Usar este procedimiento almacenado soluciona en gran parte los dos problemas que veíamos con la ejecución dinámica a través de EXEC. Por un lado lo único que se transmite a sp_executesql son los parámetros y eso evita la inyección de código, y por otro lado se puede reutilizar el plan de ejecución. Veamos un ejemplo de cómo utilizar este procedimiento. USE NorthWind nvarchar(1000) --la variabla que contiene la cadena a ejecutar debe ser unicode, por eso lo de nvarchar = 'SELECT * FROM Products WHERE ProductName EXEC N'@NombreProducto = 'chai' Como vemos el primer parámetro es la sentencia que queremos ejecutar, después viene declarada la variable que vamos a usar y por último le damos valor a esa variable. Seguro que se os ocurren un par de utilidades para sp_executesql. Más sobre SP_EXECUTESQL Sp_executesql tiene unas cuantas peculiaridades que conviene tener en cuenta. Para empezar la ejecución de una sentencia a traves de sp_executesql se hace en un ámbito propio. Esto quiere decir que las variables declaradas fuera no se pueden utilizar, que las declaradas dentro no se pueden leer desde fuera, que podemos cambiar la base de datos (utilizar USE) en la que trabajar dentro del sp_executesql, crear tablas temporales en el nuevo ámbito, utilizar sentencias SET sin hacer cambios en la configuración del procedimiento llamante, y por último aunque no menos importante que si se produce un error y se aborta la instrucción también se aborta el procedimiento en el que se está ejecutando. En cuanto a los permisos recordar algo muy importante. La sentencia SQL se ejecuta dentro del contexto de seguridad del usuario, no del procedimiento que llama a esa sentencia. Un ejemplo de cómo usar y como no usar SQL dinámico Para concluir vamos a ver un ejemplo donde podemos usar SQL dinámico. A veces tenemos que crear una sentencia que ordene una tabla según una columna que dependerá de algún parámetro que nos pasa el usuario. Eso lo podemos resolver utilizando un procedimiento almacenado y una sentencia como: CREATE PROCEDURE varchar(50) AS varchar(50) SELECT * FROM MiTabla ORDER BY Esto está en la línea de todo lo que hemos estado diciendo. Es una solución sencilla pero que como no nos hemos cansado de repetir plantea varios problemas de seguridad y rendimiento. Así que por que no pensamos un poco e intentamos crear un procedimiento almacenado que haga lo mismo? Creedme que pocas veces encontraremos una tarea que no se pueda resolver sin recurrir al SQL dinámico. Fijémonos en lo siguiente: CREATE PROCEDURE varchar(50) AS SELECT * FROM mitabla ORDER BY WHEN 'columna1' THEN columna1 WHEN 'columna2' THEN columna2 WHEN 'columna3' THEN columna3 END Cierto que es un poco más complicado (se utiliza la función CASE), pero no hay inyección de código posible y una vez calculado el plan de ejecución se utilizará sin recompilar una y otra vez Como conclusión nos queda que el SQL dinámico es una herramienta potente pero peligrosa si no se trata con cuidado, y que la mayoría de las veces no necesitamos recurrir a ella porque siempre podemos encontrar otra solución. César Manivesa sql@manivesa.com

6 Ejemplos: use banco36 create proc varchar(100) as varchar(1000) * FROM ' + ' WHERE ' exec(@sql) go exec ejecutadinamico 'cuentaxcliente',' docident=''3322''' Alter Proc varchar(100) as varchar(1000) = 'SELECT ' + ',' +' From ' + ' WHERE ' EXEC (@isql) EXEC edinamico 'apellido','nombre','cliente',' docident=''3322''' nvarchar (1000) /* Nota de cadena debe ser Unicode para sp_executesql*/ = 'SELECT * FROM alumno where Exec N'@Di nvarchar = ' ' NVARCHAR(4000); NVARCHAR(15); = ' '; = 'USE Academico; SELECT * FROM Alumno WHERE DocIdent = ' EXECUTE (@Query); --- Nvarchar(15); = '@DocIdent Nvarchar(15)'; = ' '; = 'USE Academico; SELECT * FROM Alumno WHERE DocIdent @ValorParametro; -- Con Procedimiento almacenado Create procedure nvarchar(15) as NVARCHAR(4000),@DefinicionParametro NVARCHAR(200),@ValorParametro Nvarchar(15) = '@id Nvarchar(15)'; = 'USE Academico; SELECT * FROM Alumno WHERE DocIdent @ValorParametro; --Ejecución Exec xx ' ' Exec xx ' '